Ways to Build a Modern Web Application

Joakim Kemeny, Callista Enterprise and John Wilander, Svenska Handelsbanken

Join us in a tutorial of tools, APIs, and frameworks to build a modern web application with backend and frontend. We will make use of HTML5 (history API, semantics, sandboxed iframe etc), client-side dependency management, templating, and MVC, RESTful services in Java, a CSS preprocessor, and even a dash of web sockets. Live coding style.
The tutorial will be given in Swedish.

Performance Optimization Methodology

Kirk Pepperdine, Kodewerk Ltd

Performance Optimization has always thought to be a fine art as it could not be easily formalized, or constrained into one solid workflow. However, there are common patterns all performance engineers could follow in their investigations. This session describes some approaches and tools to analyise modern application performance problems in Java and hardware.

First steps to Scala

Dick Wall, Escalate Software

In this session we will provide an introduction to the Scala programming language, a language that fuses object oriented programming with functional programming.

The session will cover topics including:
Using the Scala REPL
Control structures in Scala (while, if, try)
Type inference
Classes, Objects and Traits
Function Literals and Closures
Introduction to the Scala collections API
Avoiding nulls
For expressions
Approaching functional programming in Scala

and more if there is time. The material will be presented in 2 sessions of 1.5 hours each, and we will get through as much as possible in the time allotted.

Practical Guide to Modularity in the Cloud Age

Paul Bakker, Luminis Technologies and Bert Ertman, Luminis Technologies

Java EE 6 is an awesome platform and probably the best choice for any kind of enterprise (web) application today. But what about taking it to the next level? How do you design a system that can evolve for many years in production? And how do we run this stuff in the cloud?

Designing a system that can evolve without creating a maintenance nightmare is far from trivial and there are no silver bullets to do this correctly. A service oriented, modular architecture will help a lot to achieve this goal. Modularity forces separation of concerns which, when combined with a service oriented architecture, enables you to replace parts of a system without breaking others. The only mature modularity approach for Java is OSGi. OSGi is a framework that enables low-level modularity and services, but it is not an application framework like Java EE, i.e. you still need APIs to create web applications, use transactions, access data sources etc. Without these APIs you will have a hard time to actually build applications. Unfortunately OSGi and Java EE did not interoperate well in the past; it was very challenging to mix both. But what if we want modularity in our architecture, but also the ease-of-use of Java EE 6?

Luckily times are changing. All major application servers are getting support for deploying mixed Java EE and OSGi applications. This makes it possible to deploy OSGi bundles that contain Java EE 6 code such as EJBs, JPA and JAX-RS resources. CDI can be used to inject OSGi services and EJBs can easily be exported as OSGi services too.

The next question is how to deploy this in the cloud. Of course you could use one of the existing PaaS providers, but these basically deploy your old, monolithic WAR/EAR in the cloud. This doesn't fit modularity very well. How can you update just parts of a running application without breaking the rest of it? We will introduce Apache ACE, an Open Source Provisioning Platform to deploy OSGi bundles (containing Java EE code) and other artifacts to the cloud.

In this presentation you will learn the following things:

1. Understand the benefits of a modular code base
2. Learn how to mix OSGi and Java EE
3. Manage cloud deployments using Apache ACE

..and of course there will be lots of live coding!

Behaviour Driven Development with Cucumber for Java

Thomas Sundberg, Waymark

Cucumber has been around a long time in the Ruby world. It is a popular tool that allows development teams to describe how software should behave in plain text. The text is written in a business-readable domain-specific language and serves as documentation, automated test and development-aid - all rolled into one format. Cucumber-JVM has been available to the Java community since March 2012.

I will develop an example where we can see how a model will grow from the desired external behaviour. The developed model doesn't yet have a GUI. I will extend the example with a GUI without changing the wanted behaviour and test it using Selenium.

Feature: A system need to be developed to show BDD
-Given a requirement
-When we develop a model
-Then we have a working system

Feature: Add GUI to the system developed
-Given a model
-When we add a user interface
-Then we will not need to change the specifications

I will finally show you how Cucumber can be fitted into your continuous integration/delivery system using Maven and thus be a crucial part of your automated acceptance test suite.

