Craig Walls

Presentations

Building Next Generation Apps Workshop

For a long while, we've built applications pretty much the same way. Regardless of the frameworks (or even languages and platforms) employed, we've packaged up our web application, deployed it to a server somewhere, and asked our users to point their web browser at it.

But now we're seeing a shift in not only how applications are deployed, but also in how they're consumed. The cost and hassle of setting up dedicated servers is driving more applications into the cloud. Meanwhile, our users are on-the-go more than ever, consuming applications from their mobile devices more often than a traditional desktop browser. And even the desktop user is expecting a more interactive experience than is offered by simple page-based HTML sites.

With this shift comes new programming models and frameworks. It also involves a shift in how we think about our application design. Standing up a simple HTML-based application is no longer good enough.

In this 2-part workshop, you'll get hands-on experience building a simple, yet complete next-generation application that can be deployed in the cloud, consumed from any device, and offers a rich experience for your users.

Elements of Modern Applications: Socialization

In this session we'll talk about what it means for an application to be social and the benefits of socializing an application. We'll look at libraries for linking applications with existing social networks. We'll also discuss what it takes for an application to form its own network of users connected with each other for a better user experience.

A common attribute of many modern applications is that they inject themselves into their users' social graph. Indeed, many modern applications are a form of social network and most at least integrate with existing social networks such as Facebook and Twitter. Socialization of applications not offers a better user experience, but also affords those applications opportunity for exposure to everyone within the social graph of their user base.

Elements of Modern Applications: Spine and Spine Mobile

In this session, we'll start with an empty directory and use Spine.js to create an interactive client-side web application. Then we'll leverage what we learned to build a mobile web application with a native feel that can be deployed either through a phone's web browser or via native wrapper frameworks such as Apache Cordova (aka, PhoneGap).

Model View Controller (MVC) is often thought of in terms of server-side frameworks such as Spring MVC and Struts. But modern applications demand a rich and interactive experience on the client-side. Recently, several JavaScript-based microframeworks have emerged to address these concerns in the browser. Spine.js is one such framework that brings MVC to the client-side of web development. Based in CoffeeScript, Spine.js stands out due to its simplicity and a programming model resembling that of Rails and Grails. Also, unlike many other client-side MVC frameworks, Spine.js has a clear and well-paved path to mobile application development.

Elements of Modern Applications: Spring MVC, REST, and OAuth 2

In this session we'll work with Spring MVC to define the REST API for a modern application. We'll look at how the latest features of Spring MVC make it possible to create a truly RESTful API and also explore some extensions that provide HATEOS auto-documentation features to Spring MVC. And, since security is an important aspect of any good REST API, we'll also see how to layer OAuth 2 security using Spring Security for OAuth.

Traditionally, an application's functionality has often been defined in terms of the features experienced by its users. Screens, buttons, and text fields are what we would think of when considering what an application would do. Modern applications, however, could be fronted by any number of user interfaces, some offering similar experiences and some distinctly different. In modern applications the REST API exposed by the backend is what defines an application's functionality.

Elements of Modern Applications: Backbone.js with Thorax and Lumbar

In this session, we'll see how to develop Backbone clients using Thorax and Lumbar. Thorax is an opinionated framework built on Backbone. Along with the Lumbar build system, Thorax provides a Rails-like development experience for working with Backbone. Thorax/Lumbar will not only help you get started with Backbone, but will also help the client side of your application and ultimately build your code into deployable artifacts that target individual platforms.

Backbone is a popular choice for building the client-side of a modern application. But Backbone's getting-started experience can be a bit overwhelming. What should a Backbone project look like? What kind of directory structure do you need and how do you build your client code into deployable artifacts? How can you build a distinct deployable for each platform (e.g., web, iOS, Android) that you're targeting?