GWT is coming back ... in 2015

Note: This post was published back in 2014-02-27. I can see a year into the future :-)

GWT is coming back!

Google Web Toolkit (GWT) will have a huge come-back in 2015. Here is why.
First, let’s look when and why GWT was created and what it is. If you know the Web and GWT, you can skip straight to My Predictions at the end.

GWT History, Present and Future

1994–2006 Before GWT

• 1994: Internet Explorer 1.0 was launched as an add-on to Windows 95.
• 1996: The <IFRAME> tag was invented and allowed web sites to become slightly more interactive.
• 2001: Internet Explorer 6.0 was launched.
• 2002: XmlHttpRequest invented by Internet Explorer, adopted by Mozilla.
• 2004: GMail from Google launched publicly. Besides showing the world what was possible in a browser (“a real application!”), it also used the predecessor of the Closure compiler. AJAX was heavily used. Web 2.0 is there.
• 2005: Internet Explorer had 87% market share and kept growing.

2006: GWT Launched

Sometime here the initial GWT team must have started to work. GWT was created when Internet Explorer 6.0 was the most relevant browser. Each browser had different bugs and APIs, but IE 6 was considered the worst. GWT launched with a unified API of widgets and events, which worked the same on all major browsers.

• 2006, Q2: Release of GWT 1.0.0

2006 - 2014: From Web to Apps

• 2006, Q3: Release of jQuery 1.0.0 (source). jQuery also unified the different browser quirks.
• 2007, Q2: iPhone was launched. It could only launch web apps. There was no app store yet. Q4: Android 1.x beta launched on phones.
• 2008, Q2: Apples AppStore was launched. Soon thereafter (in 2010), “the web is dead” and people somehow needed apps. Apps, Apps, Apps
• 2009, Q4: GWT 2.0.0 released. PhoneGap launched. It allows JavaScript to access sensors, camera, local address book, and other local services on the phone.
• 2010, Q2: Apple iPad launched. Tablets! Everybody needs one!
• This was also the launch of the Chrome Web Store. Now web apps truly existed.
• 2011, Q1: Android 3.x on tablets. Q4: mgwt 1.0.0 and gwt-phonegap launched. (source). MGWT mimics the UI widgets of iOS and Android; is packaged as a normal app via PhoneGap; runs find on phones and tablets.
• 2011, Q4: Android 4.x unified phone and tablets OS. PhoneGap was open-sourced as Apache Cordova.
• In the meantime: JavaScript
  • became a lot faster - thanks to optimizations, asm.js (a fast JS subset);
  • easier to debug - step-by-step debugger in the browser
  • easier to debug from compiled languages - thanks to Source Maps Rev 3 Proposal from Mozilla

2014: The Current State of Affairs

50% of web traffic comes from mobile. Vendors have to support at least 3 major form factors (desktop, tablet, smartphone) multiplied by 3–4 platforms (Web, Windows, iOS, Android). To reduce costs, people started to code the back-ends of their apps in JavaScript and sometimes the user interface, too. Hybrid apps were born.

What is GWT?

GWT today, version 2.6.0, contains several parts, all available under the Apache 2.0 License:

• Java to JavaScript compiler - translates all of Java 7 syntax to valid JavaScript code.
• Java Runtime Emulation (JRE) - provides implementations in JavaScript for basic Java APIs. Here is the list of supported APIs.
• UIBinder - create complex layouts with XML config files

To give you a feeling for the land in which GWT lives, here are the dependencies used by GWT 2.6.0: HtmlUnit 2.13, Jetty 8.1,Servlet 3.0, Guava 15.0, Protobuf 2.5.0, ASM 4.1, JDT 3.8.3, Closure compiler 20131014 (optimizes JavaScript).
The main focus of GWT is on performance. To achieve this, GWT tries to

• minimize code size (compact javascript)
• minimize number of network requests (inlined styles, images, i18n resources)
• optimize for caching (huge cacheable chunks, tiny dynamic loader script)

GWT comes with a very nice debugging mode, called DevMode. In DevMode a native browser plug-in re-routes most calls to a running IDE such as Eclipse, which runs remote debug mode. This allows to debug step-by-step, live running Java code mapped to JavaScript code.

Is GWT relevant?

