Talks

Stéphane Nicoll

Tutorial: "Bootiful" Applications with Spring Boot

Stéphane Nicoll, Pivotal David Syer, 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.

Tomer Gabel

Presentation: 5 Bullets to Scala Adoption

Tomer Gabel, Wix

So you've heard of this newfangled "Scala" thing and think it might be worth checking out. Good for you! Unfortunately, it's also daunting. Your first search for Scala is likely to pitch it as a "statically-typed hybrid object-oriented and functional language", which is technically true but doesn't really help much.

Instead, this talk will provide an overview of the language, focusing on five highly practical advantages Scala has over Java without a brain hemorrhage-inducing paradigm shift, followed by some tips and recommendations on Scala adoption in the real world and (as time allows) open-ended Q&A.

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.

Tomer Gabel

Presentation: A Field Guide to DSL Design in Scala

Tomer Gabel, Wix

Scala's powerful type system and flexible syntax enable the design of internal DSLs, e.g. for test specifications in Specs²/ScalaTest, routing in Spray and query construction in Squeryl. While immensely useful, the budding DSL designer will quickly realize that there are precious few resources on how to approach DSL construction in Scala; the techniques, limitations and workarounds are not well understood or documented. In this talk I'll attempt to summarize lessons learned from reading, extending and designing Scala DSLs in the hopes of saving future Scala library designers a world of pain.

Magnus Larson

Quickie: Adding social login to a website using Spring Social

Magnus Larson, Callista Enterprise AB

Handling user registration and authentication on a website is hard, both for the users required to remember yet another pair of username/password and for developers implementing a secure handling of the user credentials. With requirements of more sophisticated login-methods such as two-factor authentication and single sign-on it gets even worse. A few years ago websites started to use social login, i.e. delegating the sign in process to social network services such as Facebook, Twitter and Google+. Initially social login was rather complex to setup and a number of commercial offerings evolved to simplify the setup. Today a free and open source based alternative exists, the Spring Social project. This presentation will describe how Spring Social can be used to setup social login.

Ken Sipe

Presentation: Advanced Java Unit Testing with Spock

Ken Sipe, Mesosphere

The Spock unit testing framework is on the verge of a 1.0 release and has already proven to be the next-generation thinking on how to test Java production code. Using Spock is hands-down the best way for developers to mock and test Java applications. One of Spock?s great features is the ability to write your own custom extensions. This session is a fast-paced (not for beginners), code-centric overview of how to use the advanced features in Spock, including custom extensions and interceptors.

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.

Lauren Schaefer

Presentation: Be Agile, Code, & Do DevOps--Completely in the Cloud!

Lauren Schaefer, IBM

Software development teams 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 presentation, Lauren will explain (and demo!) how you 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 your devices. She'll demonstrate how you can use Agile planning tools, code in the cloud, and set up automatic deployments (DevOps!) to collaborate with your teammates completely in the cloud.

Chris Chedgey

Presentation: Beautiful Structure

Chris Chedgey, Structure101

You know beautiful code when you see it. But what about lots and lots of beautiful code; is it still beautiful at a distance? "Structure" is how all the snippets of code are organised into containers (methods, classes, packages, jars, etc.) and how the containers relate to each other. The same code can be organised into anything from a hopelessly tangled mess, to a Beautiful Structure. This talk will explore how "locality of relationship" affects coupling, cohesion, and the width of interfaces. It will show how some structural patterns dramatically increase complexity, and how alternative patterns can massively decouple and simplify. The structure of open-source Java projects (such as the beautifully-structured Spring framework) will be used to illustrate the principles.

Mark Reinhold

Presentation: Beyond Java 9

Mark Reinhold, Oracle

Is there life after Java 9? Most definitely! This session will offer a highly-speculative sneak preview of advanced features currently in development for the Java language and virtual machine.

Angela Caicedo

BOF: Bringing MYO to the Java World!

