Stéphane Nicoll

Tutorial: "Bootiful" Applications with Spring Boot

Stéphane Nicoll, Pivotal

Spring Boot, the new convention-over-configuration centric framework from the Spring team at Pivotal, marries Spring's flexibility with conventional, common sense defaults to make application development not just fly, but pleasant! Ideal for microservices and for all your distributed systems and devops needs. Join Spring Boot co-lead Dave Syer and Spring committer Stéphane Nicoll for a look at what Spring Boot is, why it's turning heads, why you should consider it for your next application (REST, web, batch, big-data, integration, whatever!) and how to get started.

Gavin King

Presentation: 10 Ceylon Idioms

Gavin King, Red Hat

Ceylon is a new programming language that runs cross-platform on the Java Virtual Machine and JavaScript VMs. Ceylon features a flexible and very readable syntax, a unique and uncommonly elegant static type system, a powerful module architecture, and excellent tooling, including an awesome Eclipse-based IDE. In this talk, Gavin King will show how its unique static type system enables, and sometimes even requires, a different approach to some kinds of programming problems. In this session, we'll introduce the type system by presenting a series of simple examples, exhibiting common idioms in the language.

Jez Humble

Presentation: 21st Century Software Delivery

Jez Humble, Chef

For many years software engineering meant delivering software the way we constructed buildings. This turns out to be a wildly inefficient way to create innovative products and services based on software. In this talk I'll discuss what makes software different from buildings, and how we can take advantage of its unique properties to satisfy our customers through continuously delivery of valuable software. I'll also talk about how you can adopt these practices in the safety of your own office, and explore the art of the possible and the patterns and practices used by high performing companies.

José Paumard

Presentation: 50 new things we can do with Java 8

José Paumard, Freelancer

Java 8 is of course the release of lambda expressions, the Stream API and the Collectors class. These major language features and API shadow everything. But Java 8 has many more gems in many fields: a new API for dates, a new ConcurrentHashMap, a new HashMap, new concurrency utilities, and all kinds of little things that will make our lives easier, and that we present here. The goal of this talk is to present all the new things in Java 8 that are left once we have removed the lambdas, the streams, the collectors, JavaFX and Nashorn.

Petter Måhlén

Presentation: Asynchronous Java

Petter Måhlén, Spotify

In a microservices architecture, it's pretty common to want to build up a response based on a number of responses from downstream services. For performance reasons, you may not want to use threads that do blocking waits on the responses from those services. This type of code gets pretty hard to write using vanilla Java, and this talk would cover some tools and libraries that can help you write it, as well as best practices regarding how to do testing, error handling, etc. Tools and libraries covered: Guava, RxJava and Spotify's Trickle (which I am one of the authors of).

Nicola Paolucci

Presentation: Be a better developer with Docker: tricks of the trade

Nicola Paolucci, Atlassian

The talk will teach developers how to approach their development environment setups using Docker, covering awesome tricks to make the experience smooth, fast, powerful and repeatable. The talk is logically divided in three parts. Why Docker makes developers happier, Workflows and techniques and tips and tricks. The topics covered will be a selection amongst. Dockerfile caching concepts, Sharing folders into containers, Transparent tunnels, dynamic ports for your apps, Tiny Core Linux (the secret horse to super fast container automation) and heap orchestration tricks.

Mandy Waite

Presentation: Building responsive Web apps with Go, Polymer and Google Cloud Platform

Mandy Waite, Google

The Go programming Language continues to gain momentum amongst developers and is becoming extremely popular on Google App Engine. In this session will show how you can use the App Engine Go Cloud endpoints library to build from scratch, a service that exposes backend application functionality via a RESTful API running on the Google API infrastructure used to run Google's own APIs. We'll then look at how you can design and build a responsive frontend application that consumes this newly created API using Polymer and Web Components. We will also demonstrate how we used Web Components to build an interactive frontend for an existing Go application, the Kubernetes Container Cluster scheduler

Lauren Schaefer

Hands-on Lab: Code in the cloud for the cloud!

Lauren Schaefer, IBM

