Talk (60 min)

Usability Testing is easier than you think

Beyond the Prompt: Evaluating, Testing, and Securing LLM Applications

How to make friends and influence your security team

Open source maintainers are increasingly overwhelmed by “almost correct” AI-generated PRs that introduce subtle bugs, security vulnerabilities, or fail to follow contributor guidelines. Meanwhile, the rise of AI-generated Bug Bounty reports (AI slops) risks overwhelming maintainers and undermining the spirit of responsible disclosure potentially pushing projects to abandon bug bounty programs.

In this talk, we’ll explore a security-first and practical framework for using AI in software development and contribution workflows. I will cover guidelines from the well-respected communities like Linux Kernel, OpenSSF and OWASP and real-world (non-fictional) practices from the industry leaders. We will cover how to craft AI prompts with security and compliance in mind; governance templates for managing AI-generated contributions; Strategies for handling AI-generated vulnerability reports without shutting down your bug bounty program.

"Looks Good to Me": A Practical Guide to Handling AI-Generated Code

DevOps

People

Security

Testing

Tools

However, getting started with graph databases can be a bit daunting if you have only ever worked with SQL server. Especially since most graph databases are so "far" away from your standard Microsoft domain.

But it really doesn't have to be. Graph databases, like neo4j, are awesome for a lot of scenarios. So, maybe shying away from using them because of the daunting task of getting started isn't the best solution. And honestly, getting started with neo4j as a .NET developer, isn't really that complicated.

In this talk, Chris Klug, a senior .NET developer with 25+ years of coding experience, will give you the introduction to neo4j that he wished somebody would have given to him years ago.

In just one hour, you will see how to get neo4j up and running on your computer. How you connect to it from your .NET application. And how you query it using the Cypher query language. Basically, everything you need to get started with ne04j. Or...everything you need, to go from zero to neo4j n00b...

neo4j for the relational .NET developer

.NET

Database

Notebooks & .NET: A Marriage Made In Jupyter

