Google 2007 JavaOne Advance Conference Guide User Manual

Page 44

| technical sessions | track six : the next-generation web | java.sun.com/javaone

* Content subject to change.

TECHNICAL SESSIoNS

| TRACK SIX | THE NEXT-GENERATION WEB

The Next-Generation Web

Then Asynchronous JavaScript And XML (Ajax) burst on the scene. Google,
with Gmail and Google Maps, led the Ajaxian surge with web applications
that were nearly as interactive as desktop applications. Suddenly, the
JavaScript programming language, which for a long time was frowned
upon as a poor cousin of the Java programming language, was on every
web application developer’s radar, as bosses and clients demanded
applications that were as responsive as Gmail.

But much to the chagrin of developers using the Java programming
language, the JavaScript programming language, other than having a
syntactic resemblance to the Java programming language, is not the Java
programming language at all. The JavaScript language is a powerful
language in its own right, but it is a far cry from the statically typed,
inheritance-based Java programming language. To a developer using the
Java programming language, the JavaScript language is foreign and can
be vexing to use. If you are a developer who uses the Java programming
language but has no JavaScript language experience, for example, odds
are that you are not going to dive into the JavaScript language and come
up with a drag-and-drop framework in a few days of feverish coding.

Fortunately for everyone involved, the next evolution of Ajax was
JavaScript language frameworks—such as Prototype, Script.aculo.us, and
Rico—that make the JavaScript programming language easier to use and
provide indispensable features such as special effects, drag-and-drop, and
behaviors. Suddenly, the JavaScript programming language and Ajax
have become much more accessible not only to developers using the Java
programming language but also to software developers in general.

This session explores the aforementioned frameworks: Prototype, which
adds low-level JavaScript programming language enhancements in
addition to Ajax underpinnings; Script.aculo.us, which builds on Prototype
to provide UI-specific whizbang features such as special effects and drag-
and-drop; and Rico, also built on top of Prototype, which adds behaviors—
attaching Ajaxian behaviors to ordinary HTML—to the mix.

Prototype and its derivatives have enjoyed a great deal of popularity,
mostly in the Ruby arena, but they are just as valuable to developers using
the Java programming language. This session looks at these frameworks
from the perspective of developers using the Java programming language.
You learn how to integrate Prototype and Script.aculo.us into applications
based on servlets and JavaServer Pages (JSP) technology and how to wrap
Rico components with JavaServer Faces components. Come see how you
can take advantage of the Prototype family of JavaScript programming
language frameworks in your Java technology-based web applications.

If you attend this session, you should have some familiarity with the
JavaScript programming language, in addition to a solid understanding
of the Java programming language and servlets. Some familiarity
with JavaServer Faces technology is also desirable. When you leave
this session, you will have a good understanding of Prototype and its
derivative frameworks and how you can use them in your Java technology-
based web applications.

TS-6676 Blueprints for Mashups: Practical Strategies, Tips, and

Code for designing and Building

Mark Basler, Sun Microsystems, Inc.
Sean Brydon, Sun Microsystems, Inc.
Gregory Murray, Sun Microsystems, Inc.

Web applications are making their functionality and data available as a
live service, so that other applications can combine, or mash up, with
those live services to offer a new and creative user experience. This
presentation identifies some of the key problems and issues facing
developers and provides some practical strategies and code examples for
successfully jump-starting your own mashups.

The session looks under the hood, examines popular live services, and
identifies common problems and some of the underlying designs and
technical choices of building mashup applications. It also discusses
some of the issues you face when building your own live mashups. After
exploring the concepts, the session discusses building a web application
as a service and also building a mashup that combines with live services.

designing and building an application as a service:

The presentation discusses guidelines for designing the interface and
building the service. Among the issues addressed is using a RESTful
service API, an RSS/Atom feed, or a JavaScript technology library to expose
your service to mashup clients. Because using JavaScript technology is
a popular way to offer your service to clients, the session dives into the
usage of the JavaScript technology library, including widget, gadgets,
and even snippets. It then looks below the surface and discusses design
choices in implementing the service and considers issues such as access
control and metering, choosing data formats such as JSON or XML,
layering your application, and leveraging Java technologies.

Building an application to mash up with services:

The presentation considers the issues you face when your application is
the client and needs to mash up with live services. It covers strategies
for handling security models, handling aynchronous remote services,
customizing the look of widgets, making services work together in a page,
Ajax limitations, and other choices that are part of designing and building
a mashup. It also examines a live mashup application to pull it all
together and shows how to include various services in an application.

The session includes lots of code discussions, and attendees will be able
to reuse the design strategies and code to jump-start their own mashups
with the Java technology web tier.

TS-6707 Beyond Cookies: Persistent Storage (and offline Access)

for Ajax/dHTML Applications with dojo Storage

Brad Neuberg, Brad Neuberg Consulting

Web applications have been constrained by the 4K limit of cookies for
years. In this session for developers, learn how Dojo Storage, part of the
open source Ajax toolkit Dojo, can enable web applications to persistently
and securely store large amounts of data, including for offline access.
The session shows how to use the dojo.storage API; includes example
applications that use these APIs, such as a web-based word processor that
persists its files locally rather than on a server; and presents details of how
dojo.storage is internally implemented. In addition, learn the state of the
art for making your web-based Ajax applications work offline.