Software engineers everywhere are looking for faster, easier ways to get their jobs done. They don't want to worry with infrastructure or installing software--they just want to code!
In this hands-on lab, attendees will learn how they can leverage Software as a Service (SaaS) and Platforms as a Service (PaaS) to develop applications in the cloud without having to install any software on their devices.
Bring your laptop or tablet and get ready to code! Attendees will improve an existing application as they track their work, file defects, update the application's code, and see their application running live. They will also have the option of setting up automatic deployments, so they can see DevOps in action!

Jeremy Deane

Presentation: Concurrent Processing Techniques

Jeremy Deane, NaviNet

Traditional concurrent development on the Java Platform requires in depth knowledge of threads, locks, and queues. Fortunately, new languages and frameworks that run on the Java Platform have made concurrent programming easier. In this session, I will demonstrate several concurrent processing techniques including Fire and Forget, Fork-Join, and Asynchronous Web Services using the Java Concurrency Library, the Akka Framework and the Spring Framework.

James Weaver

Presentation: Creating Our Robot Overlords: Autonomous Drone Development

James Weaver, Oracle

Who wants a mindless drone? Teach it to "think", and it can do so much more. But how do you take it from Toy Story to Terminator? This session's speaker discusses a new open source library, Autonomous4j, for autonomous drone development. Combining this library and some components from their mad science toolkit, they demonstrate how to get your Internet of Things off the ground and do some real cloud computing. In the session, you'll learn how to write an autonomous drone program with Java 8; deploy it to the drone's "positronic brain," an onboard Raspberry Pi; have the Pi guide an AR.Drone to accomplish a task; monitor it via a JavaFX console; and create your own robot overlord. Demos are included: you've been warned!

Ken Sipe

Tutorial: Docker at Production Scale Tutorial

Ken Sipe, Mesosphere

There is no doubt that Docker has made containers a dev shop topic of conversation. The challenges is after learning how to use docker on your local machine, everyone asks the same question. "How do I scale this into production?". This tutorial will walk through the development steps of using docker using your favorite web application platform. The tutorial will continue with either a local virutal machine or a cloud setup on EC2 or Google Cloud Platform provisioned with Apache Mesos. Techniques covered in the tutorial will include: - Building a Docker container - Setting up a private Docker Repository - Setting up an Apache Mesos Cluster - Deploying Docker into a Docker - Scaling to multiple instances - Load balancing behind HAProxy - Service Discovery

Anton Epple

Presentation: Dukescript, put Java into JavaScript

Anton Epple, Eppleton

HTML5 has won the race for the most interesting rendering technology, but with JavaScript it?s hard to write maintainable applications. DukeScript solves this problem by simply replacing JavaScript with Java. In this session, you?ll learn how you can program in Java, render in HTML5, and deploy to any device, from a desktop to an iPhone or Android Device. You can either use our existing APIs enabling modern architectural UI patterns such as MVVM via the Knockout API, or immediate mode rendering via the Canvas API, but you can also create your own APIs very easily and utilize existing JavaScript libraries hidden behind a type-safe Java API.

Benjamin Cabé

Presentation: End-to-end IoT solutions with Java and Eclipse IoT technology

Benjamin Cabé, Eclipse Foundation

The Internet of Things market is poised for exponential growth, but there are still lots of barriers that prevent building a real open Internet of Things. Over the last few years, Eclipse has been growing an ecosystem of open source projects for the Internet of Things that are used in real-world solutions, from smart gateways bridging sensors to the cloud to device management infrastructures or home automation systems. Java is a key enabler for the Internet of Things, and this session provides you with a concrete example of how to build an end-to-end solutions with the Eclipse IoT Java stack and projects such as Kura, Paho (MQTT), Californium (CoAP) and Concierge (lightweight OSGi implementation).

Henri Muurimaa

Presentation: Functional UI Programming

Henri Muurimaa, Vaadin

The functional programming style fits the event based development paradigm of Vaadin very well. This presentation explores how the functional features of modern JVM languages combine with Vaadin to allow you to write more clear UI code. After introducing the tools and concepts we start with a short Vaadin UI written in Java 7. Next, we evolve it step by step using the capabilities of Java 8 and Scala to demonstrate the benefits of each. We will also see how Vaadin makes it easy to utilize the functional reactive approach in your user interface logic.
No prior experience of Java 8, Scala or Vaadin is needed to follow the presentation. A basic understanding of Java and interest in the functional approach are sufficient.