Angela Caicedo, Oracle

One area that had always caught my attention in technology is how people interact with software applications. Using hand gestures is the most basic of all forms, but it has been missing for so many years. Finally we have a very cool technology available: the MYO wristband from Thalmic Labs. Join this session and learn how I'm incorporating Java into the MYO paradigm and how I'm using it to control a diverse type of applications, from wearable solutions to desktop apps.

David Chandler

Presentation: Building Amazing HTML5 Apps with Sencha GXT

David Chandler, Sencha

Sencha GXT (Ext GWT) is an open source, enterprise-class UI framework based on GWT for building amazing HTML5 apps using Java. Sencha GXT provides out-of-the-box support for high-performance widgets, feature-rich templates, layouts, advanced charting, data loaders, stores, and much more, for building the most complex user interfaces with ease. The core advantage of using Sencha GXT is development time savings, allowing you to concentrate on building the desired functionality as opposed to underlying framework complexities. This session provides an overview of the Sencha GXT framework and explains how to get started with Sencha GXT in Eclipse or IntelliJ. In addition, we'll take a quick peek at super dev mode support in GWT 2.7.0.

David Syer

Presentation: Building Microservices with Spring Cloud and Netflix OSS

David Syer, Pivotal

Microservices? A thing? Or hype? What does it mean in practice? The answer, like so many Facebook statuses, is complicated. In broad strokes, microservice offer a refreshed approach to application architecture. Microservices are a new way to describe many of the patterns that have fallen out of large-scale applications in practice over the recent years. There is no doubt that the approach works. The question is: how does one build a microservice architecture? Join Dave Syer for this session introducing Spring's support for building microservice architectures, including both Spring Boot, and the new Spring Cloud project incorporating Neflix OSS.

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.

Jez Humble

Presentation: Creating Maintainable Automated Acceptance Tests

Jez Humble, Chef

Creating automated end-to-end functional acceptance tests is hard. Maintaining them over time is harder. Some agilistas even claim that the cost outweighs the benefit. In this lecture we present five principles for creating valuable, maintainable acceptance test suites. We discuss practices such as layering acceptance tests to reduce coupling between the test harness, and talk about how teams should be organized in order to efficiently manage acceptance test driven development. The core of the talk discusses how to manage the evolution of acceptance tests by organizing them as scenarios rather than as suites of story tests. Finally we show how to manage data for acceptance tests.

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!

Anton Epple

Quickie: Debugging the hell out of your HTML5 App with NetBeans

Anton Epple, Eppleton

NetBeans has silently converted to a top notch HTML5 / JavaScript IDE. Live debugging in Chrome, responsive previews, live CSS and DOM Inspectors make web development an immersive experience. Join this session to learn how NetBeans can simplify your life as a developer.

Matthias Grüter

Presentation: Docker and the JVM: a perfect match

Matthias Grüter, Transmode

Does your application deployment rely on an unhealthy amount of shell scripting glue code? Start encapsulating your application and its runtime environment in Docker containers. This talk will give you a brief introduction to the concepts behind Docker and a handful of tips to get you started on the exciting journey towards a more robust and reliable application deployment. By the end of the talk you will have learned how to build and deploy Docker images, how to let your containers talk to each other and why the JVM and Docker are a perfect match.

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).

Sander Mak

Presentation: Event-sourced Architectures with Akka

Sander Mak, Luminis Technologies

Different JVM languages lead to different architectural styles. We all know the typical three-tiered architecture and its limitations. Akka and Scala offer event-sourcing. Event-sourced apps model all state changes explicitly and store them immutably. The actor model makes this horizontally scalable. Even better are the functional benefits: a provably correct auditlog and creating new views on past data. This session introduces the event-sourcing concepts. You?ll see how well they map onto actors. To prove this, we show an event-sourced application using Akka. The new Akka Persistence module provides excellent building blocks. Want to learn about the next generation of scalable architectures on the JVM? Check out event-sourcing with Akka!

