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
IE8 brings with it some very interesting history as well as current realities of which we as developers must be aware.



In this session, Molly, who has recently finished an 18 month consulting project with Microsoft on the IE8 browser, will provide an overview of what happened during the
evolution of IE8; which features have been added in relation to the CSS and DOM, and most importantly: How you as a savvy developer can be rockin' ready to take on the challenges of IE8 before they become problems.

By Molly Holzschlag
As we enthusiastically embrace the many technologies that come together to create Web applications, it's important to also stay aware of the societal impact our software offers. In particular, social applications offer a foundation for improvements in all kinds of relationships. Spanning from business-oriented apps that enhance networking and economic opportunities to the more personal social applications that allow for myriad interaction, the social application deserves our attention not just as technologists, but as individuals and communities, too.

In this session a variety of social applications will be examined, with lessons from each highlighting how, as we develop all Web applications, we can easily add features that increase human potential.

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 Bill Scott
In every field of design one of the first things students do is learn from the work of others. They study and break down real-world examples in order to understand the underlying principles and patterns that make for successful design. Then they learn to apply these to their own set of problems. The real trick is to apply them in a nuanced manner. To be nuanced is "to be sensitive to delicate differences of style." Most of the art in crafting a rich experience on the Web can be summed up with this one word -- 'nuance'.

Over the last 24 years Bill has been involved in the study of nuanced design in crafting rich interfaces. Prior to joining Netflix, Bill led the effort to launch the public Yahoo! Design Pattern Library where he cataloged many examples of common design patterns. More recently Bill has been working on an upcoming O'Reilly book on design that explores the nuance of rich Web interfaces.



In this talk, Bill summarizes his study of rich interaction with just six design principles. Each principle is illustrated with a set of design patterns and real world examples. Each example is broken down to tease out the nuance of good design. In addition the not-so-good examples are illustrated as 'anti-patterns' to avoid.

The six principles discussed are:
Make it Direct
Keep it Lightweight
Stay on the Page
Offer an Invitation
Use Transitions
React Immediately

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 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 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 Greg Wilkins
The core concepts of Comet (Ajax Push) applications are not complex and most Ajax applications can be simply converted to demonstrate comet abilities. Comet applications are easy to write, but can be very hard to test, debug, scale and deploy. But for comet, demonstrating a chat room
on a test server is a long way from having a robust scalable production ready application.



This talk examines the issues that have had to be addressed when putting comet applications into production. Testing and debugging techniques are examined as well as analysis of problems discovered in the wild that escaped testing.

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
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 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 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
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
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 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 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 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
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
Ext JS is an amazing JavaScript library that's filled with customizable widgets; if your customers have ever asked for "Excel in the browser," you need to look at Ext.


This talk will explore Ext showing off a variety of widgets helping you to get up and running with this excellent toolkit.

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 Nicholas C. Zakas
The YUI Compressor does a lot of things to make your code smaller, but it's still based on a series of rules to ensure that it doesn't break your code. Understanding how the Compressor works makes it easy to write your code in particular ways to squeeze out every last byte of optimization. You can help the Compressor to do its job by using a few simple techniques.

Learn how the YUI Compressor works, what it looks for, and what prevents it from doing its job. Then, take a look at how some simple code changes can let the YUI Compressor shrink your code as small as possible.

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.

By Nicholas C. Zakas
A common step that is missing from front end development is a build step. Developers have become accustomed to the code-run two-step process that, at first, introducing a build step seems like a time sink. However, when done correctly, a adding a build step into the development process can actually improve productivity, free the developer from mundane tasks, and aid in deployment.

Learn how to free your code from arbitrary constraints using a build system to combine, compress, and deploy your JavaScript and CSS code based on freely available tools such as Ant and the YUI Compressor.

By Nicholas C. Zakas
Learn how to apply the fundamental concepts of Test Driven Development (TDD) to JavaScript using YUI's unit testing framework, YUI Test. The session explores the capabilities of YUI Test in achieving good TDD practices, including the use of assertions, organizing test suites and test cases, and testing JavaScript-specific features (such as XHR and DOM events).