Angela Caicedo

Hands-on Lab: Go With The Flow: Streams and Lambdas Power Lab

Angela Caicedo, Oracle

Java SE 8 introduced the biggest changes to the Java platform since its launch nearly 20 years ago. The two main features are Lambda expressions and the Streams API. When combined these features provide a more functional style of programming that will be unfamiliar to many experienced Java developers and requires a different way of thinking when designing solutions to problems. This lab provides a range of exercises intended to get attendees thinking differently about the approach they take to common bulk operations on collections. The exercises will start with simple introductory type problems and work up to complex, more real-world scenarios. An introduction will be given at the start of the lab to set the scene in terms of the features used and will conclude with the solutions

Jeremy Deane

Tutorial: Guerrilla Messaging

Jeremy Deane, NaviNet

This workshop will cover everything from messaging basics to advanced messaging techniques leveraging Enterprise Integration Patterns. In addition, the workshop will include a demo that can be turned in to a hands-on exercises using Apache ActiveMQ and Camel.

Axel Fontaine

Presentation: Immutable Infrastructure generation: the new App Deployment

Axel Fontaine, Boxfuse GmbH

App deployment and server setup are complex, error-prone and time-consuming. They require OS installers, package managers, configuration recipes, install scripts, server hardening and more. But... Is this really necessary? What if we could start over and radically simplify all this? What if, within seconds, we could wrap our app into the smallest machine required to run it and transfer this machine unchanged from our laptop to the cloud? How do the various platforms and tools like AWS, Docker and Boxfuse fit into this picture? When should you use them? This talk is for developers and architects wishing to radically improve and simplify how they deploy their applications. It takes Continuous Delivery to a whole new level. Welcome to Immutable Infrastructure. This is the new black.

Andrey Adamovich

Hands-on Lab: Infrastructure Automation with Gradle and Puppet

Andrey Adamovich, Aestas/IT

Infrastructure-as-code is becoming a mandatory part of any successful project. During this presentation we will show how to use Gradle plugins and Puppet manifests to provision and maintain consistent infrastructure configuration. We will also touch tools like Jenkins, Vagrant, Packer, VirtualBox and AWS. It is advised to have laptops with at least 8GB for this workshop. During last years we accumulated a lot of experience helping our clients automating their JVM projects starting from automated deployments and ending with fully automated production infrastructure configuration. I would like to share this experience in a workshop.

Kent C. Dodds

Tutorial: Introduction to AngularJS

Kent C. Dodds, Alianza Inc.

AngularJS is one of the most popular frontend frameworks out there right now. If you haven't tried it yet, prepare to be amazed! Here's what we'll cover:
1. Templates/Expressions - Your View
2. Module - Your app's namespace
3. Directives - DOM Interface
4. Filters - Display utils
5. Scope - What on earth is this thing!?
6. Controllers - The View Model
7. Services - Common utilities
8. Working with third-party modules
9. Routing - Single Page App with state in the URL
10. Firebase & AngularFire - A full web application with no server setup required!

We'll be following through a repository hosted on GitHub. There's a branch for each concept, so you can play around with the code and then catch right back up with the next branch. So come on, and let's learn AngularJS!

Zach Shelby

Keynote: IoT Opening Keynote

Zach Shelby, ARM

Opening keynote

Raoul-Gabriel Urma

Tutorial: Java 8: the Java you've always wanted

Raoul-Gabriel Urma, University of Cambridge Richard Warburton, Monotonic Ltd

Java 8 is here! Now the honeymoon period is over larger companies and innovators are starting to use the new features. However, Java 8 isn't just another version of Java, it fundamentally changes how you are able to approach problems. This tutorial session will help bootstrap your learning of two of the fundamental changes, lambada and streams. That is the introduction of functional programming and how we freely switch between OO and functional style of programming. The session will introduce each of the libraries building on practical applications from two bestselling Java 8 authors.

Marcus Hirt

Hands-on Lab: Java Flight Recorder Lab

Marcus Hirt, Oracle Klara Ward, Oracle

In this lab the attendees will learn how to use the Java Mission Control tool and especially Java Flight Recorder. We will look at how to create flight recordings and how to analyze them to find potential performance problems. Problem areas include Excessive GC, Synchronization problems and finding execution hotspots

