Name: NDC Copenhagen 2025
Start: 2025-09-08
End: 2025-09-12
Location: NDC Copenhagen

In this humorous talk, you'll learn which security concerns are important to think about while working in a Modular Monolith. I'll show you how you can implement those concerns so that security isn't a disaster when you need to scale your system out. And maybe you'll learn a thing or two about cats, too. Dog people are also welcome.

Talk (60 min)

Secure your Modular Monolith by pretending it's a cat

Architecture

Microservices

Security

But how do you modernize over 10 years of legacy? Throw it all out and start over? That gets even more expensive. The answer is simple: it depends.

It depends on the specific needs of the business: does it need to scale? What about safety or privacy? How about Performance? Choices have to be made.

As an application modernization architect I have done my fair share of these projects. In this session I will share my experiences, and how I deal with them. By the end of the session you will have a clear understanding of where to start, and what steps to take to bring that business-critical application into the modern age.

Modernizing your legacy application

.NET

Design

In this talk we'll explore the ins and outs of caching in .NET, from memory to distributed up to hybrid caching: we'll see both the new HybridCache from Microsoft and FusionCache.

We'll explore common scenarios, recurring problems and how to solve them with a focus on pragmatic solutions that can be used right away in the real world.

FusionCache is my free OSS project: is even used by Microsoft itself (see Data API Builder) and is the world's first production ready implementation of HybridCache.

Resiliency, performance and scalability will be center stage.

Hybrid Caching in .NET

Concurrency

Database

Several academic studies show that AI generated code based on LLM's that are trained on vulnerable OSS implementations lead to vulnerable generated code. Another study showed that developers tend to trust GenAI created code more than human created code. Combining that with the higher code velocity it will result in more vulnerabilities in it's output.
Using an AI system that runs an LLM also has additional risks tied to it, related to jailbreaks, data poisoning and malicious agents, recursive learning and IP infringements.


In this presentation, we will examine real-world data from several academic studies to understand how GenAI is changing software security, the risks it introduces, and possible strategies to address these emerging issues.

Using GenAI on and inside your code, what could possibly go wrong?

GenAI

Zero Trust architecture, with its emphasis on continuous verification and least-privilege access is the foundation. It is imperative for software engineers to integrate this knowledge into their skill set, not only to maintain security in hybrid cloud environments but also to anticipate and counteract emerging threats in increasingly sophisticated ecosystems.
By the end of this session, attendees will understand why Zero Trust practices are critical to Microsoft's Secure Future Initiative and why equipping all software engineers with this knowledge is essential for safeguarding modern, connected systems with practical examples using Azure resources.

Zero Trust Security with Azure cloud

Cloud

Event-driven architecture (EDA) offers a powerful solution that extends beyond the traditional roles of producers, consumers, and brokers. It facilitates the creation of dynamic architectures that evolve, empower teams, and enhance agility, enabling businesses to thrive in rapidly changing environments.

In this talk, we’ll explore how complexity can obscure the potential of event-driven architecture (EDA). By examining EDA through the lens of Domain-Driven Design, we'll discuss how it contributes to the growth of evolutionary architectures and the critical guardrails and governance strategies needed to manage complexity effectively.

Whether you’re refining your current architecture or embarking on a new journey, this session will provide actionable insights into controlling complexity and maximizing the potential of event-driven architectures within a domain-driven context.

Navigating complexity in event-driven architectures: A domain-driven approach

We'll cover the main ideas, such as schemas, handlers, ClaimsPrincipal, claims, challenges, session cookies, and more. It will be a practical, in-depth look at how authentication actually works in ASP.NET Core.

Demystifying authentication in ASP.NET Core

Because screens are central to modern life, our day-to-day work has monumental purpose and value. We banish interface rage, help businesses save and make serious money. We keep people safe from disaster and yes, pickles.

We'll explore why small interface problems are never the whole story behind historic (or mundane) UI failures. You'll come away with a stronger sense of purpose in the smallest details and broader context of your important dev work.

