Here’s the Deal

Java (via GWT) vs Earl Grey

28 16

2 0

When comparing Java (via GWT) vs Earl Grey, the Slant community recommends Java (via GWT) for most people. In the question“What are the best languages that compile to JavaScript? ” Java (via GWT) is ranked 21st while Earl Grey is ranked 29th. The most important reason people chose Java (via GWT) is:

That's Java, so it is strongly typed, and we can use fully the IDE: error detection, refactoring, auto-completion, etc.

Ranked in these QuestionsQuestion Ranking

Common Questions

What are the best languages that compile to JavaScript?

Java (via GWT)

Earl Grey

Pros

Pro
Strongly typed, good tooling

That's Java, so it is strongly typed, and we can use fully the IDE: error detection, refactoring, auto-completion, etc.

Pro
Familiar for Java developers

Perfect if you have a strong background in Java programming, and need to code for the client side.

Pro
Fantastic IDEs

Because Java is statically typed, integrated development environments (IDEs) for Java can provide a lot more feedback on errors you will encounter. Java IDEs can give you specific errors in the location where they occur without having to run the code every time. This makes is faster to debug and learn from your mistakes.

IDEs also have extensive auto complete capabilities that can help you learn the programming libraries you are using faster and tell you what functions are available.

Pro
Most commonly used language in industry

Java is one of the most popular languages in industry, consistently ranking either first, or occasionally second (behind C or Javascript) in terms of usage. Polls (see sources below) show it to be consistently in high demand, particularly as measured by job board postings. This makes Java a great time investment, as you will be easily able to get a job utilizing your skills, particularly as those Java applications in production now will continue to need maintenance in the future. It also results in great support for tools and plenty of computer science books, example projects and online tutorials.

Pro
Consistent programming standards

Most Java code follows very standardized coding styles. This means that when you're starting out, there are fewer questions about how you should implement something as the programming styles and patterns are well established and consistent. This consistent style means that it's often easier to follow others' example code, and that it's more likely to meet at least a certain minimum standard of quality. This discipline with consistent stylistic standards also becomes useful later, when collaborating on projects with larger teams.

Pro
Highly optimized JavaScript

Produced JS is highly optimized, can be separated in modules with lazy loading, can be internationalized while loading only the chosen language.

Pro
Powerful hygienic macros

Earl Grey's macro system allows for creating powerful control structures that look just like builtin ones. EG also supports macro libraries which allows developers to provide their macros/DSLs for others to use.

Pro
Pattern matching

Pattern matching is an incredibly powerful tool that, once you've tried, you cannot live without. This is not your average hacked-together pattern matching but a complete and integral feature to the language.

Pro
ECMAScript 6 Asynchrony

Earl Grey provides Promises based on ECMAScript version 6 and as many NPM libraries already implement. Earl Grey also provides a promisify function that converts old-fashioned callback-style asynchrony to promises.

Pro
Fully compatible with Node.js ecosystem

Anything available on NPM can be used just as easily with Earl Grey. In fact, everything else can be used too! Earl Grey has interfaces to Browserify, Webpack, and even experimental support for SystemJS. Earl Grey can even be used to generate npm packages that any node-compatible language can use!

Ad
Cons

Con
Too verbose

A Hello world needs package, class, static method and the actual printf.
Reading a line from input requires instatiating 5 objects in the right order.
Exceptions are everywhere, particularly since all values are nullable.
Java has a getter/setter culture, but without native syntax support.
portable Java code lacks anonymous functions, and continues to lack good support for partial application, compensating instead with verbose design patterns, kludges like anonymous inner classes, or just inline code.
It is statically typed without type inference, with a culture that promotes long class names.
Poor support for sum-types and pattern matching leads to overuse of inheritance for dynamic dispatch and chains of nested conditionals

Especially for beginners, this can make reading Java code feel overwhelming; most Java courses tell students to simply copy, paste, and ignore a significant percentage of the code until they've learned enough to understand what it means.

For experienced programmers, this makes Java feel tedious, especially without an IDE, and actively discourages some solutions and some forms of abstraction.

Con
Not true static typing

EG gives you the tools to implement your own type-checking inside of argument lists and elsewhere but there's no analysis done at compile-time like other compile-to-js languages.