Session Schedule

By Neal Ford

As out applications have spilled from the server across the wire to the web tier, we increasingly must debug and test in the browser. This session covers debugging and testing tools for clients, JavaScript, and Ajax. As the browser has become important again, our applications have spilled out of the server side to the web tier, and now we have to debug and test there. This session is all about debugging and testing the web tier.

I discuss the tools Firebug, Venkman, the Developer's toolbar, and bookmarklets for debugging JavaScript, Ajax, and general browser behavior. Then, I discuss testing the web tier, first with unit testing via JsUnit, the user acceptance testing with Selenium and Sahi. This session is packed with examples and demonstrations, including real-world scenarios and pitfalls.

Session Topics:

Debugging

Firebug

Venkman

Developer's Toolbar

Bookmarklets

Testing

JsUnit

Selenium

Sahi

By Neal Ford

This session discusses advanced Selenium techniques for testing web applications. It discusses techniques for both TestRunner and Remote Control Selenium, including data driven tests, creating branch points, testing Ajax applications, creating flexible tests, integration with continuous integration, and tons more.

By now, just about everyone has heard of Selenium, the revolutionary open source testing tool for web applications. This session takes Selenium to the next level, showing how to handle complex, real world scenarios in Selenium. It discusses Selenium setup for both TestRunner and Remote Control.

Mostly, though, this session delves into specific techniques for testing real world kinds of behaviors in web applications. I discuss data driven tests, generated tests, decision points in tests, interactive Remote Control, integration with continuous integration, testing Ajax applications (including applications that only Selenium can test), and future directions. This session will turn up the volume on your testing to "11".

Session Topics:

Generating random values

Data-driven tests

Remote control Selenium

Setup

Interactive mode

Writing and running tests

Decisions, decisions

Test Reusability

Integration with continuous integration

Documenting tests

Choosing the right mode for the job

Ext

By Neal Ford and Venkat Subramaniam

Back in the Web 1.0 days, we had it lucky: the browser was our pretty green screen, and we didn't have to worry about what we put there. It was pretty and dumb. Then, the guys at Google ruined it all. Now, we have to make our web applications actually do stuff. And anytime software does stuff, it needs to be tested.

This workshop is about how to test the web tier. Venkat Subramaniam and Neal Ford will discuss unit, functional, integration, and acceptance tools and strategies to provide the same rigorous testing of things that go bump in the browser as things on the server side. We discuss JsUnit, CrossCheck, Selenium and other tools, and show strategies for testing things that look hard to test.

By Nathaniel Schutta

So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust?

This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.

By Nathaniel Schutta

By now, most developers have (re)discovered the much maligned JavaScript language and the plethora of top notch libraries have helped make this grey beard of web programming accessible to a new generation of developers. While many are content to simply rely on others, we can learn an awful lot about how to write better JavaScript by taking a look under the hood.

This talk will explore the JavaScript language by walking through the widely used Prototype library.

By Nathaniel Schutta

Like many developers, you've ignored JavaScript for years. Between the initial pain and the stigma of a "designers toy", it just wasn't worth your time. But with the rise of Ajax, JavaScript has been elevated to first class citizen.

This talk will give you an overview of this misunderstood language as well as opening your eyes to some of the excellent tools available to ease the pain of developing in this dynamic language.

By Brian Sletten

Ever since we started doing relational joins, we've looked for ways to tie data together. When all we had were databases, our integration strategies were simple. The web has given us no end of new data sources to integrate but the strategies to do so are less clear. Where we can glue data together, it seems like the best we can come up with is locating Starbucks stores on Google Maps.

We want control of our data and our mashup results. We want ever more ways to view, explore and requery them in multi-faceted ways. We want data processing to be as simple as word processing has become. We want our data integration strategies to be less Vanilla Ice "Ice-Ice Baby" and more Nine Inch Nails "The Hand that Feeds" with the fluidity of a Phish tease (trust me, it makes sense).

In this first talk, we will describe the data integration landscape as we see it now and where it is likely to be in the near future. We will discuss the benefits and deficiencies of XML and Service-Oriented Architectures in this space as well as look at things like JSON, RSS and RDF. This part of the talk will be more conceptual and should be accessible to geeks and non-geeks alike.

By Brian Sletten

Following on the overview of part I, we will introduce a slew of emerging technologies that are starting to make tomorrow's integration strategies available today. Come explore technologies that allow real mashups to function on both the web and the Enterprise. We can use a variety of languages and tools to link legacy data and modern content sources. We will explore resource-oriented computing as a new way of building systems that manage information spaces, not code.

We will look at research projects like Simile from MIT, open source projects like Aperture, metadata storage systems like Mulgara and scalable orchestration environments like NetKernel. What happens when you mix the concepts of REST with Unix Pipes and Service-oriented architectures? What happens when you leverage the power of the web as a global data source in the context of your own day-to-day activities? What happens when you have an open world data model applied to the world of information resources?

This second talk will be more technical and hand's on. We will cover a lot of material so beginner technologists may get a little overwhelmed, but if they are patient and willing to go with