Marcus Lagergren

Tutorial: Jfokus VM Tech Summit, part 1

Marcus Lagergren, Oracle

Jfokus VM Language Summit is an open technical collaboration among language designers, compiler writers, tool builders, runtime engineers, and VM architects. We are sharing our experiences as creators of programming languages. We also welcome non-JVM developers on similar technologies to attend or speak on their runtime, VM, or language of choice. We are dividing the schedule equally between traditional presentations 45 minutes and "workshops". Workshops are informal, facilitated discussion groups among smaller, self-selected participants. They enable "deeper dives" into the subject matter. Space is limited: This summit is organized around a single classroom-style room, to support direct communication between participants.

Marcus Lagergren

Tutorial: Jfokus VM Tech Summit, part 2

Marcus Lagergren, Oracle

Jfokus VM Language Summit is an open technical collaboration among language designers, compiler writers, tool builders, runtime engineers, and VM architects. We are sharing our experiences as creators of programming languages. We also welcome non-JVM developers on similar technologies to attend or speak on their runtime, VM, or language of choice. We are dividing the schedule equally between traditional presentations 45 minutes and "workshops". Workshops are informal, facilitated discussion groups among smaller, self-selected participants. They enable "deeper dives" into the subject matter. Space is limited: This summit is organized around a single classroom-style room, to support direct communication between participants.

Arun Gupta

Presentation: Lessons Learned from Real-World Deployments of Java EE 7

Arun Gupta, Red Hat

Java EE 7, released over a year ago, introduced several new technologies such as WebSocket, Batch, and JSON. There are already three compliant application servers: WildFly, GlassFish, and Tmaxsoft. NetBeans, Eclipse, and IntelliJ provide extensive tooling support for the APIs. What are the best practices for building and deploying Java EE 7 applications? What to do and not to do? This session takes three Java EE 7 applications running in production and shares lessons learned from each one. It attempts to answer questions such as Is WebSocket ready for production? How do we migrate from Spring Batch to JSR 352 batch? Any change in DevOps? Are additional libraries still needed? Which is more prominent, EJB/JSF or REST/JavaScript?

Arun Gupta

Tutorial: Nuts and Bolts of WebSocket

Arun Gupta, Red Hat

WebSocket provides a rich and powerful communication channel where client and server cancommunicate with each other in a standard way. Would you like to learn how to build WebSocket applications in Java ? How and where do you deploy these applications ? What are the concerns around firewall, DNS and routers ? How do you debug message exchanges ? What to do if WebSocket is not supported in the browser or app server ? Debugging and Production tips ? Learn about phantom WebSockets. This uinversity session is for you! Here is what we'll cover: - Introduction to WebSocket - WebSocket using JSR 356 - WebSocket using Undertow/WildFly - WebSocket using Atmosphere - Surviving Firewall and Proxy - WebSocket Debugging

Vyacheslav Egorov

Presentation: Patterns of VM design

Vyacheslav Egorov, Google

The popularity of dynamically typed programming languages has been skyrocketing in the past years. This success can be partially attributed to the advances in VM engineering enabling efficient execution of those languages. Just like boilerplate of any enterprise application can be decomposed into infamous patterns of object oriented design, efficient virtual machines running dynamically typed languages seem to consist of reimplementations of common patterns of "VM design". These patterns often tread the thin line between efficiency, development time and maintainability. This talk discusses the trade offs we encountered while building virtual machines for JavaScript and Dart programming languages.

Joe Armstrong

Presentation: Pipes Were a Great Idea, But What Comes Next?

Joe Armstrong, Ericsson

This talk is about how we connect programs together. I'll talk about composing complex systems from simple parts. Simple things are easy to make, but complex things made by composing simple things are very difficult to build. It talk about why this is so, and what we can do about it. In this talk, I'll visit monads, pipes, protocols and contracts. Finally I'll suggest some ways to glue things together that provide stronger guarantees of consistency than many of the methods we use today.

Raoul-Gabriel Urma

Presentation: Pragmatic Functional Refactoring with Java 8

Raoul-Gabriel Urma, University of Cambridge Richard Warburton, Monotonic Ltd

