Talks

Simon Ritter

Presentation: 55 New Features in JDK 9

Simon Ritter, Azul Systems

Following on from the popular “55 New Features in Java SE 8” we bring you the eagerly-awaited sequel, “55 New Features in JDK 9”. Obviously, the big new feature in JDK 9 is modularity and project Jigsaw, but there’s lots more to tempt developers. We’ll divide things into five categories: 1. Features 2. Standards 3. Inside the JVM 4. Specialised 5. Housekeeping Join us on a whirlwind tour of what’s in (and what’s out) in JDK 9 so you’re ready to get started with the latest version of the most popular programming platform on the planet.

Christoffer Noring

Presentation: Angular with NGRX - there is a reducer in my soup

Christoffer Noring, McKinsey

How to handle state management is a problem as old as time. You think about things such as how should the data flow, where does my state live. Sadly you tend to end up with a mess, more times than not. With the arrival of the new Angular suddenly data was no longer two-way binded and it made sense to start to look at patterns such as Redux. It is of course possible to write your own implementation of Redux but what if you were to use what's already there in what Angular gives you. I'm talking about RxJS. If you combine Redux with RxJS sweet music will be created. This talk aims to give you a good understanding of the Redux concepts, a little bit of RxJS but most of all a good foundation on how to use NGRX for your next Angular app.

Mark Reinhold

Presentation: Ask the Architect

Mark Reinhold, Oracle

Bring your favorite questions about Java SE and the Java Development Kit — past, present, or future — to this open Q&A session

Marcus Ahnve

Quickie: Automating Your Server Setup Using Terraform and Ansible

Marcus Ahnve, Valtech AB

This talk will show you how to use provisioning tools in order to automate server setup. Starting from a basic Debian image, we will launch a server on DigitalOcean using Terraform and provision it using Ansible.

Rowdy Rabouw

Presentation: Awesome native apps with NativeScript and Angular!

Rowdy Rabouw, double-R webdevelopment

Developing native iOS (and Android apps) can be very time consuming and expensive. What if you could build native apps with one code base and web techniques? Well, you can with NativeScript! In this introduction, I’ll explain what NativeScript is and how it compares to other platforms. And in a live demo, I will show you how easy it is to get started and to make use of native capabilities.

Dierk König

Presentation: Benefits of Functional Programming beyond map/filter/reduce

Dierk König, Canoo Engineering AG

Since Java 8 we have grown to exploit the benefits of Lambdas and Streams together with high-order functions to map, filter, and reduce our data. But this is only the beginning. With purely functional programming we can explore new territory where we can go safely parallel, ensure through the type system that we never call from the wrong thread, and expand our solution space with new mental tools. Any new trick that you learn this way is immediately applicable to a growing number of functional languages: Frege for the JVM, Elm and Purescript for the web, and Haskell and Idris for native code.

Erik Wendel

Presentation: Beyond JavaScript Frameworks: Writing Reliable Web Apps With Elm

Erik Wendel, BEKK Consulting

In times where a jungle of JavaScript frameworks wants to solve every conceivable problem in web app development, creating headaches and javascript fatigue in the process, Elm offers a different approach. Elm is a functional programming language that you can use instead of JavaScript. It builds on the concepts of virtual dom and one-way dataflow popularized by React and Redux, but with a great typesystem, built-in immutability, and an amazing compiler that catches errors before you even run your code. Simply put, Elm is a great language that will make your backend team jealous! In this talk you'll see how Elm works and how to build apps with it. Pros and cons of using Elm over a traditional JS stack will be highlighted. No prior experience with functional programming is required.

Kiki Carter

Presentation: Broken Promises; How data destroys relationships in microservice systems and what you can do to win back trust.

Kiki Carter, Lightbend

Data-centric, even-driven, stateless… these terms are often tossed about when people speak on microservices or distributed systems. But how often do these things work together to deliver the promise of a resilient and trustworthy environment? If you’ve struggled to build a distributed system that can deliver on all the promises of a Reactive, it could be due to poor architectural practices, especially around handling uncertainty that is part and parcel to distribution. But it doesn’t have to remain this way; you can learn to trust and rebuild trust in your systems. In this talk, we will drill into key concepts around Promise Theory and a framework designed to embrace this theory as a principle to building highly resilient, responsive and elastic systems.

Julio Faerman

Tutorial: Building e-health IoT solutions with AWS

Julio Faerman, Amazon Web Services Vinicius Senger, Amazon Web Services

During this workshop we will use Raspberry Pi Zero with heart beat and SPO2 sensor to drive a complete device to cloud IoT solution for e-health using Greengrass (MQTT gateway resilient to internet fail), AWS IoT, DynamoDB, S3 and Machine learning to detect arrhythmia and other diagnosis. We will bring 15 kits that can be shared with 2-3 person per kit. Agenda: Hardware Architecture Starting with AWS IoT Services Security Come first IoT Rules Greengrass: MQTT resilient to internet fail Servless architecture with Lambdas and Greengrass Over-the-air updates Machine Learning with Heart beat data We will also publish the components list for anyone that want to buy!

Adrian Hornsby

Presentation: Building Interactive, AI-powered IoT Applications on AWS

Adrian Hornsby, Amazon Web Services