By Venkat Subramaniam

Developing Ajax applications is a lot of fun, up until things stop working. In addition to the general programming complexities, you need to deal with browser differences, JavaScript and framework idiosyncrasies. Alerts often help only to get our blood pressure high.

In this presentation we will take a two prong approach to addressing this issue. The first is a proactive step towards testing Ajax applications. Second, when bugs still manage to creep up, we will explore what tools can help us to fix those bugs and keep our cool at the same time.

By Tom Ball and Nandini Ramani

The talk will provide an introduction to GUI development with JavaFX Script, a new object-oriented, declarative programming language for the Java Platform. JavaFX Script is a statically-typed language, with compile-time error reporting and has type inference, declarative syntax, and automatic data binding with full support for 2-D graphics and standard Swing components as well as declarative animation. You can also import Java classes, create new Java objects, call their methods, and implement Java interfaces. IDE plug-ins are available for both the NetBeans IDE and Eclipse. Both plug-ins support as-you-type validation, code completion, syntax highlighting, and hyperlink navigation (with Control-mouseover).

JavaFX Script attempts to demonstrate that we're not exploiting the full

capabilities of the Java platform for GUI development and that, together

with supporting tools such as JavaFX, the Java platform is highly

competitive with or superior to competing GUI development platforms such

as Adobe Apollo, Ajax/DHMTL Macromedia Flash/Flex/Open Laszlo, Microsoft

WPF/XAML, and Mozilla XUL.

By Ron Bodkin

You know AJAX can improve Web application usability, but only if designed properly.

This session looks at common anti-patterns, tools for measuring performance and scalability in development and in production, and ways to improve performance and scalability

By Ron Bodkin

Rich Web apps often need to combine information from different DNS domains, though needs vary from visual mash-ups to deep integration.

This presentation looks at current and emerging security models for storing state and allowing communication across domains with JavaScript, DOM, Images, and Flash Shared Objects.

By Ryan Breen

Ajax continues to raise user expectations for interactivity and performance, and developers are increasingly treating Ajax as a must-have component of their web applications. As more code is moved client-side and the network model changes, the community is responding by building open source and commercial tools to address the unique performance challenges of Ajax .

In this talk, Ryan discusses tools and techniques for managing the performance of Ajax applications along the lifecycle of the product: at development time using tools such as Selenium and Firebug and once the application is in production via JavaScript instrumentation (such as Firebug or Dojo profile calls) to pinpoint bottlenecks in code running within the end user's browser.

By Ludovic Champenois and Greg Murray

Creating a breathtaking user interface requires that you and your team are skilled in JavaScript, Cascading Style Sheets (CSS), and Ajax interactions. This session will discuss how you can use Project jMaki (or just the ideas behind it) to create JavaScript-centric user interfaces that are developer and designer friendly. Project jMaki is an open-source client/server framework hosted on java.net that is focused on creating JavaScript-centric web applications. jMaki promotes a clean separation of JavaScript, CSS, and template code following the web design approach widely known as ?unobtrusive JavaScript?. This session will include a technical discussion of the architecture and features of jMaki including JavaScript toolkit interoperability, widget design, using layouts, wiring JavaScript functionality together, and service/data integration.

This session will include a technical discussion of the architecture and features including JavaScript toolkit interoperability, widget design, using layouts, wiring JavaScript functionality together, and service/data integration . This session will focus creating JavaScript functionality that is both re-usable and designer friendly.

By Douglas Crockford

Hidden deep inside of JavaScript is an elegantly beautiful programming language.

In this session, Ajaxmage Douglas Crockford shows how to peel away the layers of cruft and good intentions to reveal the true nature and power of the language.

By Douglas Crockford

With Ajax, a name was given to immediately interactive distributed applications, and the focus of innovation has moved from the browser makers to the web developers. We are seeing now an explosion of application patterns and styles.

In some cases, the demands of Ajax developers have gotten significantly ahead of the browsers. How will we manage large applications? How will we manage offline usage? How will we manage security when the browser's security model is hopelessly out of date?

By Douglas Crockford

JSON is quickly becoming the world's most popular data interchange format. It is simple, textual, and is able to represent the data structures used in modern programming languages.

We will look at JSON, past and future, including some important recent developments.

By Scott Davis

Yahoo! is a company that eats its own dog food. They open sourced the Ajax code that drives many of their own websites, including their eponymous homepage, Yahoo! Mail, and Yahoo! News. Come see first hand how the various pieces of the library work together as a seamless whole.

We'll look at some of the everyday useful widgets like the onscreen JavaScript logger (which effectively brings Log4J-style logging to JavaScript) and the calendar components. We'll see how event handling is managed in a cross-brower fashion. We'll look at tabbed interfaces, multi-level menus, and panels and dialog boxes that end up making your website look more like a OS-level desktop than a traditional webpage.