The Chips and Pickle Story: What's Really Behind Infamous, Historic UI Failures?

People

Testing

In this talk, we’ll dive into the challenges with Eventual Consistency, multi-tenancy, circular references, cross-origin resource sharing (CORS), and many more. You'll hear the choices we made, along with other options we considered, and what we learned from this experiment.

Migrating from a monolith to a new service

Agile


With the CNCF project Spin, we get to use WebAssembly's portability and component model, to build applications as monoliths, but being able to run them distributed across clouds and edge-compute providers networks.

Spin enables you to use programming languages like JavaScript/TypeScript, Rust, Go-lang, Python, and many more to write functions, which can execute in many different environments.

The workshop will be a fun little game, where teams will have to solve puzzles while learning the technology. The workshop has all instructions to guide you through building with Spin, and will be instructor-led.

Workshop (60 min)

Part 1/2: Geek-out with the WebAssembly Component Model: Embrace Edge- and Cloud-Native

Serverless

Microsoft

Chrome DevTools offer a variety of options for accessibility testing, including simulations for visual impairments, checking for accessibility labels, color contrast and insights into the accessibility tree. We will discuss these techniques, as well as common sources of accessibility issues and how to approach them. We will also explore how to convince your team or manager to invest in accessibility testing and where to focus your attention if you have limited time & resources.

Let's make the web more accessible, one page at a time!

Accessibility Testing with Chrome DevTools

What if I told you that there is? Let’s take a journey together towards a wholly different approach to conflict - a collaborative one. In this talk, you’ll learn how to use conflict to fuel better software, better teams, and better companies. You’ll learn how to structure your team’s environment to draw out good conflict, to squelch the bad conflict, and to handle conflict when it becomes personal. We’ll discuss how to manage different confrontational styles, avoid self-sealing prophecies, and even how to deal with conflict when you lack control. Conflict should fuel your progress, not hinder it - and after this talk, you can make that happen.

How To Not Strangle Your Coworkers: Resolving Conflict with Collaboration

Soft Skills

This talk explores what it really takes to launch and scale a SaaS in 2025 and why ignoring these factors can be a costly mistake.

The New Realities of SaaS: Why Building is Harder Than Ever

DevOps

At the same time, Java is mature, stable, backwards compatible, and runs just about anywhere. The community is pretty cool too!

This talk takes a light-hearted, warts-and-all look at some of the more frustrating aspects of Java, how the language has evolved over time and where it's headed next. A discussion on the consequences of language design decisions that can be enjoyed by programmers of all languages, but especially by C# users.

Expect to laugh, and yes maybe even cry, as we try to make sense of the beast that puts food on the table for millions of developers worldwide


- Pivotal early design decisions such as checked exceptions and generics and how we still pay for those decisions today (that is, why do lambdas suck so bad?)
- How Java has influenced the development of other programming languages, and vice versa
- Most controversial language design decisions of late and the associated fallouts

Java developers will leave this session feeling validated and with a renewed love for the language that keeps a large chunk of the world running. C# developers will leave this session with a renewed level of smugness.

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

Java

Languages

Experience the thrill of live coding as we develop the NDC Copenhagen app in real time! Will we end up with something that we can actually use for the rest of the event or will we horribly fail and watch Gerald put in blood, sweat and mostly tears for an hour?

This session will guide you through the process of building an app that lists speakers and sessions and what else we want to fit in, highlighting best practices and tips and tricks for cross-platform development with Blazor Hybrid.

Perfect for developers of all levels, you'll walk away with actionable knowledge on building dynamic and engaging apps quickly and efficiently.

Or, at the very least you'll have a good laugh and learned what NOT to do!

Building the NDC Copenhagen Mobile App Live! with Blazor Hybrid

Cross-Platform

Mobile