Yoav Landman

Presentation: Everything you wanted to know about writing async, high-concurrency HTTP applications in Java, but were afraid to ask

Yoav Landman, JFrog

Facing tens of millions of clients continuously downloading binaries from our repositories, we decided to offer an OSS client that natively supports these downloads. In this talk we will share the main challenges in developing a highly-concurrent, resumable, async download library on top of Apache HTTP client. We will cover other libraries we tested and why we decided to reinvent the wheel. We will see important pitfalls we came across when working with HTTP and how using the right combination of techniques can improve performance by a magnitude. We will also see why your initial assumptions may completely change when faced with other players on the network. Consider yourself forewarned: lots of HTTP internals, NIO and concurrency ahead!

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

Angela Caicedo

Hands-on Lab: Going Wearable: Java, Raspberry Pi, and Cool Peripherals

Angela Caicedo, Oracle

This session's presenters say, "In the last couple of years, we have been running the Java and Raspberry Pi hands-on lab. Due to the popularity this lab has always showed, we have decided to continue with it, improving and bringing new challenges for our developers. Given the big interest in the Internet of Things, we have decided to move it even further...vto wearable technology. For this lab, we are bringing an intelligent "glove" the attendees of the lab can program and play with. The glove includes some bend sensors, gyroscopes, accelerometers, and other interesting sensors, already attached to the Raspberry Pi. Come join us in this trip, where only your imagination is required!?

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.

Mårten Gustafson

Quickie: Heroku as a production platform

Mårten Gustafson, Plan 3

Learnings from using Heroku to host a distributed production system.

Christian Heilmann

Presentation: HTML5 after the hype

Christian Heilmann, Mozilla

HTML5 is a tricky subject. When we started with it, it was heralded as the solution to everything and the new amazing thing. When we started using it, we realised very soon that not every browser and environment was ready for it yet. Thus we started relying on abstractions which now are in the way of fast, memory-efficient and above all, good looking apps. In this talk Chris Heilmann will get us up to speed as to what can be safely used across browsers, how to decide what cool new technology to support and which one to maybe wait for a bit until they are supported by browsers without us as developers having to jump through hoops. If you are frustrated by HTML5, this is a good talk to get you happy again. You'll learn how to use some of HTML5's features in ways you don't expect

Nikita Salnikov-Tarnovski

Presentation: I bet you have a memory leak

Nikita Salnikov-Tarnovski, Plumbr

I will present a fairly simple web application, written using standard Java frameworks and libraries. What makes this application special is that it contains 8 different Permanent Generation memory leaks. They all are pretty standard, nothing obscure or weird. Each of them has a high chance to exist in your application as well. In fact the chances are so high I can bet a beer on the outcome.
I will describe each of these leaks explaining why this particular code leaks class loaders.
I will also reason, if this was a deliberate technical decision and/or the implementation was just sloppy. I will also show how to fix it.

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!

Charles Nutter

Presentation: InvokeBinder: Fluent Programming for Method Handles

Charles Nutter, Red Hat

The MethodHandle API provides a powerful way to build optimized function pointers that do a wide variety of call-path adaptations. Unfortunately, the API as designed requires mental contortions to write anything more than trivial handle chains by hand. Adaptations must be made backwards from the target, argument-list modifications are done by index and length, and debugging failed adaptations can be a terrific challenge. InvokeBinder seeks to make method handles fun and easy to use by providing a fluent API, building adaptations from the call forward, allowing argument-list manipulation by name and wildcard, and much more. We'll explore everything InvokeBinder does today and talk about improvements for the future.

Dan Heidinga

Presentation: J9's MethodHandle compilation pipeline

Dan Heidinga, IBM

Come hear about how IBM's J9 JVM approaches MethodHandle compilation. The MethodHandle architecture and the transitions from interpreted to compiled and finally to customized will be described. Recent performance optimizations will be touched on along with hints on how to aid the JVM to optimize your MethodHandle code.

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.

