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.

Bring your laptop! Use your JavaScript skills to build native iOS and Android apps! Learn from an Appcelerator Titan!

This is a full day workshop specifically designed to get you up and running with Titanium and build feature-rich applications! We'll install the latest Titanium Developer and iOS SDK - then create a project in Titanium Developer and run it in the simulator to verify your setup. Basic JavaScript experience is necessary for this session; please complete a basic JavaScript course or book before attending.

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 Studio, an IDE for your mobile apps, invokes their compiler and builder to take your Javascript and build a native application for iOS and Android.

This is a full day workshop intended to teach you the basics of Titanium. We'll work on several exercises as you build up a complete, feature-rich, mobile application that you can deploy on either Android or iOS. Topics we'll cover in this workshop: * Titanium quickstart * Titanium architecture and build process * Titanium API's ** UI elements: Lists, Labels, Windows, Views, Buttons, etc ** Navigation ** Tabs ** Databases ** Network operations * How to manage app upgrades * Connecting to social media sites * Debugging Titanium Applications * Best Practices * Turbo charging with Coffeescript * Building maintainable code with platform specific plugins

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.

In this course students will learn how to add interactivity and asynchronous behavior to web sites using Javascript via the jQuery library and its companion the jQuery UI library.

The workshop consists of: Beginning jQuery Advanced jQuery and jQueryUI

This is a hands on course for developers so bring your laptop and be prepared to write a lot of code!

As a web application developer, you want to just focus on the user stories producing business value for your company or clients. Increasingly however the world wide web is more like the wild web which is growing hostile environment for web applications. It is absolutely necessary for web application teams to have security knowledge, a security model and to leverage proper security tools.

This full day training workshop on security will provide an overview of the security landscape starting with the OWASP top ten security concerns with current real world examples of each of these attack vectors. The morning will consist of a demonstration and labs using hacker tools to get an understanding of how a hacker thinks.

The session will include a walk through of the ESAPI toolkit as an example of how to solve a number of these security concerns including hands-on labs using the OWASP example swingset.

The workshop will include: - Details on encryption technologies and frameworks, with details on how to tighten security on a tomcat application server. - Demonstrations and labs of open source security tools, such as zaproxy and metasploit

Attendees will come away with the following skills / capabilities: - threat modeling - security audit plan - introduction to Pen testing - key / certificate management - fixing web application security issues

Don't be the weakest link on the web!

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.

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.

Fred Brooks said, "How do we get great designers? Great designers design, of course." So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect.

The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than "Hello world". The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system.

In this session, attendees will be split into small groups and given a "real world" business problem (the kata). Attendees will be expected to formulate an architectural vision for the project, asking questions (of the instructor) as necessary to better understand the requirements, then defend questions (posed by both the instructor and their fellow attendees) about their choice in technology and approach, and then evaluate others' efforts in a similar fashion. No equipment is necessary to participate--the great architect has no need of tools, just their mind and the customers' participation and feedback.

TBA

TBA

You might have heard of this hot new platform called Node.JS that puts JavaScript on the server, and now it's time to see how easy it is to be productive with tools like express and MongoDB.

After an introduction to the tools, you will build a non-trivial web application with express, jade, stylus, MongoDB, and mocha. Bring your laptop for some hands-on JavaScript hacking.