The YUI library is included with the Grails web framework. It certainly works in all of the major frameworks as well, but the easy bootstrapping of Grails combined with the power of YUI library makes for the quickest way to get started with a minimum of hassle. No previous Groovy or Grails experience is required, so come to learn a little about all of these. Any experience JEE developer will feel right at home since Grails uses Spring and Hibernate under the covers.

By Scott Davis

Based on the book GIS for Web Developers, this talk demonstrates how you can build your own Google Maps in-house using nothing but open source software. We also discuss integrating free, public domain data from sources like the US Census Bureau and the USGS. If you're looking for real-world examples of AJAX in use, you'll find it here. If you're looking for real-world examples of web services in use, you'll find it here.

We'll start by exploring free datasets out there in the wild. They are stored in a myriad of file formats (some proprietary, some open) and projections. Free tools like GDAL and QGIS make it easy to convert them and visualize them. Once the data is normalized, we'll store it in a PostgreSQL/PostGIS database. Not only does the database centralize the mapping data, it opens up quite a few interesting querying capabilities.

Serving up the data is the final piece of the puzzle. We'll look at web services based on the OGC (Open Geospatial Consortium) standards. We'll use Tomcat and the GeoServer WAR to expose our data via OGC interfaces. We'll look at a couple of Ajax-based mapping frameworks (MapBuilder and OpenLayers) that truly bring the power of a Google Maps-like website to your own in-house application.

If you've had no previous mapping experience, this talk breaks the domain down into easy to understand concepts. You'll come out with a better understanding of the challenges and rewards of hosting your own web mapping infrastructure.

By Keith Donald

Gone are the days of page-centric web UIs that look like they were written in 1994, making the user "click and wait" repeatedly. To compete today, techniques should be used judiciously to deliver interactive, responsive, task-oriented web applications that look-and-feel like desktop applications.

In this session, Keith will explore how those in the Spring community are combining emerging UI libraries with Spring to make web applications look-and-feel like desktop applications. You will gain insight into the common "web stacks" employed today by Springers, and see examples of how to use those stacks to:

Drop-in reusable UI components anywhere on a page that can be called into asynchronously

Implement rich web forms with as-you-type validation constraints

Integrate components such as clickable tables and lists with built-in paging capabilities

Automate the binding of asynchronous form submissions to backing domains objects for server-side processing

Improve overall web application perf

By Nicholas Eddy

This presentation will look at the use of new technology that enabled developers to create sophisticated web applications with unprecedented control over rendering, the event model and abstraction. Current frameworks smooth out inconsistencies between browsers to allow cross-platform development, but none provide developers with capabilities to develop in higher abstractions. My discussion would focus on how this new tech allows developers to create rich applications with complete control over look-and-feel without ever dealing with elements or browser events directly. This means applications created using these design principles can be written once to run everywhere. In addition, developers can have control over domains that have traditionally been owned by the browser, like scrollbars, mouse and keyboard/focus handling. Developers are able to create completely unrestrained applications when giving this level of control. Designers have more control since applications can be skinned on a deeper level than currently available. UI developers are now able to complete change look-and-feel (change DOM structure freely) without ever consulting an application developer.

This leads to natural role separation in the development process and engenders more stable application level software where business logic can remain consistent while UI level software becomes malleable in new and exciting ways. A classic example of this is the ability to change a scrollbar's look from a solid rectangle (using simple divs) to a glossy, rounded tube (using images) without any modifications to the event code written to handle mouse inputs for that scrollbar.

By Jon Ferraiolo

Jon will provide an update on the latest news from OpenAjax Alliance, an organization of more than 80 leading companies and open source projects that are working together to define Ajax standards that promote Ajax interoperability and customer success.

The talk will explain the role of OpenAjax Alliance within the Ajax ecosystem and highlight its recent accomplishments and current activities. There will be a special focus on the OpenAjax Hub, the first major standard to emerge out of OpenAjax Alliance. The Hub is a small amount of client-side JavaScript that allows multiple Ajax toolkits to participate on the same Web page, such as within a mashup. The talk will also highlight other important activities at OpenAjax Alliance, such as standards activities around Ajax IDEs, Mobile Ajax, Ajax Security, Comet-based client-server communications, the OpenAjax Registry, and runtime performance monitoring.

By Jesse James Garrett

Having trouble separating hype from reality? Where is the Web really headed?

In this presentation, Jesse James Garrett looks at the deeper trends driving the latest innovations in Web development and considers the broader implications for the skill sets that Web teams will need to invest in to successfully leverage emerging Web techniques and technologies.

By David Geary

A spinoff of Ruby on Rails, Prototype is a JavaScript framework that makes it easy to implement Ajax functionality. Script.aculo.us and Rico are frameworks built on top of Prototype that provide high-level functionality, such as special effects and drag and drop.

In this session, you will learn how to take advantage of: Prototype's Ajax capabilities, including Ajax requests, updates, and periodic updates; Script.aculo.us effects, controls, and drag and drop; and Rico accordions. In addition to learning how to use those frameworks, you will also learn about some pitfalls that you may run into when using them. Come see how to take advantage of these killer JavaScript frameworks.

By David Geary

