Closure Compiler vs Rollup vs Webpack

http://www.syntaxsuccess.com/viewarticle/closure-compiler-vs-rollup-vs-webpack

by thelgevold • 9 years ago

80 31 9 years ago

noway421• 9 years ago

Last time playing with closure, it did quite a good job of dead code elimination.

Is there a specific reason why simple code elimination is not as wide spread as tree shaking, although it seems to be simpler and more effective solution?

pabl0rg• 9 years ago

Closure probably fell out of vogue because it's excellent, but written in java.

masklinn• 9 years ago

Closure fell out of vogue because it's fairly heavy and seriously subsets javascript, which makes it convenient when you're compiling to javascript (from a very different language, not just augmenting/macroing it), but not when you're writing it by hand.

Bahamut• 9 years ago

Something interesting is that I believe Google is working on a compiler that converts TypeScript to Closure, which would let you take advantage of the closure compiler while utilizing TS. That would be a very exciting development.

michaelbull2• 9 years ago

There's a JavaScript version available that has feature parity with the Java version.

https://github.com/google/closure-compiler-js

merb2• 9 years ago

that's only a transpiled version of it:

    The Javascript version of the Closure-Compiler is
    transpiled by GWT from the Java source. For more details
    on the differences in behavior see the super sourced
    files in the main repo.

ng12• 9 years ago

Or because the only real build tool (Plovr) was maintained by a single guy and hasn't been updated in years.

cestith2• 9 years ago

I'm sure patches are welcome. Well volunteered!

kybishop• 9 years ago

What is closure compiler doing that makes it so much better (for this benchmark) than webpack or rollup?

nilliams2• 9 years ago

Example from the docs [1], Closure compiler can combine 'aggressive renaming', 'dead code removal' and 'function inlining', so it can compile:

    function unusedFunction(note) {
      alert(note['text']);
    }
    function displayNoteTitle(note) {
      alert(note['title']);
    }
    var flowerNote = {};
    flowerNote['title'] = "Flowers";
    displayNoteTitle(flowerNote);

to:

    var a={};a.title="Flowers";alert(a.title);

For comparison, rollup created:

    function displayNoteTitle(note) {
      alert(note['title']);
    }
    var flowerNote = {};
    flowerNote['title'] = "Flowers";
    displayNoteTitle(flowerNote);

