Session Schedule

By Molly Holzschlag
While CSS might be the Web's Lingua Franca of presentation and design, it's
the Front End Developer who finds that he or she has to optimize CSS
documents, manage multiple CSS documents across any number of actual Web
pages, ensure that conflicts and errors are properly addressed and
effectively work with multiple browser hacks, conditional comments and
scripts related to browser compatibility.

In this session, learn tips, tricks and insights as to how to best approach the challenges of working with CSS for web sites and apps large and small.

By Molly Holzschlag
The Web was meant to be interoperable, but as every web designer and developer knows, interoperability is the very thing we lack. As we build standards-based, flexible, accessible, well-designed sites, we find it?s the browser that gives us most of our headaches. In this session, you?ll learn to take better control not through hacks and filters, but through an understanding of why browsers work the way they do.

You?ll learn the differences in layout engines, see visual models of the DOM and learn about the process of developing a Web browser. Finally, you?ll see how their flaws and features play into our daily work, and how we can all make our lives easier by advocating for better software and implementation.

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 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 Christian Schalk
The Google AJAX APIs let you implement rich, dynamic features on your existing web sites entirely in JavaScript and HTML. Using this family of APIs you can add a map to your site, include dynamic search controls, or download and mashup feeds with just a few lines of JavaScript.

These APIs include the Google Maps API, the Google AJAX Search API, and the Google AJAX Feed API as well as some newer ones that allow you to easily translate text content, visiualize graphical data and even integrate with other popular AJAX libraries including dojo and jQuery. This talk will explore various mashups between these APIs and as well as covering how to integrate them with other non-Google mashable APIs.

By Christian Schalk
This session starts with a full review of OpenSocial technologies starting with client development with its JavaScript API followed by technical coverage of OpenSocial's server reference implementation, Apache Shindig.

After reviewing OpenSocial technologies, steps on how to integrate OpenSocial with existing other Ajax technologies will also be reviewed.

By Brian Sletten
You hear a lot of talk about rich clients, but the richness they purport to provide is predicated on having access to rich data as well as a rich user interaction style. Without the right levels of abstraction, it is hard to address and link all of the data we have to care about these days. Additionally, the web sites that do support the notion of linking require you to publish your data into TheirSpace. Forget that. You want to be able to link publicly available information to sensitive information in YourSpace.

Ever since we started doing relational joins, we've looked for ways to tie data together. The problem is, the relational model is a bit tired and doesn't move at the speed of the Net. We need schemes that integrate relational data, web pages, XML files, RSS feeds and various other sources of information.



The good news is that a slew of emerging technologies are starting to make this happen. Come explore integration strategies 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 discuss the benefits and deficiencies of XML in this space as well as look at things like JSON, RSS and RDF. We will look at research projects like Simile from MIT, metadata storage systems like Mulgara and scalable orchestration environments like NetKernel. We'll see how to create your own Yahoo Pipes-like functionality without having to publish 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?

The first talk will be an overview of the various topics and technologies that enable the rich data. The second talk will focus on how we can create powerful, user and data-driven applications with the rich data we've linked.

A lot of this will be new and on the intermediate to advanced side, but an open mind is all that is really necessary to catch what is going on.

By Brian Sletten
You hear a lot of talk about rich clients, but the richness they purport to provide is predicated on having access to rich data as well as a rich user interaction style. Without the right levels of abstraction, it is hard to address and link all of the data we have to care about these days. Additionally, the web sites that do support the notion of linking require you to publish your data into TheirSpace. Forget that. You want to be able to link publicly available information to sensitive information in YourSpace.

Ever since we started doing relational joins, we've looked for ways to tie data together. The problem is, the relational model is a bit tired and doesn't move at the speed of the Net. We need schemes that integrate relational data, web pages, XML files, RSS feeds and various other sources of information.

The good news is that a slew of emerging technologies are starting to make this happen. Come explore integration strategies 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 discuss the benefits and deficiencies of XML in this space as well as look at things like JSON, RSS and RDF. We will look at research projects like Simile from MIT, metadata storage systems like Mulgara and scalable orchestration environments like NetKernel. We'll see how to create your own Yahoo Pipes-like functionality without having to publish 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?

The first talk will be an overview of the various topics and technologies that enable the rich data. The second talk will focus on how we can create powerful, user and data-driven applications with the rich data we've linked.