Technical folks struggle to find the signal in the noise, and many business brains get swept away by the hype (and by Zuckerberg's aspirational announcements... thanks, Zuk). There are a few common archetypes that have emerged:

There's the AI-ate-my-job developer, the one-with-the-vibe junior, the embrace-ai-or-get-out CEO, the cathedral-building anti-slop senior, the vc-funding-focused entrepreneur, and the not-on-my-watch IT gatekeeper. There are also people who seem to be doing things very sensibly, but it's worth looking closely at the extremes - there are a lot of pitfalls to avoid, and wisdom to be adapted and adopted (#steal-like-an-engineer).

There are clear benefits to fast iteration and quick prototypes, and adopting LLM tools on complex brown-field projects often has mixed results. It's worth knowing about the (shifting) limitations of these tools, and the emerging best practices (which often look a lot like the best practices that emerged in the before-times). It is worthwhile to deeply consider safety-nets and guard-rails as we lean on these tools, we need to iterate on our approach to engineering rather than focusing on writing more code faster (LOC is a bad measure of productivity, we know this!)

The other thing we really need to think about and solve for as a community is: how do we play the long game? I'm pretty convinced that we will still need human software engineers for a long time to come, and good ones at that. Skill comes from experience, and the junior developer job market is a bit of a dog show.

How should junior devs prepare for the future? And how should organisations adapt so that they have people that they can rely on 5 years from now? I have some opinions...

Playing the long game

Ethics

Work skills

Today, most AI designs emphasise SOPs, data quality, and evaluation, but sustainability is rarely considered. When it is, it tends to be incidental, the byproduct of choosing a cheaper or smaller model. Once deployed, very few applications measure their ongoing consumption footprint. Yet with the right monitoring in place, clear and powerful strategies emerge: caching repeated requests, nudging users toward greener prompts, scheduling tasks off-peak, or routing workloads to cleaner-energy regions.

In this session, we’ll design a Carbon Impact Agent layered on top of a support agent. This multi-agent system tracks, analyses, and recommends approaches to actively reduce the environmental footprint of AI applications. We will explore:
•	What to measure: compute usage, energy mix, task-level telemetry, carbon intensity by region.
•	How to design the system: agent orchestration for monitoring, calculation, analytics, and recommendations.
•	What insights emerge: per-task carbon costs, workflow-level emissions, and team-level benchmarks.
•	How to act on them: UI nudges, greener deployment choices, prompt optimisation, and workload scheduling.

By the end, you’ll see how we can build AI systems that are not only impactful, but also sustainable by design, embedding environmental accountability into the fabric of intelligent applications.


Building a Carbon Impact Agent: Boosting ROI with Sustainable AI in Design, Monitoring & Remediation

Architecture

Cloud

In this session, we will go beyond the basics to explore a few patterns that address some of the toughest challenges in building distributed systems. We will discuss how the Outbox pattern prevents data loss in the face of crashes, how sagas coordinate long-running workflows without distributed transactions, how scatter-gather accelerates workloads through parallelism, and how competing consumers keep systems elastic under heavy load. We will also examine routing topologies and operational safeguards like retries, dead-letter queues, and back pressure.

By the end of the session, you will have gained knowledge about when and how to apply these patterns to take your distributed system up a level with increased data consistency, resiliency, reliability and fault tolerance.

Beyond Pub/Sub - Advanced Messaging Patterns

OpenSAFELY: a quiet revolution in healthcare data

Modern .NET Configuration Practices

What is the common denominator in all these attacks? Social engineering. It is one of the most subtle yet potent set of techniques, often used by individuals or groups to exploit human weaknesses and gain access to systems and sensitive data. No organization or group is immune to this form of attack.

Working in an IT company places us in the crossfire. On one hand, we have access to not only business data but also information that could be exploited to attack our organization. On the other hand, IT professionals themselves are well-positioned, making themselves potential targets of attacks.

While it’s almost impossible to be fully protected against social engineering, it is vital to understand the possible vectors of attack. Various methods and psychological tricks can be used to compromise our security or that of our organization.

So, let’s buckle up and take a small step toward becoming more secure.

Social Engineering: Hacking Humans

Soft Skills

Open Source is Broken, and it's Your Fault

The New Frontend Toolkit: Popover API, Dialog, and Next-Gen CSS

How we support multi-cloud apps at Stack Overflow

Immutable Patterns of System Design; From Monolith to Agentic AI

Think like a user: practical UX design tips for developers

Learning not leaning: How developers can Accelerate their Learning with AI

This is not a new problem, but it's more relevant than ever. Generative AI has dropped the barrier to entry dramatically, and it's never been easier to produce probably-working software with a single prompt.
So how do we avoid sleepwalking into brittle, opaque systems that only appear correct? When is "good enough" actually good enough? And when the result always looks right, how do we know when to step in?

Keynote: The dangers of probably-working software

From early rule-based tricks to today’s generative wizardry, AI quietly shapes what you feel on the controller, what you see on screen, and what you hear in performances — and it even helps keep players safe.

We’ll start with a classic: Pac-Man’s ‘ghost personalities’, where simple rules make Blinky, Pinky, Inky and Clyde feel uncannily human. Then we’ll go behind the scenes to meet crafty foes, pixel-sharpening magic like modern upscalers, lively voice tools, and the unseen bouncers that keep matches friendly.

Join me for this whirlwind tour of the hidden brains that make games surprising, fair and fun.

The Hidden Brains of Video Games

Gaming

In this talk, Oliver demonstrates how C# Pattern Matching works, why this evolution of the old imperative "switch" is so important, and how the structure of C# code can be generally different from the past on the basis of this feature. As a conclusion, he proves that C# can now pattern match with the best, by porting some F# code as well as a complex Haskell algorithm.

Advanced Pattern Matching in C#

Functional Programming

Programming Languages

Join me in this lively, hands-on session as we demystify MCP and learn to build an intelligent context-aware MCP server from scratch.

Whether you're new to MCP or a seasoned AI enthusiast, you'll leave with everything you need to make your apps smarter, more intuitive, and ready for the AI-driven world. Let's bring AI to life, the .NET way!

.NET Meets MCP:  Build Your Own AI-Powered Service with C#

Prompt Failures and Latency Spikes: Observability for AI

Java Sucks (So C# Didn't Have To)

AI Agents Need Permission Slips

How to Instrument, Govern, and Debug Agents Before They Go Rogue

It’s not because we don’t want to develop accessible websites and applications.
But we often lack knowledge and perspective. We build based on our own experience because that’s what we know. In this talk, you’ll get to experience how our applications work for someone with a screen reader, low vision, or limited motor control, and feel firsthand the challenges they face.

The talk combines knowledge, practice, and lived experience to raise your awareness of accessibility on the web and how small changes can make a huge difference.

You'll see the most common mistakes in action, who they affect, and how to fix them. So come experience the world through someone else's senses, and learn how to be a more accessible developer.

Let's break some WCAG rules

We’ll cover practical techniques to uncover the reasons behind slow queries and fix them. Along the way, we’ll look at new features and insights that make performance tuning more straightforward.

Finding Bottlenecks with Wait Statistics: Learn how to spot the root cause of delays in your queries.

Session-Level Wait Stats: See how tracking waits at the session level can provide valuable insights.

Understanding CPU Waits: Break down CPU-related waits and what they mean for your server’s performance.

Fixing Disk I/O Delays: Understand how to reduce the impact of disk waits on your queries.

Using Wait Stats to Tune Queries: Apply what you learn to improve indexes, joins, and query plans.

This session is for anyone who wants to improve query performance and make their SQL Server run as efficiently as possible. Join us to learn simple, actionable steps that you can start using right away.

"Run Query Run" - A Fresh Look at SQL Wait Stats

Big Data

Reliable Agentic Systems need Durable Execution 🤖

We'll start with a focused deep dive into Playwright itself: modern locators, resilient test patterns, parallelization, and debugging features that help teams test faster and smarter. Then we'll explore how to connect the Playwright MCP Server to an LLM, allowing you to:
- Automatically generate meaningful tests from user flows or requirements
- Identify gaps in test coverage
- Debug and repair failing or flaky tests
- Interact with your running application via natural language

This talk is ideal for developers, testers, and QA engineers who want to level up their automation stack, reduce test maintenance, and bring AI into real-world testing workflows. Expect live demos and practical strategies you can take back to your team.

Supercharged Testing: AI-Powered Workflows with Playwright + MCP

JavaScript

We are told that as long as we keep a "human in the loop" it's all good. At one level, this advice seems sound — and even obvious — but it's as vague as it is unhelpful. What does it actually mean to be the human in the loop? It's clearly more than just LGTMing any generated code, but what skills and mindset are needed to make AI use effective? What does it take to be the driver, not the road?

This isn't a talk about tools, MCP servers or better prompts: it's a talk about understanding what productivity is and is not, the difference between value demand and failure demand, that typing is not the bottleneck in software development, that design and coding skills are important, that solutioneering the problem domain is not enough, that testing is not optional, that being able to generate and explore options has more long-term value than committing first-guess code.

Being the Human in the Loop

This session will give you some tools to help you understand how to sneak in some UX... or at least make some sincere attempts at SWAG user flows, experiences, and set ups. No, it's not ideal, but these half-assed techniques will help prevent your company from showing their whole ass with a bad experience.

How to do half-assed UX

Inspired by the Standford's paper "Generative Agents: Interactive Simulacra of Human Behavior", this session explores how to build dynamic, AI-driven worlds using Apache Kafka, Apache Flink, and Apache Iceberg. We'll use a Large Language Model to power for conversation and agent decision-making, integrate Retrieval-Augmented Generation (RAG) for memory storage and retrieval, and use JavaScript to tie it all together. Along the way, we’ll examine different approaches for data processing, storage, and analysis.

By the end, you’ll see how data streaming and AI can work together to create lively, evolving virtual communities. Whether you’re into gaming, simulations, research or just exploring what’s possible, this session will give you ideas for building something amazing.

Bringing stories to life with AI, data streaming and generative agents

Because LLM traffic is a streaming, state-heavy beast that breaks every REST assumption: requests aren’t stateless, payloads snowball with context, and GPU memory melts under token floods. We’ll map the three checkpoints where most projects stall—context explosion, batch backfires, cache chaos—and show how LLM-D’s open-source sharding plus a hybrid NVIDIA/AMD node pool turns each choke point into a green light. You’ll see live before-and-after dashboards, get a YAML ladder you can drop into any cluster, and learn a back-of-the-napkin formula to keep cost per 1 000 tokens under control.

Stop Treating LLMs Like REST APIs

Blazor Server requires an approach that is totally different than when using Blazor WebAssembly. And if you use a mix of the two rendering modes things can get very complicated.

This session is here to help you out. We'll cover the right way to do cookie and OpenID Connect authentication for both modes as well as the mix mode.

At the end of the session you'll be able to confidently secure any Blazor application.

Blazor Authentication? Hold My Beer!

In 1978, Myers noted that while the benefits of modularity were widely agreed upon, there was little discussion about how to write modular code. Almost fifty years later, many engineers continue to struggle with using modules in their code. And yet the pressure to write modular code, to support augmented coding, InnerSource, and testing rises.

In this talk, we look at how to write modular code.
- We will start by defining modules. We will provide some examples in C# of modules (assemblies) and examine language features that control visibility.
- Next, we will look at how modules can help us in software development. We will discuss information hiding and examine coupling.
- Then we will look at how we slice our software estate into modules. We will discuss how David Parnas's observations can benefit us. We will provide some examples of how we slice up an estate.
- We will step into test-driven development, so we can understand the idea that the module boundary is where we should write our tests.
- Finally, we will look at how we use modules with some architectural styles: CQRS, ports & adapters, vertical slice architecture, and flow-based programming. Again, we will provide examples in C#

We will wrap up with an overview of how these ideas relate to modular architecture styles, such as modular monoliths and macroservices

Modular Code with Examples in C#

In this session, we’ll dive into how continual learning techniques, inspired by human adaptability, help AI models improve diagnostic accuracy, minimize false positives, and handle evolving data in medical settings. We’ll discuss challenges like catastrophic forgetting, maintaining model performance in dynamic environments, and practical strategies that developers can apply to other domains. Gain hands-on insights into building resilient AI systems that evolve and adapt to new data, ensuring long-term reliability in critical applications.

Building AI That Learns and Adapts: A Case Study in MRI Diagnostics

Machine Learning

The reality is that to build reliable agents, we need to use all tools in our context toolbox to ensure they provide accurate responses in the correct format.

Let's dive into the world of context engineering, and understand the elements of context that we can tune and tweak to build more reliable AI agents and associated systems.

Crafting Intelligent Agents with Context Engineering

Vector-based searches can be used in many other scenarios besides text. If you can embed, convert data items to numbers, you can search for similar items, and this includes images, sounds, video and even music.

In this demo-intensive session Alan will explore the concepts of embedding and nearest-neighbor search. The analysis and embedding of data will be explained, along with techniques to vectorize text, images and music. He will then demonstrate how vector-based indexes can be created in Azure AI Search using both the Azure portal and programmatically. Alan will show how text and image embedding can be leveraged, and then show the techniques used to create an index using the beat signatures in music. The search index can then be used to find similar sounding beat patterns in songs, allowing code to mix tracks seamlessly, creating a stunning AI-augmented audio experience.

Well, that’s the theory, can this work in practice? Join this session and learn about the power and versatility of vector-based searching.

Drop the Bass with Embedding and Vectors in Azure AI Search

Despite how important and prolific software and programming have become over the last 50 years the general public still have a very loose understanding of what software actually is.

This hasn't been lost of the people that build the software, who often slowly try and capture themselves in the work that they do.

In this talk we'll take a look at some examples through history of seeing the humans behind the code they write as they imprint themselves on their work and we'll consider if it's possible to deliberately make art by manipulating the form and design of software itself.

A talk for everyone wanting to be seen in the work, or understand their own creative urge.

Meditations on Code As Art

Almost all the code we interact with was written by other humans, and they wrote the code that way for a reason. If we take the time to understand the context and the story behind a piece of code, we can infer a lot about what those humans meant to achieve, what their culture was like, and what they valued… in other words, we need to become an archaeologist!

Let’s work to build a better understanding of the code we didn’t write, and of who wrote it and why. Using the tools of psychology you can learn what’s happening to your brain when you’re reading someone else’s code, and then learn how you can make understanding it take less cognitive effort. Using the tools of archaeology you can learn how to use your development environment to find the real stories of the people that wrote it, and how that story can protect you from making the same mistakes they did. The ability to read and examine others’ code is essential - you can’t change or improve software without understanding what it already does, so come learn how to do it with skill and compassion!

Digging into the Matrix: Practicing Code Archaeology

This talk explores the practical aspects of performance optimisation in .NET. We’ll look at proven strategies for monitoring, identifying, analysing, and iteratively improving applications. You’ll learn how to approach the performance lifecycle, from monitoring applications in production and pinpointing the best areas to optimise, to investing valuable engineering time where it counts most.

Through a worked example, we’ll follow a feature through the optimisation cycle. We’ll profile the application, design benchmarks, theorise improvements, and iteratively refine the implementation to reduce allocations and execution time, while balancing performance gains with code readability and maintainability.

Along the way, you’ll learn how to use tools like dotTrace, dotMemory, and BenchmarkDotNet to target areas for improvement and validate gains. We’ll discuss common optimisation opportunities, from smarter memory usage and fewer allocations to more efficient execution flow.

By the end of this session, you’ll leave with practical techniques to write faster, more efficient .NET code, along with the judgment to know when optimisation is worth the trade-off, and when it’s not.

Application Performance Optimisation in Practice

There's an old wiki page, shell scripts in a random repository, and repository Readme's referencing frameworks years out of date. The excitement of starting a new project soon turns to dread as the "Time-to-Login-Screen" stretches to days.

Enter Aspire - a new set of tooling from the .NET team that supercharges local development. In this talk, I'll walk through the basic building blocks and technologies behind Aspire. I'll cover examples of development dependencies and local insights and debugging through OpenTelemetry.

Finally, I walk through migrating a complex, multi-application, multi-framework, and multi-dependency example from Docker Compose and other tools to Aspire to provide one seamless experience for local development and debugging.

Supercharging Local Development with Aspire

Microservices

In 2025 it's easy to think of "yet another chatbot" when you think about AI, but gaming has long been at the forefront of artificial intelligence and content generation.

From the earliest applications of randomisation in roguelikes, to procedurally generated universes in games like Elite and No Mans Sky, players are used to algorithmic content adding challenge, variety and fun to their games.

In this talk we experiment with using hybrid Procedural Generation and modern transformer models to create narrative storytelling for games that not only plays well, but still feels intentional, human, and engaging.

We'll cover techniques for content generation that both use and constrain our models to make worlds that make sense - that you could shift to other non-gaming mediums.

RolePl-AI

As models advance seemingly overnight, our ability to interpret their decisions struggles to keep pace. The field of Interpretability isn’t just about explaining outputs or offering post-hoc reasoning— it’s about uncovering how these models actually process and represent information.

This talk explores the latest research shaping AI Interpretability, from Anthropic’s 2024 work on mechanistic interpretability and monosemanticity scaling, to methodologies that have historically aimed at explaining models but fall short for today’s LLMs. We’ll clarify the distinction between explainability and interpretability, their respective use cases, and the current toolkit for understanding black-box models. Along the way, we’ll debunk common myths (like the tendency to anthropomorphize LLMs), and discuss why interpretable AI is essential for both reliability and trust.

For engineers at all levels– whether integrating LLMs into applications or advancing AI research– interpretability is no longer optional. It’s necessary for debugging unexpected model behavior, improving efficiency, and ensuring AI systems remain adaptable and aligned with human goals. If we don’t keep up, we risk being outpaced by models we barely understand, yet still utilize. Attendees will leave with a clearer framework for assessing LLM behavior and practical strategies for applying interpretability techniques to real-world AI systems.

Between the Layers– Interpreting Large Language Models

As a coach, I feel like there are a bunch of things that would make many tech careers go a whole lot smoother, if only we could have known them from the start. It's almost as if there should have been a course at some point, but the content didn't make the cut when they were grooming the curriculum. So in this talk, I'm going to rectify that as much as I can.

I'm going to pack this session with advice I would have loved as my earlier self. We'll talk about reasoning about technology, heuristics for making difficult choices, and how to navigate career growth in an industry that wants to keep you in a neat little box. Frameworks and languages come and go, but your core skills will remain relevant, even in the age of AI. And with things like choosing employers, or learning new skills, we don't get an infinite amount of attempts, so we better try to get it right.

Attend this session, so that when your next career decision comes around, you will have a better mental model to think about what you should do.

If only I had known ...

In this session, we'll explore and demystify this powerful feature that lets you inspect your codebase and generate new C# source files during compilation.

You'll learn how to create source generators from the ground up, including working with the Roslyn compiler API to analyze syntax trees, semantic models, and symbols. Don't worry, it's actually easier than it sounds! We'll explore practical techniques for traversing your codebase, filtering syntax nodes, and generating precise, context-aware code that integrates seamlessly with your existing projects.

Through hands-on examples, we'll implement source generators that solve real-world problems. We'll cover examples like creating strongly typed entity IDs to prevent primitive obsession, generating boilerplate code, auto-implementing interfaces, building compile-time helpers and more.

This session is designed for intermediate to advanced .NET developers, team leads and architects looking to improve code maintainability, as well as anyone interested in meta-programming and code generation.

After this session, attendees will gain a thorough understanding of source generator architecture and lifecycle, along with practical knowledge of working with the Roslyn API for code analysis. They'll learn essential techniques for debugging and testing source generators, good practices for implementing them in production projects, and acquire a toolkit of ready-to-use patterns for some common source generation scenarios.

Code that writes code - .NET Source generators

I don’t have all the answers, but I’ve learned a lot by turning my side project into a sustainable, bootstrapped open source business doing over £10K MRR — and eventually, I took the leap to leave my full-time job to focus on it completely.

In this talk, I’ll share lessons I’ve learned so far:

- Growing and engaging a community around your project
- What actually works (and doesn’t) when pricing open source
- The realities of open core models and building in public
- Why plugin-based systems and extensibility create long-term value
- How to talk to users without getting misled (using the Mom Test)
- Why focusing on what really matters beats chasing every request
- Taking the leap to go full-time — and how to know when the timing is right
- The trade-offs and hard truths no one tells you about monetizing OSS

You’ll walk away with a candid, practical playbook for making open source sustainable — whether your goal is side income, a self-funded business, or simply building a project that lasts.

Stars Don’t Pay the Bills: Turning Open Source Into a Business

Microsoft has been working on Semantic Kernel for quite some time now and has delivered a capable library that is capable of abstracting away the complexity of working with different models and allows us to AI'ify our .NET apps with ease.

This session will show you practical ways of using the library, from integrating it into an existing .NET app all the way to building, a simple multi-agent interaction, again in a practical way. We'll to the practical side of things using a Blazor application, but the principles you'll learn can be applied in other .NET platforms too.

You'll walk away with fresh inspiration and new ways to integrate SK into your apps and you'll understand that AI has practical use cases you may not have thought of in your existing apps.

Building AI Applications with Semantic Kernel in .NET

The conversations that follow sound all too familiar... "Who's subscribed to this message?" "Do other services depend on this field in the payload?" "Why on earth is that thing in the payload?" "That service should never rely on this data!" And, of course, the obvious "Can't we -just- remove this?"

But are those the right questions to ask? As software developers, we aim to be agents of change, not chaos. To achieve this, we need to understand the impact of tweaking a message contract without breaking half of the system or forcing other teams beyond their deadlines. We should prioritize techniques that ensure compatibility while also considering how long that compatibility needs to be sustained. Oh, and let’s not forget that we’re supposed to solve this problem with zero downtime, as our users are spread across every time zone. In this session, we’ll discuss practical techniques and tooling that can enable the evolution of your event-driven system so that, next time a stakeholder approaches with a change request, your heart doesn't sink to the floor.

Change is inevitable: versioning event-driven systems

Do It With Style: Rethinking CSS

In this talk, I'll explore the phenomenon of the progressive collapse. I'll explore how it manifests itself in the built environment, drawing on real world examples of structural failures in buildings. Then I'll explore examples of progressive collapse in our digital systems, and show how we can take the lessons from civil engineering and apply them to our own digital systems. As you'll see, there are a number of practical things you can take to stop a chain reaction.

Progressive Collapse

 - Conference reception in the Expo with food and drinks.


Talk (200 min)

NDC Party

Whether you need to perform sentiment analysis, summarize documents, translate text, or identify personally identifiable information (PII), PostgreSQL on Azure has you covered.

In this session, you'll explore how to leverage the power of Azure's PostgreSQL Flexible Server combined with OpenAI’s generative capabilities. You will see how to use Azure OpenAI service directly from PostgreSQL with the azure_ai extension to generate vector embeddings, implement semantic search, build recommendation systems or summarize documents.

Join me for a demo-rich session and learn how to build AI solutions using PostgreSQL and OpenAI in Azure.

Postgres and OpenAI - a match made in Azure

You can use .NET Standard Libraries and MonoGame to develop an emulator to make your childhood computer games come to life on Windows 11, Linux and MacOS. This session will show you how game emulation works, how to program it in C# with Visual Studio 2022 or Visual Studio Code and create apps using MonoGame. With plenty of demos and nostalgia this session is a welcome break even if you do not intend to write an emulator of your own.

Coding 4 Fun: 8-bit game emulation in .NET

In this deep-dive session, we will explore the best practices, advanced scenarios, and performance optimization techniques to ensure you get the most out of HttpClient in your applications. Beyond HttpClient, we will also discuss libraries that extend its capabilities, such as implementing the circuit breaker pattern.

By the end of this session, you will gain a comprehensive understanding of how HTTP calls work within .NET and how to achieve optimal performance in your applications.

Optimizing your HttpClient usage

In this darkly humorous session, we’ll explore the most heinous Git crimes—from rebase disasters to merge conflicts so brutal they could be featured in a forensic case study.

Through the lens of a "how-to" crime guide, we’ll teach you all the wrong ways to use Git—force-pushing straight to main, rewriting history with reckless abandon, and covering your tracks with git commit --amend—before revealing how to actually clean up your act and become a model Gitizen.

Come for the crime, stay for the redemption. By the end, you’ll be armed with the best practices to avoid Git-related homicides in your projects.

🔪 Warning: This talk contains traces of bad puns, git horror stories, and practical advice disguised as satire.


How to Git Away with Murder

This session provides a practical introduction to passkey authentication and its implementation in ASP.NET Core applications. We'll explore the fundamentals of passkeys and the underlying public key cryptography. Then, we'll demonstrate how to integrate passkey authentication into your projects, supporting OS management, password managers (like 1Password), and hardware security keys (like a Yubikey).

Join this talk if you want to get a thorough understanding of passkeys and the skills to integrate them into your applications.

Going Passwordless - A Practical Guide to Passkeys in ASP.NET Core

Well... here we are... But as they say, better late than never.

Join me on my "way over the top" adventure to be able to create a 1,000,000,000,000 pixel maze. I had to rethink maze generation algorithms, tackle memory optimizations, and relentlessly pursue the most obscure micro-optimizations.

You will learn:
* How mazes can be generated
* How very large mazes can be generated
* How mazes can be generated quickly
* Probably at least one obscure C# feature :)

The 1 Trillion Pixel Maze: My Decade-Long Obsession with C# Optimization

In this talk, I show the audience the power of APIs and discuss a few cool experimental APIs. I do this by taking them through on a journey through my experience of trying to hack a drone and fly it with a banana.

If you're interested in all things web, custom controllers, Bluetooth technology and accelerometer-based controls or if you just like fruit and seeing silly applications of technology, this talk is for you.

Flying a drone with twitter, bananas & Web APIs

Teams find their backlogs filled with bugs, their stakeholders frustrated by missed deadlines and the teams themselves unhappy and stressed.

Systems thinking, and in particular using causal loop diagrams to identify the feedback loops at play can shed light on how and why the fallacy is so tempting yet so destructive.

In this talk I'll demonstrate the building of a range of causal feedback loops to visualise the underlying causes of the problems. With such visualisations we can advocate for the practices of technical excellence that counter the pressures of the fallacy, such as collaborative modelling with domain-driven design, test driven development & living documentation.

A Defence of Technical Excellence

Agile

However for years we've been stuck with really "stupid" AI experiences over voice. With the advent of LLMS this is finally a reality!

Lots of different technologies have come together to create amazing audio experiences. However, there are some technical problems that we need to solve. In this talk we will learn how to chain these technologies, solve some of the common problems and build a new JARVIS together, powered by the LLM of your choice.

NDC { London }

Agenda

09:00 - 10:00 (UTC±00)

Keynote: The dangers of probably-working software

Damian Brady

10:20 - 11:20 (UTC±00)

Beyond Pub/Sub - Advanced Messaging Patterns

Poornima Nayar

.NET Meets MCP: Build Your Own AI-Powered Service with C#

Gerald Versluis

Building a Carbon Impact Agent: Boosting ROI with Sustainable AI in Design, Monitoring & Remediation

Darshna Shah

Let's break some WCAG rules

Elise Kristiansen

"Run Query Run" - A Fresh Look at SQL Wait Stats

Pinal Dave

11:40 - 12:40 (UTC±00)

The Hidden Brains of Video Games

Layla Porter

"Looks Good to Me": A Practical Guide to Handling AI-Generated Code

Roman Zhukov

Playing the long game

Sheena O'Connell

Social Engineering: Hacking Humans

Pawel Sucholbiak

Advanced Pattern Matching in C#

Oliver Sturm

13:40 - 14:40 (UTC±00)

Being the Human in the Loop

Kevlin Henney

Supercharged Testing: AI-Powered Workflows with Playwright + MCP

Debbie O'Brien

How to make friends and influence your security team

Sarah Young

The New Frontend Toolkit: Popover API, Dialog, and Next-Gen CSS

Eric Veliyulin

neo4j for the relational .NET developer

Chris Klug

15:00 - 16:00 (UTC±00)

How we support multi-cloud apps at Stack Overflow

Chris O'Dell

Beyond the Prompt: Evaluating, Testing, and Securing LLM Applications

Mete Atamel

Learning not leaning: How developers can Accelerate their Learning with AI

Emma Burstow

Usability Testing is easier than you think

Jo Minney

Modern .NET Configuration Practices

Chris Ayers

16:20 - 17:20 (UTC±00)

Java Sucks (So C# Didn't Have To)

Adele Carpenter

AI Agents Need Permission Slips

Heather Downing

Open Source is Broken, and it's Your Fault

Lotte Pitcher

Prompt Failures and Latency Spikes: Observability for AI

Prerit Munjal

Notebooks & .NET: A Marriage Made In Jupyter

Alexander Hall

17:40 - 18:40 (UTC±00)

Immutable Patterns of System Design; From Monolith to Agentic AI

James Eastham

How to Instrument, Govern, and Debug Agents Before They Go Rogue

Carl Lapierre

OpenSAFELY: a quiet revolution in healthcare data

Eli Holderness

Think like a user: practical UX design tips for developers

Lex Lofthouse

Reliable Agentic Systems need Durable Execution 🤖

Marc Duiker