Devoxx UK 2018 – Conference preparations

On may the 5th the Devoxx UK conference ist starting. As I will attend the conference, it was time to choose the right sessions.

As a result I got a great mixture of different tracks:

4 Sessions – Server Side Java
3 Sessions – Java Language
3 Sessions – Method & Culture
2 Sessions – Architecture
1 Session – Big Data & AI
1 Session – Cloud
1 Session – Mind the Geek
1 Session – Modern Web
1 Session – Programming Languages
1 Session – Security

During the conference I will try to summarize every session in a short blogpost.

Starting on the 5th I will attend two Deep Dive Sessions.

Parallel and Asynchronous Programming with Streams and CompletableFuture by Venkat Subramaniam

Java 8 makes it relatively easy to program with parallel streams and to implement asynchronous tasks using CompletableFuture. When someone says it’s easy, cautious programmers ask “What’s the catch?” Well, of course, that’s one of the major topic we’ll address in this deep dive session. We will start with a fast introduction to parallel and asynchronous programming with Java 8 and quickly delve into the gotchas, when to use these facilities, when to avoid them, and how and where to put them to good use.

Reactive Spring Deep Dive: Building & Testing Reactive Cloud-native Java Microservices by Mark Heckler

Moving to a reactive, non-blocking model is not without its challenges. Relatively speaking, a blocking model is much simpler to code, debug, and troubleshoot. How do we handle exceptions in a never-ending flow of values? How can we provide options for publishers that still keep subscribers happy…and functional? How can we debug & fix things if the wheels come off?

On the following days I will attend a few different session and tracks:

Real Time UI with Apache Kafka Streaming Analytics of Fast Data and Server Push by Lucas Jellema

This session introduces Apache Kafka as the scalable event bus that takes care of the events as they flow in and Kafka Streams for the streaming analytics. Both Java and Node applications are demonstrated that interact with Kafka and leverage Server Sent Events and WebSocket channels to update the Web UI in real time. User activity performed by the audience in the Web UI is processed by the Kafka powered back end and results in live updates on all clients. Kafka Streams and KSQL are used to analyze the real time events in real time and publish events with the live findings.

GraphQL as an alternative approach to REST by Luis Weir

What are the implications of moving to GraphQL? Is it really worth the effort of replacing REST APIs specially if they’re successful and performing well in production? What are the pros/cons of using GraphQL? What tools / languages can be used for GraphQL? What about API Gateways? What about API design?

5 Ways to Make the OpenJDK Community Hate You by Adam Farley

This talk covers the mistakes I made and/or saw while attempting to contribute to OpenJDK, along with some advice OpenJDK community members have given me.

Wearable Tech: Don’t stare at a screen all day, become the screen! by Paul Mandell

Follow our transition from blinking LED tutorial newbies to cloud controlled wearable tech designers with the production of the “almost award winning” IoT-Shirt. Fork the project code and build it using affordable off the shelf parts as you follow our journey into the murky and unpredictable world of ESP8266 microprocessors, MQTT, far too many LEDs, C++, Node-RED and sewing machines.

Mnemosyne: a distributed bitmapped indexing layer for big data by Phil Messenger

This talk is the story of this build, diving into how Mnemosyne works and revealing some surprising things we learned along the way. We’ll cover CAP theorem trade-offs, how brute force approaches are sometimes better than indexes, the data structures and techniques required to sort billions of records in milliseconds, how GPU’s can solve unexpected problems and how to do all this on the JVM.

Spring Framework 5: Feature Highlights & Hidden Gems by Juergen Hoeller

This session summarizes the major feature themes and particularly highlights personal favorites and useful refinements in the details. Last but not least, it will indicate next steps in the upcoming 5.1 release.

Top 10 Vulnerabilities you wish your Java app didn’t have! by Simon Maple

This session takes some of the most common vulnerabilities found in the Java eco-system, breaks them down and shows how simple code can exploit them. We’ll look at examples in the wild that have been exposed, some more famously than others, before showing you how to guard against these important security issues.

Cloud Native Java, part deux by Josh Long

You know what nobody has ever said to me? „I wish you’d covered even more in your 45 minute ‚Cloud Native Java‘ talk!“ And I listened! In this talk, we’ll look at Spring Cloud.next to support modern microservices development, focusing on the things that really matter (or, at least, the things we’ve got cooking in Spring Boot 2.0 and Spring Cloud Finchley, both due before April or so):

To JAR Hell And Back – A Live Migration to Java 9 by Nicolai Parlog

Im sure you’ve heard about compatibility issues with upgrading to Java 9 and beyond, but did you try it yourself yet? This live coding session starts with a typical Java 8 application and runs up against and eventually overcomes the common hurdles

7 serverless recipes for big data architectures by Blanca Garcia-Gil and Neil Crofts

The BBC Audience Platform Data team collects, transforms and delivers billions of events each day from audience interactions with mobile apps and web sites such as BBC News, BBC Sport and iPlayer.
We will share our experience of the 7 critical steps we took to migrate from Spark clusters with Map-Reduce to a serverless architecture. We will cover the good, the bad and the ugly, including lessons learnt along the way. These steps are also applicable to new architectures.

gRPC vs REST: let the battle begin! by Alex Borysov and Mykyta Protsenko

Let’s get ready to rumble! Are you developing microservices or just considering splitting your monolith? Thinking what is the right way for your services to communicate with each other? gRPC is a modern high performance RPC framework backed by Google, while REST is an established architectural pattern for designing distributed systems. We will discuss pros and cons of each approach, going deep and wide, leaving no stone unturned, outlining landmines and showing best practices.

Asynchronous programming with Kotlin coroutines by Konrad Kamiński

Coroutines is a new feature in Kotlin 1.1. It allows for writing an asynchronous code almost just like if it was regular/synchronous. This makes coroutines a great alternative to existing approaches for writing asynchronous applications.

Thinking twice about migrating to Serverless by Edwin Derks

Cloud environments provide everything to develop Serverless solutions, completely obscuring the infrastructure. It could be the holy grail that saves development teams from maintenance and platform dependence. I will go through the considerations that need to be taken when you are planning such a migration. Building a Serverless solution is completely different from conventional application development, which raises a ton of questions about whether this is a suitable replacement for a monolith. Companies and development teams need to be aware of the impact before initiating the migration.

Smarter debugging in the IDE by Rabea Gransberger

IDEs like Eclipse, IntelliJ and NetBeans have powerful tools for debugging applications. Besides the obvious features for setting breakpoints and stepping through the application, they contain additional tools which can make debugging much easier.

The Diabolical Developer’s Guide to Surviving Java 9 and 10 by Martijn Verburg

In this session, the Diabolical Developer presents a pragmatic guide to migrating your apps to Java 9/10 and how to avoid the common pitfalls. He covers how to still gain access to those restricted internal libraries, how to deal with the performance impact of moving to G1, how to split your app to use both the classpath approach and the new modularization approach, and more. Leave this session with the confidence to move to Java 9/10!