JavaServer Faces, with a mature component model and flexible lifecyle, is a perfect platform for implementing Web 2.0 user interfaces with Ajax. This session explores how you can use JSF and Ajax to create applications that act like desktop applications but run in a browser.

We'll start with a quick look at implementing basic Ajax in a JSF application. Then, once your bloodthirst has been slaked, we'll dive deeper into Ajaxian Faces dynamics with a form completion demo that requires its implementor to understand two simple, but vital facts about JSF.

If you're savvy, you probably use client-side validation to augment your server side validation logic, which parenthetically, is no no-brainer in either of the leading web application frameworks, JSF or Rails. But anyway, client-side validation is old school. All the cool developers nowadays use Ajax to implement realtime validation, where you sneak a trip to the server as an unwary user types into your input fields. But to accomplish that, we'll have to dive even deeper into JSF, with concerns such as accessing view state and accounting for client-side state saving.

All of this Ajax development is great fun, but most of it is best relegated to components and frameworks, which are the topics that will wrap up our session. We'll see how to keep your JavaScript separate from your JSF components and how to pass JSP tag attributes all the way through to JavaScript. Finally, we'll take a quick look at the Ajax support provided by the Struts Shale framework.

As web developers, we've been handcuffed long enough by the shackles of Web 1.0 development. Come to this session and see the brave new world of Web 2.0 development with one of the hottest web application frameworks.

By David Geary

The Google Web Toolkit (GWT) is truly a revolutionary framework that lets you develop Ajaxified web applications without knowing anything about Ajax or JavaScript. But the GWT goes way beyond basic Ajax by letting you implement desktop-like applications that run in the ubiquitous browser.

In this, the first of a two-part session on the GWT, you will learn about the framework and its fundamental capabilities, such as: rapid development with project and application generators; the GWT widget hierarchy; remote procedure calls; the GWT's history mechanism, including its integration with the Back button and bookmarks; and integrating JavaScript frameworks, such as Script.aculo.us, with your GWT applications.

By David Geary

In the second part of this talk, you will learn how to extend the GWT by implementing custom widgets, including a scrolling viewport and a drag and drop framework. After discussing custom widgets, you will see how to integrate database access into your GWT applications, and how to deploy your GWT applications to external servers.

You will also learn how to integrate GWT widgets into legacy applications built with web application frameworks such as Struts, JavaServer Faces, or Tapestry. The GWT is one of the most powerful Ajax frameworks on the planet, and one of the few that let you easily implement desktop-like applications that run in a browser, and because of that, it has gained incredible mindshare in a short period of time. Come to these two sessions on the GWT and see what all the buzz is all about.

By Nate Grover

Learn how to build components that persist easily and evolve well. Architectural and design considerations for building rich web components. Ensuring that the components are agnostic about the data source.

Building frameworks that minimize refactoring costs down the road. Also, preparing for javascript 2.0 and the porting of old components.

By Aaron Gustafson

In this session, we will explore forms from top to bottom, examining how they work and how their components can be incorporated with other elements to maximize accessibility, improve semantics, and allow for more flexible styling.

Come and join us!

By Aaron Gustafson

When JavaScript and Ajax go bad, your users aren't the only ones who lose out... Every descision we make in the process of building our websites, applications, and interfaces contributes to the overall experience a user has. Sometimes, in our rush to ride the latest wave in interaction design, we miss the mark and end up doing more harm than good.

This session will explore several failures in interaction design before introducing you to a developmental process which will ensure every experience you create is a good one.

By Clint Hall

With more than 1,500 clients worldwide, Cerner is the leading supplier of healthcare information technology. With over 57 solutions, deep knowledge and functionality, delivering an effective experience through the web is imperative. This case study will describe how our approach to rich web solutions has evolved, and will demonstrate a web prototyping approach that simulates not only server-supported AJAX, but also graceful degradation and even platform and browser independence. The goal of this session will not only be to share the unique experience, but to explore how this approach contrasts with those of the attendees as well.

The session will demonstrate our recent advances in prototyping web solutions, where one set of static HTML and JavaScript files provides a database, simulates live AJAX calls, demonstrates graceful degradation through loss of CSS and JavaScript, and provides tactile feedback to Designers and Engineers. The session will also delve into a portion of our unique Component Rendering System (CRS), which allows teams to revise and share UI objects (even large portions of workflow), quickly and passively across our vast catalog of solutions. Finally, it will discuss coping with delivering a rich experience through the HTTPS constraint, and together we will theorize what popular libraries and framew

By Stuart Halloway

This presentation covers JavaScript from the perspective of an Ajax programmer. We assume that you may be using an Ajax toolkit, but still need to be able to read, modify, and test the JavaScript code in your application. You will learn the common idioms of JavaScript by looking at working code from the Ajax toolkits themselves.

All Ajax programmers need to know JavaScript. Toolkits will do some of the work for you, but your own JavaScript will differentiate your applications from others. A reading knowledge of JavaScript is also necessary when selecting an Ajax framework, and for testing and debugging applications.