This talk explores how Vibe Coding works in practice and how it’s transforming the everyday workflows of people in software development. Tools like GitHub Copilot, Lovable, and Cline enable a new kind of collaboration between humans and AI, where prompting becomes the core skill. Instead of focusing on syntax and boilerplate, developers can concentrate on creativity, goals, and iteration.

But Vibe Coding is about more than just speed. It lowers the barrier to entry, democratizes technical capabilities, and unlocks entirely new creative possibilities. At the same time, it raises important questions around data privacy, quality assurance, and the evolving role of tech professionals in a world where anyone can generate working code.

Whether you’re already experimenting with AI or just curious about what’s next – this talk will provide inspiration, strategies, and a fresh perspective on what software development is becoming: Prompt. Build. Repeat.

Prompt. Build. Repeat. – The Vibe Coding Mindset

In this talk, we'll explore how to build AI-powered real-time streaming pipelines. Whether it’s for fun, profit, or simply seeking revenge on the Karens of the world.
We will discuss the architecture, libraries, and tools you need to perform real-time sentiment analysis on live unstructured user data coming from your own system or even social media, using Apache Kafka and Apache Flink. You'll learn about the challenges of integrating AI models into these technologies, and we'll walk through a practical, real-world example.
Finally, we'll break down the differences between using powerful large language models (LLMs) and lightweight small language models (SLMs), understand the pros and cons of each and how to pick the best one for your specific scenario.

Whether you are experienced in streaming systems and data engineering, or just curious about applying AI to solve real-world problems, this session will give you the foundation, insights, and inspiration to try it out yourself.


AI vs. Karen: Real-Time Customer Sentiment Detection at Scale

Big Data

The core of this talk demonstrates how the Enigma's complex encryption system can be elegantly modelled using functional programming principles in F#. We'll illustrate how the machine's components—rotors, reflector, and plugboard—naturally map to a pipeline of pure functions, with machine state threaded through using fold/reduce patterns. This approach not only simplifies the conceptual understanding of the Enigma but also highlights the expressive power of F# for modelling complex systems.

Finally, we'll explore comprehensive testing strategies for our implementation, including property-based testing to verify encryption/decryption symmetry and unit testing to validate the behavior of individual components. Through this journey, attendees will gain insights into both historical cryptography and modern functional programming techniques that remain relevant in today's software engineering practices.

Demystifying the Enigma Machine - a Functional Journey

Functional Programming

.NET MAUI is an app development framework which makes app development easy for .NET developers, with just a single codebase for developing Android, iOS, MacOS and Windows applications. In this session, you will learn what .NET MAUI is, how it uses the MVVM-architecture, and many more features.

Cross-platform development with .NET MAUI

And, have you ever wondered whether YOU would survive the sinking of RMS Titanic or not? In this talk, we'll be using Visual Studio, C# and ML.NET to find out, by making a solution to the ML training site Kaggle's Titanic Challenge.

Machine Learning is a hot topic these days. Business around the world are keen to utilise it; and there is a common misconception that ML has to be done in python

In fact - that's not true! These days it's not only possible to do ML in Visual Studio, but it's actually easy to produce high quality results with very little effort.

Be warned though, there are ice bergs ahead....

"Would YOU Survive the Titanic?", with ML and .NET

Machine Learning

This has been a critical problem across machine learning applications in the last years. To break open the black box of AI models, and understand how they make decisions, the concept of explainability was introduced.

Then, LLMs entered the chat. They answer our questions confidently and with a beautiful prose, even when they are making up data. Explainability then becomes essential to trust -or not- their output. But when the existing explainable AI methods cannot be directly applied to these models, what do we do?

In this talk, we will delve into the topic of explainable AI, and its importance in the current context of LLMs and agents. Starting from traditional machine learning to then focus on generative AI, we will cover the different methods that can be implemented, from well-known ones to novel proposals stemming from our internal research. We will go through the main risks and challenges we have encountered when implementing explainability, and how we have solved them. Finally, we will share some tips and tricks to integrate explanations into LLM-based workflows (also when using existing third-party services that are not natively explainable).

