Archive 2018

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!