We'll go straight to the interesting parts of JavaScript programming:

* Prototype-based inheritance

* Functional style

* Dynamic evaluation

* In-browser testing

We'll demonstrate these concepts using popular Ajax frameworks such as Dojo, Prototype, script.aculo.us.

By Stuart Halloway

Prototype and Scriptaculous may be the most popular combination in the Ajax world. In this presentation, you will learn to simplify Ajax development with Prototype and Scripty as we work through a series of examples.

Examples will include:

* using Ajax.Request to manage XMLHTTPRequest

* automatically updating pages with Ajax.Updater

* polling with PeriodicalExecuter

* managing forms with Form.serialize

* responding to inputs with Event.observe

* sifting the DOM with $ and $$

* simplifying DOM updates with Insertion

* creating and combining core effects

* CSS-driven effects with morph

* autocompletion

* sortable containers

* sound

By Stuart Halloway

Building on the in-depth examination of the Prototype library from Prototype: Ajax and JavaScript ++, this session delves into the corners of Prototype that modify the DOM API and JavaScript's built-in types.

We'll examine the way JavaScript extends the DOM Element class, and provides wrappers around forms for easy manipulation.

By Stuart Halloway

Scriptaculous is one of the most popular JavaScript effect and widget frameworks.

In this talk, you will learn to use all of Scriptaculous' core functions:

* Simplify user input with Autocompleter

* Combine show and edit with InPlaceEditor

* Manage collections with Draggable, Droppable, and Sortable

* Emphasize content with built-in Effects

* Build your own custom Effects

* Select points along a Slider

We will also look under the hood at how Scriptaculous works, and how you can use Scriptaculous' unit tests to test your own JavaScript code.

By Josh Holmes

Silverlight is the latest in the continuum of technologies from Microsoft to help you create differentiated user experience in the supplemented web space. Based on XAML (eXtensible Application Markup Language) for its UI and backed by a number of different options for logic including JavaScript, C#, Visual Basic, IronPython or IronRuby- it's a exciting new tool in the back of tricks for any web developer.

Silverlight brings with it a rich networking stack, fantastic media support, scalable vector graphics and much more on both Windows and the Mac in all of the major browsers including IE, FireFox, Safari and Opera. In this session, we will explore the boundaries of Silverlight, see the hosting options and integration points with your preferred technology stack.

By Kevin Hoyt

The term "rich" has numerous definitions and is highly subjective when the topic is user interface design.

In this talk we'll take a look back through time to reflect on the history of user experience, explore how web developers currently define "rich", and postulate about how users might interact with rich experiences in the near future. Along the way we?ll get a visual demonstration of why experience matters, and take a closer look at its impact on business competition.

By Kevin Hoyt

In this session, designers will learn first hand how to navigate the Ajax world with ease.

You'll discover how to load, sort and filter data from the client. You'll add advanced UI controls such as accordions, tabs and auto-suggest fields. You'll jazz up content with fancy effects such as fade, resize and shake. And you'll do it all with virtually no JavaScript

whatsoever!

By Sean Kane

This presentation will detail the innovative Netflix website features and how they came to be a part of the user experience. Following a handful of features, this will take you through the development process, from concept to qualitative and quantitative testing, out to launch. Including recent tests, this presentation will highlight design successes and give some insight to some of the ideas that were left behind.

Netflix, the world's leading online DVD rental service, has a long history of delivering one of the most simple and elegant user experiences on the web. It has proven essential to provide a highly personalized web experience to millions of Netflix members. Netflix invented the now ubiquitous 5-Star Rating widget interaction that is used across the web today. The continued use of Ajax and other rich web technologies has been core to the Netflix experience ever since.

This presentation will detail the innovative Netflix website features and how they came to be a part of the user experience. Following a handful of features, this will take you through the development process, from concept to q

By Mark Meeker

Can't we all just get along? Introducing Ajax and making a site accessible each present their own unique challenges to development teams. Most see these as being in direct competition with each other. But, by embracing some new development approaches they can end up being complementary. We will look at how best to tackle making Ajax-based features accessible and point out some of the added benefits that come with taking such approaches.

Come Learn how to build rich interactive sites that still remain accessible. This session will start by debunking some common Ajax related accessibility myths, then look at how to make common Ajax patterns accessible and finally cover what's the future holds in this area.

By Mark Meeker

Microformats may be small, but they are starting to appear everywhere. You likely visit sites daily that are enabled with microformats. They are used to make contact details, events, reviews, and other everyday data more available to you as both a user and as a developer.

Learn what sites are already using of microformats and how you can take advantage of them. Also learn how easy it is to enable your site with microformats for others to use by making each page of your site an API with only minor markup changes.

In this session you will learn: what exactly microformats are, where they can found on the web, why they are a useful addition to a site and (most importantly) how to add them to yours.

By Eric Miller