Mark Reinhold

Presentation: Java 9: Make Way for Modules!

Mark Reinhold, Oracle

Java 9 will introduce a standard module system to the platform in order to modularize the platform itself, improve performance and security, and simplify the development and maintenance of large applications. This session will explain how these changes will impact all developers, and also bring significant benefits.

Roberto Cortez

Quickie: Java EE 7 Batch Processing in the Real World

Roberto Cortez, Freelancer

This talk will explore one of the newest API for Java EE 7, the JSR 352, Batch Applications for the Java Platform. Batch is found in nearly every industry when you need to execute a non-interactive, bulk-oriented and long running operation task. A few examples are: financial transactions, billing, inventory management and so on. The JSR 352 specifies a common set of requirements that every batch application usually needs like: checkpointing, parallelization, splitting and logging. It also provides you with a job specification language and several interfaces that allow you to implement your business logic and interact with the batch container. We are going to live code a real life example batch application, starting with a simple task and then evolve it using the advanced API's.

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

Jaromir Hamala

Presentation: JCache is here. Say Goodbye to proprietary Caching APIs!

Jaromir Hamala, Hazelcast

JCache API (JSR-107) has been released in March 2014. For the first time since initial release of Java we have a standardized vendor-neutral API for caching. What does it mean for developers and why we should care? Isn't this yet another bloated & hard-to-use abstraction? This talk will introduce concepts and structures JCache is based on. I will show how to deal with differences in underlying implementations, how migrate from existing proprietary caching APIs to JCache and how to avoid common pitfalls.

Heather VanCura

Quickie: JCP, Adopt-a-JSR & You

Heather VanCura, Java Community Process

Learn how to take part in Java technology evolution through the Java Community Process (JCP) program. You can participate as an individual, corporation, or nonprofit such as a Java user group (JUG). This session gives you step-by-step instructions on how to participate in the JCP Program, the Adopt-a-JSR program and provides tools for running JUG events as part of the Adopt-a-JSR program. We will discuss details such as how to run hack days, translate content into local languages, and collaborate with other JUG leads on Adopt-a-JSR activities. In addition, highlights of use cases from JUG hack days and events leading up to and contributing to Java EE and Java SE JSRs will be shared.

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?

Tobias Järlund

Quickie: Making The News, One Small Microservice At A Time

Tobias Järlund, Aftonbladet

News websites used to be big monolithic systems, tightly coupled to a big monolithic CMS. But as the world of online news has gotten more complex, that's just no longer enough. This is the story about how Aftonbladet, one of the world's leading news sites, is transforming the architecture from a few big Java monoliths into a network of microservices. You'll get a quick history of Aftonbladet's architecture, and the reasons why microservices is the way forward. We'll touch on the key components that enables a microservice mindset, the importance of an asychronous flow, life in a polyglot environment, testing, the challenges and hard lessons learned, and the (mostly open source) tools used.

Andrey Adamovich

Presentation: Ninja Tricks for Groovy System Scripting

Andrey Adamovich, Aestas/IT

Do you write Bash, BAT, Python, Ruby, Perl, Lua scripts for system administration and scripting purposes? Stop! You don't have too. Since JVM ecosystem has a perfect answer - Groovy. With the release of version 2.3, Groovy is a mature and stable language that can be employed to deploy small scripts or to build large, mission-critical applications. This talk focuses on some less-known features of the language that are going to make the life of a Java/Groovy developer more fun than ever. In particular, this presentation will cover system administrator scripting toolkit that developers can take full advantage of: I/O operations, mini-DSLs, comparison to other languages like Python and Bash.

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

Charles Nutter

Presentation: Open Source Software Needs You!

Charles Nutter, Red Hat

