Westin Fort Lauderdale Beach Resort321 North Fort Lauderdale Beach Boulevard
Fort Lauderdale, FL 33304
Map »
Platinum Sponsors
The Rich Web Experience 2011 Brochure - Download
Full Day Workshops
with Ted Neward
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 SQLite database as well as to a straight file. We’ll look at how to make Internet calls to remote services, and when all is said and done, we’ll have an application that Really Works (TM). Bring a laptop, your Java skills, an Android device if you’ve got one, and buckle in, because it’s going to be a straight-from-the-firehose kind of workshop.
with 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.
with 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.
with Matthew McCullough
Distributed version control is all the rage these days, but is it worth it? It has been transformative for the dozens of organizations and thousands of developers that I've mentored on the unique implementation called Git. But don't take my word for it. Discover the joy of a version control system that works for you, not against you, in a hands-on workshop. Bring a Windows, Mac, or Linux laptop and we'll install, set up, use and bend Git into workflows that weren't even possible with the version control systems of yesteryear. Be prepared to rethink how lightweight, fast, and refreshing source code control can be. After completing this workshop you'll be able to do practical work with Git for your day job or weekend OSS hobby
This full day workshop takes you from the ground up with Git. By the end of the day you'll be proficient enough to contribute to an open source project using Git or to leverage inside your corporate as the canonical version control system.
Half Day Workshops
with 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.
with 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 and months of effort. We'll explore the use of pragmatic personas to see how they can simplify the task of interface design. As an exercise, we'll develop personas for our application.
The what - figuring out just what to build. Of course just knowing who we're building for is only part of the picture, we have to know what our users are trying to do. Wether you favor use cases, user stories or more traditional requirements documents, at the end of the day our customers are using our application to further some other goal. In this section we'll discuss tasks and scenarios showing how they contribute to the overall design process. We'll write up a set of user goals expanding them into tasks that will help us design a set of interfaces.
The how - designing rocking good interfaces. Want to know the secret to designing great interfaces? We'll talk about the importance of iteration; just as our code is rarely right on the first try, neither are our interfaces. To facilitate the iterative process, we'll discuss the vital importance of paper prototyping. That's right, paper and pencil are your best tools. We'll also talk about why some designs are better than others discussing the heuristics that are second nature to the experienced designer. We'll also discuss design guidelines talking about how to make sure yours aren't just a dusty document sitting in a rarely visited corner of the LAN. We'll sketch up a variety of approaches focussing on quick and dirty designs that allow us to explore a plethora of options.
Testing our design - making sure we're on the right path. Just as we test our code, we must test our interfaces. While we may not have UIunit at our disposal, testing our UIs is just as important as testing our code. From recruiting users to preparing the space, we'll discuss how to get ready for a test. We'll talk about the various roles in a user test from the all important moderator to playing computer and taking notes. User tests can be very stressful, we'll discuss ways to put our customers at ease. We'll also discuss the best way to communicate the results of testing to the rest of your team. We'll prepare a deck to test a given scenario. We'll take that deck and test it with our "customers." Of course we can also desk check our interfaces using standard heuristics - we'll look at some existing applications discussing what was done right and what could be done better.
with Ted Neward
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.)
with 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!
with 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
with 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.
with 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).
with 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).
with 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.
with 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.
with 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.
with 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.
with Nathaniel Schutta
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.
with 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).
with 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.
with 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.
with 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)
with 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.