Attendees will need their own laptop with recent versions of node v0.6+ (http://nodejs.org/#download), npm v1.0+ (http://npmjs.org) and MongoDB (http://www.mongodb.org/) installed. They will benefit most if they have a basic understanding of JavaScript and aren't afraid of the command-line.

If you've gotten your feet wet with Grails. You've talked to friends, you've done some reading, you've seen a presentation that sold you on the awesomness of the framework. What's next? Why, some hacking, of course!

Come to this 90-minute workshop ready to create a persistent domain model, build a scaffolded UI, modify page layouts, and maybe even build some Ajax into your new web app. See how quickly you can get started building robust, scalable web apps for the JVM.

Bring a laptop of be prepared to pair with a friend. Please have a current release of Grails (http://grails.org/Download) downloaded and unzipped.

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.

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.

Bring your laptops. This is a hands-on workshop.

Interested in HTML5? Want a change to play around with the latest and greatest in web app development? This workshop is for you! We'll cover feature detection, web forms, the new HTML elements, take a spin around the canvas, and we'll finish up with offline/local storage and web sockets.

Detecting 101 Before you can take advantage of a new HTML5 feature, you have to make sure a given browser can support it. This section will cover the basics of detection as well as getting the most out of rocking cool libraries like Modernizer. We'll also look at just what to do when a browser doesn't support a feature you're trying to leverage.

New elements Along with a new human type-able doctype, HTML5 introduces several new semantic elements. Recognizing that nearly every website in existence has a header, a footer and some navigation divs, HTML5 gives us a header, a footer and a nav element along with a few others. HTML5 seeks to pave cowpaths, not force the web to bend to its ways...

Canvas One of the most exciting features of HTML5 is the canvas, a space you can use to draw anything from shapes to text to, well, anything! From basic drawing to graphs to full fledged games, canvas opens up a whole new world of possibility, a world sans browser plugins.

Local Storage Web apps are, in many cases, indistinguishable from their thick client brethren, at least if you're not on an airplane. OK, so many planes have wifi, but there are parts of the world that don't have reliable Internet connections! Thanks to local storage and the offline API, all is not lost - you can create a web app that works offline.

Web sockets and web workers Ajax is like so many things in the web world - a simple (but very powerful) hack that isn't defined by a spec. With the advent of the web socket API, we'll finally have a native way to have bi-directional communication with the server. As we create richer and richer clients, we're writing more and more JavaScript. While the JS engines are getting faster and faster, there are cases where it'd be very handy to run scripts in the background. Web workers give us just such an opportunity.

Build a Web Bowling game using HTML5, CSS, accelerometer and gyroscope, web sockets, and Box2D physics.

Hey wii bowling fans, in this workshop you will learn how to build a mobile web client that utilizes the accelerometer and gyroscope data of your smartphone to build a control for throwing objects at a remote display. We will create a node websocket server for handling the communication between the controller and the display. On the display we dig into the fantastic JavaScript Box2d physics engine to create obstacles for our remote objects to crash into. Come see just how easy this is to do and build a souvenir to take home to your kids that they really will enjoy a lot more than that starfish you were thinking of buying.

Distributed computing is one of those problems with great potential but huge risk. The API is often messy and requires extensive efforts. However, distributed computing and network programming are here to stay and with rich client applications and mobile devices, the demand is only rising.

In this workshop we will learn how to use Netty to create high performance applications that rely heavily on network protocols.

The only thing better than talking about Ratpack is hacking with Ratpack. Come to this workshop for 90 minutes of directed web development using the latest un-framework for Groovy-based web apps.

The instructor will lead you in coding features in a simple web app, but you are free to hack on your own ideas as well. You will leave the session having become famliar with Ratpack and ready to start building your own small apps with it.

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.

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 Model and Do Inference with the Web Ontology Language (OWL)

Bring your laptops. This is a hands-on workshop.

Solr Recipes provides quick and easy steps for common use cases with Apache Solr. Bite-sized recipes will be presented for data ingestion, textual analysis, client integration, and each of Solr’s features including faceting, more-like-this, spell checking/suggest, and others.

Quick and easy steps for common Apache Solr use cases

• Ingesting recipes: CSV, relational databases, file system, web crawls, API

• Analysis recipes: copyField, character mapping, tokenizing and filtering, configuring for suggest, data exploration

• Faceting recipes: field, date and numeric range, pivot, and query faceting

• Integration recipes: prototyping user interactions, working with Solr from PHP, Rails, Java, Ajax, and other environments

• Other featured recipes: more like this, spell checking/suggest, grouping, clustering

For as long as there has been a Spring Framework, there has been Spring MVC, a web framework built around the principals of Spring. Although it was originally designed around a deep hierarchy of controller classes and focused on HTML-oriented views, Spring MVC has evolved in the past few years to embrace an annotation-oriented model and RESTful web development.

In this workshop, we'll use Spring MVC to build the web front-end of an application. We'll start with the essentials and work our way up to try out the latest Spring MVC features in Spring 3.1. We'll explore the following Spring MVC topics:

• Spring MVC essentials (request mapping, controllers, and views)
• Field formatting and validation
• Spring's JSP tag libraries
• Handling file uploads
• Content negotiation and non-HTML views
• Request and response body conversion
• Advanced request mapping
• And much more!

Whether you're a Spring newbie or a long-time Spring veteran, this is your chance to get a hands-on experience with everything Spring MVC can do.

IMPORTANT!!! PRE-WORKSHOP SETUP INSTRUCTIONS!!!

In order to ensure a successful workshop, it is imperative that you arrive with the following installed on your computer:

• Java SDK 1.5 or higher (not the JRE!)
• Maven 3.0.3 (or newer): http://maven.apache.org/
• SpringSource Tool Suite (2.8.0 or higher): http://www.springsource.com/developer/sts

Also, before arriving, it will save time if you have already verified this setup. As part of the verification, perform the following steps:

1. Start SpringSource ToolSuite
2. Create a new Spring MVC template project (File->New->Spring Template Project, then select "Spring MVC Project"). Name the project "SpringMVC". (Note that if this is the first time you've created a Spring MVC template project, it may take some time to download the templates.)
3. Once the project has been created and has had a chance to build in the IDE, drag the project into the tcServer instance ("VMWare vFabric tc Server Developer Edition v2.6") in the "Servers" tab.
4. Start tcServer
5. After the server starts fully, point your browser to http://localhost:8080/SpringMVC and verify that you are greeted with a "Hello World!" message along with the current time.

We will not have time during the workshop to setup your environment, so please arrive having performed these setup steps. If you need any help getting started, feel free to email craig-mvcws@habuma.com and I'll do my best to help out.

CoffeeScript is a programming language that compiles to JavaScript. The language adds syntactic sugar inspired by Ruby and Python to enhance JavaScript's brevity and readability, as well as adding more sophisticated features like array comprehension and pattern matching. CoffeeScript compiles predictably to JavaScript, programs can be written with less code (typically 1/3 fewer lines) with no effect on runtime performance. In this session, you'll need your laptop as we code through Coffeescript basics. Please bring a laptop with either Chrome and Safari installed. The coding session can be done on Windows, Mac, or Linux.

In this session we'll look at different uses for Coffeescript in the development world. We'll look at how to use it with jQuery, for example, and also with an app framework like Titanium. We'll explore the language features, take a tour of using it in different environments, and write code to demonstrate its time-saving features. We'll also spend some time looking at using it for unit-testing. Coffeescript's language features also lend it to write more maintainable code - a topic that we will discuss in detail. Finally, we'll see how Coffeescript is being wrapped into larger app frameworks like node.js and Rails 3.1.

In this workshop, you'll discover the missing link in enterprise Java development: simple, portable integration tests.

For many, developing with enterprise Java has long been an arduous undertaking because it's been a bear to test. Though development life is simple with unit tests and mocks, they only get you so far. Eventually, you need to validate that your components interact and operate properly in their intended environment--you real need integration tests.

The main obstacle is that your integration tests live in a different world than your application. We'll overcome this discrepency by adopting a component model for your tests, a service provided by Arquillian. This lab puts Arquillian in your toolbox. The goal is to allow you to make a smooth transition from unit to integration tests.

What's the secret? Arquillian, a container-oriented testing framework for TestNG and JUnit, makes testing enterprise Java applications easy by bringing your test to the runtime rather than requiring you to manage the runtime from your test. Picking up where unit tests leave off, Arquillian enables you to test real components that rely on real enterprise services in a real runtime.

We'll begin by introducing you to the fluent API provided by ShrinkWrap that is used to package a test archive, giving you fine-grained control over which resources are available to be tested. We'll work on examples that demonstrate how the test archive is deployed and executed inside standalone, embedded and remote containers. You'll work through tests that exercise a wide range of technologies, including CDI, EJB, JPA, Spring, JAX-RS, JSF, web UI tests and more.

You'll walk away confident that you can:

1. write integration tests just as you would a unit test,
2. run those tests in multiple environments (containers) and
3. have a tool in your toolbox for both testing and discovery

Join this lab to learn how simple and powerful Java enterprise testing can be.