Ajax applications have unique architectural challenges and opportunities. This presentation will show you how to take advantage of the Ajax's strengths, and work around its quirks.

We'll start with an overview of Ajax, and then dive right into an extended example where we add Ajax to an existing web application. Along the way we'll cover several tools that we use to aid in Ajax development: The JavaScript Shell, Firebug, and the Web Developer's Toolbar. We'll also look at two popular JavaScript Ajax libraries: Prototype and Scriptaculous.

With the example application under our belts, we'll move to a discussion of Ajax architectural questions, including:

• How do I select an Ajax library?
• What format data should my Ajax calls use: XML, JSON, HTML, or other?
• How do I handle the back button and deep linking in Ajax?

Prior exposure to Ajax and JavaScript is useful but not required.

This presentation covers JavaScript from the perspective of a Java 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 Prototype and Scriptaculous.

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 the popular Ajax frameworks Prototype and script.aculo.us.

Learn to simplify Ajax development with Prototype through a series of real-world examples. Along the way, learn to code in Prototype's modern JavaScript style, taking advantage of Prototype's extensions to JavaScript's object model

Prototype deserves its fame for Ajax support, and for easy integration with the Rails platform. In this presentation, you will learn to simplify Ajax development with Prototype as we work through a series of examples that demonstrate:

• 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
• simplifying DOM updates with Insertion

But there's more! Prototype exemplifies modern JavaScript coding style. You will see how to take advantage of "Prototype as JavaScript++" by

• using JSON for parameter passing
• defining classes with Class.create and Object.extend
• using Ruby-inspired extensions to the JavaScript object model, such as Array.each

Dependency Injection (DI) is the cornerstone of Spring. The core concept is quite simple, but (surprise!) actual practice can become complex. To take full advantage of Spring DI, you need to understand not only the basics on configuration, but also the container lifecycle model and the various hooks provided by the framework.

Topics will include

• The difference between DI and Continuous Integration
• Setter Injection
• Constructor Injection
• Factory Injection
• Bean lifecycle
• Method Injection
• Using the ApplicationContext
• Custom PropertyEditors

Spring offers developers a simpler, more robust method for configuring applications. These benefits extend to security through the ACEGI framework. ACEGI makes the otherwise daunting task of securing your application logical and straightforward. More importantly, through its support for single sign-on provision through Yale's CAS system and its ability to provide instance-level authorization, Spring extends the common security model of most J2EE apps beyond what they are traditionally capable of.

In this session, we'll explore:

• configuring ACEGI to authorize against an in-memory user list, a database, and a JAAS login module • page level authorization • method level authorization • instance level authorization • forcing HTTPS connections to secured sites • impersonation using the RunAsManager

JRuby is not one, but two great technologies: the Ruby language, and the Java Virtual Machine and libraries. In this talk you will learn the basics of programming JRuby, and how to integrate JRuby code into existing Java projects.

JRuby provides a very powerful development platform: the expressiveness and beauty of the Ruby language, with full access to the huge and powerful world of Java libraries. In this talk you will learn to use JRuby as your glue to assemble applications from Java components.

We'll start with how to call Java from Ruby. You will see how to use the high-level API, which provides proxies for Java objects. You will also see how to use the low-level API, where you can get total control via Java reflection.

Next, we'll look at some things you might want to do with JRuby: testing Java code with Test::Unit, automating development processes with Rake, and wrapping useful Java APIs. Oh, and of course, we'll build a Ruby on Rails on Java application.

Finally, we will look at the architecture of JRuby. This is useful so that you can understand what capabilities (and limitations) JRuby has today, and how these are likely to change in the future.

Learn to use Spring AOP, aspect injection. and AspectJ integration

Spring provides powerful support for Aspect-Oriented Programming (AOP), via

• Spring Advisors
• Dependency Injection for Aspects
• Integration with AspectJ

In this session you will learn to use Spring AOP in real-world settings. We'll start with the basics of programmatic pointcuts, advice, and joint points. Then, we'll integrate these into the application Spring-style, using Dependency Injection.

With the basics out of the way, we'll move to meatier questions, including:

• How (and when) should I step up to AspectJ?
• How are Aspects implemented, and what are the performance implications?
• What are the alternatives to Aspects?

Attendees will get more out of this presentation if they have a basic knowledge of Spring and Dependency Injection.