Introduction to The Java API for RESTful Services (JAX-RS). RESTful Java web services are a pretty radical departure from what you are probably familiar with. JAX-RS avoids the "Java method == service operation" typical in all the popular web service stacks, opting instead for a much more comfortable way of making information services available over HTTP. For the busy developer who wants a fast, practical introduction to RESTful services and the JAX-RS API in particular.

This talk starts by differentiating the RESTful model that JAX-RS relies on from the more common RPC model of web services. Basically, RESTful services use (entity + verb) as the target of a service request, which turns out to be such a better way of doing things compared to the RPC service model where the verb is king.

The introduction is brief so we can get on to several practical JAX-RS examples. We'll look at implementing a RESTful service with a service class, identifying target entities and verb, different kinds of parameters, and how other RESTful concepts map to the JAX-RS Java 5 annotations. We'll make sure to have time as well to demonstrate consuming a public RESTful service in Java.

Expose your domain model with a REST API. Its extremely easy using JAX-RS annotations and a standard JAX-RS implementation. In this extended demo talk, we'll take an example domain model and see how to decompose it in to a RESTful API. An implementation is easy to build with JAX-RS + a domain object serializer. You'll take away the skills and tools to impress your friends and colleagues.

We'll use Jersey (the JAX-RS RI), and an Object-to-XML serialization library (Apache XMLBeans and/or JAXB RI) to implement a RESTful API "from scratch" on top of an existing domain model. The same basic architecture can be used with different JAX-RS implementations and different on-the-wire alternatives such as JSON, flatfiles, ASN.1, your name it. So the techniques demonstrated are portable and can be modified to suite an existing code base and different API requirements.

This one's for all the "architects" out there designing and specing services, and those who have to work with them. Whether you are building it or consuming it, the most painful thing about sharing a service is sharing an understanding of what the service does. This presentation teaches you how to dispel ambiguities, techno-mumbo-jumbo, and reliance on institutional knowledge that bogs down service development and testing today using the 5 essential parts of an interface specification known as Operation-State Modeling (OSM).

WSDLs and XSDs describe the structure of service messages, but its not enough to describe the intended behavior of the service. Poorly-written English-language docs are the defacto standard of the day for describing service behavior. If you're like me, that seems completely ridiculous. Just like messages models (WSDL/XSD) are machine-consumable, so should behavior descriptions.

This presentation introduces the OSM way for specing services that avoids the painful and inevitable consequences of Word doc descriptions -- slow development and testing because of: subjective requirement interpretations by developers and testers, inconsistency, and ambiguity. A properly-written spec is objectively consistent, without unnecessary ambiguity, and ultimately stunningly faster to implement and test. This introduction will explain and demonstrate the 5 essential parts of a service interface specification.

Alternative languages for the Java VM are hot: Groovy, JRuby, Scala, Clojure, and more. What is driving the interest in these alternative languages? Are these new, fancy-dancey languages just a fad; or maybe are you missing out by not knowing more about them? If you've been reluctant, or don't see where Java and these new languages fit in the "big picture", start your alternative explorations in this talk.

Consider this talk a general survey of the most popular emerging alternative VM languages. Whats driving these languages is that these languages are able to express some very common, very useful concepts succinctly and easily -- concepts that are difficult or even inexpressible in reliable old Java.

Mixins, code blocks and closures, singletons, built-in collection types, maps, folds, and many more inventions make coding some concepts orders of magnitude easier, shorter, and more readable than what is available in Java.

Even if you can't imagine programming anything but Java in your day job, you need to be aware of what's on the horizon -- newer, alternative VM languages are the future. Come and learn about them before the wave rolls you by.