18-20 APR 2024

How will software development evolve in the 2020s? Join Richard Campbell as he explores the landscape of technology that will have a massive impact on software development over the next ten years. What new devices are coming? Will Artificial Intelligence take over everything? How will people connect to the web in the next ten years? And what about Quantum Computing? All these topics and more will shape our future!

Unit tests are traditionally seen as isolated entities, but the code they examine does never exist in isolation. It's always part of a broader interconnected ecosystem. In this session I propose a shift in perspective, questioning the conventional approach to unit testing by examining the social dynamics at play. Join me in a discussion about the divides in unit testing and let's explore their social lives together.

In today's digital world, cybercriminals are becoming 'craftier'. This presentation will explore the concept of phishing, a common social engineering tactic. We will tackle phishing in a bite-sized format, learning how to identify red flags and outsmart hackers before you click the bait.

Imagine a world in which you could build a distributed system that guarantees that every individual user action travels throughout a multitude of services without ever being lost or duplicated. No lost orders. No duplicate entries that require reviews. No persistent exceptions due to data inconsistencies.

If you're imagining rainbows and unicorns right now, this session is for you!

Before going into specifics, we need to stop thinking about message delivery and focus on message processing instead. We'll explore an end-to-end approach to message processing, starting from the human-to-machine interaction in the front end of the system and traversing component-to-component message-based communication throughout the system.

As a cherry on top, I'll present you with a fully operable example showcasing cross-system, exactly-once, HTTP-based communication.

Ready to explore what's over the rainbow?

Combining the power of Kubernetes and MLOps brings scalability, reliability, and reproducibility to generative AI workflows. In this session, we will explore how Kubernetes enables the orchestration of distributed generative AI training and inference pipelines, while MLOps practices ensure efficient model development, deployment, and monitoring. Join us to discover how this combination empowers organizations to unlock the full potential of generative AI while achieving seamless scalability and operational excellence.

Did you know that the .NET compiler turns our async methods into classes? And that .NET adds a try/catch block to each of these classes, potentially hiding thrown exceptions? It's true! In this session, we will learn how to best use async/await in C# by analyzing how .NET compiles our async code. Join me as we take an existing app and optimize its async code together, showing off performance gains, better exception handling, improved run-time speed, and smaller app size!

The software world is moving towards multiple interconnected applications that service our customer needs, but this makes development so much harder. Now we need to think about how were interact we other systems that we don't necessarily own. In this talk, I'll introduce outside-in testing. We'll also talk about how we can use Observability techniques in our local development to build applications that are easier to debug locally and are built to be run in production as a first class citizen

Discover the essence of Kubernetes through a brief exploration of the Operator Pattern. Uncover its streamlined approach to managing complex applications within Kubernetes clusters. Gain insights into its core concepts, benefits, and practical applications, empowering you to orchestrate containerized workloads with precision and efficiency. Whether you're a seasoned Kubernetes enthusiast or just beginning, this journey promises valuable insights to enhance your deployment strategies

In today's tech-driven world, innovative ideas are just the start. Successfully bringing them to life requires navigating complexities – whether in tech firms or local governments, understanding the broader context is vital for success.

We know it’s vital that code executed at scale performs well. But how do we know if our performance optimizations actually make it faster? Fortunately, we have powerful tools which help—BenchmarkDotNet is a .NET library for benchmarking optimizations, with many simple examples to help get started. In most systems, the code we need to optimize is rarely straightforward. It contains assumptions we need to discover before we even know what to improve. The code is hard to isolate. It has dependencies, which may or may not be relevant to optimization. And even when we’ve decided what to optimize, it’s hard to reliably benchmark the before and after. Only measurements can tell us if our changes actually make things faster. Without them, we could even make things slower, without realizing. Understanding how to create benchmarks is the tip of the iceberg. In this talk, you'll also learn how to:

- Identify areas of improvement which optimize the effort-to-value ratio 

- Isolate code to make its performance measurable without extensive refactoring - Apply the performance loop of measuring, changing and validating to ensure performance actually improves and nothing breaks
-  Gradually become more “performance aware” without costing an arm and a leg

The past few years have seen huge hype around distributed systems and microservices. Pre-emptive implementation of a distributed architecture has led to many engineering teams struggling with vast complexity and sadly for many, the dreaded "Distributed Monolith". Some teams are in such a pickle that they are even reverting their distributed applications back to a monolith. I'm all for designing and developing for future growth, but there is a better way than diving straight into distributed architecture. Behold, the Modular Monolith. By design, the modular monolith is "distribu-ready" and in this session, we'll cover the design principles and implementations that make the modular monolith one of the best options for future-proofing your application whilst minimizing complexity.

You've likely heard about OpenTelemetry and are either starting to use it, or thinking about using it in your applications as you should! But how do you use it effectively, how should you set things up, what spans or activities should you create, how should you name them?

In this talk we'll cover:
* Codeless instrumentation
* Getting automatic spans from popular libraries
* What application context is important in your observability
* Different setup techniques
* Using OpenTelemetry in messaging systems like Azure ServiceBus and Kafka
* How to export your telemetry signals to an Free OpenSource backend
* How K8s can make observability simpler

This will be a talk about best practices, tips and tricks for getting the most out of OpenTelemetry.

Ever wondered how IDE’s are built? In this talk, we’ll skip the marketing bit and dive into the architecture and implementation of JetBrains Rider. We’ll look at how and why we have built (and open sourced) a reactive protocol, and how the IDE uses a “microservices” architecture to communicate with the debugger, Roslyn, a WPF renderer and even other tools like Unity3D. We’ll explore how things are wired together, both in-process and across those microservices. Let’s dive in!

Imagine a world where you never face discrepancy between your application infrastructure requirements, your configuration and your actual infrastructure. In this world, the only thing you need to know is your preferred high-level programming language. In this presentation, I will introduce you to this world. Using source control management tool is now a common practice for both the code of our application and the code of our infrastructure. However, we often continue to manage them separately. There are many reasons for this. The most common one is that the team managing the application and the team managing the infrastructure are two distinct teams. But, today, more and more teams are embracing the 2-pizzas team model where they are accountable for what they ship from code to production. In this case, why couldn't we manage everything at once? I will show you how we can achieve this with the AWS Cloud Development Kit.

In today's rapidly evolving world of cloud computing, choosing the right platform for deploying and managing applications can be a daunting task. Let's shed light on the strengths and weaknesses of three popular Azure solutions: Azure App Services, Azure Kubernetes Service (AKS), and Azure Container Apps. By delving into their unique features, performance characteristics, and scalability options, you will gain a comprehensive understanding of which solution best aligns with your application needs.