A lot of this will be new and on the intermediate to advanced side, but an open mind is all that is really necessary to catch what is going on.

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 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 Jason Harwig
JavaScript's popularity in recent years has brought with it the attention of hackers, white and black. Both sides looking for ways to do things that weren't intended with the scripting language.

In this talk we'll look at the more popular, but also some of the interesting JavaScript security issues that could effect your applications or users. We'll use Digg.com to introduce CSRF as a case study.

By Jason Harwig
Like it or not, JavaScript is the language used for any kind of web development. Since it's the only supported language of the browser, and customers demand rich web experiences, JavaScript is the king of the web. But, increasingly complicated user interfaces require a more disciplined approach to coding in the scripting language.

JavaScript's malleable nature allow it to be used in different programming paradigms including procedural, functional, and object-oriented. Unlike Java's class-based structure, JavaScript has a prototype inheritance structure that gives it great flexibility.


This talk is intended for beginner to intermediate JavaScript programmers that don't yet have a good grasp on prototypical inheritance and JavaScript functions.

We will explore that basic prototype inheritance scheme along with library extensions that create class-like inheritance.

By Jason Harwig
I hate images. Not pictures or icons, mind you, but user interface graphics. I think that small gradient PNGs that web developers set to repeat are the spacer gifs of today. Images are hard to change, and slower to download.

Canvas is an HTML 5 standard for drawing bitmap graphics. It was created by Apple Inc, for drawing dashboard widgets. Since then all other browsers have added support (it works in IE with a JS library).

This talk covers basic drawing commands and using canvas to draw user interface elements without resorting to image files. An intermediate level of JavaScript is preferred.

By Jon Ferraiolo
This session will describe current work at OpenAjax Alliance around Ajax tooling and Ajax mashups. Ajax developer tools have been hampered by lack of interoperability among various IDEs and Ajax toolkits. This session will introduce a new XML industry standard, OpenAjax Metadata for Ajax Libraries, designed at OpenAjax Alliance's IDE committee by representatives from Adobe, Aptana, Eclipse/ATF, and Microsoft Visual Studio. This standard will result in plug&play between Ajax IDEs and toolkits. The second major topic in this session focuses on mashups. Mashups have the potential for revolutionizing the way Web applications are developed where users create their own applications, but there are interoperability challenges and security risks. In order to unleash the industry, OpenAjax Alliance has developed an open source secure mashup framework as part of OpenAjax Hub 1.1 (leveraging a set of techniques called "SMash" that were originally developed by IBM Research and allows for secure mashups that run in today's browsers) and a companion set of widget standards (OpenAjax Metadata for Widgets).

The session will introduce OpenAjax Metadata, mashups, and OpenAjax Hub 1.1, and will showcase results from the alliance’s InteropFest that where multiple leading Ajax IDEs, Ajax toolkits, mashup and widget vendors leverage these technologies to achieve secure mashups and interoperability.

By Ken Sipe
When it comes to security, the general rule is that the enemy should be in possession of your security schema / algorithm, yet due to the strength of the key, he still is denied access.



This session will start with details regarding cryptography and the creation of varies types of keys. Attendees should come away with an understanding of security keys and digital certificates, what makes a number truly random and how to leverage these concepts in Java.

By Ken Sipe
Security concerns abound... According to Gartner 75% of all attacks are at the web application tier. There has never been a more urgent time to understand the security concerns and how to apply solutions to our web applications.

This session will look through the details of threat modeling, who should do it and how does it fit into the software development life-cycle.

By Kris Zyp
In this session we look at how we can use the tools of JSON web services including Service Mapping Description (SMD) to quickly integrate JSON sources and rapidly develop applications using decoupled services for scalable high-performance standards based client server applications. We show how to use the Dojo library to easily connect to web services and build client/server applications.

We will see a demonstration of creating an application using Dojo by quickly plugging in dojo.data storage and dojo.rpc service components and using standard REST and JSON-RPC communication with a Persevere storage and JavaScript server. JSON-based storage and RPC services can easily be wired to client side code with SMDs, and we will see how Comet capabilities can easily included to provide real time views of data as well. Using open service definitions and standards based data communication allows easy client and server components to easily be interchanged without client/server lockin. We will examine scalability benefits of using JSON REST services and RESTful application state management. We will also look at best practices for security and access control in developing web client/server applications.

By Kris Zyp
In this session, we will examine several powerful forms of JSON including REST JSON, JSPON, and JSONPath, to achieve powerful capabilities with JSON. We will explore the capabilities of Ajax-accessible REST databases. The dynamic nature of non-relational databases can provide significant benefit in rapidly developing applications, and providing JavaScript object persistence. Client-side code can directly participate in database interaction with systems like CouchDB, Persevere, and ActiveResource.