Thinking and Programming in Functional Style

Venkat Subramaniam, Agile Developer, Inc.

Functional programming has been around for a while, however, they have sharply raised to prominence on the JVM with the emergence of languages like Scala, Clojure, Groovy, and JRuby. Programming in functional style is not about picking a set of syntax, it is thinking in a particular idiomatic style and programming using a set of constructs. One of the better way to learn this is by doing it. In this workshop, we will take ten different tasks, discuss how to do them with the all-too-familiar imperative style and then how to program it using functional style. We will then implement our design for each task using a language that provides functional style of programming on the JVM.

Continuous Integration with Jenkins

Kohsuke Kawaguchi, Cloudbees

Jenkins is a continuous integration server that facilitates the automation in software development. In this talk, I'll discuss what's new in the project, as well as various techniques to get more out of your Jenkins server, such as distributed build techniques, some key plugins, larger scale choreography that spans across many jobs for sophisticated automation, and so-called "unbreakable builds" set up that allows Jenkins to inspect incoming changes before it is made available to other team members.

Hands-on Lab: Deadlocks and Concurrent Testing in Java

Heinz Kabutz, JavaSpecialists.EU

One of the hazards of multi-threaded code is that if we are not careful, we might cause a deadlock in our program. The simplest of these is the "deadly embrace", where locks are acquired by multiple threads in different orders. The simple deadlocks can be detected automatically with the deadlock detection tool in the ThreadMXBean. However, there is another class of deadlock that requires us to analyze the stack traces of all the threads. In this hands-on-lab, we will explain what causes deadlocks and how we can find them. You will then be given a body of code to test for deadlocks using the techniques learned. We will also present techniques for testing concurrent code and show some of the pitfalls where the HotSpot profiler overoptimizes our code, thus leading either to code that does not fail, though it should, or that only fails in certain JVMs.

Hands-on Lab: The Mocca Raspberry Pi Hands on Lab

Simon Ritter, Oracle

The Raspberry Pi is a very cheap Linux machine designed for getting high school students interested in 'real' computer science. It's become very popular with hobbyists as well and is a great platform to see how embedded devices and applications can be developed. This hands on lab will show how Java and JavaFX can be used for applications on the Raspberry Pi, and how you can do some really cool stuff.

Secrets of an Agile Architect

Dan North, Dan North & Associates Ltd

We architects love a good framework. We like our abstractions, we like to design "enterprise" solutions, we like to mandate complex algorithms, or better yet to prescribe toolkits to enable other teams to implement complex algorithms under our expert guidance. If it looks like a good idea we slap the label "pattern" on it and tell everyone to do it.

Ok, maybe that isn't you. But it's likely you work in an organisation where the other guys do. So what can you do about it? Is this the only way to do architecture?

This toturial looks at strategies and techniques to incrementally architect your way out of a legacy mess, and to set up new applications for success.

Hands-on Lab: The President is.... (a Google App Engine Hands-On Lab)

Ludovic Champenois, Google and Alexis Moussine-Pouchkine, Google and Matt Stephenson, Google

Imagine you are tasked with putting together a web application offering information about an ongoing presidential election up to the moment the (new) president is finally announced. Obviously this application needs to scale to support many citizens for a given country. We'll build this application together, starting from scratch and using Google AppEngine. This will offer both PaaS newbies as well more advanced developers a very large tour of the requirements and capabilities of Google's flagship cloud service. Specific features covered include JSP/Servlet, user API and authentication, DataStore writes and queries, memcache optimisation, Cron jobs, sharded counter, blobstore uploads, sending/receiving email, and of course deployment, management and monitoring of the application running in Google's cloud.

Hands-on Lab: Developing JAX-RS Web Applications Utilizing Server-Sent Events and WebSocket

Markus Eisele, msg systems ag and Arun Gupta, Oracle

This hands-on lab guides attendees through building a Web application with the new JAX-RS 2.0 API. It shows how to use some value-added features of Jersey (the open source JAX-RS reference implementation) and Tyrus (the early draft implementation of Java API for WebSocket [JSR 356]) for leveraging HTML5 technologies such as server-sent events and WebSocket.