IoT is about connecting Internet-enabled devices that relay information back to us, to cloud-based applications and to each other (device to device). In this talk, I will discuss best practices and show how to efficiently build IoT apps on AWS, including the use of voice interfaces. I will also showcase the latest AWS IoT Device called DeepLens (https://aws.amazon.com/deeplens/) and build a machine learning project using Amazon SageMaker to build and train model and deploy it at the edge on the AWS DeepLens device.

Josh Long

Tutorial: Cloud Native Java

Josh Long, Pivotal

“It is not necessary to change. Survival is not mandatory.” -W. Edwards Deming Software - for many organizations and industries - is a competitive advantage. Organizations break their larger software ambitions into smaller, independently deployable, feature -centric batches of work - microservices to optimize for velocity. Velocity, for velocity’s sake, is dangerous. Microservices invite architectural complexity that few are prepared to address. In this talk, we’ll look at how high performance organizations like Ticketmaster, Alibaba, and Netflix make short work of that complexity with Spring Boot and Spring Cloud. In this workshop we'll look at how to build cloud-native Java systems that are elastic, agile, observable and robust.

Stuart W. Marks

Presentation: Collections Refueled

Stuart W. Marks, Oracle

The Collections Framework was introduced in JDK 1.2 back in 1998 and is still in heavy use today. Although its fundamentals remain unchanged, it has evolved considerably since its introduction, and it continues to evolve. This session describes some of the recent enhancements made to Collections, with a focus on the enhancements added to Java 9. Of particular note is JEP 269, Convenience Factory Methods, a library-based API that serves the purpose of collection literals. Finally, the session provides a glimpse at some possible future enhancements for the Collections Framework.

Daniel Deogun

Presentation: Cracking the Code to Secure Software

Daniel Deogun, Omegapoint Daniel Sawano, Avanza

What is it that makes writing secure software so difficult? Why do we keep making the same mistakes? One challenge is that developers are busy delivering features, another is that security seems scary and complex. In this talk, we'll address this by combining tools and mindsets from Domain Driven Design along with a pinch of security. This way, we'll teach you how to create secure code while still focusing on delivering business features. We'll also present the basic principles of Secure by Design and show how security weaknesses can be addressed using good design principles and why you shouldn't fear security as a field. Finally, the ideas and patterns presented are directly applicable in your daily work regardless if you're working with legacy code or brand new state of the art software

Leonard Gram

Presentation: DevOps Deconstructed

Leonard Gram, GrafanaLabs

What's a Site Reliability Engineer and how's that role different from the DevOps engineer my boss wants to hire? I really don't want to be on call, should I? Is Docker the right place for my code or am I better of just going straight to Serverless? And why should I care about any of it? I'll try to answer some of these questions while looking at what DevOps really is about and how commodisation of servers through "the cloud" ties into it all. This session will be an opinionated piece from a developer who's been on-call for the past 6 years and would like to convince you to do the same, at least once.

Tobias Tebbi

Presentation: Escape Analysis in V8

Tobias Tebbi, Google

Turbofan is V8's new optimizing Javascript compiler, which uses an unscheduled sea-of-nodes intermediate representation. After a short introduction to Turbofan's design, we explore the challenges encountered when implementing Escape Analysis for Turbofan. Escape Analysis is a compiler optimization that allows to remove or postpone the allocation of temporary objects, potentially storing the object fields in registers instead. This reduces load on the garbage collector and removes memory access instructions. To make the analysis phase fast enough while keeping the implementation readable, we used of a purely functional data structure to share data when storing the state of all objects at all points in the code.

Fredrik Vraalsen

Hands-on Lab: Event stream processing using Kafka Streams

Fredrik Vraalsen, Schibsted

This workshop will give you hands-on experience using Kafka Streams to solve a variety of event stream processing problems. The examples and exercises are based on real-world usage from our stream processing platform in Schibsted, used to process over 800 million incoming events daily from users across the globe. We will cover topics ranging from the basics like filtering and transforming events, to how you can use Kafka Streams for data routing, aggregating events, and enriching and joining event streams. To solve the exercises we'll be using Java 8 and/or Scala.

Ivan Krylov

Presentation: Falcon — new JIT compiler in Zing JVM

Ivan Krylov, Azul Systems

Falcon is the new JIT compiler for Zing JVM, which has replaced our C2 compiler. The new compiler is based on the LLVM infrastructure and focuses on improving peak throughput performance. LLVM had originally been used as a static compiler for C/C++. It has taken us a lot of work upstream to teach LLVM how to compile Java code efficiently. In this talk we will discuss the difference between a static compiler for C/C++ and a JIT compiler for Java and will cover GC support, deoptimizations, and Java specific optimizations. Building a new compiler is no small feat. In the talk you will find out why we decided to write a new compiler and will see examples of how Falcon speeds up execution.

Nicolai Parlog

Hands-on Lab: Getting your hands dirty with the Java Module System

Nicolai Parlog, CodeFX

The days to study the Java 9 module system from a distance, just by reading about it, is over - time to gets your hands dirty! This half-day workshop... * starts with the basics * why is there even a module system and what does it solve? * what's a module and how is one defined? * what do readability and accessibility mean and why are these terms so important? * teaches you refined techniques beyond the basics * how to model optional and transitive dependencies * how to use services to decouple modules * how to make sure reflection is working * how to create runtime images for or even with your application

Panche Chavkovski

Presentation: Gluing the IoT world with Java and LoRaWAN

Panche Chavkovski, netcetera

One of the reasons for the rapid ascension of IoT is the advancement in the communication protocols. In this field, LoRaWAN opened up a broad new spectrum of possibilities, allowing low powered devices to communicate at great distances. The entire infrastructure is non-invasive, runs on open frequencies and is completely end-to-end secure. TheThingsNetwork provides a complete LoRaWAN infrastructure which handles the entire communication, security and data delivery. Its core principles are that it's open, free and community driven, meaning that everyone can extend it and everyone can use it. This talk will explain how to utilize TheThingsNetwork and some well known frameworks like Spring Boot and Eclipse Paho in order to create robust, scalable and secure IoT solutions of your own.

Jim Dowling

Presentation: Hops, the world's fastest Hadoop distribution

Jim Dowling, Logical Clocks AB

Hops is the world's fastest and most scalable distribution of Hadoop and it has been developed by KTH, RISE SICS, and Logical Clocks AB in Stockholm. Java has been a central part of the Hops journey, not just on the backend, where JVM languages rule the Hadoop ecosystem, but also on our Gateway to Hadoop, Hopsworks provides UI-driven access to Spark, Flink, TensorFlow, and other Big Data services. We recount our journey with Java and how it enabled us to build the world's only multi-tenant Hadoop platform. We will also show you the Hopsworks platform in action from the Rise ICE Data Center at www.hops.site, where SICS North are providing reseachers and companies in Sweden with access to managed Spark, Flink, Hive, and Tensorflow services on the Hops platform.

Adrian Cole

Presentation: How to Properly Blame Things for Causing Latency: An Introduction to Distributed Tracing and Zipkin

Adrian Cole, Pivotal

This presentation reviews concepts, data model and architecture. It also talks about the difference between logging, metrics and tracing. The demo will have code in javascript and java (maybe also a surprise language!), but code expertise isn't required. When you leave, you'll at least know something about distributed tracing, and hopefully be on your way to blaming things for causing latency!

Gojko Adzic

Presentation: Humans vs Computers: five key challenges for software quality tomorrow

Gojko Adzic, Neuri Consulting LLP

With the advances in our industry we can build software faster and operate it cheaper while serving more platforms and solving more problems than ever before. This is not without it's complications though, this new landscape requires teams to change their approach to reduce risk and ensure quality in their software. In this presentation, based on the research for the book Humans vs Computers, Gojko will look at five important software quality challenges facing delivery teams due to these shifting roles. He will also present some emerging ideas that will help address these challenges and inspire you to rethink your approach to testing.

Sam Bellen

Presentation: I didn’t know the browser could do that!

Sam Bellen, madewithlove

The times when a browser simply had to parse and show some markup are long gone. These days they are full of interesting api’s exposing various information and behaviour to web developers. This talk will walk you through a few of these api’s (speech, speech recognition, battery, location, ...), some of which you might know, some maybe not. I will show a quick example of what some of these api’s can do, and how to use them.

David Delabassee

Presentation: Java EE 8 finally final! Now what?

David Delabassee, Oracle

The goal of this session is two-fold, i.e. explain what Java EE 8 brings today and understand where Java EE is going tomorrow with the recently announced move of Java EE to the Eclipse Foundation. We will start by covering in details the new capabilities added in Java EE 8: - JAX-RS 2.1’s new Reactive client API - Bean Validation 2.0 improvements - CDI 2.0 Asynchronous events - Servlet 4.0 HTTP/2 support - The addition of a new JSON Binding API - A new Security API... We will then conclude by discussing the move of Java EE to the Eclipse Foundation and what it exactly means for the platform and its relation with the MicroProfile.IO project. Attend this session to understand what Java EE 8 brings today and where Java EE is going tomorrow!

Simon Ritter

Tutorial: JDK 9 Deep Dive

Simon Ritter, Azul Systems

In this session we'll explore the major new features of JDK 9, in detail, providing developers with enough information to be able to put them to use effectively. The session will cover topics like. The Java Platform Module System (JPMS). What is it and what does it mean for existing applications. Using Java modules in applicaiton development. How to mix existing jar files with modules. JPMS beyond the basics. How to use services and layers and how abour backwards compatibility? And some of the core JDK 9 Library improvements:.

Tobe Announced

Hands-on Lab: Kotlin hands-on-lab (TBA)

Tobe Announced, Company TBA

Description To Be Announced

Jen Tong

Presentation: Kubernetes Runtime Security

Jen Tong, Google

Kubernetes makes a orchestrating containers easy, but any technology that changes the way you workflow may impact security. This talk provides an overview of security concerns that come up as you move to containers and Kubernetes. It will go over relevant security features and common pitfalls. Then it will show these features in action as they mitigate the impact of vulnerabilities in a demo web application.

Stuart W. Marks

Hands-on Lab: Lambda Programming Laboratory

Stuart W. Marks, Oracle

Interested in trying out Lambda and Streams features of Java 8? If so, this "higher-order lab" is for you. Participants will use JDK 8 and NetBeans to work on exercises intended to teach them about the Lambda feature of the Java programming language and the new Streams Library API. The exercises start off very simply, so that beginners can learn the fundamentals. Additional exercises covering grouping and parallel reduction aim to challenge more-advanced participants. Participants need not have any prior knowledge of Java's Lambda feature, although having attended a prior JavaOne Lambda session or tutorial will be helpful. The laboratory exercises have been updated to cover recently added Java 9 features.

Frej Connolly

Quickie: Learn writing good tests from bad tests

Frej Connolly, Spotify

Writing unit tests that are easy for others to understand, maintainable and provide value can be tricky. This talk will take a different approach and instead show real world examples on tests that are bad, explain why and how to fix it.

Adam Bar

Presentation: Looking for the Holy Grail of Mobile Web Performance

Adam Bar

There’s a long-standing myth in the mobile world that only native apps are able to provide a decent performance for the mobile user. With the emergence of Progressive Web Apps that suppose to mimic all the native goodness, the push for performance in the mobile web is now stronger than ever before. Is the Web Platform ready to keep up with these expectations? This talk is a wide overview of the many practices and strategies we can employ to satisfy our mobile users’ needs - from the HTTP-level tweaks via load and render time optimization to smooth scrolling and animations tricks.

Bernd Rücker

Presentation: Lost in transaction? Strategies to deal with (in-)consistency in modern architectures

Bernd Rücker, Camunda

You probably work on a distributed system. Even if you don't yet face a serverless microservice architecture using a NoSQL database, you might "just" call some remote services via REST or SOAP. Welcome to a world without ACID transactions which leaves you in charge of dealing with difficult problems yourself e.g. eventual consistency, distributed transactions, compensation or message delivery semantics like "exactly-once"? In this talk, I’ll briefly describe why this will become the new normal and which challenges arise for us as developers. I will discuss strategies to deal with it and present real-life experiences, including recipes, patterns, but also frameworks. Expect fun little live hacking sessions with Open Source components like Spring, Hystrix, Kafka and Camunda.

Katharine Beaumont

Presentation: Machine Learning Bag o’ Tricks

Katharine Beaumont

Plain Old Java Developer? Entranced by the magic of buzzwords like "Deep Learning", "Artificial Neural Networks", "Chat Bots", anything with the prefix "neuro", and "The AI Apocalypse Where They Come For Us All"? There is a world out there of other Machine Learning techniques, unfairly cast aside in the tide of trends. They are tried and tested, sad, minor characters in the AI hype stage. But do you know what? You don't need to reach for the complicated allure of Neural Networks to add a bit of intelligence to your application.

Tobe Announced

Hands-on Lab: Make your own IoT device and service using open standards and open platforms

Tobe Announced, Company TBA

Develop your own IoT device and/or IoT service using open standards and open source platforms. During this IoT tutorial session we will show how to develop a low-cost, resource constrained, IoT sensor device that use standard protocols such as LWM2M and MQTT to connect to cloud. 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 be able to choose to develop in low-level C programming or use high level languages for both device and service software.

Charles Nutter

Presentation: MethodHandles Everywhere

Charles Nutter, Red Hat

Method handles, Java's fast function pointers and functional adapters, were added in Java 7 to support new language features. Since then, they've been leveraged to make not only fast dynamic languages, but a richer set of features for Java itself. In this talk we will explore how you can use handles to improve your apps and libraries. We'll see how they wire up and optimize. And we'll play with the new loop and variable pointer handles in Java 9. If you've ever been curious about java.lang.invoke.*, this is the talk for you.

Ivar Grimstad

Presentation: Microprofile - New and Noteworthy

Ivar Grimstad, Cybercom Sweden

When the Microprofile initiative was started in 2016, it only took about three months before version 1.0 was launched. From day one, there were four different implementations from four different vendors available. One year later, Microprofile 1.1 is here! Whereas version 1.0 was a subset of Java EE specifications, version 1.1 brings something new to the table. The new kid on the block is _MicroProfile Config_. In this fast-paced, demo-heavy session, MicroProfile will be introduced and demonstrated using the available implementations in live coding demos. We will also take a look at the potential candidates for future versions. This will include technologies such as Fault Tolerance, Security, Health Checks

Klara Ward

Presentation: Mission Possible - Near zero overhead profiling

Klara Ward, Oracle

Java Flight Recorder is a low overhead profiling tool built into the Oracle JDK. It is possible to turn on whenever you wish to investigate the behavior of your Java application, the data is then analyzed in Java Mission Control. It is designed for production time usage, but it also useful during development. JDK 9 includes a new supported API for creating your own events, and for controlling the JFR engine. JMC 6 includes a redesign GUI and automated analysis, which can be extended with your own heuristics and executed in JMC or headless. Both JFR and JMC are currently in the process of being open sourced.

Carl Bergquist

Quickie: Monitoring? Not OPS problem

Carl Bergquist, Grafana Labs

Why should we monitor our system? Why can’t we just rely on the operations team anymore? They use to be able to do that. What’s currently changing? Presentation content: - Why do we monitor our system - How did it use to work? - Whats changing - Why do we need to shift focus - Everyone should be on call. - Resilience is the goal (Best way of having someone care about quality is to make them responsible)

Mark Reinhold

Presentation: Moving Java Forward Faster

Mark Reinhold, Oracle

The Java SE Platform and the JDK are moving to a rapid, six-month release cadence, with the next release in March 2018. We’ll review the motivations for this change and discuss some of its consequences. We'll then take a look ahead at the pipeline of features currently in development in various projects in the OpenJDK Community including Amber, Panama, Valhalla, and Loom.

Katharine Beaumont

Tutorial: Neural Network Walkthrough

Katharine Beaumont

You pick up the keyboard, and select 'tanh'. 'Play'. The epochs rack up... Something doesn't feel right, things aren't converging, your HP is decreasing. But you've seen people do this before... The FAQ is useless, and the documentation is like boss level 99. You know it's possible - but What The Fowler is 'tanh' anyway? And How The Fortran does this work? Neural Networks are hard. But don't worry, there is a walkthrough for this, and it has pictures.

AMahdy Abdelaziz

Presentation: Offline-first apps with Web Components

AMahdy Abdelaziz, Vaadin

We will explore how to boost the usability of web and mobile-web apps by implementing offline-first functionalities, it's the only way to guarantee 100% always on user experience. Low signal or no connectivity should no longer be a blocker for the user, we will discuss the available solutions for caching, in-browser database, and data replication. We will also take a look at how WC help solving those issues out of the box. There will be a live coding demo to see how it's simple to manipulate a large data, completely offline.

Charlie Gracie

Presentation: Pause-Less GC for Improving Java Responsiveness

Charlie Gracie, IBM

The Open J9 Java VM recently introduced a new Pause-Less GC policy. This technology uses a new HW feature on the 390 platform to create a concurrent copying GC. The Pause-less GC policy significantly reduces pause times with minor to no throughput reductions. I will provide an overview of the new hardware feature, a deep dive into the technology, discuss the pause time improvements and future advancements.

Richard Warburton

Presentation: Polishing the Diamond: Core Library Improvements in Java 9

Richard Warburton, Monotonic Ltd

The Java Core Libraries are mature, well-understood and loved, but don’t you always run into corner cases where they don’t work so well? In this talk, which is entirely live-coded, you will learn key updates and improvements that you’ll get to enjoy in the next exciting version of Java: Java 9. You will also get to see the new REPL – JShell in action as an educational tool. In this session you will learn about: – Collection factories – Improvements to Streams and Collectors – Improvements to Optional Data Type If you’ve already heard a lot about project Jigsaw and want to know about what other Java 9 updates will rock your world, come to this talk!

Lars Albertsson

Presentation: Privacy by design

Lars Albertsson, Mapflat

Privacy and personal integrity has become a focus topic, due to the upcoming GDPR deadline in May 2018. GDPR puts limits on data storage, retention, and access, and also give users rights to have their data deleted and get information about the data stored. This constraints technical solutions, and makes it challenging to build systems that efficiently make use of sensitive data. This talk provides an engineering perspective on privacy. We highlight pitfalls and topics that require early attention. We describe technical patterns for complying with the "right to be forgotten" without sacrificing the ability to use data for product features. The content of the talk is based on real world experience from handling privacy protection in large scale data processing environments.

Jesse Anderson

Presentation: Processing Data of Any Size with Apache Beam

Jesse Anderson, Big Data Institute

Rewriting code as you scale is a terrible waste of time. You have perfectly working code, but it doesn't scale. You really need code that works at any size, whether that's a megabyte or a terabyte. Beam allows you to learn a single API and process data as it grows. You don't have to rewrite at every step. In this session, we will talk about Beam and its API. We'll see how Beam execute on Big Data or small data. We'll touch on some of the advanced features that make Beam an interesting choice.

Sam Aaron

Presentation: Programming as Performance

Sam Aaron, Sonic Pi

Live Coding systems encourage us to think extremely differently about programming languages. In addition to considering standard requirements such as reliability, efficiency and correctness we are also forced to deal with issues such as liveness, coordination and synchronization all whilst working in real time. Live Coders not only run and modify our code live — they often performing with it live on stage in front of large crowds of people who really don't want the code to miss a beat. In this code and demo-heavy talk, Sam will take a deep technical dive into the internal ideas and innovations of Sonic Pi — a system designed specifically for live coding music. The audience will explore Sonic Pi's novel temporal semantics which allows multiple concurrent threads to execute in synchronizatio

Ron Pressler

Presentation: Project Loom: Fibers and Continuations for the Java Virtual Machine

Ron Pressler, Oracle

As concurrent programs grow in scale, so does the disparity between the domain unit of concurrency (session/transaction), and the software unit of concurrency -- the thread. A modern server may support a million concurrent connections but only a few thousand threads. As a result, developers are forced to abandon the thread as a model of domain concurrency and rely on finer-grained constructs. The resulting asynchronous programming style is difficult to write, debug and maintain. Project Loom is a new OpenJDK project aiming to provide an alternative, flexible and lightweight implementation of threads that would allow a good abstraction to meet modern requirements, and enable new and useful programming styles. That implementation will employ continuations, which have other interesting uses.

Josh Long

Presentation: Reactive Spring

Josh Long, Pivotal

Spring Framework 5 is here! One of the most exciting introductions in this release is support for reactive programming, building on the Pivotal Reactor project to support message-driven, elastic, resilient and responsive services. Spring 5 integrates an MVC-like component model adapted to support reactive processing and a new type of web endpoint, functional reactive endpoints. In this talk, we'll look at the net-new Netty-based web runtime, how existing Servlet code can run on the new world, and how to integrate it with existing Spring-stack technologies.

Emil Forslund

Quickie: Ready for Java 9 - Bridging the Gap Between Database and Stream

Emil Forslund, Speedment. Inc.

Whenever you write code that mixes languages and domains, such as Java and SQL, you are going to get bugs. A solution is to move away from query languages such as SQL and instead write your business logic with the type-safe and object-oriented constructs we have learned to love in Java, such as streams, predicates, and functions. The Stream interface that came in Java 8 and was expanded in Java 9 will be introduced in this session, you will rediscover the power of the Stream interface in a completely new domain: relational databases. You will also learn how nicely it blends in with your existing application, even with no modifications on the database layer. This will not only increase your productivity but also help you build safer and more maintainable Java code.

Katia Aresti

Tutorial: Real-time Streaming Data Deep Dive

Katia Aresti, Red Hat Clement Escoffier, Red Hat Galder Zamarreño, Red Hat

Dealing with real-time, in-memory, streaming data is a unique challenge and with the advent of the smartphone and IoT (trillions of internet connected devices), we are witnessing an exponential growth in data at scale. Learning how to implement architectures that handle real-time streaming data, where data is flowing constantly, and combine it with analysis and instant search capabilities is key for developing robust and scalable services and applications. In this deep dive session, we will look at how to implement an architecture like this, using reactive open source frameworks. An architecture based around the Swiss rail transport system will be use throughout the presentation.

Michael Gielda

Presentation: Renode, an open source simulation framework for developing robust, well rested ARM and RISC-V systems

Michael Gielda, Antmicro LTD

The open source Renode framework, developed by Antmicro, is a flexible simulation framework meant to revolutionize development of embedded systems by enabling a workflow with Continuous Integration (CI) that is notoriously difficult to perform with physical devices. Renode’s target is to simulate not only CPUs but entire SoCs and development boards including sensors. Hence, unmodified firmware / software, identical with that used on physical hardware, can be run in Renode without the need for using ‘special’ compilation targets. Renode supports many CPU families such as ARM, x86 and the new RISC-V architecture. The presentation will cover Renode, focusing on the landmark features and the recent development in the RISC-V domain, including a demo of multiple RISC-V based nodes.

Daniel Deogun

Tutorial: Secure by Design

Daniel Deogun, Omegapoint Dan Bergh Johnsson, Omegapoint

Security is a hot topic. But most developers don't like security. Why? Because it's hard and it doesn't matter how much time you spend on it. Sooner or later some white hat hacker does a penetration test and claims you "pwned" – so what's the point? Secure by Design solves this using patterns that implicitly promote security. It allows you to focus on delivering features rather than thinking about security guidelines & policies. In this tutorial, we share several of these patterns using code and discuss how they promote security attributes such as confidentiality, integrity, and availability (CIA). We also relate them to the new edition of OWASP Top 10 2017 and discuss how they apply to your daily work, regardless if you're working with legacy code or brand new state of the art software.

Siren Hofvander

Presentation: Security today and tomorrow : Adapting the rules to suit technological advances

Siren Hofvander, Min Doktor

From Hexagonal to Micro Services, from 3 Tier applications to BlockChain, as design patterns and technologies advance, so too must the security recommendations we apply to these systems. What was critical to keep in mind previously may no longer be an issue simply because the constraint that gave rise to it is no longer around. But as we see time and again in software development, sometimes that which is old becomes new again, and so it's equally important that we look over the security patterns we've successfully used in the past and how they are still relevant even though the buzzwords have changed!

Arun Gupta

Presentation: Serverless Architecture Patterns and Best Practices

Arun Gupta, Amazon Web Services

AWS Lambda has changed how developers build and run their applications or services. But what are the best practices for tasks such as deployment, monitoring, and debugging in a serverless world? In this session, we’ll dive into best practices that serverless developers can use for application lifecycle management, CI/CD, monitoring, and diagnostics. We’ll talk about how you can build CI/CD pipelines that automatically build, test, and deploy your serverless applications using AWS CodePipeline, AWS CodeBuild, and AWS CloudFormation. We’ll also cover the built-in capabilities of Lambda and API Gateway for creating multiple versions, stages, and environments of your functions and environments of your functions and APIs. Finally, we’ll cover monitoring and diagnostics of your Lambda functions.

Bert Ertman

Presentation: Serverless, future of the Cloud

Bert Ertman, Luminis

Are you still using Docker in production? Get over it! Serverless is the NEW future of the Cloud. But since the Cloud is still someone else's computer, that needs to be managed too. And if it is sitting idle, you probably have to pay for it whether you like it or not. No server can be more easily managed than no server. Therefore: meet Serverless, a new paradigm that truly approaches the Pay-as-You-Go philosophy once promised by the Cloud. With live coding and demos, this session explores Serverless, its impact on existing architectures, it's usability for Mobile Back-ends as a Service (MBaaS), Functions-as-a-Service (FaaS) and also for Microservices based architectures hosted in the cloud.

Bert Ertman

Tutorial: Serverless, future of the Cloud, Deep Dive

Bert Ertman, Luminis

Are you still using Docker in production? Get over it! Serverless is the NEW future of the Cloud. But since the Cloud is still someone else's computer, that needs to be managed too. And if it is sitting idle, you probably have to pay for it whether you like it or not. No server can be more easily managed than no server. Therefore: meet Serverless, a new paradigm that truly approaches the Pay-as-You-Go philosophy once promised by the Cloud. With live coding and demos, this session explores Serverless, its impact on existing architectures, it's usability for Mobile Back-ends as a Service (MBaaS), Functions-as-a-Service (FaaS) and also for Microservices based architectures hosted in the cloud.

Burr Sutter

Presentation: Service Mesh and Sidecars

Burr Sutter, Red Hat

The first generation of microservices was primarily shaped by Netflix OSS and leveraged by numerous Spring Cloud annotations all throughout your business logic. The next generation of microservices will leverage sidecars and a service mesh. In this session, we will give you a taste of Envoy and Istio, two open source projects that will change the way you write distributed, cloud native, Java applications on Kubernetes. Traffic shaping, network fault-injection, A/B testing, dark launches and much more. A highly distributed application based on microservices brings a number of additional complexities to your application architecture, increasing the weight/size of each of your components, mixing infrastructure logic within your business logic.

Aleksey Shipilev

Presentation: Shenandoah GC: What We Know In 2018

Aleksey Shipilev, Red Hat

Shenandoah is the ultra-low pause garbage collector for OpenJDK, developed by Red Hat. It adds concurrent compaction to the mix, making all heavy-weight phases in GC cycles concurrent. This talk is about brief status for Shenandoah in 2018 and what changed in past years, the performance successes it has, the challenges faced by the implementation, the ideas that are being tried.

Mark Heckler

Presentation: Springing into Kotlin

Mark Heckler, Pivotal

Developing applications with Spring Boot is already a pretty magical experience, but could it be better? Can the magic get any more powerful than it already is? In this talk, we'll look at how Kotlin can be used to reduce boilerplate, increase code quality, and elevate your wizardry. The presenter will demonstrate how to begin incorporating Kotlin into your existing Spring applications and, once you start your journey, where it can lead. Come to this session to level up on Spring+Kotlin! (Robes optional)

Galder Zamarreño

Presentation: Streaming Data Analysis with Kubernetes

Galder Zamarreño, Red Hat

Dealing with real-time, in-memory, streaming data is a unique challenge and with the advent of the smartphone and IoT (trillions of internet connected devices), we are witnessing an exponential growth in data at scale. To be able to handle potential data growth, you want to process data in a cloud environment that can easily scale. In this space, Kubernetes offers great container orchestration and auto-scaling, and when combined with Infinispan, an in-memory data grid, it empowers you with state of the art distributed data processing capabilities to tackle these challenges. In this session, we will identify critical patterns and principles that will help you achieve greater scale and response speed, and you will see them in action with live coding examples.

Henrik Kniberg

Presentation: Taming the Internet of Things

Henrik Kniberg, Crisp

Internet of Things is a hot buzzword these days, but this talk is about the nitty-gritty practicalities of it. How the heck can we remote-administrate and remote-update a bunch of devices that are inside houses and buildings all over the country, stuck behind unstable networks and unknown firewalls? How can we do agile development and continuous delivery under those circumstances? The past year I’ve been neck deep in code, developing and rolling out a “smartmeter” for solar energy (well, a raspberry Pi in disguise...). We naively thought the icky infrastructure part was “solved” and all we had to do was build the application. Wrong! 95% of the work was infrastructure, and only 5% application. So what did we build, and what did we learn along the way?

Dan Heidinga

Presentation: The Eclipse OpenJ9 JVM: a deep dive!

Dan Heidinga, IBM

Interested in learning how a JVM actually works? Want to understand the design of the Eclipse OpenJ9 JVM, formerly IBM's J9 JVM? IBM open sourced their enterprise production hardened JVM at the Eclipse Foundation as the OpenJ9 JVM. Come to this session to learn the design principles behind the OpenJ9 runtime and the key advantages of this JVM, particularly for Cloud deployments. Follow your application code as it’s loaded, linked, and excuted on OpenJ9.

Bob Dahlberg

Quickie: The elegance of Kotlin

Bob Dahlberg, Isotop AB

Want to learn the shortcuts and see the benefits of a modern programming language that have swept the Android developer community of their feet? This presentation is packed to the limits with code examples of how Kotlin have made my code more elegant, readable and safer. For all of you that can't move up to the latest JVM versions, or just want to learn something new, here is your chance of using the perks of a modern programming language.

Travis Reeder

Presentation: The Fn Project, Serverless Everywhere and Anywhere

Travis Reeder, Oracle

Serverless computing is one of the hottest trends in computing right now due to it’s simplicity and cost efficiency. The Fn Project (https://fnproject.io) enables you to run your own serverless infrastructure wherever you want— on-premise or in the cloud. Built on Docker, Fn supports writing functions in every popular programming language with excellent support for Java. All you need is Docker and you're ready to go! 1) Look at how to use Fn with a demo. 2) Walk through writing functions in Go, Node.js, and Java and deploy them. 3) Discuss how the platform is implemented including packaging, input and output, the nitty gritty on running short-lived Docker containers and hot functions to increase performance 4) How to operate and scale Fn. 5) Q&A

René Gröschke

Presentation: The Kotlin DSL experience in Gradle

René Gröschke, Gradle Inc.

Since Gradle 3.0, a Kotlin based DSL that allows better tooling, type-safety, and unprecedented expressiveness, can be used to author Gradle build scripts.This comes with a richer IDE experience, with more precise content assist, quicker access to documentation, better source code navigation, refactoring and more when working on your build. In this presentation you will learn how you and your team can start taking advantage of the Kotlin DSL in Gradle, the improved IDE support and the faster configuration times.

Clement Escoffier

Presentation: The reactive landscape

Clement Escoffier, Red Hat

Reactive Programming, Reactive eXtensions, Reactive Streams, Reactive Systems, Reactive Manifesto, that’s a lot of 'reactive' thingies. Just to make it even more confusing, 'reactive' is often associated with asynchronous, scalability, RX libraries (RX Java, RX-JS), back pressure, streams, observables, futures, promises, spreadsheets and so on…. That's a lot to digest…This session helps you understand what's behind the reactive word. It explores the reactive landscape and explains what all these 'things' are and how they are related. By providing a global overview of the reactive landscape, this session also provides to the attendees a general understanding of the 'reactive' trend, and why it matters.

Benjamin Cabé

Presentation: The Three Software Stacks Required for IoT

Benjamin Cabé, Eclipse Foundation

Whether you’re looking at the constrained devices that make for the "things" of the IoT, gateways that connect them to the Internet, or backend servers, there’s a lot that one needs to build for creating end-to-end IoT solutions. In this session, we will look at the typical software features that are specific to IoT, and see what’s available in the open source ecosystem to implement them. We will also dive into the architecture of some real-world solutions that have been built on top of Eclipse IoT technologies, and learn about the software behind them.

Nicolai Parlog

Presentation: To JAR Hell And Back - A Live Migration to the Java 9 Module System

Nicolai Parlog, CodeFX

I'm sure you've heard about compatibility issues with upgrading to Java 9 and the new module system but did you try it yourself yet? This live coding session starts with a typical Java application and runs up against and eventually overcomes the common hurdles: * build system configuration * dependency analysis with `jdeps` * dependencies on internal APIs and Java EE modules * split packages * stepwise modularization with automatic modules To get the most out of this talk, you should have a good understanding of the module system basics - afterwards you will know how to approach *your* application's migration to Java 9 and the module system.

Christoph Engelbert

Presentation: Typescript Go(es) Embedded

Christoph Engelbert

Everyone knows there isn't just one way of doing things. This is also true for web-administrated Embedded Devices and a lot of different ways to attack the implementation were taken before the combination of Golang and Typescript manifested. Plenty of the tries started by missing knowledge, inability, the hate of some programming languages or just plainly on size requirements. Over Java and C/C++ to Go+Lua, Go+JavaScript and the final decision on Go and Typescript, we follow the adventure of an embedded framework and the arising problems. Pros and Cons but also the feeling for a Java developer and new horizons are given.

Alexander Tarlinder

Presentation: Using Developer Testing to Boost the Quality of Your Code

Alexander Tarlinder, ILT Inläsningstjänst AB

“Quality cannot be tested in. It has to be built in.” While very true, this phrase is also a true cliché in our industry. What does it actually mean, who is supposed to do what and how? Developer testing is the developers’ intentional and systematic employment of testing tools and techniques to achieve the highest possible quality of the software that they create and it provides the answers to the above questions. In this talk, I'll give a short introduction to developer testing based on the nine core competencies, and I’ll explain how to use them to improve your development process as well as to identify your team’s next step. Obviously a team maintaining a legacy monolith and struggling with “quality issues” faces a different challenge than the team that starts out afresh doing TDD.

Charlie Gracie

Tutorial: VM Tech Summit part I

Charlie Gracie, IBM Aleksey Shipilev, Red Hat Tobias Tebbi, Google

9.00-9.45 Shenandoah GC: What We Know In 2018
Shenandoah is the ultra-low pause garbage collector for OpenJDK, developed by Red Hat. It adds concurrent compaction to the mix, making all heavy-weight phases in GC cycles concurrent. This talk is about brief status for Shenandoah in 2018 and what changed in past years, the performance successes it has, the challenges faced by the implementation, the ideas that are being tried.

10.00-10.45 Escape Analysis in V8
Turbofan is V8's new optimizing Javascript compiler, which uses an unscheduled sea-of-nodes intermediate representation. After a short introduction to Turbofan's design, we explore the challenges encountered when implementing Escape Analysis for Turbofan. Escape Analysis is a compiler optimization that allows to remove or postpone the allocation of temporary objects, potentially storing the object fields in registers instead. This reduces load on the garbage collector and removes memory access instructions. To make the analysis phase fast enough while keeping the implementation readable, we used of a purely functional data structure to share data when storing the state of all objects at all points in the code.

11.45-12.30 Pause-Less GC for Improving Java Responsiveness
The Open J9 Java VM recently introduced a new Pause-Less GC policy. This technology uses a new HW feature on the 390 platform to create a concurrent copying GC. The Pause-less GC policy significantly reduces pause times with minor to no throughput reductions. I will provide an overview of the new hardware feature, a deep dive into the technology, discuss the pause time improvements and future advancements.

Stefan Karlsson

Tutorial: VM Tech Summit part II

Stefan Karlsson Ivan Krylov, Azul Systems Ron Pressler, Oracle

13.30-14.15
Project Loom: Fibers and Continuations for the Java Virtual Machine

As concurrent programs grow in scale, so does the disparity between the domain unit of concurrency (session/transaction), and the software unit of concurrency -- the thread. A modern server may support a million concurrent connections but only a few thousand threads. As a result, developers are forced to abandon the thread as a model of domain concurrency and rely on finer-grained constructs. The resulting asynchronous programming style is difficult to write, debug and maintain. Project Loom is a new OpenJDK project aiming to provide an alternative, flexible and lightweight implementation of threads that would allow a good abstraction to meet modern requirements, and enable new and useful programming styles. That implementation will employ continuations, which have other interesting uses.

14.30-15.15
ZGC - Low Latency GC for OpenJDK

ZGC is a new garbage collector for OpenJDK, optimized for low latency and very large heaps. We've developed ZGC internally at Oracle so far, and we're now open-sourcing it so as to broaden the base of both contributors and users. This talk will give an introduction to ZGC, what it is, how it works, where we are and what we plan to do.

15.45-16.30
Falcon — new JIT compiler in Zing JVM

Falcon is the new JIT compiler for Zing JVM, which has replaced our C2 compiler. The new compiler is based on the LLVM infrastructure and focuses on improving peak throughput performance. LLVM had originally been used as a static compiler for C/C++. It has taken us a lot of work upstream to teach LLVM how to compile Java code efficiently. In this talk we will discuss the difference between a static compiler for C/C++ and a JIT compiler for Java and will cover GC support, deoptimizations, and Java specific optimizations. Building a new compiler is no small feat. In the talk you will find out why we decided to write a new compiler and will see examples of how Falcon speeds up execution.

Alexander Schwartz

Presentation: Vue.js - developer friendly, fast and versatile

Alexander Schwartz, msg systems ag

Vue.js is a client side JavaScript framework that is developer friendly: a command line interface to create new projects, easy to learn concepts, great online documentation, and top of the league developer tools. All this will get you started in no time working on modular and maintainable apps. Under the hood there is a fast state of the art rendering engine applying unidirectional data flow and virtual DOM that eliminates manual optimizations. Transitions are already part of the core engine so your apps will look fancy, too! Join me for this talk to see how simple and advanced applications can look like. I also provide a brief overview of the ecosystem. We’ve started to use Vue.js in early 2016 and this talk is based on our day-to-day experience.

Sara Harkousse

Presentation: Web Components: It's all rainbows and unicorns! Is it?

Sara Harkousse, Dassault Systèmes

Web components are a tale of four w3c specifications. We’ve all seen big headlines, for instance, “The Web Components revolution”, “Web Components are a game changer”, … and so many others. They are certainly exciting and promising, nevertheless, there are some factors holding them back such as performance issues and lack of browser support. In this talk you’ll examine web components from a pragmatic stand point. So if you want to start using ES6 web components in production, come to learn what features can you use today. Actually, despite the still short browser support, some of web components features seems to be the best choice to start with. The assessment you’ll learn is the reflection of my personal research and work on my spare time and also feedbacks from my co-workers.

Holden Karau

Presentation: When you need to add Deep Learning to raise your next round of funding

Holden Karau, Google

We all love working inside the JVM (personally I love Scala), but sometimes the new shiny thing doesn’t fit easily into our existing ecosystem. The rise of Apache Spark brought in lots of Scala developers, but now to keep up with the next shiny thing we need to be able to look at how we can play more nicely with tools (like deep learning) that are created beyond the wonderful JVM land. There was a time when playing nicely could mean a pipe of strings, but now days the bar is a little higher. We will look at how Apache Spark is using Apache Arrow to integrate more nicely into the world beyond. In addition to Arrow we’ll examine the different approaches taken in Apache BEAM to support a wide ecosystem of client languages. We'll finish with a DL example so you can close your series B*.

David Montag

Presentation: Winning a Pulitzer Prize with open source software – The Panama Papers story

David Montag, Neo4j

The largest ever known leak of confidential information occurred in 2015 when 2.6TB of data was leaked from a Panamanian law firm. A worldwide team of journalists secretly began work on making sense of this trove of unstructured data. In 2017 the journalists were awarded the Pulitzer Prize. Making this possible was a team of three developers who built a platform for data processing and analysis, enabling over 400 journalists to mine the data. They used a toolchain of open source software to convert the files to a searchable set of different kinds of entities. Neo4j was one of the last stages of the platform, powering queries and exploration of the semantic data extracted from the files. Come get a glimpse of how the journalists used Neo4j to make sense of the Panama Papers.

Stefan Karlsson

Presentation: ZGC - Low Latency GC for OpenJDK

Stefan Karlsson Per Liden, Oracle

ZGC is a new garbage collector for OpenJDK, optimized for low latency and very large heaps. We've developed ZGC internally at Oracle so far, and we're now open-sourcing it so as to broaden the base of both contributors and users. This talk will give an introduction to ZGC, what it is, how it works, where we are and what we plan to do.

Back to the top of the page