It is not Web 2.0, 3.0, or 4.0. It is THE Web. This is a feature, not a bug. This talk will look back in time as a means of predicting the future and debunk certain myths created by popular media about the various versions of the Web. More importantly, this talk will demonstrate how underlying Web-based data integration standards coupled with flexible front-end architectures are being used for more effective personal, group and corporate information management on a range of devices. This pairing results in an Internet Experience that is rich on both the front and back ends.

This talk will discuss where we are in achieving this goal, what is still required and where some of the bodies are buried that were lost along the way.

By Eric Miraglia

Yahoo! released the Yahoo User Interface Library (YUI) as a free, open-source JavaScript and CSS library eighteen months ago along with a commitment to the developer community: We'll share with you our best frontend tools, engage with you about how they're built and why, and we'll document them fully. In that short time, YUI has become one of the best-regarded frontend libraries and has been adopted by individuals on their blogs, startups who are going all-in with YUI as the foundation of their frontend architecture, and Fortune 500 companies using YUI as a trusted, tested, long-view toolkit for creating great user-experiences on the web.

In this session, we'll look closely at the state of YUI today:

1. How is YUI organized around the challenges of CSS and JavaScript as they manifest in rich web applications?

2. What problems does YUI solve?

3. What does YUI offer as a foundation for your own development?

4. How can you deploy YUI to best effect with respect to accessibility, performance, and scalability?

Throughout, we'll look at specific examples with code and hear from the developers behind YUI as well as implementers who are using YUI to build their businesses. You'll leave with a deep understanding of what YUI is, what its development philosophies are, and whether it's a good choice for your own projects.

By Greg Murray

Java technology is the base for many web application frameworks which up until recently have focused on having the application control and state on the server. The emergence of AJAX does not require that you scrap all of your web applications though it does cause us to think differently in how we design and manage your applications. This presentation will address using Java technologies such as Servlets, JavaServer Pages , and JavaServer Faces to create interactive AJAX applications. This presentation will address the programming model, including guidelines, patterns, and APIs for using AJAX in existing web applications and discuss how to leverage AJAX libraries and frameworks with Java.

In conclusion, this presentation will show how Java and JavaScript may be used together to build robust AJAX centric enterprise applications and how the Java web tier technologies are evolving to make the development of AJAX applications available to the masses.

By Greg Murray

As server-side developers developing Ajax applications we are finding ourselves dealing with more CSS and JavaScript, a role generally handled by a web designer. This session will focus on the underlining principles of web design from the perspective of a server side application developer.

Topics to be discussed include document types, CSS, and Ajax/DHML using current techniques. This session will explore how to clearly delineate application behavior, content, and logic using standard techniques. Performance implications related to web design along with overcoming browser compatibility issues will also be discussed. The objective of this session is to give server-side developers the basic web design skills to create better interfaces that web designers could later update without having to re-write.

By Aza Raskin

To err is human. We make mistakes. Our users make mistakes. It's a fact that our interfaces must handle gracefully. The first law of interface design is that "A computer shall not harm your work or, through inaction, allow your work to come to harm", yet the interfaces we design routinely ignore this idea. Is it possible to design interfaces that are so fault tolerant that no matter how many mistakes we make, that our work will never got lost?

Learn how to use transparent messages, non-modal dialogs, and undo on your websites.

By Rick Ross and Matt Schmidt

DZone is a social bookmarking community focused on developers and has tried to use the latest in web development strategies and standards. In this case study, the DZone team will share their insight and experience with building a large scale Web 2.0 community. .

Based on the feedback gathered from the community since starting DZone, this talk will cover what went right, what could have gone better, and what problems have had to be overcome. The team will also share some of their thoughts on the future of rich web development and where some of the latest technology releases from Adobe, Microsoft and Sun fit into a community like DZone

By Alex Russell

The web standards crowd is hurting you, your users, and the Open Web. While other speakers will paint a rosy picture of standards, this talk will explore the dark side of standards and explain why Ajax (nee DHTML) developers have long chuckled quietly when well-meaning developers explain how semantic markup and CSS will save us.

We'll also talk about how browser vendors have let us down, why Ajax toolkits shouldn't be necessaray, and how the web development community can clear the collective haze of web standards and semantic web zealotry.

By Alex Russell

Recipes for developing and optimizing large applications with dojo.

In this talk we'll touch on a variety of dojo topics including using dojo's RPC mechanisms, Deferreds and DeferredLists, creating Dojo builds and other useful techniques for making large single page applications perform well in a browser environment.

By Dean H. Saxe

In this seminar we'll examine the security concerns around Ajax applications, how they are exploited and how developers can mitigate the risks to their applications. Ajax security begins with a discussion of the Same Origin Policy (SOP) of JavaScript, this is one of the key security features of JavaScript. Next, we'll examine authentication and authorization concerns with Ajax and how the developer can avoid common pitfalls.

The remainder of the talk will focus on the role of data validation in Ajax based applications. We'll examine how attackers may abuse Ajax applications designed to bypass the SOP (i.e. mash-ups using Ajax proxies), dynamic code injection attacks and proper serialization/deserialization of XML and JSON data.

By Dean H. Saxe

