Talks

Lars Marius Garshol

Presentation: 700 million events a day

Lars Marius Garshol, Schibsted

Schibsted is a global media conglomerate with about 200 million unique users per month. The company is currently being transformed into a unified global media giant. To do this, Schibsted needs to collect data about user behaviour, and process that data with machine learning. This presentation is about we built Schibsted's infrastructure for receiving and processing this behaviour data, which at the moment comes to 700 million events per day, or 2 terabytes per day. The presentation covers the architecture, design of individual services, monitoring, and challenges in scaling and reliability. It also goes into the interaction between legal privacy requirements and overall architecture. Key technologies used ae Amazon Web Services, Scala, Datadog, Kinesis/S3, Docker, Mesos, and Spark.

Jennifer Strater

Presentation: A Test-Driven Approach to Documenting RESTful APIs

Jennifer Strater, Technical University of Denmark

Documentation generated from source code is very popular. Solutions such as Swagger are available for many different languages and frameworks. However, limitations of annotation based tools are becoming apparent. An overwhelming number of documentation annotations make for great docs but muddy the source code. Then, something changes and the docs are out of date again. Test-driven documentation solutions, such as Spring Rest Docs, generate example snippets for requests and responses from tests ensuring both code coverage and accurate documentation. It can even fail the build when documentation becomes out of date. This session will walk through how to implement test-driven documentation solutions for groovy ecosystem technologies like Spring Boot, Grails, and Ratpack.

Gerard Sans

Tutorial: Angular 2 Off Track

Gerard Sans, Angular GDE

In this university session we are going to cover some less known areas of Angular 2. These are: - Advanced Component techniques. Creating a Structural Directive (ngFor, ngIf) - Angular 2 Animations. Creating an animation sequence. - Angular 2 and Redux. How to use ngrx/store and ngrx/effects. - Angular 2 in Production. Ahead of Time Compilation. Be prepared for a few bumps. We are going off-track!

Bhakti Mehta

Presentation: Architecting for Failures in Microservices: Patterns and Lessons Learned

Bhakti Mehta, Atlassian

Microservices is the new black. Distributed systems fail in the most spectacular ways, and hence architecting for failures is of utmost importance. Assume that everything will fail, and design backwards. Using examples of real life outages and failures, this session covers best practices for building resilient, stable, and predictable services as the cornerstones of working with microservice-based architectures.

Key Takeaways are:
* Expect the unexpected
* Dismiss nothing when it comes to debugging issues.
* Identify systemic weaknesses and take control of failures before they take control.
* Plan for resiliency through the stages of development to production and post production.

Johan Andrén

Presentation: Asynchronous stream processing with Akka Streams

Johan Andrén, Lightbend