In this session, you will learn how to:
Create test cases and test suites for testing your code;
Test DOM events using YUI Test event simulation;
Split tests into a series of pages that can be run sequentially;
Gather the results of the tests for posting to a server;
Use YUI Test on projects that don't use YUI.

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
For the past ten years, application developers have been stuck with only two desktop client choices: a very thin Web-client technology implemented in HTML and CSS, or a very heavyweight thick client experience implemented using traditional client/server (C/S) technologies (e.g. Java Swing, MFC). It wasn’t until the introduction of Rich Internet Application technologies (e.g. Ajax, Adobe Flex, Curl and Silverlight) and widget engines (e.g. Yahoo! Widgets and Google Gadgets) that we were given more options.

Now, these four desktop client options are beginning to converge into a single form - the Fit Client (It's not too thick and not too thin). Each of the options that preceded the Fit Client have their own benefits and are well suited for specific scenarios - the Fit Client represents the best of all these technologies. This session examines the strengths of the Fit Client and the shift in industry focus to a platform that provides the best of thin and thick client technologies.



This session covers the evolution of Web, desktop widgets, RIA and client/server technology and the emergence of the new Fit Client – which leverages the best qualities of all of these technologies. We also cover the pros and cons of using the Fit Client platforms currently available - Adobe AIR, Google Gears, Mozilla Prism, and Curl.

In this session, you will learn:
To recognize situations in which a Fit Client platform makes sense;
Which Fit Client architecture to use for specific situations;
To understand the market dynamics driving the evolution of the Fit Client;
Strengths and weakness of RIA, Web, Widgets and Client/Server technologies;
Strengths and weakness of Fit Clients, including specifics on Adobe AIR and Google Gears.

By Richard Monson-Haefel
For the past ten years, application developers have been stuck with only two desktop client choices: a very thin Web-client technology implemented in HTML and CSS, or a very heavyweight thick client experience implemented using traditional client/server (C/S) technologies (e.g. Java Swing, MFC). It wasn’t until the introduction of Rich Internet Application technologies (e.g. Ajax, Adobe Flex, Curl and Silverlight) and widget engines (e.g. Yahoo! Widgets and Google Gadgets) that we were given more options.

Now, these four desktop client options are beginning to converge into a single form - the Fit Client (It's not too thick and not too thin). Each of the options that preceded the Fit Client have their own benefits and are well suited for specific scenarios - the Fit Client represents the best of all these technologies. This session examines the strengths of the Fit Client and the shift in industry focus to a platform that provides the best of thin and thick client technologies.



This session covers the evolution of Web, desktop widgets, RIA and client/server technology and the emergence of the new Fit Client – which leverages the best qualities of all of these technologies. We also cover the pros and cons of using the Fit Client platforms currently available - Adobe AIR, Google Gears, Mozilla Prism, and Curl.

In this session, you will learn:
To recognize situations in which a Fit Client platform makes sense;
Which Fit Client architecture to use for specific situations;
To understand the market dynamics driving the evolution of the Fit Client;
Strengths and weakness of RIA, Web, Widgets and Client/Server technologies;
Strengths and weakness of Fit Clients, including specifics on Adobe AIR and Google Gears.

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 Roman Hustad
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 Roman Hustad
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 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
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.



Grails certainly works with all of the major Ajax frameworks, 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. 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.

By Steve Souders
Steve's book, High Performance Web Sites, describes the 14 best practices he developed while working as the Chief Performance Yahoo!. YSlow, the Firebug extension he created, codified those best practices.



Now working at Google, Steve discusses the next set of best practices he's discovered, including the impact of iframes and where to place (and where not to place) inline script blocks.

In this session, you will learn:
How to make your Web sites 25-50% faster;
The impact of iframes on your Web site, including blank iframes;
How inline scripts block rendering in the entire page and downloads;
What you might be doing with stylesheets that make your pages twice as slow;
The various techniques for dynamically loading JavaScript, and how they vary in how they affect the browser.