EXT-GWT Interview Preparation Guide

Google Web Toolkit or GWT Web Toolkit, is an open source set of tools that allows web developers to create and maintain complex JavaScript front-end applications in Java. Other than a few native libraries, everything is Java source that can be built on any supported platform with the included GWT Ant build files.

The major GWT components include:

GWT Java-to-JavaScript Compiler
Translates the Java programming language to the JavaScript programming language.
GWT Development Mode
Allows the developers to run and execute GWT applications in development mode (the app runs as Java in the JVM without compiling to JavaScript). Prior to 2.0, GWT hosted mode provided a special-purpose "hosted browser" to debug your GWT code. In 2.0, the web page being debugged is viewed within a regular browser. Development mode is supported through the use of a native-code plugin called the Google Web Toolkit Developer Plugin for many popular browsers.
JRE emulation library
JavaScript implementations of the commonly used classes in the Java standard class library (such as most of the java.lang package classes and a subset of the java.util package classes).
GWT Web UI class library
A set of custom interfaces and classes for creating widgets.

Dynamic and reusable UI components: programmers can use pre-designed classes to implement otherwise time-consuming dynamic behaviors, such as drag-and-drop or sophisticated visual tree structures.
Simple RPC mechanism
Browser history management
Support for full-featured Java debugging
GWT handles some cross-browser issues for the developer.
Unit testing integration
Support for Internationalization and localization
HTML Canvas support (subject to API changes)
The developers can mix handwritten JavaScript in the Java source code using the JavaScript Native Interface (JSNI).
Support for using Google APIs in GWT applications (initially, support for Google Gears)
Open-source
The developers can design and develop their application in a pure object-oriented fashion, since they're using Java (instead of JavaScript). Common JavaScript errors, such as typos and type mismatches, are caught at compile time.
The JavaScript that the GWT compiler generates can be tailored to be either unobfuscated and easier to understand or obfuscated and smaller to download.
A number of libraries are available for GWT, by Google and third parties. These extend GWT's features.

GWT uses or supports Java, Apache Tomcat (or similar web container), Eclipse IDE, Internet Explorer, and Internationalization and Localization. Java-based GWT RIAs can be tested using JUnit testing framework and code coverage tools. Because GWT allows compile time verification of images, CSS, and business logic, many common development defects are automatically discovered without need of the manual testing commonly required by RIAs.

Google has noted that some of its products are GWT based:

► Orkut
► Blogger
► AdWords
► Flights
► Wallet
► Offers
► Groups

How does GWT app work? (compiling to JavaScript, cross-browser support, bootstrapping script, etc.)
When would you NOT use GWT? (rather general and open-ended question, but it demonstrates if developer is really into this technology) Follow-up question: What GWT alternatives would you consider?
What 3d party libraries have used with GWT? Which libraries would you recommend? Why?
Describe server-side development with GWT.
Did you use DI framework with GWT?
What does make MVP better fit for GWT than general MVC?
Serialization and Un-serialization. What is required of a user defined class for it to be serializable?
Event handling. Describe how an event bus is used and implemented.
Describe how one module can inherit or use members from another GWT module.

The Google Web Toolkit (GWT) is a toolkit to develop Ajax web application with Java. The programmer writes Java code and this code is translated into HTML and Javascript via the GWT compiler.
The compiler creates browser specific HTML and JavaScript to support all the major browsers correctly. GWT supports a standard set of UI widgets, has build in support for the browser back button and a JUnit based test framework.

GWT provides two modes:
Development Mode: allows to debug the Java code of your application directly via the standard Java debugger.
Web mode: the application is translated into HTML and Javascript code and can be deployed to a webserver.

RootPanel is the top level panel.

For layout the page, we could use following layout panels, finally we need to add all those layout panels in RootPanel.

DockLayoutPanel
SplitLayoutPanel
StackLayoutPanel
TabLayoutPanel

Use below panels inside the Layout panels for holding the widgets.

HorizontalPanel
VerticalPanel ( Prefer using FlowPanel )

Create a class that should extends Composite class of GWT.
Inside the constructor you can write you logic to create a widget and call the initWidget method().
Then you can use this class in anywhere in the application and add this widget in any panels.

private static class OptionalTextBox extends Composite implements
ClickHandler {
private TextBox textBox = new TextBox();
private CheckBox checkBox = new CheckBox();
--------
initWidget(panel);
-------
}

To split your code, simply insert calls to the method GWT.runAsync at the places where you want the program to be able to pause for downloading more code. These locations are called split points. For this you should use runAsync.

public class Hello implements EntryPoint {
public void onModuleLoad() {
Button b = new Button(\"Click me\", new ClickHandler() {
public void onClick(ClickEvent event) {
GWT.runAsync(new RunAsyncCallback() {
public void onFailure(Throwable caught) {
Window.alert(\"Code download failed\");
}

public void onSuccess() {
Window.alert(\"Hello, AJAX\");
}
});
}
});

RootPanel.get().add(b);
}
}

When you want to display dynamic data or a range of data, not just a static list, then we should use AsyncDataProvider.