Speaker: Henning 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.
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
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.
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.
Speaker: Gilles Di Guglielmo
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.