When comparing Broccoli vs Pint, the Slant community recommends Pint for most people. In the question“What are the best Node.js build systems / task runners?” Pint is ranked 7th while Broccoli is ranked 9th. The most important reason people chose Pint is:
Transparently handles calculations with quantities with uncertainties (like 3.14±0.01) meter via the uncertainties package.
Specs
Ranked in these QuestionsQuestion Ranking
Pros
Pro Brocfile fairly straightforward and small
Pro Rebuilds are really fast
In larger apps rebuilds get slower and slower as the size of the application increases. Broccoli deals with this by building only the files that were changed and intelligently figuring out their dependencies. This leads to rebuilds being of O(1) constant-time (in Software Engineering terms).
Pro Chainable plugins
With broccoli developers can chain plugins.
var tree = broccoli.makeTree('lib')
tree = compileCoffeeScript(tree)
tree = uglifyJS(tree)
return tree
Pro Uncertainties integration
Transparently handles calculations with quantities with uncertainties (like 3.14±0.01) meter via the uncertainties package.
Pro Supports both Python 2 and Python 3
A single codebase that runs unchanged in Python 2.7+ and Python 3.0+.
Pro NumPy compatibility
It supports a lot of numpy mathematical operations without monkey patching or wrapping numpy.
Pro Supports any numerical type
Supports fraction, float, decimal, numpy.ndarray, etc.
Pro Uses jobs to prevent bloated build files
Using Grunt in complex projects can lead to extremely bloated build files. Pint resolves this issue by introducing Jobs, a job is basically a set of Grunt tasks that are related to a particular build step. Using this method the build code remains organized in different job files, for example one for js compilation and one for CSS preprocessing. When the build process is started, Pint starts running these job files which in turn build the project.
Here's a sample Pintfile.js
further demonstrating the concept of jobs in PintJS.
Pro Faster builds with built-in concurrency
Every job in a build process may depend on something before it. A simple example would be copying of the minified files to the dist directory, this task needs to be performed after the compilation is complete. What Pint does is that it lets the user declare the dependencies within each job in a dependsOn
array. Hence whenever PintJS starts the build process it first generates an internal dependency model so that the build could be parallelized by spawning up new Grunt processes wherever possible resulting in the complete build process being concurrent (and really fast!).
Pro Takes advantage of Grunt's huge plugin ecosystem
Pint is built on Grunt, so it can use Grunt's plugins. Grunt has a plugin for pretty much any need with over 4000 plugins currently available.
Pro Simplified build lifecycle
In some projects there are tasks that aren't related to the build at all. These can be simple tasks such as pulling the GIT SHA or reading the package.json file into variables. With Pint these additional tasks can be defined in the build file too. This is made possible by providing users with an initializr and a finalizr; inside the initialize
callback, tasks such as generation of a list of test files or reading the package.json file can be defined, while in the finalize
callback users can define moving of the build files or pushing the source maps to their server.
Cons
Con Windows not fully supported
Con Assumptions about your project limit what you can do
Assumes you want to always output to single output directory. This directory must not exist at the time of running. It also (therefore) can't be your current directory. This puts broccoli slightly out of the class of a truly general "task runner".
Con Small community
Broccoli's community is still relatively small and not very active, at least compared to it's competitors. This leads to fewer plugins, guides and less support from developers for any problem that you may face using Broccoli.
Con Potentially unsupported
No activity on repo in 2 years as of Oct 2015
Con Configuration files are bloated and long
Pint's configuration files are the same as Grunt's. Meaning that they are long and hard to read, especially for new users.