Serverless or containers; Who cares pick both!

A common consideration when building modern applications is whether to 'go serverless' and build with FaaS services like AWS Lambda or Azure Functions. Or whether you should build with containers and run them using services like Amazon ECS, Azure Container Apps or even Kubernetes.

Whilst this conversation is valuable, most large software systems will have use cases for both. Blindly opting for one over the other risks not always picking the right tool for the right job.

During this talk, you will understand the key differences between functions and container-based workloads and, importantly, how to run them in a serverless way.

By the end of this talk, you will have a clear set of heuristics for when to choose containers and when to choose FaaS. As well as best practices for running both in production.

Rust for .NET Developers

Rust, the programming language that regularly come in at #1 in the yearly Stack Overflow developer survey. Performant, safe, with language features that protect you from yourself. But what does that mean for you as a .NET developer? Should you spend your time learning Rust? Or are you going to need to forget everything you know about .NET in order to learn Rust?

In this workshop, you'll build an entire application in Rust consisting of a web application, and a backend service processing messages from Kafka. Throughout, you'll have a direct comparison to the same service written in .NET. By the end of the workshop, you'll feel capable of building entire applications in Rust, and who knows. Maybe the next new service you build you'll choose Rust to compliment your existing .NET applications.

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.