• At Google: yes, 1k internal users; Many products built with GWT: Google Shopping Express, Adwords Manager, Google Sheets v2
• Externally: 100k users of SDK

Sources: GWT.create keynote, GWT Report 2013

2014: The Future of the Web - Components

The web (standards and browsers) morph into a real app platform.

• 2013, Q2: HTML Templates released as W3C Editor’s Draft.
• 2014, Q1. Four new W3C Editor’s Drafts released:
  
  • Custom HTML Elements - each custom element has a name, properties, functions, events, child content. Elements can be nested. The web has a native component system!
  • Shadow DOM - multiple DOM trees in a single web page; can interact with each other
  • HTML Imports - import HTML pages into other HTML pages, including scripts
  • CSS Grid Layout - native-like GUI layout (basically, tables done right)

Taken together, these 5 standards are called “Web Components”. There is a nice overview page here. To make it nicer to work with these APIs and to polyfill support in older browsers, both Google and Firefox provide JS libraries. To quote the official X-Tag blog:

“X-Tag and Polymer are both high-level sugar libraries that build upon the W3 Web Components specs - each introduces a different approach to making development of web components an even more amazing experience. To help make this more relatable, consider the following: jQuery : DOM :: X-Tag/Polymer : Web Components.”

• 2014, Q4 (planned): ECMAScript 6 (ES6) will be standardized. New stuff: Classes, modules, promises, generators.

What will GWT be?

The GWT Roadmap and the talks at the GWT.create conference promise a number of things for GWT 3.0 and beyond:

• (+) Interoperability with JavaScript: Instead of the current JSNI calls with lots of redundant Java code, GWT 3.x can auto-create annotated Java interfaces which magically just work to call the JavaScript API underneath.
• (+) Incremental compile! This will give GWT developers a work-flow similar to other JS hackers. Hack, reload, see.
• (+) Java 8 support - writing callback handler will use less syntax than JavaScript
• (+) CSS3 support - mostly boring technical work which is simply required :-)
• Most importantly: A new widget system, which is based on web components. Working draft of GWT team
• (-) The DevMode will die. It never worked on mobile, and it will stop working in 2014 (based on out-dated/internal browser APIs). The new debug mode, Super Dev Mode, will run in the browser, not in the IDE. I see a serious problem here, and we have to see, how this turns out. At least SourceMaps will allow to de-obfuscate stack traces. More infos: “Beyond Dev Mode”.

Sources: GWT.create keynote, GWT Roadmap presented at Google I/O 2013

My Predictions

The Web: As the number of devices and operating systems grows, a unified development process becomes more interesting. With web components the web becomes a composable platform for application development. There will be markets for tags, in the same way as there are markets for Wordpress plugins today.
GWT: Let’s assume the GWT community of developers manages to do the following:

• Deliver the features planned in the road map (JS interop, Java 8, incremental compile)
• Provide a solid initial widget set, maybe inspired by Polymer and Bootstrap
• Find a usable way to debug code

As soon as that happened (planned in 2014, likely to happened in 2015 :-), GWT will get a huge comeback. Why? Although the stated goal of GWT is performance, which always wins hearts of developers, the true magic is that GWT allows to tame complexity. I know, for GWT newcomers this is really quite the opposite, but for bigger apps it’s true. As requirements of users and the world only rise, the complexity rises with it. Combined with JS interop and Web Components, GWT will be the glue (and structure) that holds it all together.
The biggest apps (most complex in client-side business logic) will be written in GWT. Just like Google Sheets.

UPDATE 2015, June
Good: Technology, Usage
On Google IO 2015 there was not a single mention of GWT. However, GWT has its own conference by now, and it was even earlier than Google IO.
In Januar 2015, there was the GWT.create conference. Many Google employees spoke there. Of particular interest was the talk on Google Inbox. It turns out, the new mail client from Google, with the goal to replace GMail one day, was written 60-70% in GWT. The new Google Sheets was also written in GWT. 
Bad: Documentation
On the downside, Google seems to have used many GWT features that might or might not be released in a stable way yet -- the documentation is certainly behind. E.g. try to find something on "js interop" in the developer documentation: you find it only in release notes and some examples.
So the future in which GWT comes back is here, but its just not evenly distributed yet. Sadly, my prediction is, it will remain this way, as there are neither enough volunteers nor companies, which would have enough incentive to document GWTs new stuff.