Have you ever used an open source project? Of course you have, but have you made any contributions yourself? Filed a bug report? Submitted a patch? Have you ever started your own OSS project, or taken a closed/private project public? What licenses should you use? How do you manage contributions? How do you encourage contributors and get work done? In this talk we'll go over the basics of OSS: how to get involved, how to start a project, how to manage contributions. We'll discuss project lifecycles, legal CYA tips, and how to keep projects moving. You'll see the inner workings of real OSS projects, and learn how to be a better OSS user and producer.

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

James McGivern

Presentation: Probably, Definitely, Maybe

James McGivern, Rockshore Ltd

We live in an uncertain world and we deal with this by considering possibilities and probabilities; from what movies you might be interested in to what diseases you might have given your symptoms. But what is probability, how to we measure and work with it? Given the wealth of big data collected how can we use that to predict the future? What if there is noise in the data? What if the data changes over time? We start with the fundamentals of probability theory before looking Bayesian systems (frequently a key part of recommendation and expert systems), Markov chains (useful in predicting human behaviour), and dynamic Bayesian networks (such as Kalman filters and hidden Markov chains which are often used in real-time systems like auto-pilot navigation).

Geert Bevin

Keynote: Programmers are way cooler than musicians

Geert Bevin, ZeroTurnaround

Programmers are the wizards of our age. We weave the fabric of the modern society, tell the stories and bring dreams to life. Geeks are ruling the world of today and programmers make it all happen. The uninitiated marvel at what we accomplish without an inkling about how everything comes to fruition. Many centuries ago, musicians held a similar role in society but today they have lost that grasp on the world. Programmers are in an unprecedented position in which we can not only make a good living, but fuel our work with passion, creativity, collaboration, innovation, and forward thinking. Programmers can make a significant difference in a world that is truly our oyster, and that is worth celebrating.

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.

Forax Remi

Presentation: Proxy 2.0 - Behind The Scenes

Forax Remi, Paris East Marne la Vallee

One problem people that implement dynamic languages on the JVM have is the integration between their dynamic language and Java. This problem can be decomposed in several sub problems, some are easy like how to call a Java method from the dynamic language, some are harder like calling a function/method of a dynamic language inside Java or how to inherit/implement a Java class/interface inside the code of a dynamic language. Proxy 2.0 is a small library that aims to give a simple answer to these problems freeing people that implement dynamic languages from these problems thus lowering the bar to implement a dynamic language on top of the JVM. The code is freely available here: https://github.com/forax/proxy2

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 (akka.io) with its own client- & server-side HTTP stack: - Fully async & non-blocking - Reactive-Streams "all the way through (reactive-streams.org) - 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 spray.io 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.

Daniel Spiewak

Presentation: Scalaz Stream: Reactive Without the Buzzwords

Daniel Spiewak, RichRelevance

Scalaz Stream provides a framework for purely functional, non-blocking and IO-heavy applications operating at scale. The underlying principles are profoundly simple and yet scale remarkably well to hard problems, complex applications and high volume. This talk will provide a gentle introduction to Scalaz Stream, covering the fundamentals you need to get started with this powerful tool and also some advanced tricks and techniques derived from extensive use in a complex production application. We will also sneak a little vanilla Scalaz in the backdoor and maybe even see how it doesn't need to be quite so scary!

Daniel Spiewak

Presentation: Selfish Purity: How Functional Programming Makes Every-Day Jobs Easier

Daniel Spiewak, RichRelevance

Functional programming is too-often viewed as an academic discipline. And why not? After all, FP imposes constraints that seem to be more aesthetic and pedantic than practical, and almost all motivating examples for FP involve one-liners mapping over a list while hand-waving about endomorphisms rather than something more "down to earth". This talk takes a different approach.

Functional programming makes things easier. It makes it easier to write code, test code, design components and abstractions. It makes turnaround times faster, bugs rarer and even improves application throughput. This talk explains how all of this is possible and why it is precisely that I will *never* work on a serious application without FP again.

Benjamin Cabé

