Archive 2018

Below, you find the sessions of the past JAX London of 2017. We are happy to be able to provide a platform for connecting, learning and teaching about Java & Software Innovation. Hopefully, we’ll have you visiting in 2018 too!

Developing Java applications on the Blockchain with web3j

Stream processing with Apache Kafka and KSQL

SOLD OUT - From 0 to 100 - OpenShift, Kubernetes and Docker for budding DevOps specialists

Building an Accurate Performance Testing Harness

Continuous Delivery is better for your Brain

Testing Microservices: From development to production

All the way to 11: Delivering new features in the JDK

Become A Guru: How To Solve Java Memory Leaks In Under 10 Minutes

Building a network of APIs using middleware integrations

Using transactional BPM for service orchestration on NoSQL

On concurrency and parallelism in the JVMverse

The DevOps Cookbook

The bumpy road towards containerised microservices: why early adoption meant it took longer for us to get there

Building Java Applications on the Ethereum Blockchain

Build a 12-factor microservice in an hour

What does Cloud Native Java really mean to developers?

Gitops, Jenkins & Jenkins X

The Database Unbundled: Commit logs in an age of Microservices

Architecting an enterprise blockchain solution: Key considerations

It's all about morphisms

Java releases and support: Untangling the confusion

Production profiling: What, why and how

Testing microservices with consumer-driven contracts

The way to distributed tracing

Changing Code with Kotlin

DevOps with Kubernetes and Helm

Build responsive, back pressured services with Akka Streams

Cloud Native Java with OpenJ9: Fast, lean and definitely mean

Spring, Functions, Serverless and You

Don't Make it a Race: The Four Common Concurrency Control Patterns

Leadership at Every Level

Forget me, please? Event sourcing and the GDPR

GraphQL – forget (the) REST?

Go Kotlin Go!

3 common pitfalls in Microservice integration and how to avoid them

An Architect's Guide to Site Reliability Engineering

Continuous Kubernetes Security

Designing a high-performance blockchain in Java

The importance of communication skills for software engineers

Troubleshooting & Debugging Microservices in Kubernetes

Busy Developers Guide to VueJS

Effective leadership in Agile/DevOps environments

Testing libraries for fun & profit. Beware: Increased productivity ahead

Scala: Beyond the basics

Pair and mob programming: Secret weapon for agile and continuous software development

Making Microservices Micro with Istio and Kubernetes

A craftsman’s guide to designing a clean architecture

Service meshes: Replay-proof microservice security

Enterprise integration patterns: A look back and their use in today's serverless computing

Busy Developer’s Guide to Not Javascript

SOLD OUT - Java application security the hard way - a workshop for the serious developer

SOLD OUT - Architectural Katas

SOLD OUT - UI Development in DevOps environments

Impressions from Twitter

JAX LONDON 2018 VIDEO HIGHLIGHTS

Bernd Rücker – 3 common pitfalls in Microservice integration and how to avoid them

Integrating microservices and taming distributed systems is hard. This talk presents the 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.

Daniel Jones – Continuous Delivery is better for your brain

Continuous Delivery makes it possible to exploit findings of cognitive psychology and neuroscience to increase the productivity and happiness of our teams. This session will highlight fascinating academic research that answers:

• How can we improve willpower and decrease technical debt?
• Is the present bias real? How can we turn it to our advantage?
• Can you increase a team’s effective IQ?
• How do DevOps and Product Teams increase empathy, and what impact does empathy have on productivity?

The OECD and Bank Of England are both puzzled over missing productivity. Are we failing to exploit the benefits of modern technology by running our software businesses and teams as if they’re post-war factories, rather than continuously delivering?

Vinita Rathi – Architecting an enterprise blockchain solution: Key considerations

This talk we will focus on the following topics:

• What are enterprise blockchain solutions
• Functional blockchain solution designs
• The five pillars of an enterprise blockchain solution design
• Permissioned/Private & decentralised/P2P
• Immutability, data integrity and scalability
• Security
• The three layers of an enterprise blockchain solution design
• The blockchain
• The data store
• The application
• Overview of architecture built for POS & E-commerce platform with NEM and Ethereum underneath
• Lessons learned: Do’s and don’ts

