With DevOps you have learnt that you cannot simply state "it works on my machine" any more, not without a very real threat of violence from your team mates! You have the responsibility to appreciate the operational side of our software and, naturally, this means working on it collaboratively with your teams. However, are CI/CD, infrastructure as code or automation enough?

The complex systems you build today out of microservices have a lot of unlocked potential and pitfalls around fault tolerance and resilience. The various stresses the system is under represent learning potential and so how do you unlock that for you and, more importantly, for your teams?

Sylvain Hellegouarch will share with you what it looks like to try, learn and adapt on a complex system made of unpredictable parts through the somewhat new Chaos Engineering displine and the open source chaostoolkit. But, is it actually so new? Other industries have been conducting those experiments for decades as Sylvain will also tell you in this talk.

Serverless systems allow you to concentrate solely on your code and let the provider deal with infrastructure issues such as scaling and routing. Serverless is best known for responding to events, however it is also an excellent choice for APIs and microservices. In this session Rob will share with you how he has used Apache OpenWhisk to implement APIs using the Swift programming language.

You will learn how an API is built in Swift for deployment to Apache OpenWhisk. In order to do this, Rob will also cover key features of the Swift language and why it is good for server-side applications. You'll then learn how to write HTTP APIs frontend by the built-in API Gateway. By walking through this process of building an API, you'll be well placed to build your own serverless APIs.

The “Twelve-Factor” application model has come to represent twelve best practices for building modern, cloud-native applications. With guidance on things like configuration, deployment, runtime, and multiple service communication, the Twelve-Factor model prescribes best practices that apply to everything from web applications to APIs to data processing applications.

Although serverless computing and AWS Lambda have changed how application development is done, the “Twelve-Factor” best practices remain relevant and applicable in a serverless world. In this talk, Chris will share with you how to apply the “Twelve-Factor” model to serverless application development with AWS Lambda and Amazon API Gateway and show you how these services enable you to build scalable, low cost, and low administration applications.

The mission to μServices, should anyone choose to accept it, typically starts with a set of approaches and patterns around system design or deconstruction. The objective of these methods being to enable better isolation and autonomy for teams, data and processes. As the journey progresses, events typically appear as both a goal and an approach to enable even looser coupling and better scalability.

In this talk Kingsley will share with you a rough overview of the eventing landscape and why events, immutable data, functions and processes are key to developing scalable services. Concretely, pub/sub, event sourcing and event storming will be covered as well as experiences from building event based services and frameworks.

The talk will be both introductory and interactive, with life vests and support provided.

Huseyin will share with you best practices about Microservices like:

• RESTful Architecture

• Distributed Configuration

• Client Code Generation

• Continous Delivery

• Docker & Swarm

• Monitoring

• Event Sourcing & CQRS

This despite a threat environment, distributed development teams, and rapid iterative releases requiring security approaches that are continuous, adaptive, and heavily automated. Red Hat’s expertise with open source software and practices offers direct lessons for DevSecOps. In this session, you will learn at successful practices that distributed and diverse teams use to iterate rapidly while still reacting quickly to threats and minimizing business risk. Daniel will share with you how a platform like OpenShift can serve as the foundation for DevSecOps in your organization.

Daniel will also consider the risk management associated with integrating components from a variety of sources—another consideration that open source has had since the beginning. Finally, you will learn ways by which automation using open source tools and repeatable trusted delivery of code can be built directly into a DevOps pipeline.

If you log in to your savings account and find your money has gone missing, you might not be sticking around with that company for too long. In fact, you might even want to sue them! On a financial platform, every fraction of a penny can make a big difference.

The microservices paradigm brings more flexibility to software development, but it doesn't come for free. Whether it’s network issues or software bugs, it’s important to be able to reconcile, and rectify the platform quickly. Having a 99% success rate is not good enough - your reputation is on the line. Losing a day’s worth of transactions by restoring backups isn’t usually an option either!

In this talk, Thomas will address the question “What are the necessary building blocks for building a safe, robust and trustworthy micro-service event-driven financial platform?” You will learn what our architecture looks like and, more importantly, how Thomas and his Team have addressed some of the key NFRs of supportability, resiliency and consistency.

There’s plenty of persistent storage options out there - everything from NFS to commercial storage arrays to cloud storage. But how do you choose what you need, now and 20 years in the future?

How do you avoid lock-in to specific hardware or providers, and the resulting painful migrations? As your storage needs grow, how do you maintain the flexibility to scale? How do you balance business requirements vs developer speed and productivity?

In this session you'll learn the future of container and cloud native storage.