See the hacker's toolbox in action as various web applications are ripped open by exploiting simple software bugs. Common problems such as Cross-Site Scripting (XSS) and SQL Injection will be demonstrated and explained, along with more subtle vulnerabilities including privilege escalation, data tampering, and Cross-Site Request Forgery. Even if you've seen XSS and SQL Injection before, advanced techniques will be presented that can slip through many protections.

As a finale, the "holy grail" of web security will be broken with a Man-In-The-Middle attack on SSL. Although countermeasures are briefly covered, this is first and foremost a "shock and awe" presentation that will motivate you to secure your applications. Attendees will receive a CD with all the "Hacme" applications used during the presentation so you can practice your new "skillz".

By Bill Scott

In this talk, Bill Scott will first survey a range of tools & techniques for prototypying. Then getting inspiration from his work on Design Patterns, Bill will introduce a new toolkit focused solely on prototyping. Protoscript is a simplified scripting language for creating Ajax style prototypes for the Web. With Protoscript you can easily connect interface elements to to behaviors (think patterns) and wire them to events to create complex interactions on the fly.

Bill will walk through how to prototype with protoscript and discuss future directions for this open source project.

Protoscript will be launched and live at the start of the conference.

By Bill Scott

Sometimes it is most instructive to look at design patterns in reverse-- as a set of anti-patterns. In this new talk, Bill Scott will explore the common mistakes that designers & developers make when attempting to craft a rich web experience.

Bill will use counter-examples from consumer facing web sites (both inside & outside of Yahoo!) as well as from enterprise web applications to illustrate the right way to design.

Anti-Patterns include: meandering way. borg idiom. tiny targets.hover and cover. pogo stick navigation. novel notions. metaphor mismatch. double duty. linkitus. windows aplenty. animation gone wild. misguided misdirections. missed moments. one at a time. non-symmetrical actions.

By Deryk Sinotte

While Ajax development can be challenging in its own right, incorporating Ajax techniques in a portal environment poses a host of additional challenges to the developer.

This session begins with an overview of the fundamental challenges related to Ajax in the portal environment including markup namespacing, JavaScript library collision, Ajax server request handling, coexistence of Ajax and non-Ajax portlets, and multiple Ajax Push connections. Then, attendees will see how these challenges have been addressed with JSF and the open source ICEfaces technology. Finally, the session concludes with a walk-through of an actual Ajax Portlet, showing the major development and deployment steps required.

By Steve Souders and Tenni Theurer

Yahoo!'s Exceptional Performance team has identified 14 best practices for making web pages faster through a series of research studies on Yahoo!'s properties. These guidelines focus on the front end, for example, why it's bad to use "@import" for including stylesheets and why ETags disable browser caching. These best practices have proven to reduce response times of Yahoo! properties by 25-50%. We focus on the front end because that's where 80-90% of the end-user response time is spent. This "80-90% front end" phenomenon is not isolated to just Yahoo!. It holds true for most web sites, including the ten most-visited U.S. web sites.

In any optimization effort it's critical to profile current performance to identify where the greatest improvement can be made. It's clear that the place to focus for fast web pages is the front end:

There is more potential for improvement by focusing on the front end. Making the back-end twice as fast reduces response times by 5-10%, whereas making the front end twice as fast saves 40-45%.

Front end improvements typically require less time and resources than back-end performance projects.

Focusing on front end improvements has proven to work. Over fifty teams at Yahoo! have reduced their end-user response times by following the best practices described here.

As web applications evolve t

By Etienne Studer

Productivity is about more than just hard work. It's about using tools that intelligently amplify your abilities, speed up your progress, and handle time-consuming tasks for you, so you can focus on the work ahead while having great pleasure writing high-quality code.

This presentation, mixed with various live demonstrations, focuses on how your IDE should serve you, anticipate your needs, and help you to develop at the speed of thought. We are going to cover various topics - by looking at code examples - like unobtrusive assistance, predictive code editing, smart navigation, refactoring support, real-time code analysis, and how these powerful features apply to web application development (HTML, CSS, JavaScript, JSP, Spring, GWT, Grails, etc.), spending most of the time on live-action code crunching and some on the philosophy of productive coding. The concepts will be demonstrated using IntelliJ IDEA.

Overall, if you would like to know how a state-of-the

By David Verba

AJAX, new application frameworks and more iterative development processes means that many developers find themselves working more closely with designers or even being charged with design themselves. You know that a great user experience is key but how can make sure your project is a success?

In this session, we will survey principals of visual design, interaction design, information architecture and user research. Using these concepts as a foundation, we will discuss important design issues with an emphasis on Ajax, leading to methods to address them. Whether you need to work with a designer or do the work yourself, you will leave this session with resources, ideas, and examples you can apply immediately.

By David Verba

With Ajax, RIA's and agile development, we increasingly hear about the value of prototypes. In this session we will survey several different types of prototypes and the correct audience for each before discussing the advantages and disadvantages of incorporating interactive prototypes into your development process.

Once the groundwork is laid, we will dive into specific techniques and methods for creating prototypes along with examples of each.

