There’s no doubt advanced algorithms, machine learning and so-called Artificial Intelligence has been some of the most hyped terms the last couple of years.
In this presentation we’ll look at some of the real progress in AI and talk about why we’re seeing an explosive growth of AI now. But we’ll also discuss the very serious challenges in using these algorithms, put the phenomenon in a larger context and question the proliferation of hyperbolic salespitches.

SpeakerHenning Schwentner

Software development is model building. We rebuild a part of the world as a program in Java and improve it by doing so. A traditional approach is to reproduce the domain as accurate in every detail as possible. But is this the actual goal of models? If we look close enough, we will see that a model is the exact oposite—a model is actually an abstraction of the reality in which only the essential is transferred. The inessential is left out of the model. What parts of the reality are essential or inessential is defined by the domain.

A simple model is easier to understand than a complicated one. Therefore, it is a good idea to break a complex reality into multiple simple models. Exactly this effect is what microservices and DDD with its strategic design take advantage of. Here instead of one complex company-wide model we build several small models that are easy to understand.

In this talk we look into the tools that are available to build good models and to divide the domain in a way that we can work with several teams independently from each other.

Speaker: Vladimir Dejanovic

What does GraphQL and Traditional REST API have in common? Shouldn't the GraphQL be connected to some graphs or similar? What is actually GraphQL all about?

Join me in this talk, while I try to answer all this questions and much more.

In this talk I will explain what GraphQL is, what are differences and similarities compared to more traditional REST API and show you this on working examples, since code worth more then words only ;)

Speaker: Dmitry Vinnik

Starting Java 8, the main focus of many developers was on Functional Programming in Java including Streams, Optional, and Functional Interfaces. However, there were more amazing features introduced along the way which has changed Java programming. One of such features was CompletableFuture which is continuously being improved in Java 9 (JEP 266).

As Concurrency in Java is generally a complicated topic where many had a difficult time switching to ThreadLocal from regular Threads, the idea of Future and CompletableFuture which refers to asynchronous computations is even more difficult.

In this talk, the speaker will attempt to make asynchronous programming using Java 8/9 more compelling by approaching the topic with clear examples and references to other languages. One example of a language heavily relying on asynchronous tasks is JavaScript. Using some of the conceptual similarities of two languages in regards to asynchronous programming, this talk will cover how Future/CompletableFuture can be used in a safe and a programmer friendly way.

Speaker: Jakob Jenkov

The Grid is a vision for the next generation of Internet standards and technologies. The Grid addresses the biggest problems with The Web, both at data, protocol and architecture levels.

The Grid is a byproduct of a startup project launched in January 2015 as a collaboration between Jenkov Aps and Zaiku Group Ltd. The goal of the project was then to create a new backend as a service platform which was more coherent, consistent and focused than what you were getting back then with Google App Engine and AWS.

To create a more coherent platform we realized that we had to reinvent several of the technologies we wanted to offer, and the technologies to support that, including data formats, network protocols and application platform.

During the project we have narrowed our business focus from general SaaS / IaaS to focus on creating a
"Data Intelligence Ecosystem". Most of the underlying ideas and technologies are the same, though.

This presentation is about the vision that is the base for this project, the solutions we have come up with, and the experiences we have made along the way. Focus will be on the parts of the project that are about Internet application architecture, including our solutions to support the new architecture suggestions. Part of these solutions are released as open standards and open source software.

Speaker: Kamil Szymański

Finding bugs in distributed systems is challenging.

Finding bugs on production in distributed systems is even harder due to time pressure, especially if the bug is on critical path.

At times like that you can't afford guessing what's wrong, you have to take decisions based on real data.

In this slides-free session we will see how can we use live data for making bugs discovery quicker and finding root causes of such bugs easier.

Moreover we will discuss how to deal with production outages and quickly recover from them.

Speaker: Oleg Šelajev

GraalVM is an embeddable virtual machine designed for running all languages efficiently: Java, Scala, Kotlin, JavaScript, Ruby, or Python; and even the static one too, like C, C++ or Swift.

It uses the existing JVM architecture coupled with a state-of-the-art compiler to ensure better peak performance for long-running applications, but it can also run programs compiled ahead-of-time using a standalone native virtual machine to provide better startup time and lower runtime overhead essential for cloud applications and a true serverless experience.

GraalVM's modular design allows embedding it in existing technologies, to create secure execution sandboxes for polyglot applications and resource virtualization platforms. This way you can write polyglot applications inside your Java applications or, for example, Oracle RDBMS or MySQL databases with zero overhead for accessing the data structures of the underlying engine.

All in all, using GraalVM makes developers more productive as they can use the programming language of their choice throughout the technology stack and reuse libraries from other ecosystems with ease.