With serverless clouds on the horizon the world moves more towards event-driven choreographies. You can agree that the paradigm shift enables nicely decoupled microservices and is fundamental for decentral data management, however, you should not agree with an event purism using event chains for complex end-to-end logic crossing service boundaries. Bernd and Martin will share with you how transforming certain events to commands decreases coupling and demonstrate how you can keep sight of the larger-scale flow fulfilling the original business goal without ending up with "god services".

Bernd and Martin will discuss how lightweight, embeddable state machines can live in harmony with an event-driven paradigm and the idea of decentral governance. Based on their real-life experiences, they will share how they handle complex flows which require proper reactions on errors, timeouts and compensating actions and provide guidance backed by code examples to illustrate alternative approaches.

Consumer-driven contract testing is “alright” because it provides a way of testing contracts separately from both the client and the server. However, it creates problems of its own: it’s time consuming, complex to set up properly in your CI/CD environment, it’s boring and ultimately work you don’t need to do!

Wouldn’t it be better if you could check which versions of your interfaces work well together at compile time. Wouldn’t it be great if compatibility came for free (yes, like free beer!), with no extra effort required to test? In fact, wouldn’t it be great if instead of adding to your workload, it reduced the amount of work you needed to do so that you work less and play harder? Wouldn’t it be great if introducing something new to 100 micro-services were as trivial as hacking away a couple of lines of code, something we all do day-to-day?

At Landbay, they’ve used Swagger to help boost their confidence in API compatibility. So, they’ll show you the benefits they gleaned, lots of code and a demo of how easy it was to gain significant benefits, quickly. Chris will also share with you how it’s helped speed up and shape other testing they do (e.g. business use case testing, etc.) thanks to all their interfaces are normalised.

You're all familiar with the benefits that microservices can give you - the ability to create highly scalabale and resilient systems that also allow you to rapidly deliver new features. At the same time, you also know that Conway's Law says that your architecture will invariably follow the hierarchy and structure of your organisation.

If this is the case, how do you create organisations and culture that are optimised for building microservice oriented architectures?

In this talk, David will share with you how we can create highly aligned, loosely coupled teams that are geared up to make the most of what microservices offer and cope with the challenges they will bring.

A software developers you spend a lot of time dealing with mechanism and strategy. You try to scale systems and organizations, and you see advantages to decentralization, so you move toward blockchain technology and evermore decoupled systems. But what do you really know about scaling and the forces that lead to centralization? They are related. In this keynote, Michael Feathers will share with you their connection and what that means for your expectations about systems.

A lot of the questions I hear at microservice conferences are along the lines of “should I use technology X?” or “what are your thoughts about the Spotify organisation model?” While these focused questions are important, experience has taught Daniel that embracing a disruptive approach to building and operating software, such as that introduced by microservices, requires a much more systemic approach.

Anyone who has read Jared Diamond’s seminal book on history “Guns, Germs, and Steel”, which explains why over the past 13,000 years Eurasian and North African civilizations have survived and conquered others, will recognise that environmental differences could be at the core to making systemic changes. Following in Diamond’s footsteps, in this talk Daniel will share with you potential "environmental differences” that makes a microservice implementation successful.

Key topics and takeaways: - The importance of communicating the strategy and vision of a microservices migration. - How to establish and act upon architectural feedback. - An overview of core technology components, and how they fit into the dev, test and operation of microservices.

With the rise of DevOps, programmable infrastructure is reaching widespread adoption. However, although automated testing of software is becoming more common, the same cannot be said of testing the automated deployment of cloud infrastructure.

With microservices making our deployments more and more complex, you can no longer afford to ignore this type of testing. During this talk you will learn some approaches to programmable infrastructure testing that we have created, from the perspective of a project that required functional testing of infrastructure.

Organizations can reap large benefits from migrating from a monolith to a microservice-based architecture because microservices provide much more flexibility to adjust applications to changing business needs. Since such a migration affects every layer of an application, big-bang strategies are often perceived to be the best path of a migration.

Reality shows that big-bang strategies are difficult to make successful. Frequent slipping deadlines and not delivering business value during the process puts development teams under large and unnecessary pressure. In this talk, Gideon wants to dismantle the idea that successful microservice implementations are a simple technical game; replacing old technology for new technology. Re-architecting software should improve businesses and development processes on an organisational level, increasing flexibility to ensure full rewrites are something of the past.

Gideon will share with you a different strategy for the disentanglement of monoliths; using an incremental –domain for domain– angle, risks can be managed better, and the promise of increased business flexibility can be fulfilled from day one. Levering the concepts of DDD and the battle-tested design principles powering the Lagom framework, you will learn by example how such a migration can be jump-started using Lagom.