We will learn how to interact with these simple interface and how to use JSONPath as a query language for JSON data stores. We see how these dynamic databases utilize JavaScript on the server for a consistent client/server JavaScript environment. We will also look at how Ajax databases affect security and provide an infrastructure for more secure web applications.

JSON Referencing conventions will also be covered as a mechanism for further expressing duplicate, circular, and cross-site referencing. There will also be a demonstration of using the Persevere open source tools to utilize these extensions to provide RESTful storage and server side JavaScript.

By Kris Zyp
With the emergence of JSON Schema and Referencing conventions, there is new potential for true distributed computing paradigms in the web by leveraging portable type definitions in combination with persistence and referencing techniques. These capabilities can be brought together for a powerful new paradigm of interoperable data and web services with coherent remote method interaction using JSON-RPC. We will see how applications can be expressed as portable persisted object graphs, and how referencing capabilities can provide a foundation for cross-site persisted object graphs and well-defined distributed applications. Mashups can be built with higher levels of coherency in a distributed persistent environment.


JSON Schema provides portable typing definitions that can be used to auto-generate layouts, forms, and other UI components. It also provides a contract for type correctness that can be validated to ensure greater levels of reliability and safety in multiple system interactions. Combining JSON Schema with referencing provides a high level of type expressibility, super setting most language type expressibility. JSON Schema with referencing also heavily utilizes the concept of shared definitions, leaning on microformats, for highly interoperable data structures that can be meaningfully passed to different agents. When combined with persisted methods, JSON Schema can also be used as a typing construct for JavaScript.

By Kris Zyp
This session will cover emerging technologies for secure cross-site mashups. We will look at new transport technologies including W3C's Access Control for Cross-site Requests, HTML 5's postMessage API, and Microsoft's XdomainRequest, and how to leverage these new features, and see how we can combine leverage new security mechanisms with the new dojox.secure framework.


We will also look at fall-back strategies that use existing browser technology like JSONP with subspace sandboxing, fragment identifier messaging, and proxied requests. Next, we will examine how to properly authenticate and authorize resource access in cross-site environments without compromising security using techniques such as explicit token authorization, double cookie submission, and OAuth, while avoiding security pitfalls like JSON hijacking. Then, we will look at emerging techniques for safely executing untrusted code from widgets and advertisements without security vulnerabilities using new JavaScript subsets like Google Caja and Adsafe. Finally, we will see how we can bring this all together to securely build mashups and load widgets, APIs, and data from other domains using the new dojox.secure module.

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
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 Mark Meeker
When Orbitz Worldwide released a new generation of its global technology platform there were some lofty goals for the UI. They wanted to build a presentation tier (HTML, CSS, JavaScript) that would meet the goals of internationalization, accessibility, have rich Ajax interactions, and be faster and easier to develop in. This session will explore the key challenges in achieving these goals, including what worked, what didn't, and what's next.


This session will cover lessons learned in areas including: usability, Ajax, accessibility, internationalization, performance and developing on large teams.

By Nathaniel Schutta
Thanks to Ajax, JavaScript is cool again and developers are taking a second look at this much maligned language. This session 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.

Thanks to Ajax, JavaScript is cool again and developers are taking a second look at this much maligned language. This session 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 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.

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
We'll pick up where Part 1 left off working in even more advanced approaches such as offline support with Google Gears.

We'll pick up where Part 1 left off working in even more advanced approaches such as offline support with Google Gears.

By Nathaniel Schutta
When Yahoo! released their User Interface Library (YUI), many designers rejoiced - one of the internet's leading properties was sharing their vast wealth of knowledge in a convenient open source package. This talk with show you how to get up and running with one of the finest libraries you'll find in the Ajax space. We'll also explore the incredibly useful Yahoo Design Pattern Library.

When Yahoo! released their User Interface Library (YUI), many designers rejoiced - one of the internet's leading properties was sharing their vast wealth of knowledge in a convenient open source package. This talk with show you how to get up and running with one of the finest libraries you'll find in the Ajax space. We'll also explore the incredibly useful Yahoo Design Pattern Library.

By Nathaniel Schutta
So you want to do some Ajax and you've rightly concluded that you don't want to build your own library. After some thought, you've settled on using Dojo - but you're not sure how to get going. This talk will introduce Dojo and discuss several ways that Ajax can improve your new or existing application.