You may be hearing a lot of buzz around functional programming. For example, Java 8 recently introduced new features (lambda expressions and method references) and APIs (Streams, Optional and CompletableFutures) inspired from functional ideas such as first-class functions, composition and immutability. However, what does this mean for my existing codebase? In this talk we show how you can refactor your traditional object-oriented Java to using FP features and APIs from Java 8 in a beneficial manner. We will discuss things like: How to adapt to requirement changes using first-class functions. How you can enhance code reusability using currying. How you can make your code more robust by favouring immutability over mutability. How you can reduce null pointer exceptions with Optional

Paul Bakker

Presentation: Provisioning the IoT

Paul Bakker, Luminis Technologies Sander Mak, Luminis Technologies

How do we get our software out on the Internet of Things? Many assumptions in current deployment practices don't hold up. Devices can be occasionally connected, through low-bandwidth networks and are generally outside of direct control. Manually shuffling around binaries is not an option. Apache ACE is an open-source Java provisioning tool tackling such challenges.You can manage Java apps and configs in a modular fashion. The foundations of ACE are OSGi, semantic versioning and reliable communication. Pushing out incremental updates and managing numerous devices becomes possible. We'll show an example where a fictional car-entertainment system is updated and extended using ACE. Although the talk focusses on IoT, the mechanisms demonstrated applies to environments like the cloud too.

Sven Anders Robbestad

Presentation: Reactive Programming in JavaScript

Sven Anders Robbestad, Inmeta Consulting AS

Go reactive with me as I'll get you up to speed on react.js and go through the process of getting started with reactive programming. Learn how to "think in React". This means throwing out the classic MVC pattern, and start re-rendering your entire application everytime your data changes. This a radical approach that requires a new way of thinking when you're developing apps. In this talk I'll walk you through a demo app which will show you how React components are built, how they operate and how they communicate with each other.

Mathias Doenitz

Presentation: REST on Akka: Connect to the world

Mathias Doenitz