Event Sourcing is a popular persistence pattern that allows reconstructing different views of reality from its history. But the commonly accepted approach guarantees consistent events at write-time but may fall short scaling to big-data magnitudes, or coping with unreliable clients and transport, as when working with IoT and mobile.

Embracing Event Sourcing you have already abandoned ACID transactions, but you have to push BASE (Basic Availability, Soft-state and Eventual consistency) one step further, making compromises between low-latency writes, read delays and read-model consistency. You also have to leverage Reactive architectural principles and message-driven microservices to scale out to big-data and keep command processing latency low.

In this talk Lorenzo will share with you experience, errors and successes from real-world projects. Authentic problems like building a consistent state from late or missing events, and when you lack any global time reference, at least until everyone will have an atomic clock on his mobile phone. It offers an alternative point of view on Event Sourcing, described with whiteboard-like drawings and lessons from the trenches.

-Developer: “I’m done with the code. Just need to test and deploy now!”

-Boss: “Great! When I can see it live?”

-Developer: “At the end of the sprint?”

-Boss: “2 weeks? Why does it take 2 weeks to put a few lines of code into production?”

-Developer: “Hmm…. Actually, I might have just found a way to make it 6 minutes

-Team: gasp

The ability to react quickly to changes and outperform competitors is one of the key advantages to microservice architecture. But just how fast can these changes be delivered without forsaking quality, robustness, etc. Chris and his Team decided to find out by streamlining their delivery pipeline and leveraging the latest technologies. Using Jenkins 2.0 pipelines, Terraform and a number of other tools, they now build, test and deploy our microservices to AWS.

In this talk, Chris will share how they built their “infrastructure-as-code” repo as well as their full continuous deployment pipeline, all using open-source tools. This will be a nitty-gritty, practical session rather than pure theory which will show the tools in action, as well as the code Chris and his team wrote to get things right.

During this talk you will learn how microservice interconnectivity layers (a.k.a. edges) should be tested. There is a fundamental flaw in existing testing practices, which carries major risks to microservice architectures.

Rand and Nikhil will share a solution in which the provider microservice ships with an intelligent fake that expresses the provider's behaviors. The consumer microservice uses the fake to exercise its non-vanilla interactions with the provider in unit testing.

At ING they already have a microservices-based architecture. It certainly sounds cool, but how can you enable developers create innovative customer experiences even faster? How can you help them reason about their system complexity and change functionality comfortably without breaking it?

Nikola will share with you an open-source technology he and his Team developed to declare, verify and execute microservices-based orchestration flows. During this talk you will learn: - to write a recipe for such a flow with an internal DSL (domain specific language); - visualize the recipe as a graph to communicate the steps of the process with business and technical stakeholders; - and run the resulting flow within a RESTful API.

In this talk, you will learn how to use proven patterns & open source software to rapidly build a robust portfolio of microservices that provide a solid foundation for your dynamic and growing microservice architecture. Mark will share vital points such as:

• Configuration services

• Microservice registration and discovery

• Circuit breakers for graceful degradation

• Load balancing and intelligent routing

• Asynchronous messaging

Mark will also discuss logging & tracing, testing approaches, and migration patterns and will demonstrate how to develop & effectively manage microservices using OSS tools employed by Netflix to keep movies streaming globally 24x7.

It has been said that “Microservices is SOA done right”. But really, what’s the difference between SOA and microservices and why is this question fundamental and has implications that could go beyond a potentially amusing twitter debate?

Microservices have been around for a few years now. Many organisations with large and complicated systems that would truly benefit from introducing microservices can not do so in a vacuum; they are often operating in a context that has been heavily influenced by the SOA movement - for better or worse. This influence can often be easily discerned by existing technical choices, but what is less obvious but more important is the conceptual and architectural influence that the SOA approach is still exerting on how microservices systems even when technical legacy is not an issue.

This talk is based on 4 years and a few microservices project that Tareq has been directly involved in at different stages of maturity. Tareq will share with you some fundamental differences between SOA and microservices, and following that you will learn a number of pragmatic lessons and simple design recommendations that hopefully help bridge the gap between the reality of organisations trying to adopt microservices today and the bleeding edge of theory and technology. Many of these lessons can help you design and build better microservices architectures today.

During this Keynote talk you will learn about two things, both related to simplicity.

1 - Mel will describe the twelve attributes of “hands-on, modeless-workflow” application development, and he will illustrate these attributes using a wiring tool to build two applications without code.

2 - Then he will share with you how the common Domain-Application-Presentation three-layer model clears a large space for non-programmer business stakeholders to contribute importantly to building prototypes as part of the application definition process.