Akka Streams is an implementation of Reactive Streams (http://www.reactive-streams.org) for the JVM providing asynchronous processing with non blocking back pressure of potentially infinite streams of data. In this talk we'll cover what Reactive Streams is, why you shouldn't implement it yourself and how Akka Streams makes it easy to define and compose streaming pipelines of back-pressured asynchronous processing stages.

Agnes Crepet

Presentation: Become a ninja with Angular 2

Agnes Crepet, Ninja Squad Cédric Exbrayat, Ninja Squad

Angular 2 is a framework which eases the development of modern JavaScript applications. This talk will present the framework, its concepts (component approach, services, dependency injection, forms, routing, validation, tests, etc.) and foremost what is behind “the Angular magic”. All JavaScript frameworks work roughly the same way: they help the developer to react to application events, to update the application state, and to refresh the DOM accordingly. But they don’t all use the same way to achieve that goal. Angular 2 comes with its great solution: the change detection mechanism with the concept of Zones.

Tugdual Grall

Hands-on Lab: Build a Time Series Application with Spark Streaming, Kafka and HBase

Tugdual Grall, MapR Technologies

More and more applications have to store and process time series data, a very good example of this are all the Internet of Things – IoT – applications. This hands on tutorial will help you get a jump-start on scaling distributed computing by taking an example time series application and coding through different aspects of working with such a dataset. We will cover building an end to end distributed processing pipeline using various distributed stream input sources, Apache Spark, Kafka API and Apache HBase, to rapidly ingest, process and store large volumes of high speed data. You will learn the key features of Spark Streaming for processing live data streams ingested from sources like Apache Kafka, sockets or files, and storing the processed data in HBase.

Matt Raible

Presentation: Building a PWA with Ionic, Angular and Spring Boot

Matt Raible, Stormpath

In this session, you'll learn how to build a Progressive Web App (PWA) using Ionic, Angular and Spring Boot. PWAs are being hyped as the next big thing in mobile development. This talk will cut through the hype and get down to the nitty-gritty. Are they really better than native applications? Can you develop PWAs and easily target mobile and desktop with the same application?

Wendy Ginsberg

Presentation: Building Progressive Web Apps with Polymer*

Wendy Ginsberg, Google

*To be detailed...

Kai Wähner

Presentation: Comparison of Open Source Frameworks for Integrating the Internet of Things

Kai Wähner, TIBCO

This session shows and compares open source frameworks built to develop very lightweight applications or microservices, which can be deployed on small devices with very low resources and wire together all different kinds of hardware devices, APIs and online services. The focus of this session is the comparison of open source projects such as Node-RED or Flogo, which offer a zero-code environment with web IDE for building and deploying integration and data processing directly onto connected devices using IoT standards such as MQTT, WebSockets or CoaP, but also other interfaces such as Twitter feeds or REST services. The end of the session compares these open source projects to other options such as SaaS offerings like AWS IoT or more powerful streaming analytics platforms.

Todd Gardner

Tutorial: Debugging Browser JavaScript

Todd Gardner, TrackJS

The web is a hostile place. Browser variance, invasive plugins, unstable networks, evolving languages and tools, and complex systems--our JavaScript apps will inevitably break. When they do, we need to be ready to debug the problem and fix it fast. We'll debug errors live in a demonstration of debugging techniques and tools.
Come along, and let's build a better web.

Breandan Considine

Tutorial: Deep Learning on Java

Breandan Considine

Machine learning has recently made enormous progress in a variety of real-world applications, such as computer vision, speech recognition and language processing. And now, Java has the libraries to help you apply these techniques to large data sets, with new Spark-based tools like deeplearning4java (DL4J). In this workshop, you will learn the basic building blocks for deep learning: gradient descent, backpropogation, model training and evaluation. We'll cover how to build and train supervised machine learning models, give you an overview of deep learning and show you how to recognize handwritten digits. You will gain an intuition for how to develop custom models to discover new insights and untapped patterns big data. No prior experience in machine learning is required.

Magnus Larson

Hands-on Lab: Developing microservices using Spring Cloud, Netflix OSS and Docker

Magnus Larson, Callista Enterprise AB

In this hands-on lab you will build a set of collaborating microservices from ground up using Spring Boot, Spring Cloud, Netflix OSS and Docker. We will provide a virtual machine (based on VirtualBox) for you to download. The virtual machine will contain all tooling required for the workshop. The hands-on lab is based on the blog series: http://goo.gl/HLIX7q

Jonas Wåhslén

Presentation: Device-to-Device Sensor Communication in Home Healthcare

Jonas Wåhslén, KTH School of Technology and Health

My grandmother “the cyborg” , has titanic screws in her right foot, shoulder joint replacement in both hear shoulders, spinal fusion, a quintuple bypass and she is a competitive fisher The talk is about IoT's roll and possibility for working AAL(ambient assisted living) in general. And in detailed how to make a Smartphone-Centric Device-to-Device Sensor Communication for User Mobility in AAL. That could provide a mobility , flexibility and reliability system in order to avoid the risk of losing critical data. Data that may be safe life. How can we built a system will let my grandmother be able to have the same safety and direct access to her healthcare provider when she is fishing, new trophy put on her shelf , as would she be at home watching fishes on discovery channel.

Arun Gupta

Presentation: Docker Swarm or Kubernetes - Pick your framework!

Arun Gupta, Couchbase

Docker and Kubernetes are two very competent, and one of the most heavily used, container orchestration frameworks. This code-driven session will compare and contrast Docker Swarm and Kubernetes on the following aspects: Local development Deployment options Multi-container applications Service discovery Scaling service Run-once jobs Maven integration Rolling updates Creating a Couchbase cluster Attendees will have a clear understanding of what each orchestration framework has to offer. They will also learn techniques for using these platforms effectively.

Andrey Adamovich

Hands-on Lab: Dockerized Java

Andrey Adamovich, Aestas/IT

Dockerizing Java applications may seem simple, but it meets several challenges related to configuration management, service discovery, licensing, dependency management and scaling. This workshop will cover some practical aspects of running Java inside containers: - Choosing base image: be aware of the license and size DOES matter - Simple use cases: creating Docker containers for Tomcat, Spring Boot, WebLogic - Planning Docker image hierarchy: - Docker containers for Application servers - Fat JAR vs. thin JAR - Performance considerations: mapping JVM settings to container limits - Multi-container setups and service discovery

Anders Ahlgren

Presentation: Don't bore your cores!

Anders Ahlgren, Mercur Solutions AB

They say it is a multi-core world. Really? You may have to fight to get more than one VPU at customer sites. Even when on an actual physical multi-core, keeping all cores busy usually isn't the hardest problem you face. You may see all your cores working all out, but it may be a lie. Even if they seem busy, your cores might be "bored". They may be stalled for memory access, or at least not use their instruction-level parallelism to the fullest. We will look at some small code examples that might surprise you, even if you think you know of the importance of cache locality, pre-fetching, and branch prediction. There is no general magic solution, but we will get you started thinking the right way, give you some tips, and perhaps make you question some of the accepted "truths" of performance.

Ray Tsang

Presentation: Efficient Microservices w/ Binary Protocol - gRPC 101

Ray Tsang, Google

gRPC is a high performance, open source, general RPC framework that puts mobile and HTTP/2 first. gRPC is based on many years of Google's experience in building distributed systems - it is designed to be low latency, bandwidth and CPU efficient, to create massively distributed systems that span data centers, as well as power mobile apps, real-time communications, IoT devices and APIs. It's also interoperable between multiple languages. But beyond that fact that it's more efficient than REST, we'll look into how to use gRPC's streaming API, where you can establish server-side streaming, client-side streaming, and bidirectional streaming! This allows developers to build sophisticated real-time applications with ease.

Nicolai Parlog

Presentation: Expert Java 8

Nicolai Parlog, CodeFX

By now Java 8's features are well understood. But best practices are still forming. Did you ever wonder ... * ... how to create a "lambda-enabled" API? * ... whether your methods should return or even accept streams and how that might impact your design? * ... how to write readable stream pipelines, especially when exceptions are involved? * ... how to estimate and examine stream performance? * ... about the details of and opinions on Optional? * ... how to use default methods to evolve interfaces without breaking client code? This talk will discuss these and other advanced topics of Java 8, so you can get the best out of its awesome features.

Tugdual Grall

Presentation: Fast Cars, Big Data - How Streaming Can Help Formula 1

Tugdual Grall, MapR Technologies

Modern cars produce data. Lots of data. And Formula 1 cars produce more than their share. I will present a working demonstration of how modern data streaming can be applied to the data acquisition and analysis problem posed by modern motorsports. Instead of bringing multiple Formula 1 cars to the talk, I will show how we instrumented a high fidelity physics-based automotive simulator to produce realistic data from simulated cars running on the Spa-Francorchamps track. We move data from the cars, to the pits, to the engineers back at HQ. The result is near real-time visualization and comparison of performance and a great exposition of how to move data using messaging systems like Kafka, and process data in real time with Apache Spark, then analyse data using SQL with Apache Drill.

Sven Ruppert

Presentation: From mess to masterpice?..leagacy code transformation done right

Sven Ruppert, macros reply GmbH

How a migration to MicroServices could change the team, architecture and coding culture. What you could you do and how you could transform a "Jurassic Park" into a lightweight environment. In this talk we will explore the strategy, techniques, pattern and tools I used to transform a team and the architecture that was grown over 15yrs. This will be a mix of pattern, tools and techniques that was able to migrate old systems, used inside insurance and banks. We had to migrate fat systems with a few million lines of code...

Rabea Gransberger

Presentation: Functional Libraries for Java 8

Rabea Gransberger, MEKO-S

Java 8 provides us with new APIs to support a functional programming style. While the standard provides us with a good basis, we sometimes wish for even shorter or powerful ways to write clean code for complex tasks. In this talk I will show you some additional libraries for Java 8 (and beyond) which give you this little extras here and there. I will cover a wide variety of use cases like filter/map/reduce, stream API add-ons, lambdas with unit testing, SQL query support.

Chris Thalinger

Presentation: Graal @Twitter

Chris Thalinger, Twitter

HotSpot's optimizing Just-In-Time compiler C2 is reaching its end-of-life and it's time to look for alternatives. One very promising replacement candidate is Graal. Graal is a Java JIT compiler written in Java. It is being developed by Oracle Labs for a couple years now and has reached a state where it's viable to be that replacement. Twitter's huge distributed system tickles every corner of the JVM and is the perfect testing ground for a new JIT compiler technology like Graal. This presentation will talk about Twitter's experiences with Graal, good and bad, the bugs we found and also the wins.

René Gröschke

Quickie: Gradle 3.0 and Beyond

René Gröschke, Gradle Inc.

This session is about the latest major Gradle release and what it has to offer for building authors and developers. The talk will be started with a short overview of Gradle build system, then some new functionalities will be explored like: Latest dependency management improvements and Composite builds, Functional testing of build logic, Distributed Cache and Gradle Build Scan. The talk will be finished up with an outlook of what the Gradle team is working on next and what you can expect beyond Gradle 3.0.

Brian Vermeer

Presentation: Identity theft: Developers are key

Brian Vermeer, Blue4IT

Identity theft is perhaps the most concerning kind of Cybercrime nowadays. The most concerning aspect of identity theft is that once you are a victim it is hard to get rid of the consequences. Although as developers we are probably well aware of the risks towards cybercrime and identity theft in particular, in many parts we as developers play a big role in making identity theft happen. It is not only about how secure is your program, but how aware are you? Or better said how naive are we in practice as developers in this big bad world.

Joakim Eriksson

Hands-on Lab: Instant IoT - Open Source Standard Based IoT Device Development

Joakim Eriksson, SICS Swedish ICT

Develop your own IoT device and control it via a variety of smart home platforms. During this IoT tutorial session we will show how to develop a low-cost IoT device that use standard protocols to communicate with smart home environments (such as Apple HomeKit). You will use open-source software and IoT devices that have WiFi and/or 6LoWPAN (802.15.4) for wireless connectivity. Before the hands on part starts up there will be a short introduction to some of the IoT protocols and the open source software that will be used during the session. You will after the tutorial have a device that you bring home. We will provide basic IR sensor for developing a electricity meter sensor, but other types of devices can also be developed.

Hanneli Tavante

Presentation: Introducing Rust

Hanneli Tavante, Codeminer 42

A quick introduction to the Rust Language. Code comparisons between Java and Rust, compiler features, type system, environment and integrating the two languages. Topics - Brief History of Rust - how did the project get started, main goals, first stable releases. - Main types and Functions - writing a very basic code and a deep comparison between Java style and Rust style. The level of verbosity is similar; however, the way you explicit the types may be different. - Structs and Traits, contrasting them with Interfaces and Abstract Classes in Java. - Lifetime vs GC - how can we remove objects from the memory without a GC? An interesting alternative approach from Rust to Java's GC. We will show the good and the complicated parts. - Notes about the compiler

James Ward

Presentation: Introduction to Machine Learning

James Ward, Salesforce.com

Machine Learning is all the rage today with many different options and paradigms. This session will walk through the basics of Machine Learning and show how to get started with the open source Spark ML framework. Through Scala code examples you will learn how to build and deploy learning systems like recommendation engines.

Joachim Lindborg

Hands-on Lab: IoT interaction – Create an Energy and IoT mobile app in an afternoon

Joachim Lindborg, Sustainable Innovation

Visualisations, Interactions and feedback are core technologies to retain a sustainable future. Interaction between users and IoT data and devices can make big behavioural changes. During the hands-on session we will combine the Evothings development environment with open energy http://op-en.se tools. You will be using MQTT, socket.io, animation.js and XMPP. You will create your own mobile app that you can deploy in appstore. If you take part in the pre-noon session you will be able to take your IoT device data into your private mobile app. Evothings http://evothings.com and Sustainable Innovation http://sust.se

Shahid Raza

Presentation: Is IoT security a nightmare?

Shahid Raza, SICS

The future Internet will be an IPv6 network interconnecting traditional computers and a large number of smart objects or networks. This Internet of Things (IoT) will be the foundation of many services and our daily life will depend on its availability and reliable operations. Therefore, among many other issues, the challenge of implementing secure communication in the IoT must be addressed. Providing security is challenging in the Internet and in tradition resource-constrained Wireless Sensor Networks (WSNs). It is even more challenging to enable security services in the IoT. This talk will discuss these challenges and address solutions to overcome these challenges.

Monica Beckwith

Presentation: Java 9 - Beyond Contention!

Monica Beckwith, Code Karam LLC

At JavaOne keynote this year, Mark Reinhold talked about how Java 9 was much bigger than Jigsaw. To put that in numbers - 80+ JEPs bigger! Yes, we see more presentations on Jigsaw since it brings about modularity to the once monolithic JDK. But what about those other JEPs?! One of those "other" JEPs, is JEP 143 - 'Improve Contended Locking'. Monica will apply her performance engineering approach and talk about JEP 143 and Oracle's Studio Analyzer Performance Tool. The crux of the presentation will entail comparing performance of contended locks in JDK 9 to JDK 8.

Heinz Kabutz

Hands-on Lab: Java Concurrency Live(li)ness

Heinz Kabutz, JavaSpecialists.EU

In this hands-on-lab, we will solve a number of concurrency challanges, starting with relatively easy and ending with, um, shall we say "sporty"? The first two labs involve solving simple "deadly embrace" deadlocks using lock ordering and tryLock(). Our third and fourth labs look at slightly more complex scenarios that do not appear as obviously in the thread dumps. Our last lab consists of multiple sections where we first have to implement Dijkstra's "Sum of Squares" using BigInteger followed by parallelize our algorithm using the Fork/Join framework. In the last section, we change our cache to use the ManagedBlocker in order to maximize our CPU utilization at the beginning of the calculation.
Warning: This is not a beginner's hands-on-lab.

David Delabassee

Presentation: Java EE 8 and Java EE 9 - What's coming?

David Delabassee, Oracle

New paradigms such as microservices architecture, cloud-native development, reactive programming, serverless computing suggest enhancements to Java EE going forward. The goal of this session is to describe proposals to better position Java EE for use in the cloud, with the goal of supporting users who need to more efficiently build and configure distributed applications based on cloud-native and microservices-style architectures.We will discuss some key investigation works around Java EE 8 and Java EE 9 • A more reactive approach • Eventing • State management • Configuration • Service resiliency and health check • Services grouping and versioning • Security improvements • HTTP/2, ... The goals of the session are to present potential improvements but also to gather feedback!

Viktor Gamov

Presentation: Java Puzzlers NG S02: Down the rabbit hole

Viktor Gamov, Hazelcast Baruch Sadogursky, JFrog

Moar puzzlers! The more we work with Java 8, the more we go into the rabbit hole. Did they add all those streams, lambdas, monads, Optionals and CompletableFutures only to confuse us? It surely looks so! And Java 9 that heads our way brings even more of what we like the most, more puzzlers, of course! In this season we as usual have a great batch of the best Java WTF, great jokes to present them and great prizes for the winners!

Stephen Colebourne

Presentation: Java SE 8 best practices

Stephen Colebourne, OpenGamma

The Java 8 release takes Java to a whole new level. Learning the new features is just the first step. The real question is how to make best use of them. There won’t be too much time in this session to introduce the new features, so you’ll need to know what lambdas and method references are in advance. Instead, the focus will be on how coding in Java 8 differs to previous Java versions, and how to avoid going too far with the new goodies. Join me for an opinionated session of best practices.

Todd Gardner

Presentation: JavaScript's Most Wanted

Todd Gardner, TrackJS

Something terrible has happened. Errors litter the floor; memory leaking from cracks in the ceiling. Someone lost their object context in the corner. Everything reeks of jank. The web is overrun. In this session, a JavaScript error tracking expert tracks down some of the most common and most dangerous outlaws of web applications. You’ll leave the session armed with track down and capture the problems in your own JavaScript web applications. Bring your bugs and let’s fix up our web.

Attila Szegedi

Presentation: jdk.dynalink is here

Attila Szegedi, FaunaDB

JEP 276 Dynalink is now integrated into JDK 9 and available under the jdk.dynalink package. The API was streamlined and polished and it's a great and easy way to add handling of dynamically typed expressions to your language. With this presentation we want to show you how can you use Dynalink in your language implementation and what can you achieve with it. We'll cover topics of creating linkers, handling type conversions, and interoperability between languages (with a demo). We'll show how does the API provide a foundation for implementing advanced language and runtime features such as the deoptimizing recompilation in Nashorn, customizing behavior for missing methods on POJOs, or even linking null values - all the kinds of details that you never thought you need.

Ryan Knight

Tutorial: Large Scale Data Pipelines with Kafka, Spark Streaming and Cassandra

Ryan Knight, Starbucks James Ward, Salesforce.com

In this University session we will walk through building this type of large scale, mission critical data pipeline using Kafka, Spark Streaming and Cassandra. We will start by looking at the individual technologies that make up the data pipeline. Then we will discuss the overall architecture of the data pipeline and how to address these core principles. We will walk through each of the pieces of the architecture.

Ray Tsang

Tutorial: Managing Cloud Native Applications with Kubernetes - End-to-End

Ray Tsang, Google

This university session will teach you everything you need to know about running and managing applications and microservices in containers at scale using Kubernetes. This university session is composed of several topics, including: 1. Importance of orchestration and cluster management and how it helps you improve cluster utilization 2. Introduction to basic DevOps tasks using Kubernetes, including deployment, rolling update, rollback, provisioning stateful workload and batch jobs 3. Advanced usages such as Configuration Management, Secrets, and Cluster Federation 4. Automated CI/CD pipeline with Jenkins and Fabric8

Katherine Stanley

Presentation: Microservice communication and integration: what are my options?

Katherine Stanley, IBM

I've heard it said that the American and English are one nation, separated by a common language. This quote can apply nicely to microservices too; you are all speaking in the same language, or, in the case of microservices, using language agnostic protocols, but everyone has their own way of doing things. As a result, having stable and resilient communication is a big challenge in microservices. Common hurdles you will have to overcome are how to find services and what communication methods to use. This talk will cover some of the choices you have including service location and using rest protocol vs an event-like websocket protocol. I will include lessons learned while creating the open source text-based adventure Game On! about the world of microservice communication and integration.

Gojko Adzic

Presentation: Migrating to serverless -- an experience report

Gojko Adzic, Neuri Consulting LLP

The new generation of cloud services such as AWS Lambda, Google Cloud Functions and Azure functions lower the bar for deploying responsive event-driven micro-services, auto-scaling web APIs, and high-performance web sites to the cloud. But with a major impact on architecture, these services also require teams to re-think how to approach sessions, storage, authorization and testing. This talk provides an experience report of moving a large collaboration platform from Heroku to AWS Lambda, leading to a huge improvement in scalability and performance, and a significant decrease in cost. You'll find out what worked well, where we got stuck, and how we made it work well at the end.

Jeroen Resoort

Presentation: Mission to Mars: Exploring new worlds with AWS IoT

Jeroen Resoort, JDriven

Would you like to explore new worlds with your connected devices? In this presentation we will build a simple robot and connect to it remotely, receiving data and sending instructions over the internet. Just like the Pathfinder spacecraft and its Sojourner Mars rover, our little robot will boldly travel into uncharted territory. In a live demo, our robot will explore the session room and transmit all kinds of sensor data. We will visualise that data in a web UI. With the Mars robot use case, we explore the capabilities of the Amazon IoT platform. AWS IoT comes with easy to use APIs and arranges secure communication with our robot. Are you curious about how to connect your devices to the cloud? Take this journey and find out if this mission will lead to new discoveries.

Philipp Krenn

Presentation: Monitor your containers

Philipp Krenn, Elastic

Containers are quickly gaining popularity as the preferred tools for deploying and running services. While being easier to deploy and isolate, containerized applications are creating new challenges for the logging and monitoring systems. During this talk we will look into the details about how the Elastic Stack, and in particular Beats — lightweight shippers — are gathering data from containers. The session shows our way to: * fetch logs from a container * collect different measurements from cgroups * collect metrics using the Docker API * enhance the data with the metadata of the containers * monitor the network traffic exchanged between the containers * get metrics from the host system

Pär Sikö

Presentation: Programming your body with chip implants

Pär Sikö, Jayway

Would you put a chip in your body if it meant a longer and healthier life? Would you put a chip in your body in order to open doors, withdraw money from an ATM, and to safely store sensitive data? This session will introduce you to connected bodies, look at the possibilities available today and end by discussing a few important things we can expect in the future:
* Medical reasons - what if we could implant thousands of chips and let them monitor vital parts of the body?
* Identification - what if we could use chip implants as identification.
* Tracking - what if we could publish our "body status" and whereabouts as a service?

The speaker has been wearing a chip implant for a year.

Sebastian Daschner

Presentation: Putting Hypermedia Back in REST

Sebastian Daschner, IT-Beratung

Everybody is doing REST -- at least everybody claims they are. But mostly web APIs are built without Hypermedia, what would allow the client to follow related resources and autonomously navigate through the API without prior implicit logic of the application. This sessions shows the concept and benefits of a Hypermedia driven REST API and how to implement this using JavaEE 7 with JAX-RS.

Ola Petersson

Presentation: Reactive Java EE

Ola Petersson, Squeed

At JavaOne 2016 Oracle announced their plan for Java EE8. One of the key points was to improve support of the 'reactive programming model'. But until Java EE8; are we cut short on building reactive applications? In this hands-on presentation we'll go through the concepts of reactive programming and proceed to how we actually implement it. Using the current APIs, we'll cover areas such as asynchronous programming, WebSocket and message- and event-driven architecture. When you leave this session, you will have the utilities to build responsive applications with higher throughput, better use of your hardware, and especially a nicer user experience.

Burr Sutter

Presentation: Reactive Microservices with Vert.x

Burr Sutter, Red Hat

Everybody is talking about microservices and reactive programming these days. And there’s a reason for that: the high-demand and high-scale distributed world that we have today, reacting to events in an asynchronous and non-blocking fashion seems the right approach to deal with scalability. And to achieve microservices you need a lightweight, fast, modular and high-performance engine. Meet Vert.x: a toolkit for building reactive applications on the JVM. Come to this session to see how you can use Vert.x to create reactive apps using Java, Groovy, JavaScript or other JVM languages. We’ll demonstrate how to build Vert.x-based systems leveraging the unique Vert.x eventbus for creating apps with real-time communications from the modern web browser to the cloud and back again.

Burr Sutter

Tutorial: Reactive Programming, Systems and Microservices

Burr Sutter, Red Hat

Reactive Programming is a subset of functional programming where your logic is designed around streams while Reactive Systems, defined by the Reactive Manifesto, focuses on distributed applications that are highly responsive, resilient, elastic and message driven. In this session, we are going to quickly explore reactive asynchronous programming models, dive into reactive systems infrastructure and then distributed microservices principles, where every component can be independently deployed, scaled and updated.

Stephen Chin

Presentation: RetroPi Reloaded - Arcade Machine on Raspberry Pi

Stephen Chin, Oracle

The RetroPi is a custom-designed handheld console using a Raspberry Pi with a pure Java software stack for emulation and graphics. In this rework of the original RetroPi console, we go broader and bigger! While 8-bit consoles like the NES are a lot of fun, the C64 (Commodore 64) was a real hacker’s machine. And 3D printing is suitable for building a small handheld console, but what if you want to automate prototyping of a full-size arcade console? In this talk we update the RetroPi to support C64 applications and emulate the C64 Joystick using the Pi4J library. Also, we convert the design to use a wood enclosure milled with a CNC Router. This presentation will inspire you to start hacking the real world with Raspberry Pi and Java.

Viktor Gamov

Presentation: Riding the Jet Streams

Viktor Gamov, Hazelcast

Java 8 introduced the Stream API as a modern, functional, and very powerful tool for processing collections of data. One of the main benefits of the Stream API is that it hides the details of iteration over the underlying data set, allowing for parallel processing within a single JVM, using a fork/join framework. I will talk about a Stream API implementation that enables parallel processing across many machines and many JVMs. With an explanation of internals of the implementation, I will give an introduction to the general design behind stream processing using DAG (directed acyclic graph) engines and how an actor-based implementation can provide in-memory performance while still leveraging industry-wide known frameworks as Java Streams API.

Matti Pehrs

Presentation: Scaling the Data Infrastructure @Spotify

Matti Pehrs, Spotify

Over the last years Spotify has had an enormous growth. This has lead to some interesting challenges for our data infrastructure. In this talk we will share some of these experiences such as our move to Google Cloud and how we have solved some of our challenges.

Juergen Hoeller

Presentation: Spring Framework 5: Themes & Trends

Juergen Hoeller, Pivotal

Spring Framework 5.0/5.1, scheduled for release in early/late 2017, focuses on several key themes: reactive web applications based on Reactive Streams, comprehensive support for JDK 9 and HTTP/2, as well as the latest API generations in the Enterprise Java ecosystem. This talk presents the overall story in the context of wider industry trends, highlighting Spring's unique programming model strategy.

Matt Raible

Presentation: Testing Angular 2 Applications

Matt Raible, Stormpath

The best reason for writing tests is to automate your testing. Without tests, you'll likely be testing manually. This manual testing will take longer and longer as your codebase grows. In this session, you’ll learn how to test an Angular 2 application. You'll learn how to use Jasmine to unit testing components and Protractor for integration testing. We’ll also take a look at code coverage options and explore continuous integration tools.

Gerard Sans

Presentation: The amazing Angular 2 Router

Gerard Sans, Angular GDE

Angular 2 comes with a new router. We will review its main features and show how we can use navigation gards, secure sections, use nested routes and do lazy load while quickly building a fully working prototype! The Angular 2 Router is one of the most fundamental pieces in any Angular 2 Application. We will cover it's main features. Possibly the most interesting one is the ability to Lazy Load Components on-demand. We will go through all the steps to cover the common scenarios and some more advanced ones. Auxiliary routes allow totally independent navigations so you can handle complex scenarios with ease. We will show common pitfalls and best practices to take advantage of them. Content will be updated accordingly to use latest Angular 2 release available.

Presentation: The DevOps disaster: 15 ways to fail at DevOps

Bert Jan Schrijver, JPoint

Getting DevOps right isn't easy. It's downright hard. In this talk, I'm not going to explain how to 'do' DevOps in your organisation, since there is not just one 'right' way to do it. What I can show you however, is how NOT to do DevOps. This session shares 15 common misconceptions, call them anti-patterns, of DevOps. I'll talk from my own experiences in getting things wrong, explain why they are wrong and prevent you from making the same mistakes. You'll leave this session with a basic understanding of how (not) to fail at DevOps and hopefully, a smile on your face ;-)

Erik Helin

Presentation: Throughput, latency and footprint - pick two

Erik Helin, Oracle

This talk will focus on the fundamental trade-offs when designing a memory management algorithm - throughput, latency and footprint. When designing an memory management algorithm, you can only optimize for two out these three features. However, an algorithm is always made up of smaller parts and this talk will show how various design choices, small and large, all shape a memory management algorithm. Examples of optimization being presented are: - Dense prefix for Parallel and Serial (latency over footprint) - Concurrent refinement of remembered sets (latency over throughput) - Using cards instead of references (footprint over latency)

David Simms

Presentation: To serve Odin, adventures in project Valhalla prototyping

David Simms, Oracle Svenska AB

Over the last year or so, a number of prototyping efforts have taken place within the JVM and JDK order to implement various ideas from the Valhalla project. Not all of the prototypes have been pretty, but we've learnt a few things along the way. Listen to an overview of what's been going on in terms of prototype implementation of generic specialization and value types, and where we are likely going from here. Includes discussing: value type byte code evolution, evolution of specialization, prototyping via byte code transforms, exotic type changes like "trait" injection, and various feature feasibility studies

Heinz Kabutz

Presentation: Turbo Charge CPU Utilization in Fork/Join Using the ManagedBlocker

Heinz Kabutz, JavaSpecialists.EU

Fork/Join is a framework for parallelizing calculations using recursive decomposition, also called divide and conquer. These algorithms occasionally end up duplicating work, especially at the beginning of the run. We can reduce wasted CPU cycles by implementing a reserved caching scheme. Before a task starts its calculation, it tries to reserve an entry in the shared map. If it is successful, it immediately begins. If not, it blocks until the other thread has finished its calculation. Unfortunately this might result in a significant number of blocked threads, decreasing CPU utilization. In this talk we will demonstrate this issue and offer a solution in the form of the ManagedBlocker. Combined with the Fork/Join, it can keep parallelism at the desired level.

Kirk Pepperdine

Presentation: Using jPDM, a performance diagnostic model

Kirk Pepperdine, jClarity Ltd.

Java Performance Diagnostic Model (jPDM) is the key to a performance tuning methodology that I have been using in my engagements to help me quickly get to the (sometimes surprising) root cause of performance bottlenecks in many applications across many different domains. In this demo driven talk, you, the audience, will use jPDM to reason through a couple of commonly seen but often unidentified performance bottlenecks in a sample application.

Presentation: Value types - The Next Big Thing for Java

Henning Schwentner, WPS - Workplace Solutions

Brian Goetz from Oracle has announced: after lambdas in Java 8, the next big thing for Java will be the support for value types directly in the programming language. With this Java is getting a feature that other languages have already had for some time. In this talk we will look at: * what's behind the motto "Codes like a class - works like an int" * why value types make your code at the same time better readable and more efficient * the difference between refence and value types * the new syntax to support value types in Java * how value types are implemented in other languages * what inheritance means for value types * the advantages of storing data on the stack versus storing data on the heap

Andrey Adamovich

Presentation: Visualizing Java code bases

Andrey Adamovich, Aestas/IT

Code lines are added at high speed? Too many developers? How do you see the big picture? What processes are going on with your large code base? This presentation will show how to leverage existing code analysis tools (Cloc, Structure101, SonarQube) and combine them with data storage (ElasticSearch, Neo4j) and visualization tools (Gource, D3, Inkscape, Kibana) to at least make some sense out of millions of code lines and their history. During his consulting work, author often meets unfamiliar and at the same time large Java code bases that need quick analysis and input for decision making. That's where visualizations come to into play by helping mining important knowledge directly from the code statistics.

Vyacheslav Egorov

Tutorial: VM Tech Summit, part I

Vyacheslav Egorov, Google David Simms, Oracle Svenska AB Chris Thalinger, Twitter

9.00-9.45 To serve Odin, adventures in project Valhalla prototyping
Over the last year or so, a number of prototyping efforts have taken place within the JVM and JDK order to implement various ideas from the Valhalla project. Not all of the prototypes have been pretty, but we've learnt a few things along the way. Listen to an overview of what's been going on in terms of prototype implementation of generic specialization and value types, and where we are likely going from here. Includes discussing: value type byte code evolution, evolution of specialization, prototyping via byte code transforms, exotic type changes like "trait" injection, and various feature feasibility studies

10.00-10.45 What I learned from LuaJIT
You might have heard about LuaJIT - an implementation of the Lua programing language sporting a fast interpreter and a sophisticated tracing JIT - all hidden within 100KLOC of a filigree C code. This talk summarizes my experience from digging into LuaJIT sources while working as a compiler engineer for Google DeepMind. We will walk through the whole pipeline starting at the bytecode format and value representation and finishing in the trace compiler. This is not a deep insight into LuaJIT inner design but rather a collection of choices made by the original LuaJIT implementor which I found interesting, elegant and educational.

11.15-12.30 Graal @ Twitter
HotSpot's optimizing Just-In-Time compiler C2 is reaching its end-of-life and it's time to look for alternatives. One very promising replacement candidate is Graal. Graal is a Java JIT compiler written in Java. It is being developed by Oracle Labs for a couple years now and has reached a state where it's viable to be that replacement. Twitter's huge distributed system tickles every corner of the JVM and is the perfect testing ground for a new JIT compiler technology like Graal. This presentation will talk about Twitter's experiences with Graal, good and bad, the bugs we found and also the wins.

Monica Beckwith

Tutorial: VM Tech Summit, part II

Monica Beckwith, Code Karam LLC Erik Helin, Oracle Attila Szegedi, FaunaDB

13.30-14.15
Write Barriers in Garbage First Garbage Collector

Garbage First Garbage Collector (G1 GC) is HotSpot VM’s latest addition to the GC family. G1 GC has remembered sets (RSets) and regions. Also, G1 GC implements a new marking algorithm called snapshot-at-the-beginning (SATB). With the advanced structures and the new marking algorithm comes the maintenance cost of post-write and pre-write barriers. During this talk, Monica will cover the SATB algorithm and also discuss the reason for pre-write barriers. Monica will also talk about RSet maintenance costs and discuss post-write barriers then.

14.30-15.15
Throughput, latency and footprint - pick two

his talk will focus on the fundamental trade-offs when designing a memory management algorithm - throughput, latency and footprint. When designing an memory management algorithm, you can only optimize for two out these three features. However, an algorithm is always made up of smaller parts and this talk will show how various design choices, small and large, all shape a memory management algorithm. Examples of optimization being presented are: - Dense prefix for Parallel and Serial (latency over footprint) - Concurrent refinement of remembered sets (latency over throughput) - Using cards instead of references (footprint over latency)

15.45-16.30
Ajdk.dynalink is here

JEP 276 Dynalink is now integrated into JDK 9 and available under the jdk.dynalink package. The API was streamlined and polished and it's a great and easy way to add handling of dynamically typed expressions to your language. With this presentation we want to show you how can you use Dynalink in your language implementation and what can you achieve with it. We'll cover topics of creating linkers, handling type conversions, and interoperability between languages (with a demo). We'll show how does the API provide a foundation for implementing advanced language and runtime features such as the deoptimizing recompilation in Nashorn, customizing behavior for missing methods on POJOs, or even linking null values - all the kinds of details that you never thought you need.

Felipe Hoffa

Presentation: What I learned from analyzing 750 billion GitHub events and 42 TB of code

Felipe Hoffa, Google

"Data gives us insights into how people build software, and the activities of open source communities on GitHub represent one of the richest datasets ever created of people working together at scale." --GitHub Universe 2016 We are going to analyze - live on stage - 5 years of GitHub metadata and 42 TB code stored in it to answer questions like: - How coding patterns have changed through time. - Guiding your project design decisions based on actual usage of your APIs. - How to request features based on data. - The most effective phrasing to request changes. - Effects of social media on a project's popularity. - Who starred your project - and what other projects interest them. - Measuring community health. - Running static code analysis at scale. - Tabs or spaces?

Vyacheslav Egorov

Presentation: What I learned from LuaJIT

Vyacheslav Egorov, Google

You might have heard about LuaJIT - an implementation of the Lua programing language sporting a fast interpreter and a sophisticated tracing JIT - all hidden within 100KLOC of a filigree C code. This talk summarizes my experience from digging into LuaJIT sources while working as a compiler engineer for Google DeepMind. We will walk through the whole pipeline starting at the bytecode format and value representation and finishing in the trace compiler. This is not a deep insight into LuaJIT inner design but rather a collection of choices made by the original LuaJIT implementor which I found interesting, elegant and educational.

Monica Beckwith

Presentation: Write Barriers in Garbage First Garbage Collector

Monica Beckwith, Code Karam LLC

Garbage First Garbage Collector (G1 GC) is HotSpot VM’s latest addition to the GC family. G1 GC has remembered sets (RSets) and regions. Also, G1 GC implements a new marking algorithm called snapshot-at-the-beginning (SATB). With the advanced structures and the new marking algorithm comes the maintenance cost of post-write and pre-write barriers. During this talk, Monica will cover the SATB algorithm and also discuss the reason for pre-write barriers. Monica will also talk about RSet maintenance costs and discuss post-write barriers then.

About

Back to the top of the page