Dehumanizing Agents: Why Explainability is Crucial in the LLM Era

Ethics

Traditional access control can’t handle contextual, document-level permissions at scale, leaving enterprises vulnerable.

In this talk, discover how Fine-Grained Authorization (FGA) locks down RAG and agentic AI systems, ensuring AI respects strict data boundaries. We’ll dive into real-world implementations with OpenFGA & LangChain, tackling multi-tenant isolation, leakage prevention, and auditability, all while scaling to billions of access decisions without sacrificing performance.

Whether you're building internal copilots or customer-facing AI, this is a must-win security battle.

Your AI Agents Are Overprivileged: The Case for Fine-Grained Authorization

In this session, I’ll cut through the noise to demystify the fundamentals of software supply chain security. We’ll explore these frameworks and tools in depth, understand how they work together, and provide a clear practical guide to building stronger, more resilient pipelines. I’ll also highlight real-world supply chain threats from dependency confusion to insecure deployments and show how open-source tools can help you detect, prevent, and respond to these risks effectively.

By the end of this session, attendees will have:
- A clear understanding of key security frameworks like SLSA, SBOM, and Sigstore
- Awareness of emerging threats in cloud-native software delivery
- Hands-on knowledge of tools and strategies to enhance trust in their development workflows
- Confidence to implement defense-in-depth strategies to secure their supply chain and deliver trusted verified software

Building Trust in Open Source: A Practical Guide to Securing Your Software Supply Chain

Continuous Delivery

In this session Callum shares his near-decade of experience leading successful software teams distributed across vast timezones and continents (UK and Australia). He'll reveal his approaches to implementing processes, coding standards, and collaboration tools to keep teams running like a well oiled machine despite physical distance.

Let's discuss some tried and tested approaches for ensuring remote teams thrive – with a particular focus on supporting mental health, team wellbeing, and adjusting ways of working to support neurodiversity like ADHD. Additionally we'll explore ways to maintain a strong, supportive team culture despite physical distances – including tips for remotely onboarding new colleagues.

Whether an engineer or a manager, you will leave inspired with ideas for how to improve collaboration and quality across your team.

Leading successful remote teams

In this talk, we will take it a step further and look into some more advanced topics around .NET Aspire. The things that takes it from a cool demo, to a really helpful tool for you development.

The focus of the talk, is to cover what is really happening when you use it. Knowledge that lets you know how to tweak it to your need, when you needs aren't covered out of the box.

It will also cover how you can build your own extensions to Aspire, to allow you to use it for your custom applications, or projects that aren't already supported by the community. Things like creating your own .NET Aspire resources and custom commands.

.NET Aspire Beyond the Introduction

This session provides actionable strategies for modernizing configuration management in your .NET projects, significantly boosting productivity and security.

- Strongly Typed Configuration: Enhance readability and reduce errors.
- Configuration Providers: Optimize use of JSON, XML, INI, environment variables, Azure App Config, and Key Vault.
- Dependency Injection Integration: Simplify and modularize configuration management.
- Options Pattern: Achieve flexible and scalable application settings.
- Containerized Applications: Securely manage configurations, including secrets and environment-specific settings.
- Deployment Strategies: Securely inject configurations using Azure DevOps Pipelines, GitHub Actions, and Kubernetes.
- .NET Aspire Configuration: Streamline service-oriented configurations in distributed applications.

Gain practical guidance on transforming your approach to configuration management, ensuring your .NET solutions are secure, efficient, and ready for modern deployment scenarios.

Modern .NET Configuration Practices

Tools

We'll go through what is our there for solving different problems and how you as a developer can use these models in your applications.

A developers guide to really cool computer vision models

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

But increasingly, the term “AI” has become synonymous with only one flavour of artificial intelligence - that being “machine learning” (ML) - e.g. generative AI, applied AI, large language models (LLMs) and the such.

