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"

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.

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.

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

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

    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.

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

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

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...

    alert("Flowers");

    return e || (e = new zh({
        enableLongStackTrace: dt()
    })), e.run(function() {
        var r = yh.resolveAndCreate([{
                provide: zh,
                useValue: e
            }], n.injector),
            o = t.create(r),
            l = o.injector.get(th, null);
        if (!l) throw new Error("No ErrorHandler. Is platform module (BrowserModule) included?");
        return o.onDestroy(function() {
            return _t(n._modules, o)
        }), e.onError.subscribe({
            next: function(t) {
                l.handleError(t)
            }
        }), bt(l, function() {
            return o.injector.get(bh).donePromise.then(function() {
                return n._moduleDoBootstrap(o), o
            })
        })
    })

    var c;
    c || (c = new Af({
        Lm: yh()
    }));
    return c.run(function() {
        var d = Ne([{
                sb: Af,
                Be: c
            }], a.s),
            e = b.create(d),
            f = e.s.get(ee, null);
        if (!f) throw Error("No ErrorHandler. Is platform module (BrowserModule) included?");
        e.ec(function() {
            return Hh(a.mi, e)
        });
        c.hq.subscribe({
            next: function(a) {
                f.handleError(a)
            }
        });
        return Ch(f, function() {
            return e.s.get(Ze).xp.then(function() {
                Eh(a, e);
                return e
            })
        })
    })

    $ ag --count function eg-closure.js
    eg-closure.js:2905

    $ ag --count function eg-rollup.js
    eg-rollup.js:4421

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

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