Session Schedule

By Tim Berglund

You love Groovy and you're a believer in cloud computing. For a larger project you might choose Grails and hosting on Amazon EC2, but what if you want to take advantage of the nearly massless deployments of a cloud provider like the Google App Engine? You could make Grails work, but it's not always the best fit. Enter Gaelyk.

Gaelyk is a lightweight Groovy web application framework built specifically for the Google App Engine. In this session, we'll talk through the simple abstractions it offers, then show how easy it is to code and deploy a useful application to the cloud.

By Tim Berglund

Once you've been introduced to Gaelyk and the Groovy way it wraps the services the Google App Engine, it's time to write some code. Bring your laptop for a hands-on Gaelyk hack session in which we build a working Gaelyk app utilizing as many of the GAE services as we can pack into a 180 minutes of coding!

Workshop attendees should have a laptop with the following: JDK 5+, an IDE or editor capable of editing Groovy code and HTML, the Google App Engine SDK already downloaded and installed (http://code.google.com/appengine/downloads.html#GoogleAppEngineSDKfor_Java), and the current version of the Gaelyk project template (https://github.com/glaforge/gaelyk/downloads).

Prerequisite: Gaelyk: Lightweight Groovy on the Google App Engine (or a working knowledge of Gaelyk)

By Tim Berglund

Once you've been introduced to Gaelyk and the Groovy way it wraps the services the Google App Engine, it's time to write some code. Bring your laptop for a hands-on Gaelyk hack session in which we build a working Gaelyk app utilizing as many of the GAE services as we can pack into a 180 minutes of coding!

Workshop attendees should have a laptop with the following: JDK 5+, an IDE or editor capable of editing Groovy code and HTML, the Google App Engine SDK already downloaded and installed (http://code.google.com/appengine/downloads.html#GoogleAppEngineSDKfor_Java), and the current version of the Gaelyk project template (https://github.com/glaforge/gaelyk/downloads).

Prerequisite: Gaelyk Workshop Part I

By Tim Berglund

Watch Preview Video

Grails is emerging as a standard JVM web framework in environments ranging from startups to the enterprise. It's a full-stack solution build on rock-solid components, fully relying on convention over configuration, and using the best application language the JVM has yet seen: Groovy. This is the place to be for web apps on the JVM.

In this introductory talk, we'll get a whirlwind introduction to Grails, visiting seven things you need to know about the framework to get started.

Programming in Groovy

Creating an app

Interacting with the database

Building your UI

Processing web requests

Tapping the huge plugin community

Deploying to production

By Tim Berglund

Watch Preview Video

Some systems are too large to be understood entirely by any one human mind. They are composed of a diverse array of individual components capable of interacting with each other and adapting to a changing environment. As systems, they produce behavior that differs in kind from the behavior of their components. Complexity Theory is an emerging discipline that seeks to describe such phenomena previously encountered in biology, sociology, economics, and other disciplines.

Beyond new ways of looking at ant colonies, fashion trends, and national economies, complexity theory promises powerful insights to software development. The Internet—perhaps the most valuable piece of computing infrastructure of the present day—may fit the description of a complex system. Large corporate organizations in which developers are employed have complex characteristics. In this session, we'll explore what makes a complex system, what advantages complexity has to offer us, and how to harness these in the systems we build.

By Matthew McCullough and Ben Ellingson

You're adept at Java. You've got a solid grasp of that ecosystem. But you keep hearing about iPhone this, iPad that. It worries you just a bit that you haven't yet spent the time to explore this new frontier. Cure that with a nearly Java-free intense eight hour boot camp on the iPad. During this session, you'll use your iPad device to get started coding on the XCode platform, learning the Objective-C language, testing, and deploying your apps.

No previous iPad ecosystem knowledge is assumed. Matthew McCullough and Ben Ellingson will take you from the ground up in this unique coding environment. With their hands on teaching style and one-on-one assistance, you'll explore what it takes to build and deploy an application for the iPhone and iPad devices. We'll start with a simple application that you'll code from line 1 to line 200, all the while testing it in the iPad simulator. Along the way, you'll also discover the Developer signup process and digital certificate setup required to push beta applications to the device. Finally, we will integrate an iPad app with data from a JSON web service.

By Ted Neward

Watch Preview Video

Games? What do games have to do with good business-oriented applications? Turns out, a lot of interesting little tidbits of user-interface, distribution, and emergence, found normally in the games we play, have direct implications on the way enterprise applications can (or should) be built.

Come to this session, find out some intriguing things about what’s going on in the game industry, but more importantly, how ideas from the gaming world can turn around and answer some thorny problems in the business world.

By Ted Neward

Watch Preview Video

Android is a new mobile development platform, based on the Java language and tool set, designed to allow developers to get up to speed writing mobile code on any of a number of handsets quickly. In this presentation, we'll go over the basic setup of the Android toolchain, how to deploy to a device, and basic constructs in the Android world.

Attendees should be intermediate to advanced Java developers, as no time will be spent on Java basics, just the Android parts. Attendees are encouraged to bring laptops to the session (and your Android-based device, if you have one) to fill out code as we go, but the limited time frame means a focus on fast delivery of content and example code; have your fingers warmed up (and the SDK downloaded!) before you get here. (Latest Android SDK will also be on a USB key for attendees' use, in case attendees haven't had a chance to download & install.)

By Ted Neward

Watch Preview Video

First there was iPod. Then iPhone. Then iPad. And with each new release, the mobile device market grew hotter and hotter. Now, as Google’s entry into this race, the Android system, begins to hit its stride as a competitor platform to the iOS, as a Java developer you’re intrigued—it’s Java (well, assuming you ask anybody except Oracle), and it’s a mobile device, and it’s open source, and…. What’s not to love?

In this all-day workshop, we’re going to turn you into a journeyman Android developer. This is a Java-based platform, so we’ll have a leg up on those other “Java-free” environments where you’ll have to spend half the day just learning how to count from 1 to 10 and print it to the console all over again. We’ll start by looking at the Android toolchain and how it integrates with your existing toolchain (Eclipse or otherwise). We’ll get your hands dirty writing some code to the Android emulator, then (for those of you who have Android devices handy) push it to a device. We’ll write some unit-tests for testing an Android application. We’ll look at how to store data to the device, both in a SQLit

By Ted Neward

Watch Preview Video

First there was iPod. Then iPhone. Then iPad. And with each new release, the mobile device market grew hotter and hotter. Now, as Google’s entry into this race, the Android system, begins to hit its stride as a competitor platform to the iOS, as a Java developer you’re intrigued—it’s Java (well, assuming you ask anybody except Oracle), and it’s a mobile device, and it’s open source, and…. What’s not to love?

In this all-day workshop, we’re going to turn you into a journeyman Android developer. This is a Java-based platform, so we’ll have a leg up on those other “Java-free” environments where you’ll have to spend half the day just learning how to count from 1 to 10 and print it to the console all over again. We’ll start by looking at the Android toolchain and how it integrates with your existing toolchain (Eclipse or otherwise). We’ll get your hands dirty writing some code to the Android emulator, then (for those of you who have Android devices handy) push it to a device. We’ll write some unit-tests for testing an Android application. We’ll look at how to store data to the device, both in a SQLit

By Ted Neward

Watch Preview Video

First there was iPod. Then iPhone. Then iPad. And with each new release, the mobile device market grew hotter and hotter. Now, as Google’s entry into this race, the Android system, begins to hit its stride as a competitor platform to the iOS, as a Java developer you’re intrigued—it’s Java (well, assuming you ask anybody except Oracle), and it’s a mobile device, and it’s open source, and…. What’s not to love?

In this all-day workshop, we’re going to turn you into a journeyman Android developer. This is a Java-based platform, so we’ll have a leg up on those other “Java-free” environments where you’ll have to spend half the day just learning how to count from 1 to 10 and print it to the console all over again. We’ll start by looking at the Android toolchain and how it integrates with your existing toolchain (Eclipse or otherwise). We’ll get your hands dirty writing some code to the Android emulator, then (for those of you who have Android devices handy) push it to a device. We’ll write some unit-tests for testing an Android application. We’ll look at how to store data to the device, both in a SQLit

By Pratik Patel

Bring your laptop! This is a workshop specifically designed to get you up and running with popular mobile GUI frameworks and build feature-rich application in 90 minutes! Install a good Javascript/HTML editor, Google Chrome, and Safari (or another newer Webkit based web browser) and the latest PhoneGap release. Also install the latest Android SDK. MAKE SURE YOU HAVE DONE THIS BEFORE COMING TO THE WORKSHOP. Of course, you're welcome to come watch as we work through the exercises, or pair up with a new friend. You can also install the latest iOS SDK if you have a Mac and are interested in iPhone/iPad development.

There are a number of great Javascript frameworks for creating slick-looking Mobile Web GUI's. In this session, we'll look at some of the popular ones while building a mobile GUI. We'll have a look at JQTouch, Jo, and jQuery Mobile.

This is a 90 minute workshop intended to teach you the basics of working with these mobile GUI frameworks. We'll work on several exercises as you build up a complete, feature-rich, mobile application that you can test on either Android or iOS devices. Topics we'll cover in this workshop:

* Webkit web browser

* webkit extensions

* jQTouch

** Navigation

** UI widgets

* Jo

** Navigation

** UI widgets

* jQuery Mobile

** Navigation

** UI widgets

* Creating a native app using PhoneGap

** PhoneGap overview

** Bundling your HTML/CCS/javascript in PhoneGap

** Building with PhoneGap

Prerequisite: Easy Mobile Development

By Pratik Patel

Titanium is an open-source development tool for producing cross-platform mobile applications by Appcelerator. Using Titanium, you develop your mobile application using Javascript coded against the Titanium API's. Titanium Developer, a management GUI for your mobile apps, invokes their compiler and builder to take your Javascript and build a native application for iOS and Android.

This session will walk you through the details of building great apps for the Android and iOS platforms. We'll talk about Titanium development, its ecosystem, and architecture. We'll spend time looking at lots of code - we'll build an app, in fact, while we discuss and explore the framework. We'll also spend some time discussing best practices, what to expect when developing against it, and the limits of this type of development.

By Nathaniel Schutta

While your project might have nearly 100% code coverage on the server tier, many projects ignore testing the web layer. With more and more code being pushed to the browser, a lack of tests for the client code begs for trouble.

This talk will explore several testing options including Selenium, JsUnit, Crosscheck, JSCoverage, Watir, JSLint, JSSpec and others.

By Nathaniel Schutta

Watch Preview Video

Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.

Once we've established a solid understanding of just what jQuery can do out of the box, we'll delve deeper into the plugin space. jQuery is designed to be extended and while odds are there's a plugin that meets your needs, sometimes only a homegrown solution fits. Starting with a couple of very simple examples, we'll work our way up to more full fledged widgets.

By Nathaniel Schutta

Watch Preview Video

Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.

Once we've established a solid understanding of just what jQuery can do out of the box, we'll delve deeper into the plugin space. jQuery is designed to be extended and while odds are there's a plugin that meets your needs, sometimes only a homegrown solution fits. Starting with a couple of very simple examples, we'll work our way up to more full fledged widgets.

By Nathaniel Schutta

Watch Preview Video

Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.

Once we've established a solid understanding of just what jQuery can do out of the box, we'll delve deeper into the plugin space. jQuery is designed to be extended and while odds are there's a plugin that meets your needs, sometimes only a homegrown solution fits. Starting with a couple of very simple examples, we'll work our way up to more full fledged widgets.

By Nathaniel Schutta

Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.

Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.

By Nathaniel Schutta

Day in and day out we are subjected to poorly designed applications. From those we experience directly to the time we waste waiting on others who are struggling with systems that seem like they were built to hinder the user. It doesn't have to be like this and many users are waking up and demanding better applications. Are you prepared to deliver? After this workshop, you will be. When you're done, you'll have the tools you need to make sure your application helps your users kick ass!

Usa-what now?

While most developers are schooled in algorithms and programming languages, they often lack a grounding in the fundamentals of usability; we'll start by exploring what usability is dispelling many of the myths surrounding this misunderstood aspect of software. We'll show why usability matters and help you see how it can make the difference on your projects.

The who - developing pragmatic personas.

We can't build a great UI without knowing who we're building it for. Personas are a time tested technique to help teams understand their users and facilitate building the right interface. While personas are often backed by extensive ethnographic research, they don't require months a

By Nathaniel Schutta

Day in and day out we are subjected to poorly designed applications. From those we experience directly to the time we waste waiting on others who are struggling with systems that seem like they were built to hinder the user. It doesn't have to be like this and many users are waking up and demanding better applications. Are you prepared to deliver? After this workshop, you will be. When you're done, you'll have the tools you need to make sure your application helps your users kick ass!

Usa-what now?

While most developers are schooled in algorithms and programming languages, they often lack a grounding in the fundamentals of usability; we'll start by exploring what usability is dispelling many of the myths surrounding this misunderstood aspect of software. We'll show why usability matters and help you see how it can make the difference on your projects.

The who - developing pragmatic personas.

We can't build a great UI without knowing who we're building it for. Personas are a time tested technique to help teams understand their users and facilitate building the right interface. While personas are often backed by extensive ethnographic research, they don't require months a

By Ken Sipe

1st workshop - Black Hat - Hacking

TBA

By Ken Sipe

White Hat Section

TBA

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 Brian Sletten

HTML 5 is an adventurous and confusing prospect that will help change the Web as we know it. It is being finalized as a standard but won't be fully supported by most browsers for quite some time. Companies like Apple and Google have already committed to it as the future of Web application development, however. There are a huge number of new features, updates and gotchas coming at us (including the proverbial kitchen sink!) so it is time to get prepared. This talk will walk you through the new bits and try to put it all into perspective.

Attendees will learn about HTML 5 and related specs including:

New and deprecated elements

Immediate mode 2D drawing w/ the canvas element

Timed media playback

Local storage and offline mode

Bi-directional communication sockets to servers

Messaging between documents

Drag and drop support

And much more!

There will be a lot covered but this should be accessible to anyone interested in Web development.

By Brian Sletten

People are confused about the status of HTML 5. Is it ready? Is it not? What is part of the spec and what isn't? We'll talk about the situation in the "HTML 5 and the Kitchen Sink" discussion, but as always, the proof is in the pudding. We will introduce the most exciting new features of HTML 5 and its related technologies and build examples that use them. Bring your notebook computers and a text editor and we will go from there.

We will work with real code covering:

The new input elements

Editable content

Canvas Element and its related 2D APIs for drawing and animation

Audio and Video elements and how to use fallbacks for codec coverage

Browser native drag and drop

Local storage

Web Workers

Websockets

The Geolocation API

Web DB (SQL in the browser!)

This workshop will assume no special knowledge of HTML 5 and should be accessible to any web developers.

By Brian Sletten

The Web is changing faster than you can imagine and it is going to continue to do so. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.

Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.

Whether you are jazzed or jaded, this workshop will provide you with the understanding of a technological tidal wave that is heading in your direction.

In this workshop, we will:

Explain the Web and Web architecture at a deeper level

Apply Web and Semantic Web technologies in the Enterprise and make them work together

Integrate structured and unstructured information

Create good, long-lived logical names (URIs) for information and services

Use the Resource Description Framework (RDF) to integrate documents, services and databases

Use popular RDF vocabularies such as Dublin Core, FOAF, DOAP

Query RDF and non-RDF datastores with the SPARQL query language

Use the Simple Knowledge Organization System (SKOS) to represent taxonomies in RDF

Model and Do Inference with the Web Ontology Language (OWL)

Prerequisite: Semantic Web : The Future Now would be a useful introduction but is not required

By Brian Sletten

The Web is changing faster than you can imagine and it is going to continue to do so. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.

Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.

Whether you are jazzed or jaded, this workshop will provide you with the understanding of a technological tidal wave that is heading in your direction.

In this workshop, we will:

Explain the Web and Web architecture at a deeper level

Apply Web and Semantic Web technologies in the Enterprise and make them work together

Integrate structured and unstructured information

Create good, long-lived logical names (URIs) for information and services

Use the Resource Description Framework (RDF) to integrate documents, services and databases

Use popular RDF vocabularies such as Dublin Core, FOAF, DOAP

Query RDF and non-RDF datastores with the SPARQL query language

Use the Simple Knowledge Organization System (SKOS) to represent taxonomies in RDF

Model and Do Inference with the Web Ontology Language (OWL)

Prerequisite: Semantic Web : The Future Now would be a useful introduction but is not required

By Brian Sletten

HTML 5 is an adventurous and confusing prospect that will help change the Web as we know it. It is being finalized as a standard but won't be fully supported by most browsers for quite some time. Companies like Apple and Google have already committed to it as the future of Web application development, however. There are a huge number of new features, updates and gotchas coming at us (including the proverbial kitchen sink!) so it is time to get prepared. This talk will walk you through the new bits and try to put it all into perspective.

Attendees will learn about HTML 5 and related specs including:

New and deprecated elements

Immediate mode 2D drawing w/ the canvas element

Timed media playback

Local storage and offline mode

Bi-directional communication sockets to servers

Messaging between documents

Drag and drop support

And much more!

There will be a lot covered but this should be accessible to anyone interested in Web development.

By Brian Sletten

People are confused about the status of HTML 5. Is it ready? Is it not? What is part of the spec and what isn't? We'll talk about the situation in the "HTML 5 and the Kitchen Sink" discussion, but as always, the proof is in the pudding. We will introduce the most exciting new features of HTML 5 and its related technologies and build examples that use them. Bring your notebook computers and a text editor and we will go from there.

We will work with real code covering:

The new input elements

Editable content

Canvas Element and its related 2D APIs for drawing and animation

Audio and Video elements and how to use fallbacks for codec coverage

Browser native drag and drop

Local storage

Web Workers

Websockets

The Geolocation API

Web DB (SQL in the browser!)

This workshop will assume no special knowledge of HTML 5 and should be accessible to any web developers.

By Brian Sletten

People are confused about the status of HTML 5. Is it ready? Is it not? What is part of the spec and what isn't? We'll talk about the situation in the "HTML 5 and the Kitchen Sink" discussion, but as always, the proof is in the pudding. We will introduce the most exciting new features of HTML 5 and its related technologies and build examples that use them. Bring your notebook computers and a text editor and we will go from there.

We will work with real code covering:

The new input elements

Editable content

Canvas Element and its related 2D APIs for drawing and animation

Audio and Video elements and how to use fallbacks for codec coverage

Browser native drag and drop

Local storage

Web Workers

Websockets

The Geolocation API

Web DB (SQL in the browser!)

This workshop will assume no special knowledge of HTML 5 and should be accessible to any web developers.

By Matt Stine

The Selenium project comprises a suite of tools designed to enable browser-based testing of modern web applications. During this talk we'll examine the three key components of the Selenium suite:

• Selenium IDE: A Firefox plugin which allows you to record browser automation scripts in Selenese, Selenium's HTML-based dialect for scripting the browser.
• Selenium Remote Control (RC): A client-server testing tool which allows you to write your tests in multiple programming languages and execute them in most modern web browsers.
• Selenium Grid: An extension to Selenium RC which allows you to execute your tests in parallel across multiple servers.

We'll walk through each of these components and examine how they can be used to test a basic web application. By the end of this session you should have a good feel for how you can develop automated tests for your web applications using Selenium.

By Matt Stine

This focus of part one will be to introduce web developers and testers to the powerful WebDriver API that comes with the release of Selenium 2.0. In addition, we'll look at the differences found in WebDriver's API and architecture as compared to the classic Selenium 1.x, and demonstrate how we can gracefully migrate our test suites forward.

In this session you'll have an opportunity to build an automated test suite that will verify the behavior of a simple web application across multiple modern browsers. We'll start by recording and running tests within the Selenium IDE Firefox plugin. We'll then export our tests to Java JUnit tests and then leverage WebDriver's powerful support for the Page Object pattern, a mechanism for the separation of the orthogonal concerns of logical application functionality and DOM structure, to construct effective tests which read more like executable specifications than code.

By the end of the session we'll be reusing components developed in earlier tests to construct new ones, thus accelerating our capacity to grow our test suite.

Prerequisite: Familiarity with Java will be necessary for an effective student experience. Familiarity with JUnit and/or TestNG will be helpful.

By Matt Stine

This session builds on "Selenium 2.0 Workshop - Part I" by experimenting with some of the more advanced features of Selenium. We'll dig into WebDriver's new Advanced User Interactions API, which allows us to perform actions such as drag and drop or clicking multiple elements while holding down the Control key. We'll also look at Selenium 2.0's capabilities for testing mobile web applications on both the iOS and Android platforms.

Finally we'll parallelize our tests across a compute farm using TestNG and Selenium Grid.

Prerequisite: Selenium 2.0 Workshop - Part I

By Matt Stine

Today's web application developers and testers have a host of options at their disposal for building automated user acceptance tests. This session will be a "shootout" of sorts between several of the popular available frameworks:

• Selenium
• WebDriver
• Watir
• HtmlUnit

We'll briefly examine the feature set of each of these tools and look and their pros, cons, and appropriate usage patterns. We'll then take a few web application screens and utilize each of the tools to implement a test scenario. I'll allow you, the session attendees, to declare the winner, and then follow up with my recommendations.

By Matt Stine

Watch Preview Video

One of the hallmarks of lean software development is the elimination of waste. Several of the key wastes in software development revolve around incomplete, incorrect, or obsolete documentation, especially documentation of requirements. One effective means of ensuring that your requirements documentation is complete, correct, and up-to-date is to make it executable. That sounds nice, but how do we get it done, especially in the world of modern, cross-browser web applications?

Executable web application specifications are within your reach through the combination of Spock, a testing and specification framework written for the JVM in Groovy, and Geb, an elegant Groovy wrapper around the powerful WebDriver browser automation framework. In this session we'll take a close look at Spock specifications for describing and verifying the behavior of our applications. We'll then examine how we can use Geb's implementation of the Page Object pattern and its "jQuery-ish" API for interacting with our web applications in WebDriver's range of supported browsers. Finally, by gluing these two technologies together via Geb's Spock integration, we'll automate the requirements specif

By Venkat Subramaniam

This session is intended for programmers with good working knowledge in at least one OOP language and interested in learning Objective-C to develop Mac and iPhone Apps.

After a rapid introduction to the basic language constructs, you'll deep dive into Objective-C specific concepts including Protocols, Categories, blocks, and how to really manage memory without getting overwhelmed in the process. You will also be introduced to tools and techniques to monitor and improve your code quality and performance.

By Venkat Subramaniam

There's nothing more frustrating than apps that crawl and crash.

In this session we'll discuss ways to improve the quality of apps and ways to proactively monitor their

performance.

By Venkat Subramaniam

You have used your share of iPhone Apps that misbehaved or simply crashed. Those experiences reminded you the need to create robust application that work well and know how to gracefully handled error situations. One way to achieve this goal is to develop your application using test driven approach.

In this session we'll see how to use test first coding approach to develop iPhone Apps and also how to enjoy the benefit of code coverage, and continuous integration. The speaker will share his experience in setting up these tools and using these process.

By Venkat Subramaniam

Come to this workshop for an in depth understanding of the fundamentals of developing applications on the iOS platform for iPhone and iPad devices.

The intent of this session is not to teach you the click and run techniques. The intent is to hone in the under the covers event handling mechanism, the organization of the application, and its deployment configuration. While you will learn how to develop Apps, you will also leave with confidence to debug and to improve the performance of your Apps.

By Venkat Subramaniam

Come to this workshop for an in depth understanding of the fundamentals of developing applications on the iOS platform for iPhone and iPad devices.

The intent of this session is not to teach you the click and run techniques. The intent is to hone in the under the covers event handling mechanism, the organization of the application, and its deployment configuration. While you will learn how to develop Apps, you will also leave with confidence to debug and to improve the performance of your Apps.

By Venkat Subramaniam

Come to this workshop for an in depth understanding of the fundamentals of developing applications on the iOS platform for iPhone and iPad devices.

The intent of this session is not to teach you the click and run techniques. The intent is to hone in the under the covers event handling mechanism, the organization of the application, and its deployment configuration. While you will learn how to develop Apps, you will also leave with confidence to debug and to improve the performance of your Apps.

By Venkat Subramaniam

Come to this workshop for an in depth understanding of the fundamentals of developing applications on the iOS platform for iPhone and iPad devices.

The intent of this session is not to teach you the click and run techniques. The intent is to hone in the under the covers event handling mechanism, the organization of the application, and its deployment configuration. While you will learn how to develop Apps, you will also leave with confidence to debug and to improve the performance of your Apps.

By Craig Walls

Watch Preview Video

In this example-driven session we'll see how to swiftly develop Spring applications using Spring Roo. We'll start with an empty directory and quickly work our way up to a fully functioning web application. You'll see how Roo handles a lot of heavy-lifting that you'd normally have to do yourself when working with Spring. And we'll stop at a few scenic points along the way to see how Roo accomplishes some of its magic.

In recent years, rapid application development frameworks such as Rails and Grails have earned a lot of attending. By employing code generation, convention-over-configuration, and the dynamic capabilities of their core languages (Ruby and Groovy) to offer unparalleled productivity, helping get projects off the ground quickly.

As awesome as these frameworks are, they do have one negative mark against them. Although developers love working with them, convincing the "boss" to build mission-critical applications in a relatively new development style based can be difficult. The mere mention of a word like "Groovy" conjures up images of tie-dye shirts and VW vans. Risk-averse project managers oft

By Craig Walls

In this hands-on workshop, we'll work together developing a Spring application using Spring Roo.

To fully benefit from the workshop, you should bring your computer loaded with Java 6 and Spring Roo 1.1.0 and SpringSource ToolSuite 2.5.1.

By Craig Walls

In this hands-on workshop, we'll work together developing a Spring application using Spring Roo.

To fully benefit from the workshop, you should bring your computer loaded with Java 6 and Spring Roo 1.1.0 and SpringSource ToolSuite 2.5.1.

By Craig Walls

Do you know what your application's users are doing when they're not using your application? Odds are good that they're spending time on Facebook, Twitter, or any of the other social network sites that are so prevalent today. If only your application could somehow go with them into those sites, adding value to their experience in both places.

In this session, you will learn how to build rich web applications that interact with the major social networks. We will highlight the open source technology available for simplifying social media integration, and will show you how to add social features to your own applications.

By Thomas Burleson

Building support for multiple languages within your RIA is a non-trivial effort requiring translators, developers, and designers to address changes to text, graphics, skins, dates, validations, data, and [possibly] layout. In this session, you will learn about (a) best practices for localization [l10n] and (b) important considerations when enhancing your custom RIA to support multiple languages and international cultures. Learn why the standard Flash and Flex approaches are solutions best avoided since they introduce maintenance and scalability issues.

Learn about an open-source framework called "BabelFx" which centralizes all localization considerations and easily injects localized resources into your application at run time. When using BabelFx your application source code remains unchanged and maintainable... and adding another language to your application becomes fun and easy.

By Thomas Burleson

Deploying a Rich Web Experience with engaging content and multiple screens is non trivial, time consuming, and expensive. Such deployments become significantly more challenging when the experience must include offer client-side validation, engaging experiences, animations, multi-page workflows, and more.

With web forms, your architecture now must consider form submissions and require server-side processing for form submission and file attachments. Then add to those requirements additional features for multi-language support, translations, and data tracking... and suddenly deploying web Forms can be a show stopper!

This session will contrast traditional web Forms with Smart Forms from ThunderBay software. Learn about the myriad issues that must be addressed when using Web forms. Learn about the significant issues of adding multilingual features to your forms.

Get a sneak preview of Insertables: the new Smart Form Platform from ThunderBay Software. With Insertables... create multi-page, multi-language smart forms in minutes with the FormDesigner. Easily deploy your smart form to any site or page (WordPress, CMS, internet, website, etc) with practically no changes to your existing site or web page.

By James Carr

Back in 2004 there wasn't much in the world of test driven development for javascript... you just had jsunit. Since then there has been an explosion of frameworks for javascript and it is almost to the point where it is difficult to choose the right one.

Come find out about a handful of some of the most popular ones and a comparison of their pros, cons, support within other frameworks, and much more. Also covered will be some tips and tricks for handling difficult to describe code and hooking tests up to run through a CI server.

By James Carr

Websockets are promising us the future we've always wanted with real time web applications, providing a bidirectional communication channel between the client and browser with no need to poll from the client. Come see how to start leveraging websockets and explore various implementations available.

This session will cover websockets in deep detail in accordance with the specifications and demonstrate them in currently supported browsers. An in depth coverage of client side libraries such as Socket.IO for older browsers as well as support on the server side for various languages and platforms will also be provided.

By James Carr

NodeJS is quickly picking up steam as a popular and high performance web platform and in this session I'll cover the details on what makes it so fun to work with..

Node.js has been gaining a lot of momentum over the past year, and for good reason! Written atop google's V8 engine with C++ bindings, it makes server-side development simple, easy, and fun. In addition to exploring the details of the platform this session will also give a feel for the the ecology around it.

By James Carr

You might have heard a bit about nodejs, now it's time to get fully immersed in it and not just learn it in detail but gear up to start becoming an active member of the nodejs development community.

We'll show you how to get started at creating your own node modules and how to package them up for distribution. This will be a hands on lab to get all the essential tools setup and at the end you will have a

package that anyone can install via npm (thing of ruby gem for nodejs) and start using right away.

Since node.js currently doesn't work on plain windows, you will need a laptop with BSD, Linux, OSX or if you have windows you will need cygwin installed with common development tools (g++, python, make, etc).

By James Carr

You might have heard a bit about nodejs, now it's time to get fully immersed in it and not just learn it in detail but gear up to start becoming an active member of the nodejs development community.

We'll show you how to get started at creating your own node modules and how to package them up for distribution. This will be a hands on lab to get all the essential tools setup and at the end you will have a

package that anyone can install via npm (thing of ruby gem for nodejs) and start using right away.

Since node.js currently doesn't work on plain windows, you will need a laptop with BSD, Linux, OSX or if you have windows you will need cygwin installed with common development tools (g++, python, make, etc).

By James Carr

Websockets are promising us the future we've always wanted with real time web applications, providing a bidirectional communication channel between the client and browser with no need to poll from the client. Come see how to start leveraging websockets and explore various implementations available.

This session will cover websockets in deep detail in accordance with the specifications and demonstrate them in currently supported browsers. An in depth coverage of client side libraries such as Socket.IO for older browsers as well as support on the server side for various languages and platforms will also be provided.

By Roy Clarkson

With the rising prevalence of smart mobile platforms such as iPhone, Android, and Web OS, the desire for rich mobile clients as another means of accessing enterprise services cannot be ignored.

In this session, we will explore the current mobile development landscape and discuss what is available in open source to support this increasingly important paradigm. We will examine the benefits and tradeoffs of native mobile client development vs. web-based mobile client development, and we will explore some of the emerging cross-platform options such as PhoneGap. Finally, we will look at the strategies for connecting mobile clients to back-end services, such as the consumption of RESTful services, authentication and authorization via OAuth, and server-push style messaging.

By Douglas Crockford

Software is the most complicated stuff that humans make.

This presentation discusses the grand subject of "Quality", and the processes by which we engineer quality into our software, and the processes by which we incorporate bugs into our software.

By Douglas Crockford

JSON is a simple data interchange format. It is rare among standards in that minimalism was one of the principle goals of its design. Radical minimalism made it possible for JSON to compete successfully against entrenched, maximal standards.

This is the true story of the origins of JSON, and how it overcame intolerance, inurement, and death threats to become the web's favorite data interchange format. JSON is the x in Ajax.

By Gabriel Dayley and Mike Heath

The Google Web Toolkit is a development toolkit for building and optimizing rich web based applications. It enables developers to be productive and build high performance applications without having to be a JavaScript ninja.

With GWT, front-end AJAX is written in Java using familiar tools like Eclipse and then cross compiles into optimized JavaScript. Learn more about GWT's features, advantages/disadvantages, and whats new and coming. Oh, did I mention there would be demos?

By Gabriel Dayley and Mike Heath

The GWT SDK contains the Java API libraries, compiler and development server. The SDK compiles optimized JavaScript that automatically works across all major browsers.

In this workshop we will dive into the GWT SDK and demonstrate how to install and get setup, explain the development process and construct a basic AJAX application using many of the core features of GWT. We will also dive into how to architect an enterprise GWT application using the MVP pattern and event bus.

By Gabriel Dayley and Mike Heath

The GWT SDK contains the Java API libraries, compiler and development server. The SDK compiles optimized JavaScript that automatically works across all major browsers.

In this workshop we will dive into the GWT SDK and demonstrate how to install and get setup, explain the development process and construct a basic AJAX application using many of the core features of GWT. We will also dive into how to architect an enterprise GWT application using the MVP pattern and event bus.

By Keith Donald

This session will explore the architecture of a major open source web application system built on SpringSource technology. Attendees will gain real-world insight into the technologies SpringSource employed, as well as insight into the team's agile development practices.

Technologies illustrated:

- HTML / CSS / JavaScript (jQuery)

- Spring 3, including MVC, Security, and Integration

- Apache Tomcat with NonBlocking IO for Async Push (Comet)

- H2 Relational Database

- Native iPhone, Android, and a Mobile Web Client

- Social Media Integration with Facebook, Twitter, and TripIt

By Arun Gupta

The Java EE 6 platform allows you to write enterprise Java applications using much lesser code from its earlier versions. It breaks the “one size fits all” approach with Profiles and improves on the Java EE 5 developer productivity features. Several specifications like CDI, JSF 2, JAX-RS, JPA 2, and Servlets 3 make the platform more powerful. It also enables extensibility by embracing open source libraries and frameworks such that they are treated as first class citizens of the platform. NetBeans, Eclipse, and IntelliJ provide extensive tooling for Java EE 6.

This session explain the Java EE 6 key concepts and specifications and use several live coding sessions.

By Arun Gupta

The Java EE 6 platform improves on the Java EE 5 developer productivity features. The true potential of this platform can be unleashed using tools and IDEs to quickly create Java EE 6 compliant applications. Syntax coloring, code completion, javadocs, debugging, profiling, and refactoring are some of the features that are important during a development cycle.

Using a live coding session, this mostly slides-free session will demonstrate the different tooling options available for Java EE 6 developers. It will demonstrate how NetBeans, Eclipse, IntelliJ, JDeveloper, and Maven makes developers life easy in creating Java EE 6 applications. The attendees will learn several tips & tricks for each IDE to boost their productivity.

By Arun Gupta

Contexts and Dependency Injection (CDI) defines a set of services for the Java EE environment that make applications much easier to develop. It provides an architecture that allows Java EE components, such as servlets, enterprise beans, and JavaBeans, to exist within the lifecycle of an application with well-defined scopes. CDI also unifies the user interface layer of the application with the model layer.

In this session, we'll explore how to use CDI with Java EE 6 technologies such has JavaServer Faces (JSF), Enterprise JavaBeans (EJBs), Java Persistence API (JPA), Java API for XML Web Services (JAX-WS), and Java API for RESTful Web Services (JAX-RS).

By Patrick Haney

Changing the world sounds like an impossible task for any one person, but we can all use our skills for good rather than evil and make progress towards a better planet.

In this session, Patrick Haney will talk about the responsibility that designers have to make a positive change in the world, how we can "go green" as web folk, what to do to gain people's trust and get them involved in your cause, and look at actual techniques we can use right now in order to "do good" on the web.

By Patrick Haney

Design principles have been around for centuries, and while technology has advanced plenty over the years, these "laws" of design still apply today. Just because technology allows us to do things on the web that we couldn't do before, doesn't mean we should.

In this session, Patrick Haney will touch on some of these principles, the research behind them, and how they still apply to today's interaction design on the web.

By Denise Jacobs

Everyone has their eyes set on the future with CSS3 and rightfully so, as the newer properties allow for ease of implementing coveted visual effects. However, advanced CSS and CSS3 not only adds richness to a site's visual layer, but also can create an experience layer by injecting interactivity.

Even though the CSS3 specification as a whole is still in flux, there are many CSS3 properties you can use today to engage and delight your users, providing not only a visual layer that will initially attract, but then following through with an experience layer that will endear.

By Denise Jacobs

The passion for CSS3 grows steadily as more designers become smitten with its properties and ease of use.

In this session, we''ll cover the few complications that stand in the way of the seemingly perfect love affair, and then will get down the nitty-gritty of how to execute designs for the present and future while using graceful degradation techniques to respect the browsers of the past.

By Denise Jacobs

This hands-on workshop answers the question "Can I use CSS3 Now?" with an emphatic "Yes You Can!" Join the ranks of the people pushing for change and start using the new CSS3 properties and attributes for true website styling power. Yes, there will be a little code bloat. Yes, you have to institute fall-backs for older browsers. But don't let the naysayers dissuade you: the pros far outweigh the cons. You can believe the propaganda: CSS3 rocks! Join the revolution and start using CSS3 now!

Workshop details coming soon!

By Denise Jacobs

This hands-on workshop answers the question "Can I use CSS3 Now?" with an emphatic "Yes You Can!" Join the ranks of the people pushing for change and start using the new CSS3 properties and attributes for true website styling power. Yes, there will be a little code bloat. Yes, you have to institute fall-backs for older browsers. But don't let the naysayers dissuade you: the pros far outweigh the cons. You can believe the propaganda: CSS3 rocks! Join the revolution and start using CSS3 now!

Workshop details coming soon!

By Denise Jacobs

In this session, we’ll explore just how far we’ve come since the beginning of the web and how leveraging newer technologies is changing the face of web design towards emotional and experience design, and how the lastest platforms are redefining how we use and experience websites now and in the future. It’s time to examine what we consider a “standard” web user experience and discover ways to transform a really good website from a user interface and experience standpoint into a great one.

We are at a critical nexus point in the history of web design: the web is finally coming of age with respect to increasing sophistication of the structure and presentation of visual information, the standardization of technologies to more easily create and display this information, physical devices that make this information easily accessible, and finally growing social connectivity. The confluence of these factors creates an improved platform and foundation upon which to start designing user interfaces that not only create user affinity by being beautiful, but through increased responsiveness and ease of use, delight as well.

By Denise Jacobs

Just when you thought you were out of the CSS learning curve frying pan, you fall straight into the CSS troubleshooting fire.

In this session, we’ll cover some advanced CSS investigative and problem-solving techniques, including tiny tidbits to lay the foundation for clean, informative markup; ways of dealing definitively with the dastardly IE6, proactive coding practices for the “other” browsers’ bugs, problems with the popular float-clearing techniques and ways around them, and creating and using the more esoteric selectors and newer css3 selectors for true targeting power.

By Dave Klein

The goal of this hands-on tutorial is to get started and get productive with Grails. We’ll do this by jumping right in and building an application, from design to deployment.

Rather than try to learn Grails feature by feature, we’ll let it unfold as we build the application. We’ll begin with a simple application structure that runs right out of the box, then we’ll gradually build our application while building our knowledge of Grails. Bring your laptop and be ready to code.

We will be using Grails 1.3.5 for the exercises.

By Dave Klein

The goal of this hands-on tutorial is to get started and get productive with Grails. We’ll do this by jumping right in and building an application, from design to deployment.

Rather than try to learn Grails feature by feature, we’ll let it unfold as we build the application. We’ll begin with a simple application structure that runs right out of the box, then we’ll gradually build our application while building our knowledge of Grails. Bring your laptop and be ready to code.

We will be using Grails 1.3.5 for the exercises.

By Dave Klein

As Java web developers, most of our work is on the server side. With Grails, that work is much easier and more fun. But what about the client-side? The best-written web app isn't going to do well without a good user experience. And these days, a good user experience means JavaScript. Grails' GSPs and custom tags provide a powerful and easy-to-use framework for including JavaScript in our applications.

n this session we'll see what Grails' built-in JavaScript tags give us, and what we can learn from them. Then we'll look at some tips, techniques and plugins that can help us go even further. Finally, we'll learn how to create our custom GSP JavaScript tags. Our examples will be using Prototype and jQuery, but will apply to most of the major JavaScript libraries.

By Brian Leroux

We know the future of the web is mobile, but what's the future of mobile? The latest builds of mobile browsers include HTML5 APIs, which enable speedy hardware-accelerated CSS, offline capability, client-side storage, geolocation and other goodies. But, what's next?

Two web technologies are ushering in the next generation of mobile apps: widgets and device APIs. As self-contained web apps, widgets significantly improve user experience. Device APIs do more than extend web apps to mobile devices; they allow access to native device sensors, like the accelerometer and camera, and to data such as photos and contacts. By adding widgets and device APIs to your toolbox, you can start building sophisticated mobile apps now.

In this session, Brian LeRoux will guide you through the step-by-step creation of a W3C widget. He'll show you how to combine it with device APIs and deploy it using the PhoneGap open source framework. Don't miss this session to learn how to develop for the mobile web of the future, today.

By Andrew Lombardi

The model supplied by Java Web Frameworks is broken. As software engineers break away from the shackles of Struts and the false promises of JSF, a new model based on object oriented programming and a clean separation of concerns has emerged with Apache Wicket. The framework has a simple component hierarchy allowing for reusability without pain.

This session looks at the core aspects that Wicket provides. Walk through the basic components and concepts and peer into an example app built using Wicket. Get insights into the differences between it and two other popular Java frameworks: JSF and GWT. Learn how Wicket embraces the object oriented concepts you haven't been able to use in web frameworks in the past, and have fun in the process.

By Andrew Lombardi

Apache Wicket injects fun back into your web application development. The in-depth look went over the components and concepts of Wicket while showing the clear alternative that it provides. Our advanced talk took you through the simple process of interactivity using Wicket's AJAX support and proved that reuse while often promised with other frameworks, is a reality here.

In this hands on, we'll take what was learned in the previous two sessions, and build our own application. Given a project requirement which will be provided, build out a web application in record time using simply Java and HTML. Find out how simple it is to introduce interactivity with Wicket's AJAX support, jazz up your boring forms, and integrate any necessary third party libraries: Java or Javascript, with ease. After this hands on session you'll feel equipped to build out any project in record time using everything learned.

By Andrew Lombardi

Apache Wicket injects fun back into your web application development. The in-depth look went over the components and concepts of Wicket while showing the clear alternative that it provides. Our advanced talk took you through the simple process of interactivity using Wicket's AJAX support and proved that reuse while often promised with other frameworks, is a reality here.

In this hands on, we'll take what was learned in the previous two sessions, and build our own application. Given a project requirement which will be provided, build out a web application in record time using simply Java and HTML. Find out how simple it is to introduce interactivity with Wicket's AJAX support, jazz up your boring forms, and integrate any necessary third party libraries: Java or Javascript, with ease. After this hands on session you'll feel equipped to build out any project in record time using everything learned.

By Rebecca Murphey

Your first iteration of a feature gets the job done, but you have a sneaking suspicion it could be a whole lot cleaner. Where to start? Is refactoring worth the time?

In this talk, we'll look at strategies for refactoring our JavaScript, with a focus on isolating individual pieces of functionality and eliminating repetition. We'll weigh the evils of premature optimization against the imperative of lean, maintainable code, and you'll learn how to spot bad decisions you might be making in that first iteration, reducing the need for refactoring in the first place.

By Mark Murphy

You have seen Android climb from a classic Google “beta” product to one of the leading mobile operating systems in use today worldwide. With Google TV, Android is also making the leap to the living room. With those plus other future opportunities, maybe you are considering getting into Android application development.

This 90-minute presentation will review what Android is and the primary options for building Android applications. We will also discuss common concerns with Android application development, support resources, and how you can make money with Android.

By Mark Murphy

Many developers think of Android as being only for Java developers. While that is the “sweet spot” today for Android, there are plenty of opportunities to develop applications for Android using Web technologies you may already know.

This 90-minute presentation will describe five means of building Android applications using Web

technologies, including HTML5, Flash, and AIR. We will review the strengths and weaknesses of each

approach, what it takes to create an application in each and take it to the Market, and where each is

likely to go in the future.

By Aaron Newton

Being a JavaScript Badass isn’t only about knowing JavaScript. If you want to get past the kinds of front end jobs that stop at making the company site look pretty and start developing hardcore applications with interesting challenges, you need to be able to do a lot of things really well, most of which aren’t really in the job description or, at least, don’t appear to be as important as just knowing JavaScript.

In this talk Aaron will talk about the things you need to be awesome at and what you can do to learn them as well as what you can expect to get for your trouble.

By Aaron Newton

The JavaScript frameworks make it increasingly easy to write highly expressive and concise functionality that enhances an HTML component, but the power of JavaScript's somewhat hidden inheritance model shouldn't be lost in that power. As programmers gain greater control over user experience design, it's more important than ever to write functionality that is reusable, scalable, and as cheap to maintain as possible without affecting performance. Architecting nearly everything you author into objects that can be extended and reused presents a lot of benefits. T

The speakers (Aaron Newton of MooTools and Dylan Schiemann of Dojo) will each tackle the same problem with code examples in MooTools and Dojo to illustrate the concept.

By Aaron Newton

Being a JavaScript Badass isn’t only about knowing JavaScript. If you want to get past the kinds of front end jobs that stop at making the company site look pretty and start developing hardcore applications with interesting challenges, you need to be able to do a lot of things really well, most of which aren’t really in the job description or, at least, don’t appear to be as important as just knowing JavaScript.

In this talk Aaron will talk about the things you need to be awesome at and what you can do to learn them as well as what you can expect to get for your trouble.

By Aaron Newton

There's more to JavaScript than effects and AJAX. Web browsers increasingly are where we write applications from email and maps to rich editors and tools for business analytics. For the past year and a half Aaron Newton, working at Cloudera, has been building a suite of tools for managing large scale Hadoop clusters - thousands of machines used for distributed computing.

The challenge of presenting a highly interactive user experience for a variety of tasks - from file browsers to system monitors to query editors - as well as a robust SDK for 3rd parties to write additional tools yielded several lessons and some interesting code that will be presented and discussed, with a focus on object oriented principals, code abstraction, and a range of of JavaScript from low-level architecture to user facing UI development.

By Matt Raible

The rise of Java Web Frameworks has come and gone, yet many are still widely used today. This session looks at the top JVM web frameworks and compares their pros and cons.

Frameworks included: Struts 2, Spring MVC, Wicket, JSF, Tapestry, GWT, Grails and Rails.

By Matt Raible

This session takes you through the nitty-gritty of online video and what it takes to build a high-traffic video portal. How do you get content, encode it properly and deliver it to a CMS and CDN? How do you program the backend infrastructure to handle load and high-availability? We'll also talk about various clients (Flash, HTML5, iPhone, iPad, Android, Sony) and lessons we've learned implementing applications on them.

This session should be particularly interesting since it's being delivered by members of the Online Video Team at Time Warner Cable, the 2nd Largest Cable Provider in the US.

By Rob Rusher

For over 7 years, the Flex SDK has grown from the original Rich Internet Application to the leader in expressive user experiences for the browser, the desktop and mobile devices. And with the recent addition of Adobe AIR for TV, Flex is still expanding its reach. Whether your curious or skeptical you will leave this session with a solid understanding of the technology and its future.

This Adobe Flex Training session will highlight the current capabilities of this ubiquitous platform and expose the future of Adobe Flex.

By Rob Rusher

Make software easier to use Streamline information through a better interface Deliver a better expression of your brand

This session is a must for those interested in changing the way people use your software. I'll show you how to design, architect and build an engaging user experience with Adobe Flex. Bring your laptop with Flash Builder (download from here) installed and we'll deploy a P2P video app to as many Android devices as we can.

This fast track to learning Adobe Flex session will explore how to get started, making software usable and design patterns commonly used to help you make robust, yet engaging, Flex applications.

By Rob Rusher

Make software easier to use Streamline information through a better interface Deliver a better expression of your brand

This session is a must for those interested in changing the way people use your software. I'll show you how to design, architect and build an engaging user experience with Adobe Flex. Bring your laptop with Flash Builder (download from here) installed and we'll deploy a P2P video app to as many Android devices as we can.

This fast track to learning Adobe Flex session will explore how to get started, making software usable and design patterns commonly used to help you make robust, yet engaging, Flex applications.

By Rob Rusher

This is an advanced Adobe Flex training session that will dig very deep into the life of a Flex component. The detail will be mind numbing, but the knowledge will be career steroids. The goal here is to take you from Flex developer to Flex master.

Flex is an event driven programming model, everything (and I mean everything) happens due to an event. The life of a Flex component is defined by the sequence of steps that occur when you instantiate an object. As part of that life cycle, the Flex SDK automatically calls component methods, dispatches events, and manages children.

It is the knowledge and understanding of the life of a component that separates the men from the boys. So, who of you are men?!

By Rob Rusher

This session is a must for advanced Flex developers that want to better understand how Adobe Flex Profiler can identify and fix memory and performance issue encountered in Flex applications.

When the Flex Profiler is running, it takes a snapshot of data at very short intervals, and records what Adobe Flash Player is doing at the time. You can use this information to help you identify performance issues and memory management problems that will take your applications to the next level.

By Andrew Wirick

jQuery mobile framework takes the "write less, do more" mantra to the next level: Instead of writing unique apps for each mobile device or OS, the jQuery mobile framework will allow you to design a single highly branded and customized web application that will work on all popular smartphone and tablet platforms.

We'll talk about the focus of the jQuery mobile project and incorporating jQuery mobile widgets in a web application.

By Andrew Wirick

Medium and large sized companies have begun to standardize the use of jQuery across their web architecture. While jQuery provides a great tool for developers there are extra considerations that should take place when building these large applications.

We will discuss common problems seen in large application development with jQuery, some of the techniques used to create maintainable large applications, and the frameworks available which leverage jQuery and help you get started with large application development.

By Tim Berglund

Most teams manage database change using an ad-hoc system of SQL migration scripts manually applied to various development, staging, and production servers. Some even contrive automated processes, but rarely does this surplus build engineering deliver value directly to the customer. We should be writing applications, not build tools.

In this session, we'll take a look at a ready-to-use, open-source database refactoring tool called Liquibase. Liquibase enables developers to make database changes with confidence, share those changes in a predictable way with other team members, and apply them to automated QA builds, staging servers, and production environments. It provides a credible path to agile database development, and it integrates well into popular build tools. It's a key enabler of the culture of database responsibility that most teams are missing.

By Tim Berglund

Watch Preview Video

Take one ugly legacy schema, a toolbox full of simple database refactorings, and a world-class schema refactoring tool, and you've got 90 minutes of workshop that will equip you to bring a culture of database responsibility to your team.

In this workshop, we'll start with a live schema in need of some help, and slowly improve it in a controlled fashion using Liquibase. We'll see how to create and alter tables, add constraints, drop columns, control changes in stored procedures, and more. You should come away with a solid understanding of how to use the tool and how to integrate it into your team's development, build, and deployment processes.

Attendees should already have a conversational understanding of Liquibase, or have attended Scripting the Schema with Liquibase session. Please bring a laptop or be prepared to pair with a friend.

Prerequisite: Database Refactoring with Liquibase

By Tim Berglund

Watch Preview Video

Take one ugly legacy schema, a toolbox full of simple database refactorings, and a world-class schema refactoring tool, and you've got 90 minutes of workshop that will equip you to bring a culture of database responsibility to your team.

In this workshop, we'll start with a live schema in need of some help, and slowly improve it in a controlled fashion using Liquibase. We'll see how to create and alter tables, add constraints, drop columns, control changes in stored procedures, and more. You should come away with a solid understanding of how to use the tool and how to integrate it into your team's development, build, and deployment processes.

Attendees should already have a conversational understanding of Liquibase, or have attended Scripting the Schema with Liquibase session. Please bring a laptop or be prepared to pair with a friend.

Prerequisite: Database Refactoring with Liquibase

By Matthew McCullough

Maven 3 is out the door now and developers everywhere are beginning the migrations to this exciting new version of the most popular build tool on the planet. This talk assumes a basic knowledge of Maven 2 and will equip you with all the practical and technical details necessary for you and your team to migrate to Maven 3. We'll explore the performance improvements, features that make debugging Maven issues easier, and changes to POMs that may require modifications to your build, but will result in more determinate build outputs.

Maven 3.0 has undergone major refactorings, and correspondingly, a battery of backwards compatibility tests to ensure a smooth transition from Maven 2.0. These refactorings prepare Maven for the next several years of development, including the separation of the POM file language from from the POM in-memory processor, which is already leading to Groovy, Ruby and YAML based POM file parsers. While Maven 3 is designed as a drop in replacement, the tips and tricks in this presentation will make your migration smooth and let you extract the greatest performance benefit from this ground-up reimplementation while simultaneously minimizing your POM editing efforts.

Prerequisite: Basic knowledge of Maven

By Matthew McCullough

You're serious about improving the quality of your code base, but with 10,000 lines of code, where do you start and how do you ensure the greatest ROI for the re-work your team members will perform?

Sonar is an open source tool that brings together the best of breed static and dynamic analysis of Java projects. The result is a unified view of problematic areas of your code on a time-line basis, allowing the team to attack the problems with the best ROI, and maintain a more watchful eye for positive and risky trends in the codebase in the future.

This talk will show you Sonar from the ground up and explain 10 critical metrics that affect your code's flexibility, stability, and durability.

Prerequisite: Basic familiarity with Ant, Maven or Gradle builds and a desire to measure the quality of your code base.

By Matthew McCullough

Watch Preview Video

Git is a powerful content tracker and has gained acceptance by many forward leaning consultants and teams over the past several years. Those developers know that it offers the usual commit, branch, merge and tag in a distributed environment, and yet, only a few developers have explored the more powerful functions of Git. These range from searching months of history for a unit-test bug to undoing literally any mistake to splitting in-progress work into multiple commits within a single file.

This talk is targeted at developers who have dabbled with the basics of Git but are aiming to explore, gain productivity secrets, and push the very limits of this life-changing version control system.

By Matthew McCullough

Watch Preview Video

Git is a version control system you may have been hearing a bit about lately. But simply hearing more about it may not be enough to convince you of its value. Getting hands on experience is what really counts. In this workshop, you'll bring your Windows, Mac or Linux laptop and walk through downloading, installing, and using Git in a collaborative fashion.

The workshop style of this class will allow you to observe and discover the value of this new version control tool first hand. You'll be cloning, creating, commiting, and pushing repositories by the conclusion of this session.

Prerequisite: Basic knowledge of a version control system. Subversion knowledge is a plus, but not imperative.

By Matthew McCullough

Watch Preview Video

Git is a version control system you may have been hearing a bit about lately. But simply hearing more about it may not be enough to convince you of its value. Getting hands on experience is what really counts. In this workshop, you'll bring your Windows, Mac or Linux laptop and walk through downloading, installing, and using Git in a collaborative fashion.

The workshop style of this class will allow you to observe and discover the value of this new version control tool first hand. You'll be cloning, creating, commiting, and pushing repositories by the conclusion of this session.

Prerequisite: Basic knowledge of a version control system. Subversion knowledge is a plus, but not imperative.

By Ken Sipe and Hans Dockter

Gradle allows you to describe your build using a rich, easily extendable build language based on Groovy. It provides compelling solutions for many of the big pain points that exist with current build systems. This session will be mostly driven by live demos. You will see how easy and elegant Gradle enables you to solve a broad range of requirements - over the full life cycle of typical and atypical Java builds.

Gradle pushes declarative builds to a new level. It allows users to provide there own declarative elements and to customize the behavior of the build-in ones. Thus enabling concise, expressive and maintainable builds. All this is build on a rich, flexible imperative layer of tasks.

With its Deep API Gradle allows you to hook in and customize every aspect of the build, be it configuration or execution behavior.

Gradle comes with many optimization strategies for building fast and yet reliable. It has a powerful support for multi-project builds and transitive dependency management. It allows to integrate with your existing Ant/Maven builds and your Ivy/Maven/Custom repositories.

The demos wi

By Ken Sipe and Hans Dockter

Gradle allows you to describe your build using a rich, easily extendable build language based on Groovy. It provides compelling solutions for many of the big pain points that exist with current build systems. This session will be mostly driven by live demos. You will see how easy and elegant Gradle enables you to solve a broad range of requirements - over the full life cycle of typical and atypical Java builds.

Gradle pushes declarative builds to a new level. It allows users to provide there own declarative elements and to customize the behavior of the build-in ones. Thus enabling concise, expressive and maintainable builds. All this is build on a rich, flexible imperative layer of tasks.

With its Deep API Gradle allows you to hook in and customize every aspect of the build, be it configuration or execution behavior.

Gradle comes with many optimization strategies for building fast and yet reliable. It has a powerful support for multi-project builds and transitive dependency management. It allows to integrate with your existing Ant/Maven builds and your Ivy/Maven/Custom repositories.

The demos wi

By Matt Stine

Watch Preview Video

You've got your build automated using Ant/Maven/Gradle and you're building and running your unit test suite every time you check-in. That's easy. In fact, with Jenkins you can do this in under 5 minutes.

However, if we want to move beyond "mere" Continuous Integration to Continuous Delivery, there are many other areas in which we need to achieve "push button" automation. This talk will survey many of these areas and tie everything together with an integrated case study at the end.

In this talk, we'll look at:

Automated Provisioning with tools like Vagrant, Chef and Puppet

Automated Database Migrations with Liquibase

Automated Deployment with Capistrano

Automated User Acceptance Testing with Selenium 2, Geb and Spock

Using Jenkins to orchestrate the entire delivery process

By Chris Beams

Over the last year, many of SpringSource's open-source projects have made the move from both Ant and Maven to Gradle.

This session will explore the reasons for this decision, benefits realized, and problems encountered. You'll see how we've achieved a concise and reusable, yet easily extensible build toolkit suited for the complex project automation needs of open-source projects.

By Hans Dockter

For our production code we apply a wealth of design values and principles. Currently this is rarely done for our builds. Yet the project automation domain, specially in the enterprise, is often at least as complex as the business domain.

The design of your build is heavily influenced and possibly constrained by the design of the build system you are using. The main focus of this talk is to evaluate those design forces of the build systems. Mostly with the help of two books: Refactoring by Martin Fowler and Domain Driven Design by Eric Evans.

The build systems under review are dramatically different and thus the design of the corresponding builds. We will talk about best practices for build design and how different build systems might support that or stand in the way, thus preventing expressive, maintainable and easy to use builds. Those differences should be a major factor when you are choosing a build system appropriate to your needs.

The speaker is the founder of Gradle. So there might be some bias :). But the design principles referred to are core principles fully accepted by the Java community. The way they are violated is astonishingly obvious once pointed out. Production code would not get away with this and neither shou

By Hans Dockter

TBA

TBA

By Olivier Gaudin

The Job of a developer has evolved strongly in the last 10 years, pushed by new requirements and new tools. Software Development Industry has now reached a sufficient level of maturity to engage into a new practice to manage source code quality while running projects : Continuous Inspection.

This practice is supported by Sonar as Continuous Integration is supported by Hudson. Continuous Inspection enables developer to fight back the temptation of the seven deadly sins of the developer. Sonar enables to declare war to those sins.

By Olivier Gaudin

Continuous Inspection is an emerging practice to manage source code quality. This practice has a single objective : keep the technical debt associated to source code under control throughout time.

The requirements relate to unit tests, duplications, complexity, design, coding standards...

In this workshop, you will learn how to use Sonar and its ecosystem of plugins to support this practice.

By Olivier Gaudin

Continuous Inspection is an emerging practice to manage source code quality. This practice has a single objective : keep the technical debt associated to source code under control throughout time.

The requirements relate to unit tests, duplications, complexity, design, coding standards...

In this workshop, you will learn how to use Sonar and its ecosystem of plugins to support this practice.

By Kohsuke Kawaguchi

In this talk, we'll discuss the techniques that go beyond simple build and test, by using Hudson, an open-source CI server. These techniques allow developers to get more out of their investment to CI. This talk targets those who have started using CI and are used to the idea of automated build.

• One of the key themes of a larger automation is to control the flow of changes. This may be between developers in the same team or between different teams. This talk discusses these topics and techniques in details.

• As CI produces and consumes a lot of binaries that are only slightly different, tracking them accurately is important. This talk discusses techniques and challenges.

• Techniques to reduce the turn-around time of a long build/test.

This talk targets those who have started using CI and are used to the idea of automated build.

One of the key themes of a larger automation is to control the flow of changes. This may be between developers in the same team or between different teams. This talk discusses these topics and techniques in details.

As CI produces and consumes a lot of binaries that are only slightly different, tracking them accurately is important. This talk discusses techniques and challenges.

Techniques to reduce the turn-around time of a long build/test.

By Kohsuke Kawaguchi

The first workshop on Wednesday gives you a hands-on experience of setting up Hudson and setting up some builds on Hudson. The second 1/2 day workshop on Friday walks you through the basics of a Hudson plugin development. You'll be building a few simple plugins and get introduced to various lower level components in Hudson.

As time permits, we'll evolve this setup to an inreasingly sophisticated one that includes such things as staging, findbugs, etc.

By Kohsuke Kawaguchi

The first workshop on Wednesday gives you a hands-on experience of setting up Hudson and setting up some builds on Hudson. The second 1/2 day workshop on Friday walks you through the basics of a Hudson plugin development. You'll be building a few simple plugins and get introduced to various lower level components in Hudson.

As time permits, we'll evolve this setup to an inreasingly sophisticated one that includes such things as staging, findbugs, etc.

By Kohsuke Kawaguchi

The first workshop on Wednesday gives you a hands-on experience of setting up Hudson and setting up some builds on Hudson. The second 1/2 day workshop on Friday walks you through the basics of a Hudson plugin development. You'll be building a few simple plugins and get introduced to various lower level components in Hudson.

As time permits, we'll evolve this setup to an inreasingly sophisticated one that includes such things as staging, findbugs, etc.

By Kohsuke Kawaguchi

The second workshop on Friday walks you through the basics of a Hudson plugin development. Join 300+ people who has developed Hudson plugins to enhance Hudson to meet their needs --- if that many people can do it, it can't be so hard!

You'll be building a plugin with a few simple extensions and use that to get introduced to various lower level components/concepts in Hudson.

We'll start by learning the basic build/edit/debug/deploy cycle of a Hudson plugin, then focus on key subsystems --- such as view technologies, persistence, extensibility, remoting, unit testing, and so on in turn.

The workshop style allows the audience to gain more hands-on experience.

By Kohsuke Kawaguchi

The second workshop on Friday walks you through the basics of a Hudson plugin development. Join 300+ people who has developed Hudson plugins to enhance Hudson to meet their needs --- if that many people can do it, it can't be so hard!

You'll be building a plugin with a few simple extensions and use that to get introduced to various lower level components/concepts in Hudson.

We'll start by learning the basic build/edit/debug/deploy cycle of a Hudson plugin, then focus on key subsystems --- such as view technologies, persistence, extensibility, remoting, unit testing, and so on in turn.

The workshop style allows the audience to gain more hands-on experience.

By Baruch Sadogursky

It's amazing, but true - for a very long time "the enterprise language of the new century" didn't have a decent build automation tool. We had imperative-only Ant, then declarative-only Maven2, but both not without significant downsides. As usual, a gloomy present leads to a brighter future and today we witness great developments in the build automation tools industry.

During this session you'll get a comprehensive overview of today's tools, including what's good, what's bad and what's ugly in Ant and Maven2. Next we will define what we expect from the perfect build automation tool, and then dive into the sea of various tools, rating each one according to those expectations.

By Baruch Sadogursky

So, you want more from your build, but want to spend less on migration? Here's a session for you - Migration from Maven2 to Gradle: the easy way.

We'll build a migration todo list, overview existing technological solutions, and see how we can migrate existing builds with minimum effort.

During this session you'll see how to create a basic Gradle script out of a pom.xml file, how to extend it replacing the functionality of Maven plugins with Gradle tasks and plugins and how to keep your Gradle build compatible with other Maven projects/modules it interacts with. You'll learn everything you need to know if you are currently using a Maven build and want to get started on Gralde.

By Frederic Simon

Every layer of the Application Lifecycle Management (ALM) is supported today by tools that are becoming increasingly simpler and powerful. One layer that is not used to its full potential is The Repository Manager which is hosting and serving binary artifacts.

In this session we will show the positioning and importance of Repository Managers, and how they greatly increase the quality of the ALM process. Then we will demonstrate the advanced features of Artifactory (a Repository Manager by JFrog) that helps creating a state-of-the-art flow between your VCS and your production environment.

By Frederic Simon

Using module-based software development in Java is already the common practice in most development shops. Still, having several de-facto competing standards for module systems and the lack of zero-config support for modular development leaves room for many improvements and changes to be desired.

This session will provide a "state of the union" of today's modular Java software development, contrasting the various approaches for module representation, storage & provisioning and examining what we can learn from other languages and infrastructures that embraced modular system development before and after Java.

Some of the topics that will be discussed:

- Build time vs. runtime module systems

- The role of modules in current build-time module frameworks: Maven, Ivy, OSGi, WebStart, Jigsaw

- Metadata-only vs. build supporting modules

- The Jigsaw Project - will it make a change

- Module provisioning and resolution

- Module repositories - beyond Maven and beyond Java

- Versions - us