From this session, you'll learn key advantages and use cases of GraalVM for Java and JavaScript developers.

Speaker: Ryan Cuprak

In this session you will learn how to use Arquillian and several of its extensions to construct powerful tests for Java EE and Spring. Extensions to be covered in this session include Cube, Cube Q, Graphene, Warp, and Drone. With these extensions, you get the power of Arquillian along with Docker and Kubernetes. Extensions such as Cube Q enable you to simulate network issues and introduce latency and bandwidth problems as well as unreachable services. This will cover all of these extensions and also how to leverage Mockito to create interesting test scenarios.

Speaker: Jan Ypma

Developers are increasingly building reactive server applications and leveraging streaming frameworks to get maximum resource utilization and elasticity. The functional programming concepts that Akka and RxJava apply, result in great testability and ease reasoning about parallelism. However, what about the front-end?

As it turns out, reactive techniques fit user interfaces just as well as servers, with the same testability advantages. However, it pays off to have a type-checker when turning a Stream<T> into Stream<List<U>>, which via Stream<Map<K,U>> result in Stream<U>. A solution has been found in ScalaJS, which enables using a well-established, highly type-safe language in the web browser (without repeating GWT's mistakes...)

A real-time document editor is being developed to edit semantically-rich documents like invoices and orders with multiple participants simultaneously. The prototype architecture is built around ScalaJS and Outwatch, with an Akka-based server.

Speaker: Ensar Basri Kahveci

Distributed databases employ replication to achieve performant, available, and fault tolerant solutions.

However, managing replicated data is challenging.

Building a distributed database is hard, and clarifying its high level properties is even harder.

Hazelcast makes use of several replication techniques together to offer choices for the trade-offs between consistency, availability, and latency properties.

In this talk, I take a closer look at these techniques, and discuss them from the perspective of the CAP and PACELC principles.

SpeakersGilles Di Guglielmo & Alexandre DuBreuil

Fluent, stream-like API are great for writing type checked code, taking advantage of Java 8 functions and lambdas.

But what about creating your own fluent API to manipulate and validate your model?

We created an open-source framework called dOOv, for "Domain Object Oriented Validation" (http://doov.io), that generates a validation DSL from a domain model.

This presentation will demonstrate the efficiency and expressiveness of dOOv to define validation constraints.

The validation rules are represented as an abstract syntax tree, which makes it possible to visit the tree and show the rule in text format, markdown, or HTML.

We will compare our solution to industry standards like Bean Validation. During the session, we will live code legacy business rule migration to dOOv.

Speaker: Kenneth Finnigan

Even though ServiceMesh has not been around for long, you are probably hearing a lot about it. It’s gained a lot of steam with respect to Cloud Native development, Linux Containers, and Kubernetes. This session will introduce the attendee to the ServiceMesh concept, what it is, how they work, and why we should use them. We follow that up with an introduction to Istio before delving into how we can combine Istio and WildFly Swarm (Red Hat’s MicroProfile implementation) on OpenShift to reduce the amount of boilerplate we need when developing Cloud Native applications to utilize circuit breakers, tracing, etc. Come in curious (or even skeptical) and leave pumped to go home and get going with the awesomeness.

Speaker: Jonathan Giles

As developers we build on the shoulders of giants - using APIs developed by others to propel ourselves further forward. We also often find ourselves in the position where we must provide our own APIs for other developers to use. Building a Java API is not without perils -we must know the features of the language extremely well, we must understand the implications of breaking compatibility, we must own many other responsibilities such as creating excellent documentation, and most importantly, we must practice restraint.

This session, presented by Jonathan Giles, will give an introduction to developers on how they should develop their own APIs, whether it be for internal use, an open source project, or a commercial library. The focus is purely on building Java APIs, not REST APIs or anything else! Jonathan has over 10 years experience building Java APIs, firstly at Sun Microsystems and Oracle in the Java team working on Java releases 7, 8, 9, and 10, and more recently he has joined Microsoft as a cloud developer advocate, where he works closely with the engineering teams to improve the Java API offering for Azure.

This session will work through tips that developers should follow, and advice for developers to avoid.

Speaker: David Delabassee

It is an exciting time for enterprise Java! First, Java EE 8 was recently finalized. But more importantly, Oracle surprised the industry by transitioning the development of the Enterprise platform to the Eclipse Foundation under the EE4J umbrella.

This session will first introduce you to some of the new capabilities introduced in Java EE 8 and how they align with Jakarta EE. We will also discuss what EE4J and Jakarta EE mean for the platform going forward and why this is important for the whole ecosystem!

Attend this session to understand what Java EE is today and what Jakarta EE will be tomorrow!

Speaker: Nicolas Frankel

Despite being quite recent, Spring Boot has seen a spectacular start as an amazing kickstarter for Spring-based application. You can now start your project in a matter of minutes, not days!

On the other hand, you're still using Java, with all its ceremony regarding code... Wouldn't it be great if we could pair Spring Boot with a powerful yet simple language?

In this talk, I'll live code a Spring Boot application using Kotlin, the friendly language provided by JetBrains. Come discover how you can now cut through all the red tape and finally focus only the important stuff.

Speaker: Walid El Sayed Aly

The security of passwords and the handling of them are core elements of any IT structure. Whether we use passwords for databases, application servers or service APIs, their backup and administration is always the linchpin of our privacy.

Do you use Encrypting / Decrypting Algorithm passwords for your applications? Then you may also know that everything encrypted can be decrypted in no time. So safety is on a bit rough ground.

In order to optimize your privacy, you should now switch to more modern methods. An interesting alternative is the ability to centrally manage passwords with HashiCorp Vault. The passwords are thereby "hashed", that is, the data are en- and decrypted, but not stored in these processes. In addition, Spring offers a new module called "Spring Vault". This is an abstraction from HashiCorp, which has client-side password management support.

A brief explanation of the use of these two new technologies will help you understand the benefits.

Speaker: Dervis Mansuroglu

Whenever you have applications that consume data from API's, you soon or later experience one of several different scenarios typical for most developers: upgraded API's, deprecated or deleted fields, changed data structures and value types are all examples that developers often deal with.

Ensuring that independently deployable applications won't fail in complex environments is an essential task when developing distributed services. In governmental institutions and public sector organizations, it's often even more difficult as they require multiple different components, external Web Services and API's to communicate and interact together. Adding to the complexity is communication between your own micro-services in modularized architectures. Consumer Driven Contracts is a way to deal with these challenges.

In this talk, I will tell you how to make sure components that consume and provide data can be deployed safely by writing tests that verify the interactions between your consumers and the API's they consume. You will be introduced to Pact, one of the most popular and active open source projects for Consumer Driven Contracts and learn how to use it with JVM-applications. What are the possibilities and limitations? Which of Pact's many variations should you use?

I will answer these questions by sharing my experiences on how we introduced Pact in the Norwegian Labour and Welfare Administration and why we had to contribute to the open source project itself.

Speaker: Bernd Ruecker

You probably work on a distributed system. Even if you don't yet face a serverless microservice architecture using fancy NoSQL databases, you might simply 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, recipes, patterns and frameworks. Expect fun little live hacking sessions with Open Source components like Spring, Hystrix, Kafka and Camunda.

Speaker: Ivar Grimstad

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.

 And the progress does not stop there! Whereas version 1.0 was a subset of Java EE specifications, the following versions bring additional technologies useful for building microservices.

Current version contains APIs and implementations for:

  • Externalized Configuration
  • Fault Tolerance
  • Health Checks
  • Application Metrics
  • Security
  • Open API
  • Open Tracing
  • Client API
  • In this fast-paced, demo-heavy session, MicroProfile will be introduced and demonstrated using the available implementations in live coding demos. All implementations will be explored and compared in a vendor neutral way.

We will also take a look at the potential candidates for future versions, Java EE 8 support and the relationship to EE4J and Jakarta EE.

Speaker: Johan Janssen

Two years ago we started a new Internet of Things project: The Internet of (Lego) Trains. We wanted to figure out if we could use Java/Scala to build software for IoT hardware like the Raspberry Pi.

The Lego trains are equipped with a Raspberry Pi, camera, wireless dongle, infrared transmitter, speaker, RFID reader and battery pack. Next to that we have automated switch tracks and cameras again with the help of Raspberry Pis. To control the trains and other parts we built an actor based application with Scala, Akka, Akka HTTP and AngularJS.

The session will cover when and how to use Akka HTTP and remote actors to create a new generation of applications. The results of the performance tests we did to compare the two options will be shown as well. A live demo with Lego trains is of course included.

Speaker: Dmitry Chuyko

"CRC", "polynomial ring over a finite field", "intrinsics". All this is designed to create strong visual images in the head of a Java developer. It turns out that the harmony of BigData can not live without algebra with identity and a good pinch of assembler code. This talk is more about the code.

Many systems that we use "out of the box" are equipped with newly invented wheels, whose tasks can be performed by a standard library. Let's try to predict where you might encounter a checksum. Also let's discuss why you need it, and what to choose. And, of course, what is the performance and bottlenecks in checksum implementations, in particular, on x86 and ARM64.

Here Java 9, 10 and Graal introduce some good optimizations that also begin to be used by other software.

Speaker: Daniel Mitterdorfer

Benchmarking is a tricky business. Pitfalls await at every corner: What is your workload and how do you model it correctly? Which hardware do you choose? Can you trust your load generator? How do you avoid accidentally introducing bottlenecks?

 In this talk we will discuss rules and guidelines for seven common "gotchas" in benchmarking that will help you to evaluate performance correctly. While we use Elasticsearch as an example, these rules apply to benchmarks of Java applications in general.

Speaker: Yusuke Yamamoto

Twitter4J is an wrapper library for the Twitter API. It is one of the most popular libraries in the Java community. The popularity of Twitter4J is supported not only by the huge adoption of the Twitter API, but also by it’s simple, clean and easy-to-lean API design. The library design inspired many other REST API wrapper libraries such as Weibo4J, Fitbit4J, and Facebook4J. In this session, you’ll learn the key to make your library fun to use, easy to lean, and even extensible.

Speaker: Vlad Mihalcea

Hibernate is the most popular JPA provider and knowing its inner-workings can make the difference between a high-performance enterprise application and one that barely crawls.

This presentation goes through the most common performance bottlenecks issues like exotic mappings, too much flushing, inappropriate queries, JDBC batch updates misuse, and suboptimal result set fetching.

Aside from common anti-patterns, I will also present some very useful Hibernate features like the enhanced identifier generators, caching strategies, and state-of-the-art connection management and monitoring.

Reason:

I've been answering over 1200 questions about Hibernate on StackOverflow, and this made me realize that Hibernate is still a very difficult topic for many application developers.

For this reason, I decided to write 100 articles about Hibernate on my blog (http://vladmihalcea.com/tutorials/hibernate/), as well as a book about High-Performance Java Persistence (https://leanpub.com/high-performance-java-persistence).

  • what are the best identifier generators to use
  • what mappings are not suitable for a data-intensive application
  • how statement batching can be enabled and what can compromise its usage
  • flushing best practices
  • caching best practices and gotchas

Speaker: Kees Jan Koster

This talk gets you started with JVM bytecode engineering. Kees Jan peels away the fluffy Java language syntax to lay bare the gears that make the JVM tick. He will show what options there are for you to compile bytecode and create classes just the way you want them to be. The talk starts by looking at the low level JVM architecture and the byte code design. You will learn how to compile your own class files from byte code. Kees Jan will demonstrate a number of byte code assemblers and disassemblers, discussing pro and con of each. You walk away from this talk with a solid understanding of class files and the JVM and byte code architectures. This talk is open for any developer who programs Java for their day job.

Speaker: Stéphane Nicoll

The new generation of Spring Boot applications is here! With Spring Boot 2.0, developers can use the new Spring WebFlux reactive web framework.

During this live coding session, Stéphane and Brian will create a WebFlux application and leverage Boot features such as Actuator, Developer Tools and more.

Spring Boot 2.0 comes with many improvements and new features - Spring WebFlux allows reactive web endpoints and new HTTP runtimes such as Netty. This comes into two variants: a familiar annotation based approach similar to MVC and a new functional variant called "WebFlux.fn".

With 2.0, the Spring team leverages WebFlux with the "convention over configuration" flavour that made Boot so popular:

  • Auto-configuration of your web application
  • Customizing your app with configuration properties and callback-based interfaces
  • Actuators and Developer Tools support
  • Leveraging the Spring ecosystem such as Spring Data and Spring Security

SpeakerFelix Mueller

Integrating microservices and taming distributed systems is hard. In this talk I will present three challenges we observed in real-life projects and discuss how to avoid them.

  1. Communication is complex. With everything being distributed failures are normal so you need sophisticated failure handling strategies (e.g. stateful retry).
  2. Asynchronicity requires you to handle timeouts. This is not only about milliseconds, systems get much more resilient when you can wait for minutes, hours or even longer.
  3. Distributed transactions cannot simply be delegated to protocols like XA. So you need to solve the requirement to retain consistency in case of failures.

I will not only use slides but also demonstrate concrete source code examples available on GitHub.

SpeakerMartin Skarsaune

Do you have a good way to see how your Java application is doing? Or are you just about to implement an application specific system monitoring interface?

You will find that good old JMX in combination with Jolokia and hawt.io offers well defined solutions to these problems. This is also a good match in todays world of elastically scaled microservices, that are not easily accessed from traditional management consoles.

You get great insight into any Java VM out of the box, and in addition excellent support and visualisations of many common Java technologies.

If you know the power of these tools already, you will also benefit from demonstration of some significant recent features, as well as in depth coverage, such as application specific plugins and monitoring.

  • 1
  • 2