So You Want to Build An Event Driven System?

Making your system 'event driven' is a common consideration when building modern systems. But what does that actually mean in the real world? What are the benefits of adopting this architecture style, what are the challenges and some of the tradeoffs?

In this session, you'll learn all about that and more with tips taken from building event driven systems in the real world. Starting from why, understanding what and plenty of practical things you can take away and use in your own applications. From the simple, through to some advanced integration patterns that this architecture style unlocks. To improve the resilience, extensibility and scalability of your systems.

So You Want to Maintain a Reliable Event Driven System

Building an event-driven system is the easy part. You build producers that produce messages and consumers that consume messages, and you leverage managed services as the message channels between your systems. But what does this mean for your operations? The things that keep your systems online, your users delighted, and your pager quiet at 3 am.

In this session, you'll gain practical knowledge you can apply when building and operating event-driven systems. You'll learn how to test systems that prioritize asynchronous communication, evolve them over time, and, most importantly, observe them and recover from failures when things go wrong. This session will walk through the software development lifecycle for an actual application, and it includes the theory behind the different practices and practical things you can take away and implement in your architectures.

This is not a vendor specific talk, it tells a story focused on the software development lifecycle when building event-driven systems.

Speed, Safety, Sustainability. Have all 3 with serverless & Rust

As technologists, living in a world ran by technology, we have an obligation to society and to the planet. Speed, safety and sustainability should be the 3 principles all of us live by. Rust is a fantastic language for this at the application code level, but there are still lots of other steps required before that Rust application code can be shipped to production. And that is where the combination of Rust and serverless technologies come together perfectly.

Serverless provides a way to ship application code, only using the resources you need when you need them whilst shifting the operational responsibility on to the cloud provider. It enables developers to focus on writing code and shipping features, and doing that in a performant and safe way.

This talk will explore the beauty of this combination, and how it’s a fantastic way to build modern business applications with Rust across containers and FaaS.

N/A

Serverless Integration Patterns; The Why, the What and the How

Serverless applications consist of lots of small, loosely joined components. The integration between these components becomes a key part of your architecture.

Join me for this demo heavy session where we will walk through an application architecture, looking at:
- Why it's important to consider how your applications integrate
- The important of thinking about your architecture in the form of patterns, not services
- What are integration patterns and an introduction to some important ones
- How to build these patterns on AWS using serverless technologies and the AWS CDK for .NET