Hands-on Lab: Sensor Networks with Contiki and Java/Eclipse IoT

Benjamin Cabé, Eclipse Foundation

Join us for an extensive tutorial on sensor networks, involving Contiki on the embedded side, and Java/Eclipse IoT technologies on the server side.
We will introduce the core technologies of sensor networks such as 6LoWPAN, RPL, CoAP, and we will jump on very hands-on examples to get you started with Contiki, an operating systems for the "things" of the Internet of Things, and how to hook your sensors to your backend infrastructure using CoAP and Java.

We will cover many aspects of the development of an end-to-end IoT solution including:
* Setup a Contiki development environment,
* Contiki core APIs,
* Simulation of sensor networks,
* Exposing sensor data using CoAP,
* Bridging CoAP to good ol' HTTP,
* Intro to LwM2M and Device Management.

Gerrit Grunwald

Quickie: Sensor networks with Java SE embedded

Gerrit Grunwald, Oracle

Sensor networks are the way to go if you have to monitor environmental data such as temperature in a wide area. Usually you need some infrastructure, including servers for communication, data storage, and the like and to manage the network and make the sensor data available. This session shows how you could build a sensor network, including the infrastructure, based on embedded devices only. It uses several embedded devices such as a Raspberry Pi, a BeagleBone Black, a Cubieboard2, and an i.MX6-based Cubox-i. The idea is to use cheap standard devices in combination with Java technology to realize a sensor network. In addition, it shows mobile clients, such as a smartwatch, for visualizing the sensor network data.

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.

Simon Maple

Presentation: The Adventurous Developer's guide to JVM Languages

Simon Maple, ZeroTurnaround

Today there are over 50 actively worked JVM languages in existence today. Some have been ported to the JVM while others have been written specifically for the JVM. This hands on session with take an introductory (but non hello, world) look at a number of JVM languages including, Java 8, Scala, Groovy, Kotlin, Ceylon and Xtend as well as the tooling support, discussing how and why they came about along with the evolution of the languages and distinguish the innovative languages versus those which consolidate existing features from other languages. We'll cover our initial experiences including what rocked and sucked learning each one with example code snippets of a sample HTTP Server from each language. You don't need any prior knowledge in these languages to attend the session.

Zach Shelby

Keynote: The Future of IoT

Zach Shelby, ARM

The Internet of Things is here, and its just as big and disruptive as the Web was in the 1990s. Hear what is really happening in the IoT industry, how not to be another American Online, why the Cloud is just as important as Things, the birth of the IoT software ecosystem, and the role that Java is going to play in this space.

James McGivern

Presentation: The House That Skynet Built

James McGivern, Rockshore Ltd

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.

Nitsan Wakart

Presentation: The Illusion of Execution

Nitsan Wakart, Azul Systems

Contrary to our intuitions, the execution of our software is far from the continuous and sequential mental model we use when reading and writing code. In this talk we will discuss the gap between this model and the reality of the average Java application:
* Placing the Java process in the stack: HW (real/virtual)/OS/Process
* The other threads in your process
* When the JVM stops (and the promise of a "pause free JVM")
* Open to interpretation: from your code to assembly
* The pause button: Safepoints in your code
* Pointer accounting: store barriers and load barriers in your code

Niklas Therning

Presentation: The return of Java on the Mobile Client

Niklas Therning, RoboVM / Trillian Mobile AB Johan Vos, LodgON

While the Java Platform was initially targeting clients and embedded devices, the majority of the Java developers today are working on back-end systems. The lack of standardization in the mobile area, and the difficulties to run cross-platform Java applications made it very hard to create a successful Java client business. Today, this is changing. The popularity of the AppStore (for iOS devices) and the PlayStore (for Android devices) and the availability of Java and JavaFX SDK's for those devices allows Java developers to create real cross-platform Java applications. Join this session and learn how the work done by RoboVM and LodgON allows every Java developer to create native applications for iOS and Android.