However, there are many other types of AI, which until recently, were the mainstay algorithms found behind automated decision making solutions.

Many of these concepts can be found in the video games we know and love.

Are these other types of AI still relevant? Do they risk being drowned out, or forgotten, in the rush to embrace machine learning solutions?

In this session, intended for the enterprise/business application developer, we’ll open a window into the world of the video game development.

We’ll explore the type of algorithms that are a staple of game development: pathfinding, state machines, decision trees, and goal-oriented action planning.

We’ll delve into some of the performance considerations necessary to keep these algorithms running efficiently.

We’ll circle back to how the business application developer can use this type of AI in applications, and how the lessons learnt making video games can help us write better software.

The Forgotten AI of Video Games

Gaming

In the workshop we'll go over the basics of CTFS, a few different types of CTF challenges, and how to approach the different types. The goal is to give you a taste of what CTFs are like and how to get started with them. The format will be guide presentation, while people have the option to solve challenges on their own or in groups. The presentation will be a mix of slides and live demos, with a focus on hands-on practice, once the presentation is done, I'll walk around the room to help people with the challenges and answer any questions they have.


- Introduction to CTFs
- Types of CTF challenges
- web, forensics, cryptography, reverse engineering, pwn, misc, etc.
- How to approach CTF challenges
- Tools and techniques
- Web security tools (Pwntools, etc.)
- Forensics tools (Wireshark, etc.)
- Cryptography tools (CyberChef, etc.)
- Reverse engineering tools (Ghidra, IDA Pro, etc.)
- Hands-on practice with a few sample challenges
- Web security challenge
- XSS vulnerability
- SQL injection vulnerability
- Forensics challenge
- File analysis
- OSINT
- Cryptography challenge
- Basic ciphers
- Hashing and encoding
- Reverse engineering challenge
- Basic binary analysis
- Static and dynamic analysis
- Conclusion and resources for further learning
- Hack the box
- How to get involved with CTFs teams in your area
- DEfcon, CCC, BSides, etc.
- Q&A & help with challenges

Part 1/2: Introduction to capture the flag(CTF) with walkthrough and hands-on practice

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

Talk 1: Open source is broken and it's your fault! - Lotte Pitcher

Talk 2: The 10 Most Common Azure Mistakes (And How To Fix Them) - Scott Sauber


After working with dozens of companies in Azure, I’ve seen the same mistakes pop up again and again — from mismanaged subscriptions to sketchy security setups and overlooked cost controls. In this session, we’ll walk through the 10 most common Azure missteps I've encountered in the real world, including gotchas in account organization, governance, compliance, performance, and how developers are misusing DefaultAzureCredential to authenticate to Azure.

Whether you’re deep into your cloud journey or just getting started, odds are your team is making at least one of these mistakes. By the end, you'll leave with practical, actionable advice to spot these issues early and fix them fast — before they turn into bigger problems.

Talk 3: View Transitions: The brand-new browser API that will blow your mind - Jakob Endrestad Kielland


Have you ever wondered why a well-made native app often feels way smoother than a similar web page? The answer is that native apps have long wielded the full power of seamless transitions, while on the web we have had to use heavy JavaScript frameworks to accomplish anything remotely similar.

That ends now! In this lightning talk we will take a look at the mind-blowing View Transitions API, a brand-new browser API that lets you control every aspect of the transition between web pages with just a few lines of CSS. In addition to seeing what the API is capable of we will dive under the hood to see how exactly the API does its magic.

Talk 4: This Place is a Mess, Rewrite Everything! - Josef Goldstein


We’ve all been there at some point.
We joined a new company or a new engineering group, and none of this “legacy code” makes any sense.
The longer you stare at it, the louder that voice becomes... the voice that tells you to just rewrite it all.

But should you?
In this short talk, we'll try to explore the good, the bad, and the unavoidably ugly of dealing with legacy code.
We'll take a deeper look into the psychology behind the desires we all share to remake code in our image, why it's not always the best approach and when it actually is.
Lastly we will discuss some practical tips for successfully dealing with legacy code management and hopefully surviving to refactor another day.

