Are you doing or considering Cloud Native microservices? Ever wondered what the unique challenges are and how best to address them on fully open Java technologies? Are you doing Cloud Native microservices the right way? In this workshop, you'll learn what it means to be cloud-native and how that impacts application development. You'll learn about Eclipse MicroProfile, an industry collaboration defining technologies for the development and management of cloud-native microservices. With a full set of MicroProfile workshop modules available to you, you'll be able to start with the basics of REST services and progress to more advanced topics such as secure, fault tolerant, configurable and monitorable microservices. Once you've developed your microservice, you'll learn how to package it in a Docker container and deploy it to a Kubernetes cluster. The role of a service mesh and use of Istio to manage your microservice interactions will also be learned. Finally, you can also learn how to deploy onto OpenShift, an enterprise Kubernetes application platform, to see how your microservice functions. In summary, this workshop connects powerful open stacks to cover end-to-end cloud-native microservices from development to deployment.
This Best of Java Hands On Workshop introduces various improvements included in Java 9 up to the brand new Java 15. We will have a look at language and syntax improvements namely switch, records, text blocks and var as well as new api features in streams, strings and files, optionals, concurrency and HTTP/2, and many more. Your knowledge will be established by a lot of hands-on exercises. All in all you will receive a thorough overview of important features in modern Java. This should be helpful for software engineers and for architects to decide if Java 11, 14 or 15 is valuable for their products and to ease migration.On last thing to cover is one of the key features in Java 9: modularization. Due to the fact the this is not quite established since now in many companies in the real world we will just have an introduction with some migration hints. In summary, Java gets cooler and better with every new release. Let's take a look together at important and helpful new features in the language and APIs.
More rapidly than ever, companies are adopting new technologies, tooling and practices, that allow them to be so agile that it changes their culture overnight. Disruptors are being disrupted within the year. Fast movers are overhauled quickly due to instant response of competitors. Longterm strategies, roadmaps and plans appear useless. During this inspiring talk Kim van Wilgen shows you how moving towards continuous delivery and DevOps changes the DNA of your company. Learn how continuous delivery will speed up your company at all levels. How your thinking changes through the presence of fast feedback, short cycles and data-driven decision making. It’s time to move to the continuous culture.
Java has been the leading programming language for more than 20 years. However, many people still believe that Java is complex, heavyweight and memory-hungry. Today, other languages and especially modern serverless approaches seem to overtake Java more and more. What are the plans for Java, is Java also suited for the cloud, what is comming next and, why should I continue to use Java in the future?Good news: The holy grail is already found! With GraalVM and a new generation of microservices frameworks such as Micronaut, a completely new Java technology stack is emerging that will replace Java as we know it so far and bring Java to a completely new level and establish it in the cloud. Developing native applications with Java, Java as fast as C, app start in milliseconds, minimal memory footprint and database access up to 1000 times faster. This is not a vision - it is already possible today.In this session you will learn everything about the Java technology stack of the future and how you can use it to develop lightweight and at the same time ultra-fast in-memory cloud-native applications and microservices in Java. While watching our incredible performance demo, you better fasten your seatbelt.
We needed to validate our use cases with tests:
That specify the user intents, not the technical details that are human-readable (but without regex tricks), and that run both end-to-end to verify our infrastructure and using the domain only to verify our hexagonal architecture.
This talk is about how we solved these problems with the DDT approach and how you can apply this technique on your own backend application.
A demonstration with live coding will show how to write them and use it to drive the development.
This talk will teach you a new approach to test your system that can be immediately useful, especially if you are aiming for continuous delivery.
There is a lot of buzz around reactive architectures. Take, for example, event-driven architectures, event-streaming or reactive programming. I believe that these architectures will dominate in the future as we build more complex systems, connect more distributed components and slice systems into smaller autonomous pieces. Unfortunately, I see many companies that don’t update their customer experience or business processes to reflect this new world. In this talk, I’ll give an example and discuss the consequences, hopefully motivating you to advocate for a redesign of your business processes internally – because too much attention gravitates towards the technical side of reactive, without thinking about the user journey or business implications.
http4k is a lightweight HTTP library written in Kotlin that enables serving and consuming of HTTP services in a functional and testable way. Unlike many other libraries and frameworks which have complicated abstractions and workflows, http4k captures the essence of communication over HTTP with few simple concepts. In this session, I will explain and demo the core concepts in http4k by live coding from scratch a http server for a noughts and crosses game.
Ever wanted to get changes into production more quickly, safely and often? Do you wish you spent more time working instead of waiting? Then stop debugging your technology, and start debugging your development process!
CEO of EngineerBetter Daniel Jones will explain how he has helped CTOs, Development Managers and Engineers from startups and global media conglomerates to improve their time-to-production along with code quality, staff satisfaction and morale.
Learn how to use techniques from Liberating Structures, Systems Thinking and more to perform a '5 Whys on Steroids' and build a causal model of organisational dysfunction. Discover how this model exposes a shared understanding of challenges, aids empathising, and most importantly allows the identification of actionable remedies, complete with an understanding of the trade-offs involved.
You don't need any shiny new technology to go faster - you just need to ask the right questions.
Java for Cloud Native applications in 2020? You better believe it! This session will cover advancements in the Java language and platform, improvements in developer productivity, and Java's reduction in resource consumption as well. After this session you'll be itching to modernize that legacy app and reap the benefits!
Machine Learning is hot but organisations are struggling to run it in live and MLOps is not easy to master. DevOps skills are needed but in more than just the usual DevOps ways. The key reasons are that the development/delivery workflow is different and the kind of software artifacts involved are different. We will explore the differences and look at emerging open source projects in order to appreciate why the DevOps for machine learning space is growing and the needs that it addresses.
Getting a better picture of MLOps will help us in lots of ways. It will help us evaluate Machine Learning Operations (MLOps) tools and platforms. We'll come to understand the specific needs for governance, versioning and monitoring in machine learning. We'll get a sense for the range of MLOps use-cases and better understand how to scope Machine Learning projects.
Getting the best performance out of your Java applications can often be a challenge due to the managed environment nature of the JVM and the non-deterministic behaviour that this introduces.
This session will start by looking at what we mean by speed and how the JVM, whilst extremely powerful, means we don’t always get the performance characteristics we want. We’ll then move on to discuss the three ways Azul have addressed these issues:
1.The Falcon JIT compiler that leverages the LLVM open source project to provide optimisations specific to the newest CPU architectures using features like AVX2.
2.ReadyNow!, which allows details of speculative optimisations and JIT profiling to be logged on production systems. ReadyNow! profiles can then be used to substantially reduce the warm-up and deoptimisation issues that affect performance when restarting an application.
3.The C4 garbage collector, which eliminates GC pauses that affect the performance of an application even after all hot code paths have been compiled and optimised.
Similar to most JVM languages, Kotlin abandoned the idea of checked exceptions. Instead it suggests using a combination of runtime exceptions and nullable types. But there are other options! This session will take you on a refactoring journey to explore the pros and cons of error handling strategies starting from the most basic ones to functional programming. The main goal is to have an overview of possible approaches and choose the most appropriate one(s) in order to avoid ad-hoc error handling.
Google's AlphaGo uses reinforcement learning to win against Go Masters. This method is especially useful when the search space of solutions is polynomial: at some stages in a game of Go, there are more possible moves than atoms in the universe. Instead of brute force, the algorithm uses reinforcement learning to do probabilistic search of potential solutions and make the move that’s most likely to result in a win. At Diffblue we use the same approach to write unit tests for Java projects, using reinforcement learning to search for tests that achieve coverage and usefulness goals, while remaining human-readable. The result is a suite of regression unit tests that run quickly and early to find bugs, accelerating DevOps pipelines and reducing cycle times. In this talk I'll look at how machine learning works, supervised vs. unsupervised approaches, reinforcement learning and how it is applied in both in AlphaGo and Diffblue Cover.
As organizations are maturing in agility the only constant is change. Enabling fast change is essential to meet the needs for speed, changing requirements and experiments. Increasing your speed means you’re also investing in your brakes: security, governance, and sustainability. Organizations will have to deal with the complexity of simultaneously changing architectures, ways of working, technology, and foremost culture. How to continuously deliver continuous delivery? During this session, Kim van Wilgen will give practical insights on the process of transformation to continuous delivery, with real-life examples from her experiences. She'll share the lessons learned from the successes and the mistakes.
Kubernetes works by running reconciliation loops to make sure that currently existing resources match a desired declared state.
Operators are a way of extending the Kubernetes core with control loops for custom resources, often for the management of companies' own applications or third party ones.
Imagine if you could code everything operations needs to know about your application, from expected behaviour and deployment to how to deal with problems, into a system that automates it for you.
Most of the time these Operators are written (like Kubernetes) in Golang, but there are frameworks that allow for writing Operators in Java.
This talk is an introduction to Kubernetes Operators and how to write a first simple Operator in Java.
Ever wondered how memory allocation on the JVM works?The Java Virtual Machine features many generational garbage collectors that also use pointer bumping for allocation. The combination of these two techniques gives a fast allocation and collection path which has led to a commonly held belief in the Java community that allocation in general is cheap. This talk will challenge that belief by looking at what happens outside of the fast path and considering the impact of even fast path allocation on other parts of the system, such as caches and memory bandwidth.
You will see how optimisations from the JIT can reduce or eliminate many allocations but how reasoning about when these happen can be almost impossible from glancing at code. Examples will introduce you to common problems and tooling you can use to understand the allocation behaviour of your code.
From attending this talk you will understand:
- How allocation works in modern JVM Garbage Collectors
- Why allocation isn’t necessarily as cheap as it seems
- Why the JVM makes it difficult to reason about allocation behaviour by code examination
- What kind of tooling you can use to understand the real allocation behaviour of your code
Most projects probably have some kind of documentation of the architecture and code conventions. It's just a question of: Where? And is this documentation up to date? Does the code really adhere to these standards? In the field, documentation is all too often "write-only" and bears only faint resemblance to reality.
Wouldn't it be nice if your architectural and coding rules were checked automatically, as part of your continuous integration build? And if architecture wasn't just the occupation of some distant architect, but rather a team sport for all developers, like in an agile, cross-functional team?
With "ArchUnit" it's possible to code your architectural decisions as plain Java (or Kotlin) rules, using an easy to read fluent API. These rules can check for layered architectures, vertical slices, hexagonal (onion style) architectures, acyclic package dependencies, and for coding conventions like namings, containment of classes in packages and the use of annotations and exceptions. The rules can be checked by any unit testing framework, as for instance JUnit.
You'll see the basics of ArchUnit along with practical tips and tricks, including how to write custom rules. There will be some slides, but mostly live coding.
Everyone is talking about event-driven architectures and streaming data. But people may not be actually using them successfully. If you haven’t started yet, you must learn to leverage the power of this approach. And even if you’ve already achieved a measure of success, you want to ensure your business’s viability and long-term flexibility in design that responds well to the inevitable ongoing change. And why stop at event-driven when your entire system can be reactive through message-driven architectures, both inside single services and across many collaborating services. This talk walks you through DDD context mapping with open host service and publish language and shows how to integrate using reactive implementations that transform streaming to well-designed solutions. Employing the right tools is key.
In recent years, software engineering and the role of software engineers has changed. Teams have evolved heterogeneously to incorporate technical, non-technical and domain specific experts. Solutions are now expected to be rapidly delivered, whilst also being highly performant and scalable. At the same time we have the cloud and ever more increasingly powerful multi-core CPU and GPU hardware at our disposal. Programming languages are the principle tools by which we interact with our machines to solve problems. The world needs our languages to evolve in order to suit this new environment.
In this talk we explore Concurnas, a JVM language designed for solving the concurrent, distributed and parallel programming problems faced by the modern enterprise. We see how Concurnas affords developers of all ability the capacity to easily leverage modern multi-core CPU and GPU hardware for solving problems. We learn how Concurnas's unique simplified model of concurrent and GPU computing allows developers to easily create not only new code, but use leverage their existing Java (or JVM language) code to build safe, reliable, concurrent software.
When migrating an existing application to a microservices architecture, a key consideration is how (or whether) to reuse the current/working code. There may be a substantial cost implication to making a good decision on this. Ultimately it boils down to how feasible it is to partition the monolith into smaller chunks of functionality that can be ported to the microservices framework.
When the existing application is already organized into modules, these can make good candidates for microservices. However more often than not, one or more modules will have become monolithic and must be further decomposed if the benefits of microservices are to be realized.
How we go about this depends on the dependency structure of the code in the monolith, and how features that we may like to extract are distributed across this dependency structure.
This talk will show by examples how different strategies can be employed to decompose monoliths with different dependency characteristics.
In this industry we often find ourselves sharing software development techniques with experienced software developers from a wide variety of backgrounds. This might mean, for instance, extolling the virtues of test-driven development and pair programming to people who have never even heard of it. But it could also mean working with old hands who have worked on several projects which flew the “agile” banner but left them with the impression that techniques such as TDD are cumbersome and pointless.
It’s easy to forget what it felt like to be a beginner, and it’s easy to ignore the fact that experienced developers are not stupid and will have good reasons for any cynical attitudes they hold. This is a talk about the rewards and pitfalls involved in introducing new techniques and technologies to developers from a wide variety of backgrounds. It includes several practical suggestions of how to help your colleagues to learn new stuff and try new techniques. Let’s embrace a culture of growth and create an environment where technologists can be excited about learning any new skill or technology, and empowered to explore and ask questions without making assumptions.
When you build an app, you typically need to choose agility with serverless or flexibility with containers but not both. But why does it have to be that way? Wouldn’t it be nice to have the best of both worlds? In this talk, we’ll explore the open source project Knative and its managed version Cloud Run. Through a series of demos, we’ll see how these projects enable you to deploy and manage containers in a serverless way on wherever you want, on-prem or in the cloud.
Mob Programming is a way of truly collaborating for whole teams. But - why should we care? We are a team already, aren't we? Well ... Our aim with software development is to deliver the most important feature quickly and in good quality to our customers. Reality looks different, though: Individual workload is maximized, the developers work on too many tasks at the same time. Half-baked features annoy our customers. Developers are fixing bugs around the clock, there's just no time for feature development.
Some years ago, the idea arose of having the entire team carry out software development - together, task by task. "Mob Programming" was born. Blockages during development disappear because all the necessary specialists are in the same room. And if that room is a virtual one, this practice becomes Remote Mob Programming - quite important these days for distributed teams or when working from home.
In this talk I'll show the basics of (remote) mob programming. We'll discuss when working as a "mob" pays off. And I will offer insights and good practices from almost four years of programming "mob style" (and coaching it to various teams in all kinds of companies).
Even if you’ve never done anything with machine learning, you have probably already heard that it’s very powerful, adaptive and will change our way of thinking about computing forever. But how can you, a web
developer, who’s never been interested much in statistics benefit from the ML hype?
In this talk I want to give you the tools to build a small self-learning application that runs completely in the browser with deeplearn.js
New languages bring new ways of thinking and teach us new principles and tools that we can bring back to your day to day language.
Using a real application as an example, we will learn how to build and design Java applications that follow Clojure’s functional principles using just core Java, without any libraries, lambdas, streams or weird syntax; and we will see what benefits those functional principles can bring.
No Clojure or functional programming knowledge required, just plain old good Java.
After creating your first microservice and putting it into production, you heard a lot of people talking about reactive. You'd like to find out more about reactive and have several questions: Why should I care? What I can do to make my microservice reactive, nonblocking? How can I use CompletionStage in my microservices? Should I consider using Reactive Streams? Come to this session to find out what reactive means. It explains reactive programming and then Reactive Streams, followed by a demo of using MicroProfile Fault Tolerance, MicroProfile Reactive Streams Operators, and MicroProfile Reactive Messaging to create a truly reactive microservice and integrate with Kafka.
Most developers have experience with dependency injection (DI), whether it’s with Spring, Google Guice or CDI. But how many developers actually know how these frameworks make this magic happen? Or how dependency injection works in general? I, for one, didn’t have a clue. That’s the reason I built the Injectinator: my own DI implementation for Java SE. Creating the Injectinator has taught me a lot about DI and how the “magic” happens.
In this talk I will show the audience how Java reflection works, and how they can harness its capabilities to create their own dependency injection framework. The following subjects will be covered:
- Reflection in Java
- Inversion of Control
- What is Dependency Injection?
- Types of Dependency InjectionAll of this will be demonstrated with a live demo.
After this talk you will have a better understanding of how a DI framework works and you should be able to build your own DI framework.
We now live in a world with data at its heart. The amount of data being produced every day is growing exponentially and a large amount of this data is in the form of events. Whether it be updates from sensors, clicks on a website or even tweets, applications are bombarded with a never-ending stream of new events. So, how can we architect our applications to be more reactive and resilient to these fluctuating loads and better manage our thirst for data? In this session, explore how Kafka and Reactive application architecture can be combined in applications to better handle our modern data needs.
At Expedia we are moving thousands of services into the cloud at various paces. In our Hotels.com brand, we've nearly completed the move of the 100s of brand-specific services to be fully cloud-enabled multi-region services, and this talk details many of the useful best practices we in the performance and reliability team have learned in that re-engineering process.
In recent years, Functional Programming has stormed software development in a similar way to Object Oriented programming 20 years ago. The promises of stateless coding and immutable data are powerful and seductive to developers of all kinds. Are these promises as good as they sound? Functional Programming is not new, it's been around for a long time, albeit in different guises, so why is it taking over now? This talk will cover the recent meteoric rise of FP, it will discuss the factors that have come about that have enabled the rapid rise of the new generation of FP styles. Specifically, it will discuss the implications of the FP stateless programming style in a stateful world. Is it really possible to do FP in a stateful world? Or are we creating pseudo statelessness? How do you manage state in FP? Should you even try? It will also look at the philosophy and techniques of FP, the things that it is suited to and the things to which it is not suited. From LISP to Kotlin, FP has gone from early trailblazer, to legacy dinosaur, to the cool kid in town - which narrative should you believe?
It’s only in the last couple of years that it has become possible to have a simple flow you can follow for JVM GC tuning. For most of the last decade GC tuning was arcane and fragile, but now the options are clearer and more targeted and there is a clear step-by-step procedure you can follow, which I detail in this talk.
An API gateway is at the core of how APIs are managed, secured, and presented within any web-based system. Although the technology has been in use for many years, it has not always kept pace with recent developments within the cloud native space, and many engineers are confused about how a cloud native API gateway relates to Kubernetes Ingress or a Service load balancer.Join this session to learn about:
- The evolution of API gateways over the past ten years, and how the original problems they were solving have shifted in relation to cloud native technologies and workflow.
- Current challenges of using an API gateway within Kubernetes: scaling the developer workflow; and supporting multiple architecture styles and protocols.
- Strategies for exposing Kubernetes services and APIs at the edge of your system.
- A brief guide to the (potential) future of cloud native API gateways.
When should you use request-response and when should you use messaging instead? What if you could use REST for everything, including event-driven Architectures?
Learn how to design REST APIs that support both conventional human user interfaces and services and those that support event-driven, and more generally, message-driven architectures. As a bonus, expect to pick up tips on reactive programming. This session is about REST API design for request-response and event-driven microservices with domain events using event sourcing and CQRS.
These days, you can’t swing a dry erase marker without hitting someone talking about microservices. Developers are studying Eric Evan’s prescient book Domain Driven Design. Teams are refactoring monolithic apps, looking for bounded contexts and defining a ubiquitous language. And while there have been countless articles, videos, and talks to help you convert to microservices, few have spent any appreciable time asking if a given application should be a microservice. In this talk, I will show you a set of factors you can apply to help you decide if something deserves to be a microservice or not. We’ll also look at what we need to do to maintain a healthy micro(services)biome.
Agile alone doesn't guarantee project success. Getting everyone working towards a shared vision requires a level of teamwork beyond just methodology. Specialisation can lead to barriers to teamwork. We'll use 'The Five Dysfunctions of a Team' to see how to build a culture of openness and teamwork.
Maximising teamwork has a big impact on effectiveness but it isn’t easy. It requires everyone to challenge themselves, come out of their silos, build trust and be disciplined about improvement. Some challenges are different for different roles. We’ll see routes to improvement for the team by looking at each role through the lens of its main biases and how to correct for them.
In today’s data-driven world, machine learning and AI play a substantive role in how organizations collect information and extract insights. Now a growing number of companies are combining this power with blockchain technologies to distribute the collection and tracking of data, as well as to ensure transparency and security.
In this talk, Marta will delve into details on solutions being built to maximize machine learning and blockchain technologies to create better overall data tracking, insights and security. Use cases will include:
- Leveraging machine learning to discover patterns and spot false negatives in blockchain-based provenance tracking systems.
- Removing bottlenecks in financial services by combining immutable and transparent records and transactions with faster analytics and quicker approvals.
- Collecting and recording transaction data from on-chain and off chain sources, including IoT, to provide end-to-end visibility for supply chains.
- Making it possible to separate health data from health records to help aggregate vital information for research while protecting patient privacy.
Since JDK 9, G1 GC is the default garbage collector (JEP 248). Back in 2017, with G1 GC: The Dark Horse, I shared some G1 GC details, performance tips, optimizations that help G1’s adaptiveness and provided advice on manual tuning.
Since then, G1 has come a long way in improving its adaptiveness. In this session I will cover most of the important optimizations that are delivered from JDK9+ and how they can help your application’s responsiveness, its throughput and help with footprint reduction. This is a saga that involves various regions and generations (all pun intended).
Bring your own laptop and find a pair. This is a fully hands-on session about how to design and build an event-sourcing service.
You will learn:
Event Sourcing pattern: store changes instead of state
The Functional approach: define behavior combining functions operating on immutable data
Command Query Segregation principle: how having two models give us more flexibility
Kotlin language (if you don't know it yet)
You will practice:
How to use and debug the design pattern.
How to add new functionalities (Commands).
How to display information in new ways (Queries).
We will discuss together:
What are the pros and cons of different approaches
You will be able to develop an Event Sourcing service yourself without using any framework.
A couple of hours of programming fun.
The workshop focuses on the challenges of a service mesh. To demonstrate this, multiple MicroProfile and SpringBoot based microservices will be combined together with Istio to form a service mesh. Based on concrete code samples, we will learn how the necessary Istio rules work together with these services. We will explicitly show different real-world requirements such as configuration, tracing, resilience and testing, and combine them with best practices. In addition, the workshop shows what other features Istio offers to avoid wrecking in everyday use of distributed applications.
All participants will receive the slides and code samples, together with the relevant Kubernetes/Istio scripts. A special handout will be an Istio cheat sheet and a collection of Istio best practices.