... (which you'd then have to minify, but as you can see it only eliminated the unused function).

[1] https://developers.google.com/closure/compiler/docs/api-tuto...

josteink• 9 years ago

Intuitively I would assume that for most codebases dead-code removal would have the biggest impact, especially when importing third-party libraries and only using portions of them.

But from your comment I can see that rollup should be able to handle this too. Yet the data in the linked article seems to imply Google Closure compiler still can optimize the code 33% further.

I find it hard to imagine that inlining functions can make that kind of difference.

Is it the test which contains flawed data? Or is this just an area where it's hard to generalize results due to the varying characteristics of different code-bases? Anyone got an opinion?

KenanSulayman• 9 years ago

Good example, original uses ES6 classes:

https://github.com/psychonautwiki/mw-UserBadge/blob/master/u...

After applying Google Closure Compiler in advanced mode:

https://github.com/psychonautwiki/mw-UserBadge/blob/master/u...

(There isn't even a prototype chain like it babel)

Beautified version of compiled version:

https://gist.github.com/anonymous/1b6b96ec319f1272f9bbc3f19b...

I think that gives the whole thing a very new kind of aesthetics

echeese• 9 years ago

I just tried that example code in closure compiler, I actually got

    alert("Flowers");

Can't get any better than that.

shouldbworking• 9 years ago

Closure compiler understands how the code runs, whereas those other tools only understand how its parsed.

Closure compiler is really awesome but never fully caught on outside of Google because it doesn't let you use some features of JS that aren't optimizable. The main one I can remember is only allowing dot syntax for properties

cromwellian2• 9 years ago

There are too many optimizations in Closure Compiler to describe simply what it does. It is a full blown optimizing compiler like C, right down to supporting graph coloring in the naming of locals. It even does type-based optimization by disambiguating property names on prototypes by types (https://github.com/google/closure-compiler/wiki/Type-Based-P...) -- this alone I've measured at 14% code size reduction in my projects, and it can move code at the function level out of the main module into late loaded modules if it detects the code is not used until later.

Malte Ubl has exposed some of this functionality to the outside world with his Splittable project (https://medium.com/@cramforce/introducing-splittable-1c882ba...)

All of Google's main projects, from the Google Home page, to Docs, Gmail, Maps, etc rely on Closure Compiler. Google Photos makes particularly aggressive use of this splitting functionality (take a look at the network tab in Chrome)

Closure Compiler also pairs well with Google Style Sheets, which is a style sheet compiler like SASS/LESS (but predated them), but it optimizes and prunes CSS.

Closure has it's downsides, the Advanced Mode makes assumptions about the way you write Javascript that can break. However, there are conformance checks you can enable to check for many of these. The compiler has to "see" what you're doing, so if you do something like this:

foo.hello = 42;

function blah() { return "hello"; }

foo[blah()] = 42;

The compiler may not be able to see that 'foo.hello' and 'foo["hello"]' are the same thing, and the former will get renamed to foo.xyz. The price you pay huge savings in code size is being consistent and diligent in your code, and sometimes giving up a little bit of dynamism

wildpeaks• 9 years ago

You can also use Closure Compiler (instead of UglifyJS) with Webpack: https://github.com/roman01la/webpack-closure-compiler

abritinthebay• 9 years ago

Caveat: it's really, really, really, slow if you use the JS implementation. Still needs Java for perf reasons. They do mention that tho.

BinaryIdiot• 9 years ago

That's pretty interesting. Do we have any comparisons on the performance of the outputted code between each? Like do they all perform identically? Are there optimizations one may do that others do not or perhaps even the opposite like a shortcut that cuts down on code but makes it perform worse? Also what about memory performance?

It's been a while since I've used closure. I may look into this to do a comparison on my current open source project and see what difference, if any, it makes.

susi22• 9 years ago

I remember back in the day, Google Closure was so advanced they even tried out shuffling code around in the final JS file and measured which way produced the best GZIP compression. They since abandoned that code though, but that's something they did over 5 years ago.

dunham• 9 years ago

They do (or did) something similar with the back end of GWT (globally sorting method definitions by length). But it's probably easier with GWT output (vs arbitrary js), because it has a well defined structure.

cromwellian2• 9 years ago

You can see some of the original research I did on this in my old blog post: http://timepedia.blogspot.com/2009/08/on-reducing-size-of-co... I followed up by researching different clustering metrics including something called LZDIST instead of edit-distance. http://timepedia.blogspot.com/2009/11/traveling-salesman-pro...

I think it works better for GWT than for Closure because GWT's optimizer permits inlining functions in some circumstances even if they increase code size. This causes repetitious fragments to appear, and re-ordering the code to bring those fragments within GZIP's compression window functions as kind of a late-stage "anti-inliner/common subexpression elimination"

michaelbull2• 9 years ago

This seems misleading. Rollup doesn't ship with an uglifier/minifier, and Webpack ships with UglifyJS. So what you're really comparing is UglifyJS vsthe Closure Compiler, however both webpack _and_ rollup have plugins for utilizing the closure compiler:

https://github.com/roman01la/webpack-closure-compiler

https://github.com/camelaissani/rollup-plugin-closure-compil...

Silhouette• 9 years ago

Unfortunately, recent versions of Closure Compiler don't appear to produce entirely reliable output when run with the advanced optimisations that make it interesting and give the kinds of impressive results observed by the OP here.

Case in point: We just installed the latest version on a new computer yesterday, and it causes some JS code that runs fine in its original form to fail on IE11 after transformation. The original code isn't complicated at all and multiple developers and lint tools think it's correct and not doing anything non-standard, but the transformed version seems to confuse IE. In fairness to Closure Compiler, we also can't immediately see why the transformation it has applied would be invalid, so maybe this is really a bug in IE's JS parser or something along those lines. Unfortunately, the fact remains that the original code works, the slightly different transformed version from a previous version of Closure Compiler also worked, but the transformed code in the new version does not.

Closure Compiler vs Rollup vs Webpack

Related Stories