SmartClient and Smart GWT are "sister technologies" with a common Ajax / HTML5 runtime. Both technologies provide:

• a zero-install Ajax/HTML5 client engine
  
• rich user interface components & services
  
• client-server databinding systems

With SmartClient, you write your application in object-oriented JavaScript. With Smart GWT, you write your code in Java, and via the Google Web Toolkit, this code is translated into JavaScript so that it runs in normal browsers, without plugins.

SmartClient and Smart GWT support the same set of UI components, data binding systems and general APIs, with slight differences to take best advantages of each language's strengths (Java vs JavaScript).

NOTE: in all of the materials in this section, "SmartClient" is used as shorthand for the SmartClient platform, comprising both SmartClient and Smart GWT.

In this section:

• Fundamentals: defining traits of SmartClient technology
• Advantages: why choose SmartClient over other technologies
• Features: technical and architectural features that set SmartClient apart (with samples)
• Visual Builder: a web-based drag and drop screen builder for non-coders, which you can include within your applications to make them more customizable
• Our Customers: who else is using SmartClient
• Why Ajax / HTML5 is the right choice for business applications
• Examples: live examples of SmartClient in action, with code
• Tech Brief: after touring the site, download a one-page takeaway

SmartClient / Smart GWT Technology Fundamentals

Pure Client-side Ajax

In SmartClient, all presentation duties, and all HTML generation, takes place in the browser. No HTML generation or presentation duties are handled by the server. Once a SmartClient application has loaded, only data is transmitted between the browser and server.

By minimizing server contact, this architecture boosts responsiveness and scalability far beyond what is possible with server-side architectures such as JSF, ZK or Vaadin. By minimizing the amount of server-side code, the architecture also improves stability and reliability (only server code can crash the application for all users).

Component-Oriented & Cross-Browser Safe

SmartClient delivers a set of extensible UI components which manage presentation automatically, and provide uniform appearance and behavior on all supported browsers.

Using standard object-oriented approaches, you can extend, customize and create new components without ever learning low-level Ajax techniques or doing cross-browser testing and debugging.

This capability exists both for Smart GWT applications written in Java, and for SmartClient applications written in JavaScript. In JavaScript, SmartClient provides a true class system, enabling clean encapsulation, Java-like inheritance, calls to superclass methods and other standard object-oriented programming features.

Model-Driven

SmartClient enables you to automatically generate a default UI from your server side data model, then customize any part of it without losing auto-generation.

All of SmartClient's data-aware components, including grids, forms, detail and tiled views, can be generated directly from standard metadata sources such as Java Beans, SQL Schema or XML Schema.

Without this capability, you need to hand-code every component, and every screen of your application duplicates the information you already have in your server data model, leading to highly redundant, brittle applications.

Business Application Focused

SmartClient focuses on business applications as opposed to simple web sites. Where many Ajax toolkits handle principally the display of data, SmartClient focuses on the full data lifecycle: display, edit, save, repeat.

SmartClient's core strengths include efficient navigation and editing of large, complex data models, and the productivity features needed by business users.

SmartClient's grid component is far and away the most sophisticated available, with out-of-the-box support for inline editing, frozen columns, multi-field sort, grouping-by-value, expandable rows, auto-fitting to data, inline filtering, formula columns, user-defined highlighting rules, export and charting, as well as deep customization APIs in every area of appearance and behavior.

Mobile & Touch Device Support

SmartClient applications provide support for mobile and touch devices without additional effort, and also allow you to tune your application to best support specific devices.

Because finger taps and gestures arrive as normal mouse events, normal event handling code just works on touch devices - users can even trigger context menus and hovers via touch-and-hold, and drag and drop via finger slides. Device-aware components automatically switch appearance and behavior to mimic typical mobile UIs.

For deeper control, gesture & orientation change events, as well as native functions like phone dialing are all there to let you fully tune the mobile experience.

Offline & Desktop Capable

SmartClient supports offline and intermittently connected applications, with built-in support for automatic caching of recently accessed data.

SmartClient web applications can also be delivered as installable desktop applications with elevated priveleges such as local file access via "packaging" technologies like Adobe AIR, Mozilla Prism, and Titanium Desktop.

Any Server Platform

SmartClient integrates with any server platform through standards-based approaches such as REST and WSDL web services.

SmartClient also includes a Java integration server for accelerated integration with Java servers, with special support for popular Java frameworks such as JPA, Hibernate and other Java Beans persistence frameworks, Spring, and JDBC.

Supports Incremental Upgrade

SmartClient components can be easily embedded in existing applications. Grids, forms, trees, dialogs, wizards and other SmartClient components can be added without making architectural changes.

When embedded in this fashion, SmartClient components are fully functional, still capable of drag and drop, dynamic databinding, data paging and adaptive client-side operations.

Ajax MVC Architecture

Going beyond just widgets, SmartClient provides a model/view/controller architecture within the browser. The SmartClient MVC architecture provides a standardized model for server contact that simplifies Ajax applications and allows developers to quickly learn each other's code. This avoids the "code soup" typical of projects that adopt widgets-only Ajax frameworks, where loading and saving of data is done differently on every screen.

Ajax MVC also provides tremendous performance and scalability benefits. All loading and saving of data is performed by intelligent data manager components, which:

• cache and reuse loaded data in multiple views without further server contact
• handle load on demand for high data volume applications
• adaptively perform operations such as sorting and filtering within the browser