Dr. Daniel Bryant – Testing Microservices: From development to production

Testing microservices is challenging. Dividing a system into components naturally creates inter-service dependencies, and each service has its own performance and fault-tolerance characteristics that need to be validated during development, the QA process, and continually in production. Join Daniel Bryant to learn about the theory, techniques and practices needed to overcome this challenge.

Joram Barrez & Paul Holmes-Higgin – Using transactional BPM for service orchestration on NoSQL

Transactions are still important to process management in the age of microservices orchestration in heavily regulated industries, such as banking. With ACID transactions becoming available in NoSQL, we show how we have achieved a native integration of open source BPM to MongoDB. We compare the potential of this with the established relational implementations, in terms of performance, scalability and flexibility.

Simon Ritter – All the way to 11: Delivering new features in the JDK

JDK 10 was released only six months after JDK 9, demonstrating that the new six-month cadence for the OpenJDK works. Even with such a short development cycle, there were still over a hundred new features covering the language, core libraries and the JVM.

In this session, we’ll take a look at how the Java platform is evolving with the introduction of big features like the Java Platform Module System (JPMS) in JDK 9, local variable type inference in JDK 10 and dynamic class file constants in JDK 11. We’ll also cover many of the smaller features that will make your life as a developer easier. What might JDK 12, 13 and 14 include? We’ll explore some of the longer-term plans for Java, like project Amber, Loom and Valhalla.

Robert Kubis & Ray Tsang – Troubleshooting & Debugging Microservices in Kubernetes

Debugging applications in production is like being the detective in a crime movie. Especially with microservices. Especially with containers. Especially in the cloud.

Trying to see what’s going on in a production deployment at scale is impossible without proper tools! Google has spent over a decade deploying containerized Java applications at unprecedented scale and the infrastructure and tools developed by Google have made it uniquely possible to manage, troubleshoot, and debug, at scale.

Watch this session to see how you can diagnose and troubleshoot production issues w/ out of the box Kubernetes tools, as well as getting insight from the ecosystem with Weave Scope, JFrog Artifactory & Stackdriver tools.

Andrew Morgan – Testing microservices with consumer-driven contracts

Testing microservices is challenging. This is because, despite their independence, they are often still coupled via API calls or message passing. It’s this coupling that can lead to issues such as:– Too much reliance on slow and brittle end-to-end testing– False positives generated by inaccurate stubs– No idea whether changing an API endpoint will break anything– Difficult to reason about microservice dependencies.

This talk will introduce the consumer-driven contract testing technique, a TDD at the API level approach for microservices. It aims to resolve all of these issues and more, leading to truly independently testable and releasable services.

Steve Poole – Cloud Native Java with OpenJ9

The economics of Cloud continues to dictate the need for radical changes to language runtimes. In this session, you’ll learn about how OpenJDK with the Eclipse OpenJ9 JVM is leading the way in creating an enterprise strength, industry-leading Java runtime that provides the operational characteristics most needed for Java applications running in the Cloud. This talk will introduce the significant benefits that Eclipse OpenJ9 brings to Cloud applications and will show you how easy it is to switch to OpenJDK with Eclipse OpenJ9 in various Cloud and container environments. Whether deploying microservices or more traditional Java applications, the combination of OpenJDK with Eclipse OpenJ9 can help you reduce operational costs across the board.

Christopher Batey – Scala: Beyond the basics

What can you do in Scala that you can’t do in Java? What are the practical uses of more advanced language features? What could the future hold for Java? We’ll cover specific language features with their use cases:

– Function composition as an alternative to layered architectures
– Functional approaches to implement dependency injection
– Writing reusable code with higher kinded types
– Avoiding mutability with expressions
– Compile time checked serialisation with generic programming. As well as posing some higher level questions about language features
– Why do we embrace runtime reflection frameworks but fear compile time implicit parameters?
– Ease of initial understanding vs long-term productivity of a language
– Simple vs familiar language features and patterns. The goal of this talk is for you to learn some specifics about language features not yet in Java as well as to get you excited about programming languages in general.