By Joe Walker

The security landscape has changed dramatically in the past 12 months. Unless you are aware of CSRF, Javascript Highjacking, and the many ways to fool an XSS filter, it's likely that your web application will not be secure. Attackers used to concentrate on ActiveX, but now Javascript, CSS and even simple HTML elements have are used against websites.

This session will outline the challenges facing the inhabitants of this strange world called 'web 2.0' and the options for protection, both from the point of view of site owners, and web users.

By Joe Walker

This presentation digs into many advanced DWR features such as Reverse Ajax and the JavaScript proxy APIs. We start with a simple web-based multiplayer game, and illustrate how straightforward it is to create advanced effects with minimal coding. By demonstrating advanced page manipulation and server-based control of browsers, the game shows how to update any web application to react to server changes.

We will look at how DWR integrates with other Ajax libraries like TIBCO GI, Scriptaculous, and the Open Ajax Hub.

By James Ward

With so much invested in their established Web presence, enterprises may be reluctant to change the status quo. Nevertheless, enterprises face a growing need to engage meaningfully with their customers ? to build and maintain brand recognition, to strengthen customer loyalty and satisfaction, and to drive competitive differentiation in today?s crowded markets.

Can you create more meaningful engagements with your customers and constituents with minimal disruption to your business? Yes. In this session, you will learn practical ways to port traditional Web and desktop applications to the kinds of rich Internet applications that create engaging user experiences.

James will use code examples and extensive demos to guide you

through the porting process. Using a real-use case example, he will show

you how to port an HTML- and Java-based CRM system to a RIA based on

Adobe Flex and AIR.

Outline:

Why are we rebuilding... AGAIN?

- Discuss motivators for moving to RIA

How do we begin?

- Think SOA: Define your applications in terms of services

- Think about the User Experience

Then what?

- Build a UI prototype

- Build it fast, don't worry about connecting to the back-end

- Test it with users

- Refactor it until it's right

Make it work

Connect the RIA to the back-end

Now do this live with real code for a CRM application

By James Ward

This workshop is hands-on coding where you will learn how to build Rich Internet Applications for the web and for the Desktop. Attendees should bring their laptops loaded with the Flex Builder 3 Beta from labs.adobe.com.

Topics which will be covered:

- Basics of Flex and Flex Builder

- Basics of MXML and ActionScript

- Communicating with the back-end

- Skinning and Styling

- Effects and Transitions

- Custom Components

- Advanced Architecture

By Greg Wilkins

Subtitle: The Bayeux protocol and standardization efforts from the Open Ajax Alliance.

Communication for Comet (or Ajax Push) remain a problematic issue for deploying scalable Ajax applications. This talk looks at two related efforts to deal with the many concerns of Ajax Comet communications. The Bayeux protocol from the Dojo foundation is multi channel event bus that spans client and server over a variety of Ajax transports. The protocol has multiple implementation and aims to become a defacto standard for Ajax push communications.

The Open Ajax Alliance is an industry organization formed to deal with the interoperability issues of Ajax. Through their communications task force, the alliance is investigating common API solutions that will allow the semantics of Ajax communications to be captured without mandating a protocol solution or preventing continuing innovation in Ajax transports, interoperability and browser support.

By James Williams

Build rich-client user interfaces with Ajax, and get Ruby on Rails-like productivity with Java's standard web application framework, JavaServer Faces (JSF). In this session you will learn how to use the Seam framework, which combines the JSF and EJB3 component models, with Facelets and Ajax4jsf.

Seam is Java's answer to Ruby on Rails, providing incredible productivity and seamless database integration; Facelets is a replacement for JavaServer Pages that combines some of the best features of Tiles, JSTL, and Tapestry; and Ajax4jsf is a popular tag library that integrates Ajax functionality with JSF with no JavaScript required. Come see how this stack of

technologies enables rapid development of rich-client web applications.

By Nicholas C. Zakas

Just because you can doesn't mean you should. Learn the techniques and pitfalls of architecting your JavaScript code for posterity in an enterprise environment. There is a huge difference between what works on your personal web site and what your employer has hired you to write. The code you create today could be touched by dozens of people tomorrow and hundreds by next month. Making sure that it can be understood, updated, and debugged is part of the value you add as a frontend engineer.

JavaScript programming is not just about being efficient, having a proper inheritance tree, or delivering on time; it's about making sound architectural decisions that will enable your code to live on long

after its creation.

By Nicholas C. Zakas

With tens or hundreds of thousands of lines of JavaScript in modern web applications, there's a lot that can go wrong. Is your application prepared for the errors that may happen when your users login? Have you properly anticipated weak points in your code as well as problems with network connections?

Although error handling is typically part of traditional server-side architectures, it is often overlooked when dealing with the client-side world of JavaScript. Learn where to anticipate errors, how to determine if they are fatal, and what to do when they occur.

Learn why it's important to look at your error handling strategy before you ever start coding as you explore case studies involving highly trafficked web sites, such as My Yahoo! and the Yahoo! home page.