Lightning Talks 1

Part 2/2: Introduction to capture the flag(CTF) with walkthrough and hands-on practice

With the CNCF project Spin, we get to use WebAssembly's portability and component model, to build applications as monoliths, but being able to run them distributed across clouds and edge-compute providers networks.

Part 2/2: Geek-out with the WebAssembly Component Model: Embrace Edge- and Cloud-Native

Join Richard Campbell as he explores the evolution of undersea cabling, culminating in today's fiber optic cable connections that span thousands of kilometers. How the cables are made, laid, damaged, and repaired is amazing—and essential to our modern world!

The Undersea Cable Network

But here's the real question: are you absolutely certain that your API only accepts access tokens issued by your service?

In this session, I’ll demonstrate some tricks that can bypass improperly configured token validation. You’ll see how easy it is to fool your API if you’re not careful. But don’t worry, I’ll also show how to write tests that ensure your application is protected against these exploits, keeping your data and users safe. 

Are you sure your access tokens are really secure?

In this session, we’ll explore how to train Regression and Classification models using C# and ML.NET, and how to run those models in a .NET MAUI app, enabling offline AI analysis directly on a mobile device. We’ll also look at how to create an image classification model using Azure Custom Vision, and use it offline in our .NET MAUI app with the power of ONNX.

After this session, you’ll have a basic understanding of what Regression and Classification problems are, how to train and evaluate models with ML.NET and Azure Custom Vision and how to use these models locally in a .NET MAUI app.

Building Intelligent .NET MAUI Apps with ML.NET

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.

So You Want to Maintain a Reliable Event Driven System

People have often told me they’d never be able to do design, as it’s too subjective and a completely different mindset to coding. Well I’m here to tell you that UI design isn’t as complex as it looks when you’ve got the right tools to hand.

In this talk, I will help you understand some of the main design principles that you can apply across UI design. Including – Typography, Emphasis, Hierarchy, Layout, Spacing, Size, Depth and Colour.

We’ll be discussing these principles and through visual demonstrations show just how you can implement them across typical features such as forms, cards, dashboards and other interface elements . There may even be some *live designing* to help demonstrate.

Whether you’re the ‘dev-signer’ or you’re just somebody who would like to learn some fundamental design skills to widen your knowledge – you should then leave feeling well equipped with new design skills to apply day to day!

Design for Developers

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

In this session, we’ll explore HTMX and ASP.NET Razor Pages, a dynamic duo that lets you build modern, interactive web applications without the bloat of a JavaScript-heavy frontend.

In this session you will learn:
- How HTMX enhances Razor Pages with minimal effort
- Making AJAX requests, swaps, and transitions without writing JavaScript
- Real-world example of cleaner, simpler, and more maintainable web application

HTMX & ASP.NET Razor Pages – Web development without the JavaScript pains

This session dives into the real-world impact of WebAssembly for .NET developers, from Blazor WebAssembly to Uno Platform and beyond. We’ll explore how .NET can leverage Wasm to create fast, portable apps and how WASI is opening the door for server-side execution. Whether you're looking to extend your .NET skills to the browser or streamline multi-platform development, this session will give you the insights and tools to harness Wasm effectively. 

WebAssembly & .NET: The Future of Cross-Platform Apps

Language

In this session, I'll do a deep-dive into the publish/subscribe API of Dapr, the Distributed Application Runtime, a graduated CNCF project, used by hundreds of organizations who run microservices at scale in production. Dapr provides APIs that abstract away the underlying infrastructure, and in this session we'll look in detail at the pub/sub API that can be used with many different message brokers while the application code remains unchanged.

Topics covered include: the various subscription types such as declarative, programmatic, and dynamic (streaming), bulk publishing, CloudEvents, routing, and the outbox pattern. For all topics, I'll be doing demos in C#, and run the demos across various message brokers, including Azure Service Bus, RabbitMQ, and Redis.