Jack Shirazi – Don’t Make it a Race: The Four Common Concurrency Control Patterns

Developers have a tendency to focus on low-level implementations to handle concurrency, locks, lock-free algorithms, compare-and-set etc. But you shouldn’t jump into any implementation without first deciding which high-level concurrency control pattern is right for the problem. To help you make the right decision, I cover the four common concurrency control patterns that let you safely update shared mutable state: pessimistic locking, optimistic transactions, queue to a single thread, and partitioning the data.

Nathaniel Schutta – Spring, Functions, Serverless and You

Today our world is full of things that are “as a service” – infrastructure, containers, platforms, software…and of course functions. With developers just now wrapping their heads around application platforms and containers, what are they to make of functions as a service? How does a busy developer cut through the hype and make sense of the world of serverless, Kubernetes, Spring Cloud Function and all the rest? This talk will clear up the confusion! We examine Riff, a FaaS built atop Kubernetes. We will discuss where functions and serverless fits in your world, and how you can get started with some simple demos. Though functions aren’t a silver bullet, they are an important part of the development toolbox; this talk saves you from the buzzword bingo to give you a solid foundation of the FaaS landscape.

Liz Keogh – Leadership at Every Level

Leadership is easy when you’re a manager, or an expert in a field, or a conference speaker! In a Kanban organisation, though, we “encourage acts of leadership at every level”. What does that mean for those of you who code as part of a team?

In this talk we look at what it means to be a leader in the uncertain, changing and high-learning environment of software development. Find out about the importance of safety, how to create it both technically and socially, and become an agent of change… without changing your job!

Uberto Barbini – Go Kotlin Go!

The session shares some experience on writing a software to play the game of Go in Kotlin. The game of Go was born in China more than 2000 years ago and despite its very simple rules is considered more complex than chess and so one of the most interesting from a software developer point of view. Until 2018 when AlphaGo beat the world champion, it was considered humanity’s last stand. It will present a didactic Go bot engine I developed in Kotlin. It’s very simple but it is already able to give interesting matches.

Geertjan Wielenga – Finally, Enterprise JavaScript Is Easy!

JavaScript in the enterprise: is it hard? Is JavaScript really usable in the context of enterprise applications and as the basis of front-end browser-based applications? How are enterprises such as PayPal, Tesco, and Oracle solving these problems? In this session, you’ll be introduced to Kraken.js by PayPal, as well as Oracle JET (oralejet.org) which is Oracle’s JavaScript toolkit, including data visualizations, architectures, templates, components, and a range of enterprise solutions, such as modularity, internationalization, and accessibility.

Everything is free and open sourced on GitHub and you’ll be shown how to get started with it, via demos and live coding. By the end of the session, you’ll be able to leverage free and open source technologies as the basis of your own web and mobile solutions, today!

Michiel Rook – Effective Leadership in Agile/DevOps

The Agile and DevOps movements place a lot of emphasis on the autonomy, self-organization and responsibility of teams. A common misconception is that there is little or no role for leaders of such teams. On the contrary! In this rapidly changing world, where competition is fierce and the pressure to deliver is high, effective leaders create environments that allow teams to thrive. They enable, coach and inspire. But what makes a leader an effective leader?

Ray Tsang – Making Microservices Micro with Istio and Kubernetes

Microservices are here to stay. When applied properly, microservices techniques and culture ultimately help us continuously improve business at a faster pace than traditional architecture. However, microservices architecture itself can be complex to configure. All of a sudden, we are faced with the need for a service discovery server, how do we store service metadata, make decisions on whether to use client side load balancing or server side load balancing, deal with network resiliency, think how do we enforce service policies and audit, trace nested services calls…. The list goes on.

Sure, it’s easy to have a single stack that makes everything work provided there are good microservices support – but what if you have a polyglot environment? How would you make sure all of the stack canaddress the same concerns in a consistent way? This is where a service mesh comes in.

In this talk, Ray will introduce Istio, an open source service mesh framework created by Google, IBM, and Lyft. We’ll see how the service mesh work, the technology behind it, and how it addresses aforementioned concerns.