by Neal Ford
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours, sometimes even minutes, no matter what the size of a project or the complexity of its code base.
In this workshop we take the unique approach of moving from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. We spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
In the second half of the workshop, we introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We'll discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.
by Arun Gupta
The Java EE 6 platform allows you to write enterprise Java applications using much lesser code from its earlier versions. It breaks the "one size fits all" approach with Profiles and extensively improves on the Java EE 5 developer productivity features. Several specifications like CDI, JSF 2, EJB 3.1, JAX-RS, JPA 2, Servlets 3, and Bean Validation make the platform more powerful. It also enables extensibility by embracing open source libraries and frameworks such that they are treated as first class citizens of the platform. NetBeans, Eclipse, and IntelliJ provide extensive tooling for Java EE 6.
This hands-on lab builds a complete end-to-end application using all different technologies of Java EE 6 with NetBeans. You'll learn the tips and tricks to be more effective in your development and deployment cycles. And you'll also learn how to monitor your Java EE 6 applications more effectively. A quick preview of Eclipse and IntelliJ tooling will also be shown.
by Lars Vogel
Getting started with Android is simple. This session presents the basic architecture of Android, demonstrates the Android Development Tools (ADT) for Eclipse, and guides the audience through the base concepts like Activities, Services, Broadcast Receiver and ContentProvider.
During this presentation an Android application is live developed. This application demonstrates the creation of a several Android programs including a drawing program and how to track incoming phone calls. via incoming calls.
After this session the audience should feel comfortable to start developing own Android Applications.
Let's face it, the cloud's here to stay. Spring's always been about portability and choice, and the cloud is no different. CloudFoundry, introduced to rave reviews and massive enthusiasm in the NOSQL, Node.js, Ruby, Scala and Java communities, represents the most promising, most open cloud platform for Java and Spring applications today, and tomorrow. In this talk, Josh Long will introduce CloudFoundry, it's architecture, and how it can be used with existing Spring applications and new ones, leveraging Spring 3.
Kanban is a software development methodology that implements the pull and flow elements of lean thinking. Learn how to use Kanban as a tool that can enhance other methodologies through visualisation of the workflow to highlight bottlenecks, impediments and other problems, limiting work in process to eliminate waste, and more. This talk introduces Kanban from a practitioners point of view which let you get started with Kanban and lean inspired enhancements right away, regardless of what methodology you use today.
We will show the mechanics of visualisation, flow, and how to monitor the flow in order to identify bottlenecks, impediments etc, using animations of real bords created with more than 150 photographs. This method has shown to be very popular and successful when teaching the practice of Kanban to many teams.
There will also be a case study of a Scrum team that adopted Kanban. This will give attendees an opportunity to learn and discuss how to apply Kanban to their own team and process.
by Robert Nyman
Java EE 6 contains new APIs that revolutionary change the way you can build enterprise level applications with an even stronger focus on ease-of-development and further reducing the need of boilerplate code and configuration. The result is a strongly simplified programming model, while still keeping enterprise features such as transactions, security, load-balancing and fail-over.
In this session we'll demonstrate how to use the APIs together to build a portable, full stack enterprise application and solve real-world problems. We'll not only focus on the APIs but we'll also show you how to set up a vanilla Maven build from scratch and do unit and integration testing going into almost all parts of the Java EE 6 specs.
At the end we'll discuss the architectural consequences of this simplified programming model. Do we still need business delegates, transfer objects or DAOs? And what about separation of concerns? The session is fun and very interactive while still showing the technology in depth.
by Greg Young
In this tutorial we will look at Command and Query Responsibility, Segregation and how it can be applied with Event Sourcing. Subjects included will be what the patterns are, what problems they can solve, and how to apply the patterns. Attendees need bring nothing but an open mind and some experience in "enterprise" development.
Play! framework brings expressive and productive development to the Java world to match Rails, Django etc. This tutorial will teach what is great about playframework, how it differs from traditional java web development and illustrate this with live coding tutorial where participants build a small web application supported by experienced practitioners. We will also briefly touch on common pitfalls, the Scala module, the upcoming 2.0, and other back ends.
Bring a laptop with your favourite editor!
by Juergen Hoeller
The Java space is facing several disruptive middleware trends. Key factors are the recent Java EE 6 and Java SE 7 platform releases, but also modern web clients, non-relational datastores and in particular cloud computing, all of which have a strong influence on the next generation of Java application frameworks.
This keynote presents selected trends and explores their relevance for enterprise application development, taking the most recent Java SE and Java EE developments into account as well. In addition, the Spring Framework will serve as a reference example for an application framework on top of modern deployment platforms.
Topics include flexible deployment, web endpoints, caching abstractions, access to alternative datastores, and patterns for concurrent programming.
by Cliff Click
Just what the heck is a JVM *supposed* to do? JVMs already provide a host of services. The 'J' part definitely slants the service selection and the 'V' part means that underneath the illusion there's a lot of really cruddy stuff. The success of these illusions has led to the real popularity of JVMs. In particular, JVMs are probably the most popular way to distribute ready-to-use GC technology to the masses, and the 2nd most popular way to distribute ready-to-use compilation technology (just behind "gcc" I'm guessing).
Just what are these illusions?
But these are not enough! The People cry out for more illusions! The illusion of an Infinite Stack (tail recursion), the illusion that running-code-is-data (closures), the illusion that Integers are as cheap as 'ints' (autoboxing optimizations), or that BigIntegers are as cheap as 'ints' (tagged ints), the illusion that memory supports atomic update (software transactional memory), or the illusion that with enough hard work other language implementation experts can make a JVM run utterly different languages (invokedynamic).
Meanwhile, JVM engineers labor under the illusion that they can maintain this giant piggy pile of code, and maybe even expand the provided services without it collapsing under it's own weight.
Here's my take on what services could & should be provided by a JVM, what services probably belong to the next layer up (STMs, new concurrency models), and what services belong to the next layer down (fast time management, sane thread scheduling).
by Toomas Römer
Jenkins is believed to be a continuous integration tool, but in reality it is an orchestration platform with a GUI. The large set of plugins and the loose definition of projects lets you use Jenkins for operations that it was not originally meant for. We use it for building software, artifact propagation, release management, VCS branch propagation, cron replacement, server monitoring etc. In this session, I will go through the different successes and failures that we?ve experienced in the past years of using Hudson/Jenkins to get our products and company off the ground.
There is widespread acceptance that software development using Agile methods works well. However, there are still areas of software development organisations that view their roles or mandates as incompatible with Agile methods. This talk addresses the legitimate role of an Enterprise Architect and provides concrete recommendations on how Architects can work with Agile development teams to accomplish their objectives. Topics will include concerns about data architecture, addressing the "ilities", and why evolutionary architecture works.
by Peter Hilton
The Play framework has brought high-productivity web development to Java with three innovations that changed the rules on Java EE: Java class and template save-and-reload that just works, a simplified stateless architecture that enables cloud deployment, and superior ease-of-use. Following Play's rapidly-growing popularity, Play 2.0 will be released in early 2012 with innovations that are not just new in the Java world: type safe view templates and HTTP routing, compile-time checking for static resources, and native support for both Java and Scala.
Type safety matters. After dynamically-typed programming languages such as PHP and Ruby set the standard for high-productivity web development, Play built on their advantages and has created a type safe web development framework with extensive compile-time checking. This is essential for applications that will scale to tens of thousands of lines of code, with hundreds of view templates. Meanwhile, Play avoids the architectural-complexity that is promoted by Java EE-based approaches. The result is that Play 2.0 first enables rapid initial application development and then Play 2.0 helps you build big, serious and scalable web applications.
Kotlin is a new statically typed JVM-targeted programming language developed by JetBrains and intended for industrial use. Kotlin is designed to be fully Java-compatible, and at the same time safer, more concise than Java and way simpler than its main competitor, Scala. Also, IDE support is being developed in parallel with the language itself.
Kotlin is under development. Currently, documentation describing the design of the language is available, and an initial beta release of the compiler is planned for the end of 2011.
In the presentation, we will give an overview of the language and demonstrate the IDE support capabilities. The features we're planning to cover include: first-class functions (closures), pattern matching, null safety and automatic casts, extension functions, class objects, reified generics and declaration-site variance.
Project homepage: http://jetbrains.com/kotlin
by Marcus Ahnve
The most important question to be asked when developing a new software system is "How will we replace it?" It is however a question seldom asked. Instead organization focus on reusability, which unfortunately helps create rigid and inflexible architectures.
The talk shows how to design systems made up of small parts, why you should standardize on protocol and not platform and how you will end with a system that is easier to scale and maintain.
AST Transformations are how many language features are implemented, and is the magic behind frameworks like Lombok, Groovy, Mirah, IDEA Inspections, CodeNarc, Spock, and Groovy++. This session reviews these approaches including examples of how and why we'd want to do this. Come see the newest language tools, look in-depth at production deployed AST Transforms, and view libraries based on these techniques.
by Bodil Stokke
With Java 7 being GA you can start thinking about putting it to work in the Enterprise. But what are the challenges? How does the adoption path look like? What are the reasons you should do it and when? This session looks at the details about putting Java 7 into production. Tells you about things to keep in mind and gives a brief overview about how Enterprises would put it into production.
by Hardy Ferentschik
Ant, Maven, Gradle, Buildr - the choice of built systems for Java based systems is manifold and only discussions about coding styles are getting more heated than discussion on which built system is superior. In this talk we are looking at two built system - the well established veteran Maven against the Groovy based newcomer Gradle. Where are the similarities between these two built systems and what differentiates them? Why and when would you chose one over the other? Both built systems are introduced by examples and the Open Source project Hibernate is used as a case study for a migration from Maven to Gradle. We will learn why this migration took place and what the lessons learned were.
by Pamela Fox
With the increasing availability of HTML5 client-side storage APIs like localStorage and IndexedDB, web developers can choose to store application information locally. But what should you be storing, how long should you store it for, and what technology should you use?
In this talk, I'll review the current storage APIs and libraries and give real world examples of how to use them across websites, mobile apps, and browser extensions both to improve performance and add functionality.
Modern Web apps are rich, snappy, and work offline and mobile, too. In this talk, we'll look at the frameworks and HTML5 features that make these possible and introduce Dart, a new language for structured Web programming. In particular, we'll take a look at the motivation for Dart, language syntax and features, the Dart Editor, using the Dart JS compiler, and improvements to the DOM. We'll take a look at several sample apps built with Dart and see how easy it is to use Dart with HTML5+CSS to create rich client applications.
by Ben Evans
Java 7 is only just out, so why are we already talking about Java 8? I'll explain how the 2nd half of 'plan B' plays out, what new technologies are coming in Java 8, what changes are happening in the overall Java roadmap and process and then showcase some examples of the sort of code you might be writing later on this year. The much talked about lambdas/closures will be covered in detail as well as modularisation and the host of small ticket items.
The Spring Framework has no-doubt played a major role in evolving the way we write enterprise applications on the Java platform today. However, it is still a proprietary framework owned by a single company. The age of having to rely on such proprietary frameworks in order to develop decent enterprise applications is now over and Java EE 6 has become an even easier way to develop enterprise applications based on standards which makes it the best choice for any enterprise application.
In this session you will experience how to migrate a typical full stack Spring application to a standards based, completely portable, Java EE 6 application including integration tests.
by Greg Young
Our application runs over 10,000 sustained transactions per second with a rich model. The key? Modeling state transitions explicitly. In today's world many systems have non–functional requirements that prevent them from being single database centric. This presentation looks at how Domain Driven Design can fit into such environments including extremely large scale web sites, batch processing, and even using highly scalable backing stores such as CouchDb or HyperTable. Event streams, a different way of storing the current state of an object, open many doors in this session not only in how we scale and store our domain but also in how we rationalize about it
Enterprises today collect and generate more data than ever before. Relational and data warehouse products excel at OLAP and OLTP workloads over structured data. The open-source project administered by the Apache Software Foundation known as Hadoop, is designed to solve a different problem: the fast, reliable analysis of both structured data and complex data. As a result, many enterprises deploy Hadoop alongside their legacy IT systems, which allows them to combine old data and new data sets in powerful new ways.
Technically, Hadoop consists of two key services: reliable data storage using the Hadoop Distributed File System (HDFS) and high-performance parallel data processing using a technique called MapReduce.
This technology opens the door to new enterprise solutions, as you no longer have to predict how you want to search or query your data in future use cases! This technology is playing a key role in the new trend of Big Data that is taking off in a rapid speed within huge enterprises.
Come see this talk to get an intro to Hadoop, what it is, and what it can do for you - and how you can get involved to influence the future!
Are you waiting for closures in Java 8 or hoping for more type inference in Java 9? Thinking about switching to Scala or even holding your horses for Ceylon or Kotlin? How about keeping Java where it seems fit, but replacing just its outdated parts with a concise and modern language? What about an enhancement to Java instead of yet another attempt to hire a killer.
Xtend is an an open-source programming language hosted at Eclipse.org and built for Java developers. It reuses Java's keywords, terminology and concepts as much as possible, but abandons some dead freight at the same time. Xtend is a very powerful alternative for implementing Java classes and works great with all the existing libraries. Since the language can be seen as a little complementary add-on to Java, it offers many modern language features that you are currently missing in your daily work. Xtend comes with a variety of goodies reaching from type inference over closures and extension methods up to smart string interpolation that make development great fun again. And of course there is powerful Eclipse IDE tooling available.
In this session we will demonstrate why Xtend is so great for everyday programming. You will get an introduction to the seamless integration with the Eclipse Java IDE and an impression of the expressiveness and conciseness of the language.
Short overview of what you have be aware of when you try to create a HTML5 port of your custom Java Swing components. Unfortunately one could not simply convert the Swing component to HTML5 but with a little knowledge and fortune one could port most of the Java2D code to HTML5 Canvas. As an example a gauge from the Java Swing library "SteelSeries" will be ported to HTML5 Canvas.
by Johan Haleby
Testing asynchronous systems is hard. Not only does it require handling threads, timeouts and concurrency issues, but the intent of the test code can be obscured by all these details. Awaitility is a small Java based DSL that allows you to express expectations of an asynchronous system in a concise and easy to read manner. Come and see how easily fragile time consuming tests can be transformed into its more robust and elegant counterpart.
13th–15th February 2012