So you want to do some Ajax and you've rightly concluded that you don't want to build your own library. After some thought, you've settled on using Dojo - but you're not sure how to get going. This talk will introduce Dojo and discuss several ways that Ajax can improve your new or existing application.

By Nathaniel Schutta
While some companies have the luxury of a full time usability team, most of us have to make do on our own. Sure, it might be easier (and more comfortable) to focus on all the hip back end goodness, but if your user interface makes users yack, your product is doomed.

This talk will provide an overview of usability from the perspective of the software engineer.

By Neal Ford
Provides a punchlist to ensure your shiny new web application is up to spec.

When you buy a new house, you tour the new property with the builder with a punchlist, finding all the fit and finish things that aren't quite right yet. You've built your web site, and it all seems to be working. Where's the punchlist for your web site? This session gives you just that: a checklist you can use to verify that your web application is ready for occupation. I cover things like where import your JavaScript and CSS, how to handle images so that they are aggressively cached, how much you should care about XHTML, and lots more. This talk will give you a fit and finish check list you can apply to your shiny new web application to see if it's up to spec.

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
Extending Selenium
Testing Ajax applications
Testing data
Testing dynamic user interface
Specialized Selenium
Future directions

By Nik Krimm
Effective testing is key to professional software development. Static code analysis is an often neglected at the UI, but can eliminate whole classes of defects and regressions, and increase confidence when refactoring. Learn how to author and use scripts to automate CSS validation, find defects in JavaScript, identify dead or missing code, and enforce global coding standards. These techniques are especially valuable for large or distributed teams.





This session will discuss theory and application of static code analysis, using real world examples from Orbitz, CheapTickets, and ebookers.com.

By Nik Krimm
Modern JavaScript libraries help abstract away cross-browser issues, and make hard things easy. However, performance is often an issue, and design choices by library vendors may have unexpected consequences downstream.


Learn real world approaches used when developing JavaScript at scale, including performance profiling, working with thousands of DOM nodes, advanced debugging techniques, and a little stunt JavaScript thrown in for good measure. Code examples will use the Prototype.js library, but concepts and techniques are broadly applicable.

By Richard Monson-Haefel
The world of desktop and web client software is about to change and for the better. Fit Clients, application platforms that combine the capabilities of Web 1.0, RIA, desktop widgets, and client/server technologies, are gaining mind share quickly and for good reason. Fit Client platforms such as Adobe AIR, Curl Nitro, Google Gears, and Mozilla Prism promise web developers the power of client/server applications, the ease of management and access of Web 1.0 applications, the cross-platform capabilities of RIA, and the holistic environment of desktop widget platforms.


Fit Clients ensure that code written to one desktop operating system (i.e. Windows, Mac, Linux) are portable across the other desktop operating systems. Without modification. Fit Client platforms promise stronger security, easier access, better performance, and a much richer experience than any desktop client technology that proceeded them. They are the future of the desktop. In this presentation, Richard Monson-Haefel, explains the advantages of Fit Client platforms and how the Fit Client platforms are having a significant and lasting impact on application development and software distribution.

By Richard Monson-Haefel
With literally hundreds of RIA products (e.g., Adobe Flash, Nexaweb, Backbase) and open source Ajax projects (e.g. Dojo, GWT, Prototype) to choose from. Picking the right RIA technology for the job requires months of research. Richard Monson-Haefel has been researching and writing about RIA alternatives for three years and has already done the research so you don't have to.

In this presentation, Richard Monson-Haefel will explain the differences between RIA alternatives and provide a framework for selecting the best product or open source project for your application. The choices for RIA technologies seem mind boggling, but after this session you'll know the market and be able to choose the right solution easily.

By Richard Worth
jQuery is one of the most popular and easy to use JavaScript frameworks. jQuery is an open source library that simplifies DOM manipulation, event handling, Ajax, and animation. The jQuery core is lean and light, while having the power and extensibility to support a rich plugin ecosystem. It also sports a concise and elegant API that is a joy to behold and use.



This session introduces jQuery and demonstrates basic and advanced use. Topics include:
* Basics: DOM Manipulation, events, Ajax, animation
* Advanced: jQuery plugin architecure. Writing your own jQuery plugin. Creating an Ajax app using jQuery and progressive enhancement.