By the end of the session, you'll have a good understanding of the capabilities of the Dapr pub/sub API and know how to apply it in your distributed applications.

Async messaging deep dive with Dapr, take your pub/sub skills to the next level 📨🚀

We live in a world that constantly demands more from us, making focus a rare and valuable skill. Through trial, error, and necessity, I’ve discovered practical, science-backed techniques that help manage the chaos—strategies that anyone can use. From task management frameworks like the Eisenhower Matrix to unconventional motivators (yes, bribery works), I’ll walk you through methods that help turn distractions into productivity.

But productivity isn’t just about working harder—it’s about working smarter, protecting your time, setting boundaries, and finding joy in what you do. In this talk, I’ll share both tactical strategies and deeper psychological insights into why focus is so elusive and how we can reclaim it.

Whether you're struggling with ADHD, burnout, or just an ever-growing to-do list, you’ll leave this session with actionable tools to help you work more effectively, reduce overwhelm, and maybe—just maybe—start feeling in control of your time again. 

The Art of Focus: Managing Productivity with an ADHD Brain (And Why It Matters for Everyone)

In this session, we'll explore how changes in software design can have unexpected, profound impacts. In this story-based session, I'll reference both popular and little-known "laws" of computing and life. I'll show how to use these laws to write better software. This session will give you new mental models for thinking about the tradeoffs we make in software...and life. 

The Immutable Laws of Software and Life: Code Accordingly

This talk tells the story of Computer Lib, the man behind it, and the philosophy that shaped it. It explores how Nelson’s ideas could have led to a very different digital world—one built around open, decentralised knowledge rather than the walled gardens and algorithmic control we have today. What if his vision had won? What would the internet look like if computing had followed the path of Computer Lib instead of Big Tech?

Nelson once wrote that “most authority is malignant.” This is a talk about the man who wanted to dismantle it, and the future we lost when the world ignored him.

Dream Machines and Walled Gardens

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

If you have a dataset that is even remotely connected, graph databases can be a game changer. Exploring connections, finding insights and patterns in data, evolving the schema, backing GenAI applications: these are all things that come natural in the land of graphs, and not-so-natural in relational arenas.

Join to learn the architectural differences that make graphs so efficient for networks of data, how to write queries in the Cypher language, how to model your dataset for graphs, and how to translate your relational dataset into a graph. This is a hands-on workshop!

Part 1/2: Querying and modeling for graph databases

This talk focuses on the tactical patterns with a pragmatic approach and explains how to layer your software, how to practically implement aggregates, repositories, domain services, application services and other fundamental building blocks with real-world examples and well-defined rules.
The solution structure and code samples are based on .NET and C#. 

Implementing Domain Driven Design as a Pragmatic .NET Developer

This session will explore what happens when number of applications, environments and environment types starts to reach double digits. You will learn how scaling up adds complexities and how to approach this on both team and organizational level.

NDC { Copenhagen }

Agenda

10:20 - 11:20 (UTC+02)

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

Adele Carpenter

11:40 - 12:40 (UTC+02)

Modernizing your legacy application

Nico Vermeir

Code that writes code - .NET Source generators

Glenn F. Henriksen

13:40 - 14:40 (UTC+02)

.NET Aspire Beyond the Introduction

Chris Klug

Demystifying the Enigma Machine - a Functional Journey

Isaac Abraham

Modern .NET Configuration Practices

Chris Ayers

Cross-platform development with .NET MAUI

Anjuli Jhakry

15:00 - 16:00 (UTC+02)

"Would YOU Survive the Titanic?", with ML and .NET

Simon Painter

17:40 - 18:40 (UTC+02)

Building the NDC Copenhagen Mobile App Live! with Blazor Hybrid

Gerald Versluis

Hybrid Caching in .NET

Jody Donetti

Demystifying authentication in ASP.NET Core

Tore Nestenius