Geared towards providing and consuming REST APIs in high-performance systems, akka-http enhances the increasingly popular Akka toolkit ( with its own client- & server-side HTTP stack: - Fully async & non-blocking - Reactive-Streams "all the way through ( - Flexible and concise, yet powerful and type-safe high-level APIs - Entirely written in Scala, no external deps - Deeply typed, immutable HTTP model - Successor of Akka-http delivers an excellent tool for connecting your applications to the world. In this session we'll look into what akka-http brings to the table, how it is used and how it improves upon previous solutions. You'll learn about best practices, who'll benefit most from its features as well as the roadmap forward.

Martin Kleppmann

Presentation: Scalable real-time data processing with Apache Samza

Martin Kleppmann

High-volume event streams are becoming widespread: IoT sensor data, activity events on social media, and monitoring events for fraud detection, to mention just a few. Hadoop is great for analysing data after the fact, but it's often too slow to respond to things happening right now. Traditional event processing frameworks are not scalable enough to handle the onslaught of data. Apache Samza and Apache Kafka, two open source projects that originated at LinkedIn, have set out to solve this problem. They are designed to go together: Kafka is a fault-tolerant message broker, and Samza provides a scalable and powerful processing model on top of it. This talk will introduce those projects, and explain how you can use them to solve your real-time big data problems.

David Currie

Presentation: Scalable, Available and Reliable Cloud Applications with PaaS and Microservices

David Currie, IBM

Attendees at this session will discover how a combination of Platform-as-a-Service and a microservices architecture can provide the basis for a scalable, highly available and reliable web application running in the cloud. We'll show how simple it is to take a Java web application and scale it with a Platform-as-a-Service offering such as the open source Cloud Foundry. We will then see how breaking an application down in to microservices can increase the reliability of the application. Specifically, we'll look at using the Netflix OSS projects to isolate and monitor service interactions.

Kai Kreuzer

Presentation: Smart Home Development Made Easy

Kai Kreuzer, Deutsche Telekom AG

Despite the buzz around the Internet of Things (IoT) there are still many devices, systems and protocols for home automation that cannot be directly hooked up to your wifi and used through IP. To enable smartphone apps to access them and to integrate them with other devices, a home gateway is required. Eclipse SmartHome is a flexible software framework for such home gateways. It was initiated by the popular open-source project openHAB, which connects to a multitude of different systems and comes with powerful automation rules and nice UIs. Its modular architecture guarantees simple extensibility. This session includes live hacking and you will of course see a smart home live demo that goes way beyond the standard use cases.

Simon Maple

Presentation: The Adventurous Developer's guide to Application Servers

Simon Maple, ZeroTurnaround

There are many application servers on the market today, but which are right for you as a developer? This session looks at the popular application servers?including Tomcat, TomEE, GlassFish, Jetty, IBM WebSphere, Oracle WebLogic Server, Liberty Profile, and JBoss/WildFly?and analyzes them from the point of view of a developer. It focuses on performance, config management, open source compliance, feature richness, tooling, and developer productivity, among others. Come to this session to learn about the main differences between the application servers on the market today and understand which might be best for your needs.

James McGivern

Presentation: The House That Skynet Built

James McGivern, Cisco Cloud Web Security

We are rapidly entering a world of agents: microservices, internet enabled devices (IoT), bots, and robotics. However, even when acting on simple rules, unexpected, and sometimes disastrous, behaviours can occur. By looking at examples such as the algorithmic trading on stock markets and SmartHomes we will seek to understand "emergent behaviour", how complexity and choas theory can predict the behaviour of these systems, and the practical and pragmatic ways of preventing and limiting the negative effects. The aim is to get developers thinking in a "multi-agent" paradigm, which in a way is the next abstraction level up from multi-threaded design considerations, whether the system comprises fully autonomous or semi-autonomous agents, controlled by a "central AI", or a hybrid of all of these.

Daniel Bryant

Presentation: Thinking Fast and Slow in Software Development

Daniel Bryant, Open Credo

In the international bestseller 'Thinking, Fast and Slow', Daniel Kahneman explains how we as human beings think and reason, and perhaps surprisingly how our thought processes are often fundamentally flawed and biased. This talk explores the ideas presented in the book in the context of professional software development. As software developers we all like to think that we are highly logical, and make only rational choices, but after reading the book I'm not so sure. Here I'll share my thinking on thinking. Topics that will be discussed include; the 'Availability Heuristic', which can lead developers to choose the 'latest and greatest' technology without proper evaluation; 'Optimistic Bias' which can blind architects from the 'unknown unknowns' within a project; and more!

Oleg Shelajev

Presentation: Unlocking the Magic of Monads in Java 8

Oleg Shelajev, ZeroTurnaround

This session demystifies what monads are and outlines reasons why you would even want to introduce them into your code. It takes a look at the traditional definition of monads and offers a corresponding type definition in Java. You'll see a sample Java 8 implementation of a 'Promise' monad, which represents the result of async computation, to help answer practical questions about monads. Also, the presentation goes over the laws of monads and shows that you can have a proper monad in Java if you are brave enough to allow the underlying platform to change the rules a bit. PS: You won't be penalized or ridiculed during this session for your (lack of) Haskell knowledge!

Kent C. Dodds

Presentation: Using ReactJS with existing AngularJS codebase

Kent C. Dodds, Alianza Inc.

ReactJS is an amazing View library that promises (and delivers) high performance, composability, and maintainability. AngularJS is an amazing MV* framework.
Tons of shops have adopted and totally bought into AngularJS for their entire frontend application. They're loving it, but some are finding that as these applications get bigger, they can become unwieldy, unperformant, and difficult to reason about. Many of these problems can be solved by doing things better with angular, but not all of them.
In this talk, we'll go over why you don't need to re-write your whole application to get some of the wins of React and that it actually is quite easy to integrate the two. We'll talk about where it makes sense to bring in React to an existing Angular codebase and how it works well.

Stephen Chin

Presentation: ZombieTime - JSR 310 for the Undead

Stephen Chin, Oracle

Surviving as a zombie is tough... with the constant risks of sunlight, fire, and pesky mobs, doing your job of infecting the local villagers can be deadly. Fortunately, with the new JavaFX ZombieTime app, powered by the JSR 310 Date and Time API, you can rest easy. With built-in time zone and DST support you no longer have to worry about roaming around under the scorching hot sun. Accurately calculate out how long you have to infect the villagers before you decompose using Durations. And coordinate global attacks on the humans by syncing with your undead brethren on Instants. This presentation is designed to teach Java Date and Time APIs to the undead, but the living are welcome to be our "guests".



Back to the top of the page