By Richard Worth
jQuery UI, built on top of jQuery, is a complete set of behaviors and components that can be used in building Rich Internet Applications. Behaviors and components included in jQuery UI include drag-and-drop, resizing, mouse-sorting, mouse-selecting (click-select, shift-select, ctrl-select, lasso select), dialogs, sliders, tabs, trees, grids, toolbars and menus. Each component adheres to a consistent standard across API, design, behavior and theming. This minimizes the surprise and makes learning all of them as easy as learning one. Just as with jQuery, there is a plugin system in jQuery UI that allows users to easily modify/extend existing components, as well as create your own. jQuery UI is also built with themes and supports custom themes, for consistency with existing sites/applications.



This session covers how jQuery UI is designed and how it leverages the power, flexibility, and expressiveness of the jQuery API. A live demonstration shows you how to use some of the more common jQuery UI behaviors and components to create rich interactivity.

By Scott Davis
How optimized is your website? YSlow, a FireFox/FireBug plugin, doesn't pull any punches. It gives any website an A, B, C, D, or F rating based on 14 individual analysis points. You'll be amazed (or depressed) at what YSlow thinks of your site. In this talk, we'll walk through these points step by step, learning what Yahoo! (the creator of this utility) does to keep its web properties running as quickly as possible.

These points are nicely summarized in "High Performance Web Sites", by Steve Souders (a companion book to the plugin). The analysis points that YSlow looks at are programming language, server, and web framework agnostic. The lessons learned here are really a deep look into HTTP, taking advantage of the native capabilities of the protocol -- making the Internet work for you.

By Scott Davis
JavaScript Object Notation is becoming a familiar delivery platform for Web 2.0 content. JSON gives you all of the flexibility of a RESTful web service without the hassle of trying to deal with deeply nested, complex XML in a language that is conspicuously lacking in native XML support. In this talk, we look at popular websites (like Yahoo!) that offer JSON output. We look at client-side JavaScript code that effortlessly consumes JSON in the browser. We even look at ways to easily generate JSON from Java Servlets (using JSON.org libraries) and the native support for JSON that Grails offers out of the box.


This talk also gives us the opportunity to brush up on our JavaScript, as well as look at clever ways that JSON can work around Cross-Site Scripting issues.

By Scott Davis
Grails is a Java- and Groovy-based web framework that is built for speed. First-time developers are amazed at how quickly you can get a page-centric MVC web site up and running thanks to the scaffolding and convention over configuration that Grails provides. Advanced web developers are often pleasantly surprised at how easy it is to break out of that coarse-grained navigation model using the native Ajax support baked into the framework.

We'll start with the solid Web 1.0 foundation that Grails provides and mix in JavaScript libraries like Prototype and Scriptaculous. (Both are included with the framework.) Grails tags like remoteLink and formRemote make it easy to asynchronously replace strategic parts of the web page while leaving the whole unchanged.

There is first-class support for JSON (JavaScript Object Notation) in Grails. You'll see how easy it is to return JSON (and XML) instead of the usual HTML using the grails.converters package.

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. The Portland, Oregon Transit Authority recently migrated from a proprietary web mapping solution to the suite of 100% free and open source software discussed in this book. We look at Java-based clients, Java-based servers, and everything in between. 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 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 uDig make it easy to convert them and visualize them. Once the data is normalized, we 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 look at web services based on the OGC (Open Geospatial Consortium) standards. We use Tomcat and the GeoServer WAR to expose our data via OGC interfaces. We 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.

Who should attend? Anyone who has ever wondered how that Google Maps stuff works and how they could use something like it in their own Java-based web applications. Open source fans who like seeing public-facing success stories will be especially pleased with the wide range of FOSS tools and libraries discussed.

What should you know before attending? Not a darn thing. This talk is aimed at sharp developers who don't have lick of previous mapping experience.

By Shashank Tiwari
A brief but thorough introduction to the Adobe Flex and AIR technologies.

A quick but interesting review of 10 most useful tips for Flex application development.

By Shashank Tiwari
Real-time event driven highly responsive systems are replacing their legacy pull based counterparts in many application scenarios. Driven by the need for faster and better decision making such applications are seeing rapid adoption in many disparate domains, including financial services, healthcare, telecom and transportation. Such systems have two main elements: (1) a fast event stream processing and complex event processing engine and (2) a highly interactive and engaging user interface, which gets updated as the underlying data evolves.

In this session we will walk through the involved concepts, practical nuances and real life case studies of creating such applications. Java centric event processors and Flex and Ajax centric UIs would be discussed as a part of the case study.