Stéphane Nicoll

BOF: the Spring BOF

Stéphane Nicoll, Pivotal David Syer, Pivotal

A BOF for all fans of Spring to talk about the latest and greatest tech, including Spring Boot, the convention-over-configuration centric framework built on top of Spring.

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!

Adam Dunkels

Presentation: To be announced

Adam Dunkels, Thingsquare

To be announced

Petra Sundström

Presentation: To be announced

Petra Sundström, Husqvarna Group

To be announced

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.

Joonas Lehtinen

Presentation: Vaadin X and Web Components

Joonas Lehtinen, Vaadin

The upcoming web components standard promises encapsulation and isolation between web UI components so that they can be reused. The standard is built on shadow DOM, customer HTML elements, HTML import and CSS sandboxing. While each of these is interesting by its own right, the combination of these tools has a potential to simplify web platform and empower developers building larger applications. The value proposition is really close to that of component based frameworks like Vaadin: Make building good quality user interfaces easy with a powerful encapsulation. Let me present you Vaadin X - a new research project that answers what Vaadin has to do with web components. Is Polymer related? How GWT fits in? Which is the right way to go - Java or JavaScript for the user interface layer?

Florian Scholz

Presentation: What's next for JavaScript? - ECMAScript6 and beyond

Florian Scholz, Mozilla

The modern web needs a better programming language and at the same time, there is no way the current one could break existing code on the web. The ECMAScript 6 / harmony project solves this problem and specifies compatible, major updates to JavaScript -- the language of the web. A ratified standard of the already feature-frozen ES6 will be published in mid 2015. All modern engines are working on implementing it. This talk looks at what features are coming for JavaScript with ES6 and what is in the makes after that.

Presentation: Writing Beautiful JavaScript Tests

Kim Joar Bekkelund, BEKK

Testing JavaScript is hard. When my team first started writing JavaScript tests we almost gave up several times. We struggled with topics such as the DOM, Ajax requests and asynchronicity. After months of practice we had written hundreds of unit and end-to-end tests. The problem was that we were slowing down. Our tests had become a burden. They were complex, difficult to understand and a chore to maintain. Gradually, through experimentation and trial-and-error we got better. The same way we need to learn how to build large-scale JavaScript applications, we need to learn how to write maintainable, beautiful tests for them. In this talk I'll share my experience with JavaScript tests, and show the most important patterns we rely on to write simple, beautiful and maintainable tests.

Glenn Richard Bech

Presentation: Writing for wearables, an introduction to the Android Wear platform

Glenn Richard Bech, Inmeta Consulting AS

Android Wear is a version of Google's Android operating system designed for smartwatches and other wearables. By pairing with mobile phones, Android Wear integrates Google Now functionality and mobile notificationsinto a smartwatch form factor. It also adds the ability to download apps from Google's Play Store.

The presentation will cover
- What is Android Wear?
- Features, Design Principles, Types of Applications
- Developer Tools, how to get started
- How to extending your existing application to the smart watch

In the presentation I will use one of my published applications, "Food Facts" to show how Android Wear can extend the usability of an existing app. I will go through all tools, setup, code and configuration needed to get you started with wearable development.

Christian Heilmann

Keynote: You don't need another hero app - you need one that survives the Thunderdome

Christian Heilmann, Mozilla

Technical marketing and advertising always tells us about a soon-to-come future where everything is connected at high speed and all our wishes are fulfilled with the swipe of a hand, the wink of an eye or by typing lots of green text on a black screen maniacally. The reality very much lies in the middle of the two. Connectivity will always be an issue and our users are never the parachuting, yacht-owning superheroes we want them to be.
In this keynote Chris Heilmann will show some of the trends in the app space, some of the honest truths we have to face when developing software and how to build for the future of the now rather than the one we'd love to have. Our job as software creators is to build things that work like magic. If our magic fails, our users move on.

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".

About

Twitter

Back to the top of the page