Evolutionary Architecture

Featuring Matt Belcher

Join Matt Belcher and explore the concepts behind Evolutionary Architecture. You will come away with an understanding of how to start building an Evolutionary Architecture, the engineering practices you’ll need and some pitfalls to watch out for along the way.

architecture software-craftsmanship evolutionary-architecture

Agile During the Time of Jesus

Featuring Abid Quereshi

In this tongue in cheek talk, Abid Quereshi explores the reaction to tradition and power structures and an attempt to help us see ourselves through the lens of Rome, 33BCE.

agile power

What an Architect Can Learn from Retrospective Failures

Featuring Aino Vonge Corry

Based on 15 years of experience with facilitating retrospectives for software developers, I have described the most common challenges in antipatterns.

architecture antipatterns

Event-Driven Microservices: The Sense, Nonsense and a Way Forward

Featuring Allard Buijze

Learn the promises made and if microservices delivered, how microservices technology evolved and impacted decisions, and what it means to be event-driven.

architecture cloud microservices

Lightning Talk: E Pluribus Unum – Adventures in Polycloud Delivery

Featuring Paula Paul

devops cloud delivery

Technologies for Microservices

Featuring Eberhard Wolff

Many say: "Microservices are small REST services" — but the technology choice for microservices is much bigger. This talk provides an overview of various approaches and when to use them.

cloud istio kubernetes atom kafka microservices

Minimum Viable Migrations (MVM), A Path to Cloud Modernization

Featuring Ben Ellerby

Most teams take an Agile approach to day-to-day engineering, but for migration projects this strategy goes out the window. In this talk, Ben Ellerby explores how a focus on Minimum Viable Migrations allows assumptions to be tested faster, increased team focus and better value to customers.

cloud modernisation cloud-migrations migration

Service Mess to Service Mesh

Featuring Rob Richardson

Join Rob Richardson for this introduction (or reintroduction) to service mesh. Through live demos of both Istio and Linkerd, Rob explains why (and why not) to use this popular infrastructure layer.

cloud linkerd istio service-mesh

CI/CD Agility and Controlling Pipeline Sprawl

Featuring Angel Rivera

In this talk, Angel will discuss the common pain points associated with existing CI/CD platforms — such as the issue of “Pipeline Sprawl” — attendees will learn technical strategies to develop optimized pipeline configurations and diminish potentially costly vendor-lock in.

devops vendor-neutral cicd-pipelines continuous-delivery continous-integration

Designing Loosely Coupled Microservices

Featuring Chris Richardson

An essential principle of the microservice architecture is loose coupling. Ignoring this principle is a surefire way to becoming yet another "microservices failure story”. In this talk you will learn about the different kinds of coupling, how to minimize design time and increase the...

devops cloud microservices architecture

Event-Driven Autoscaling on Kubernetes with KEDA and Azure Functions

Featuring Erwin Staal

Event-driven, serverless architectures are a hot topic in today’s cloud-native application development. In this demo-filled session, I'll introduce you to KEDA. KEDA is a component that provides event-driven autoscaling

devops cloud azure kubernetes

NodeJS, ML, K8s and Unethical Face Recognition

Featuring Joel Lord

Inspired by the show Black Mirror, Joel Lord set out to see if he could build an app to "rate" people. This talk is about all the tech he used to create it... and also on why you shouldn't build it.

cloud microservices nodejs machine-learning kuberenetes

Taming Dependabot: Keeping Microservices up to Date

Featuring Chris Eyre

In this talk, Chris Eyre looks at how he uses "dependabot" to manage 70 GitHub repositories.

cloud continuous-delivery github microservices

Evolving to Cloud Native

Featuring Nathaniel T. Schutta

This talk will explore the strategies, tools, and techniques you can apply as you evolve towards a cloud native future.

devops cloud legacy microservices

Kubernetes: A Gateway Drug for Vendor Lock-in

Featuring Ernesto Garbarino

Many organisations believe to be betting on interoperability by choosing Kubernetes rather than, what they believe to be, a proprietary platform. However, this could be a trap that can easily lead to vendor lock-in.

cloud kubernetes

How Cities Heal: Minneapolis 2021

Featuring Lynn Langit

Lynn Langit explores the role of Cloud Native tech plays in recovery for a wounded city? With COVID, civil unrest, a struggling economy and bitter political division impacting the globe, are there considerations or lessons we can all apply?

cloud techforgood

Process Automation in Cloud-Native Architectures

Featuring Bernd Rücker

In this talk Bernd Ruecker will foster your understanding of how (business) processes can generally be implemented and monitored, as he compares different approaches. You'll see the impact on agility, what's different in modern architectures, plus learn about choreography and...

cloud camunda spring-boot java event-driven serverless microservices automation process-automation

The Death of Silos

Featuring José Huerta

We have all been victims of poor collaboration. How is it that if everyone wants what is best for the organisation, we can’t seem to agree on how to achieve it? In this talk, José Huerta explores the causes of this phenomena and shares lessons learned from trying to address it.

agile leadership teamwork collaboration

Theorems for Free

Featuring Lars Hupel

We can extract a lot of information from type signatures. But how does it work? In this talk Lars Hupel will revisit Philip Wadler's influential (and very cool) paper "Theorems for free!".

haskell parametricity

Comparing Strict and Lazy

Featuring Arnaud Spiwack

Strict and lazy languages are often pitted against each other but rarely honestly compared. Let's take a step back from the slogans and examine the trade-offs between lazy and strict. Not which is best: how they compare.

haskell strict lazy