In day one, you'll see and work with a practical example of going from no code to a deployed feature.

In day two, you'll learn various techniques for keeping an existing code base clean.

This workshop is an in-person, hands-on companion to the book 

Tools and techniques for writing and maintaining a code base that fits in your head.

Developers who have suffered through a few bad projects.

C# code examples are written in a style friendly to developers working in C#, Java, TypeScript, C++, etc. Hands-on exercises are in C# on .NET Core 3.1. You don’t have to be a professional C# developer, but you should at least feel comfortable trying your hand with C#. You can get assistance during exercises, but we will not have time to cover basics of installation, compilation, syntax, and such.

You'll need a development environment that enables you to work with C# on .NET Core 3.1, a Git client, and (for some exercises) SQL Server Express. If on Windows, Visual Studio Community Edition is a great fit. In general, free versions of those application will be sufficient.

2 Days

Code That Fits in Your Head

.NET

Architecture

Once upon a time, software was simple. You built a website, connected it to a database, and you were done. Then customers started asking for APIs, mobile apps, notification emails, realtime chat… Today, cloud hosting lets us build “elastic” systems – websites that automatically scale up to handle demand; message queues and publish/subscribe patterns to handle spikes in traffic and workload without impacting your end users.

If you’re just starting out with distributed systems design, the possibilities can be overwhelming. APIs, message queueing, REST, GraphQL, gRPC… what should you choose, how does it work, how do you get started?

This workshop gives you a hands-on introduction to the most important messaging patterns used in modern application development. Using C# and .NET, we’ll build a series of small example apps and services, wire them together using these patterns, and discuss how – and when – you’d apply the same patterns in your own applications.

HTTP architectural patterns – XMLRPC, REST, GraphQL

HTTP frameworks: WebAPI, NancyFX, ServiceStack

Working with HTTP APIs: testing and tooling

Exercise: building an HTTP API client and server

Message queueing in .NET – Redis, MSMQ, EasyNetQ

Advanced architectural patterns: CQRS, event sourcing

Exercise: building a pub/sub system using .NET

History of RPC on .NET – SOAP, DISCO, WSDL, WCF

Exercise: high-performance architecture using gRPC

Integrating browsers with distributed systems

Exercise: real-time browser notifications using SignalR

This workshop is aimed at developers with some experience writing applications using C# and Microsoft .NET.

Attendees will be writing and running .NET code during the workshop, so will need a computer running Windows, macOS or Linux, and ideally install the Microsoft .NET SDK from https://dotnet.microsoft.com/download.

Exercises can be done in .NET Framework 4.6+ or .NET Core 2.0+

Introduction to Distributed Systems with C# and .NET

ASP.NET Core 6, gRPC, Protobuf, Visual Studio, .NET CLI, Docker, Kubernetes, services meshes, monitoring, distributed tracing

Day 1: Building gRPC applications in ASP.NET Core

Day 2: Security, Deployment and Observability

Service mesh (using Linkerd as an example)

Attendees will be expected to be familiar with .NET and C#.

Bring a laptop with the following installed:

Visual Studio 2022 or JetBrains Rider EAP or VS Code

Modern distributed systems with gRPC in ASP.NET Core 6

The class is a combination of lectures, security testing demonstrations, code review, and interactive threat modeling discussions. Students will learn the most common threats against applications. More importantly, students will learn how to code secure software via a variety of techniques such as secure design practices, defense-based coding, the use of security libraries and services, and the use of a variety of web security standards.

As part of this course, we will explore the use of third-party security libraries and frameworks to speed and standardize secure development. We will highlight production quality and scalable controls from various languages and frameworks including Java, PHP, Python, Javascript, and .NET, but any developer building web applications and webservices will benefit from this class.

Familiarity with the technical details of building web applications and webservices from a software engineering point of view.

Any laptop that can run an updated web browser and "Burp Community Edition".

Day 1 of the course will focus on web application basics.

Introduction to Security Goals and Threats

Day 2 of the course will focus on API secure coding, Identity, and other advanced topics.

Webservice, Microservice, and REST Security

The course will include several hacking and secure coding labs!

Building Secure API's and Web Applications

Security

Multi-platform, multi-client, and highly-mobile users bring a new set of challenges, so the approaches of the past are no longer appropriate for modern applications. This two-day workshop is your chance to dive into all things security related to these new technologies. Learn how to securely connect native and browser-based applications to your back-ends and integrate them with enterprise identity management systems as well as social identity providers and services.


.NET Core, ASP.NET Core, MVC, Web APIs, Claims, OpenID Connect, OAuth 2.0, WS-Federation, SAML, JSON Web Tokens, Single Sign-on and off, Federation, Delegation, Home Realm, Discovery, CORS

Social Logins (e.g. Google, Facebook, Twitter, etc.)


Attendees will need to bring a computer with the latest .NET Core SDK and the IDE of your choice (e.g. Visual Studio) installed.

Identity & Access Control for modern Applications and APIs using ASP.NET Core 6

If this sounds familiar, then this workshop is for you. We cover both the theory and patterns of Domain-Driven Design, and connect it to code with hands-on examples in .NET 6.

Where DDD fits in to software delivery and what business problems it addresses

How to craft and enforce a ubiquitous language

The role of refactoring in shaping and reshaping our model

How to define bounded contexts and microservices

Realizing a pragmatic implementation with ASP.NET Core 6 and EF Core 6

We spend day 1 on the theory and concepts of DDD and day 2 applying it to a real-world, complex example with hands-on code exercises.

Attendees will need to bring a laptop with the following installed:

Visual Studio 2022 Professional or higher

Domain-Driven Design: Theory and Practice

Microservices

In this workshop, we will introduce you to GraphQL and the major concepts behind it. We will look at how to build a GraphQL server with ASP.NET Core 7 and Hot Chocolate. You will learn how to query GraphQL and what tools are out there that can help you explore and manage large schemas. Further, we will dive into React and explore how to efficiently build fast and fluent web interfaces using the JavaScript client Relay.

.NET, ASP.NET Core, GraphQL, Hot Chocolate, React, Relay

GraphQL client ecosystem in .NET and JavaScript (Apollo vs Relay)

You will need basic knowledge of .NET and JavaScript.

Also, you will need a computer with the .NET 7 SDK, Nodejs LTS, and Visual Studio Code.

Building Modern Apps with GraphQL in ASP.NET Core 7 and React 18

React

The problem is, leveraging ML with IoT has historically meant backhauling all your sensor data to the Cloud. When the cloud is involved, security is a concern, and in the realm of IoT, security is often a dirty word.

In this workshop, you’ll learn how to leverage the power of Machine Learning on Edge Devices and build secure, cloud-independent IoT applications.

Section 1: The Basics of Machine Learning

Session 2: ML models for Complex Data: CNNs and LSTMs

Lab 2: Building a CNN for Image Recognition

Session 1: Introducing the Blues Wireless Ecosystem

Session 2: Working with Sensors and Actuators to collect data

Session 2: ML at the Edge with Single Board Computers (SBCs)

Lab 2: Building ML Models for Edge Inferencing

Session 3: ML at the Edge with Microcontrollers (MCUs)

Lab 4: Building ML Models for Microcontrollers

Session 4: What's next for ML on the Edge?

Lab 1: Hacking Challenge and Free Exploration

Edge Impulse CLI (npm install -g edge-impulse-cli)

Chromium-based web browser (e.g. latest version of Chrome, Edge, Brave)

Set up a free account on Blues Wireless Notehub @ 

Set up a free account on Edge Impulse Studio @ 

Machine Learning from the Cloud to the IoT

Machine Learning

Cloud

Join Scott Hanselman as he walks you through the state of the art of Linux on Windows. What's possible, what's not, what about the Windows Terminal and Docker? Tons of lives demos in this highly technical session.

Talk (60 min)

Developing for Linux on Windows with WSL and Windows Terminal

Linux

In this talk we will learn how async is implemented, see what problems it creates, and explore other possible approaches. We will reimplement some of its features with monads, coroutines, and fibers to see how it could look like in an alternative world. We'll see if we can do better than the thread-pool based approach.

This is loosely related to project Loom in JVM world which explores fibers to improve threading.

Implementing async with coroutines and fibers - project Loom in C#

Concurrency

Choosing the right partition key for your Azure Cosmos DB containers is an important task. In the first half of this session, I will explain how Physical and logical partitions work in Azure Cosmos DB.
We will explore the importance of indexing data properties. This step is critical in Cosmos DB just like many other databases. You can easily reduce your Azure Cosmos DB bill by indexing the right properties of your data. In the second half of this session, we will focus on expanding upon available index types of Cosmos DB. I will explain how to handle Indexing policies to include or exclude data properties.
Please join me as I share how to develop affordable, scalable, and fast Azure Cosmos DB solutions.

Cost cutting strategies for Azure Cosmos DB

Database

With fifteen years in IT and a successful career as a world-class infrastructure engineer, a speaker at many industry conferences, a blogger, analyst and technical marketing freelancer for Silicon Valley Startups and a CTO of a 1200+ infra and software engineering company, I can definitely say I suffer from impostor syndrome, and by extension, perfectionism.

And it doesn’t go away with success. The opposite seems to be true, actually. I’ve learned to harness it, spending a lot of time way out of my comfort zone to figure out how to come to terms with it and use it for good. Maybe the fact that I experience the syndrome makes me more humble, which makes me more valuable as a leader.

I’m here to show the little things I did differently every day:
1.	How being kind to yourself is key. Forgive, don’t judge. Accept who you are.
2.	Learn about your internal convictions and expose these to the world authenticly and honestly.
3.	How complimenting yourself and others goes a long way
4.	Build a case for yourself by keep notes of people saying nice things about you
5.	Self-doubt is a powerful tool as a leader, if used consciously
6.	Focus on (professional) relationships, not on technical merit
7.	Harness feedback, even it’s scary

With these small, incremental improvements, I now live in a self-inflicted, perpetually non-existing comfort zone. I’m constantly in the imposter zone, because I’m constantly doing new things, learning new skills, meeting new people. And I love it! It has brought me many smaller and larger victories, a career that’s led me to new and unexpected ventures and most importantly, a network of friends and relationships I otherwise would never have had.

Come listen to me, I’m a fraud! A story on success, impostor syndrome and self-inflicted, perpetuall

How do you surface a definition that describes your event driven API

What declares your topics and queues, consumer of CD pipeline?

What if you don't want someone to use your events?

How do you avoid breaking downstream consumers?

In this talk we will look at solutions to these problems. We will review emerging standards such as CloudEvents, and AsyncAPI and understand how we might use them. We will look at the role of CDC in helping us with versioning, and the tooling around we can use for that. We will look at the concept of a message registry and how it can help you understand the interactions in your estate. We will look at ways that we can use Logging and Monitoring tools to understand what is happening to your messages. Finally, we will look at how you determine the number of consumers that you need.

Managing Event Driven Architectures

Continuous Delivery

DevOps

In Chapter 8 of the original DDD book, Eric Evans talks about making a big domain breakthrough after a long New York winter of refactoring on an inherited legacy codebase.

Eric's story emphasises the importance of models and modelling breakthroughs. I'd like to re-visit this story and show you how many of the insights are still highly relevant to modern software development... possibly even more so.

Share Pie: The DDD Treasure Hidden in Plain Sight

Design

Soft Skills

In this workshop, you will work through scenario-based activities in groups. Each scenario will provide the design of one or more Bounded Contexts as Bounded Context Canvases. In small groups, your challenge is to review the design by identifying the positive and negative design choices, and flagging up areas of the design that need further attention. You will also refine and create Bounded Context Canvases to fix some of the design problems you identify.

After this workshop, you will know how to visualise the design Bounded Contexts and you will know how to critique a design and explore alternative modelling choices.


Part I - Advanced Bounded Context Design With The Bounded Context Canvas

In this session we take a deep-dive into Azure Machine Learning, a cloud service that you can use to track as you build, train, deploy, and manage models. We use the Azure Machine Learning Python SDK to manage the complete life cycle of a PyTorch model, from managing the data, to train the model and finally run it into a production Kubernetes cluster.

At the end of this session you have a good grasp of the technological building blocks of Azure machine learning services and train a PyTorch model on scale.

Build and deploy production ready PyTorch models

Microsoft

With the new spec release, GraphQL strengthens its type system with more capable interfaces and allows for pipelining features through repeatable directives. Moreover, we are finally getting support for @stream and @defer in modern GraphQL Servers that take full advantage of async iterators.

This talk will explore how to take advantage of these new capabilities and how to build a next-generation mobile-first, cloud-first GraphQL backend with the revamped ASP.NET Core 6 web stack.

Building modern applications with GraphQL 2021 and beyond in ASP.NET Core 6

This talk will cover my frameworks & workflows to bring together technical knowledge with communication, problem solving and creativity to reach business outcomes with AI/ML and Data.

For extra context, we'll also apply these frameworks to some real-world use cases from Blackbook.ai, so the audience can understand how to put things into practice.

Realities & Misconceptions about Enterprise Applications of AI/ML and Data

Big Data

We will walk through the whole process! Starting from writing and debugging your Blazor app and Functions API, we will also unit test our front and back-end and glue them together with the authentication service emulator for local development. For CI/CD and service management needs, like staging environments and user invitations, we will conclude with a scalable build pipeline that can be flexibly reused for your future projects!

Come to this talk when you want to improve your development process with the best tooling and focus on the business value of your app!

Developing and Deploying a Static Web App with Blazor and Azure Functions

Serverless

Tools

In this session, Laurent Bugnion, a Cloud Advocate working with Microsoft will share his recent journey discovering the basics of Deep Learning. We will not make data scientists out of you, but we will enable you to understand what people talk about when they mention artificial intelligence. We will see how Azure can help you with tools, services and machines. Last but not least, we will also have a discussion about the ethics of AI and what we should be careful about.

A gentle introduction to Deep Learning

In this session, we will demonstrate use of latest functional additions to C# - records, tuples, deconstruction, nullable reference types, LINQ, extension methods, and a few others - which will be integrated with object-oriented and even procedural elements into a unified design which effectively solves a practical problem.

Mixing Paradigms Using the Latest C# Language Features

Functional Programming

In this talk we will go through our learnings of doing Open Source at a company with thousands of engineers. The focus will be primarily on producing open source software rather than on using it.

How we improved the open-source release cycle from almost a year to a few days

Providing an on-road experience for Open Source across the company

Moving from 10+ GitHub organisations to a single one

Why your legal and security counterparts are your friends and how you can best work with them

Open Source at commercial organisations

Open Source

planed the new system so that it fully replaced all old ones, leaving no holes;

were at any time sure what would be the next piece of software that we need to develop;

released new functionality in small portions that were immediately taken in use without necessity to wait for some other piece to be ready;

met the deadlines in spite of additional complications caused by the pandemics.

This was not just luck. It was the result of application of a methodology that ensures this very result: product that covers end-to end flow, minimal releases and clear priorities. In this case study I will show how this methodology works.


Change wings on the fly: replace a system that handles 50 million euro turnover with zero downtime

Things can be in many states at once (superposition), objects can instantaneously affect each other or we can even teleport their state (entanglement), objects can behave as both particles and waves (wave-particle duality) and probabilities appear to be built into the very fabric of reality. In this talk, we will explore these bizarre concepts of quantum mechanics using quantum programs authored in Q# and a computation theory fundamentally different from what we know from regular computers.

The Bizarre Quantum World with Q# and Azure Quantum

In this code-focused tour, we’ll systematically analyze the test scenarios we want to build, then live-code mocks in two scenarios: Express and Vue. It’s easy to gain value and speed once you know how.

Mocking in Front-end and Back-end TypeScript Tests

JavaScript

Testing

While many Open Source projects have amazing code-bases, the Readme and documentation are letting them down and as a result, they are losing influence and opportunities for adoption and feedback.

In this talk, Ben uses his expertise in building an Interactive Learning Platform to highlight The Art of Documentation and the Readme file. The aim of the talk is to help open source contributors understand how small changes to their documentation approach can have an enormous impact on how users get started.

Defining technical details in an accessible way

Building documentation that encourages users to get started

How to manage documentation and keep it up-to-date and relevant

In the end, attendees will have an understanding of how to build beautiful, useful documentation. This will be backed by examples from some of the best open-source projects.

The Art of Documentation and Readme.md

Programmable Software Architecture

These modern applications typically also need authentication and single-sign-on as well as token-based security for calling APIs – in other words OpenID Connect and OAuth 2. There are different patterns for securing such applications and this session covers some of the pitfalls of the various approaches, especially given the ever-changing browser landscape. We will conclude with the “backend for frontend” (or BFF) pattern which has become the most secure and stable of these approaches.

Securing SPAs and Blazor Applications using the BFF (Backend for Frontend) Pattern

This talk looks at the essentials you should know about, if you would enter the OAuth ecosystem today. Which protocol flows and extensions should you study, which “dialects” like OpenID Connect are important, and if you decide to dive deeper, what would that “recommended reading” list look like?

OAuth – the good Parts

You can decrease the time you waste reading complicated code by writing code that's easy to read - code that fits in your head.
Code should fit in your head at all levels of abstraction. At the entry point, at the business logic level, and at the lowest levels of detail. This is fractal architecture - code that is organised according to that principle of self-similarity.
Key to achieve fractal architecture are encapsulation, aggressive thresholds, and referential transparency. Code examples will be in C# - written in a style also readable to developers working in Java, TypeScript, C++, etc.

Fractal architecture

Cross-Platform

The impact open source can have on your applications

Examples: Obviously everyone is talking about Log4j but there may likely be more examples by April

How to choose the best open source package

Known vulnerabilities (and the severity thereof) - where there’s smoke there’s fire. 

Nested dependencies and the trouble they can cause

Secure Open Source Practices

And if you are dabbling in the hardware space, you can also use Python to power your low-power, embedded, and IoT projects, be it Python on a Raspberry Pi, or MicroPython and CircuitPython on inexpensive microcontrollers connected to sensors, screens, buttons, and more. As Python grows in popularity overall, the Python on devices world is pushing the pace, with new Python-compatible devices coming online every day. The latest, the Raspberry Pi Pico is a $4 device with MicroPython support baked in. It's never been cheaper, or easier, to build physical projects with Python!

In this session, we'll explore the world of Python on devices and look at ways to use it with single-board computers like the Raspberry Pi, microcontrollers like the Pico and ESP32, and even how to build IoT solutions with cellular connectivity in your Python-based projects. By the end, you'll have everything you need to build your own powered devices.

Exploring the Wonderful World of Python on Devices

Python

In this session, we'll look at anemic, procedural, boring code and examine code smells that can point us in the right direction. We'll also look at standard design patterns for more complex behaviors and models, and how to recognize when (and when not) to apply them. Finally, we'll cover how to safely apply refactoring techniques to achieve our domain-driven model nirvana.

Domain-Driven Refactoring

What's the difference between mentorship and sponsorship and how does that build successful teams? What's the role of the senior engineer as a colleague to an early-in-career engineer? What's the difference between learning how to code and learning how to think about systems? What must we do to welcome the next generation of creators, and what are your responsibilities? 

Let's facilitate a welcoming culture of learning and exploration and normalize not knowing the answer!

Keynote: Building Teams Through Systems Thinking and Stories

This technical talk will discuss the requirements analysis, and dozens of decision points that need to be made to move this into a sustainable future. We will discuss the complexities of moving legacy systems into the cloud, considering operating systems, platforms, open source code, testing, DevOps, and much more.

Moving 17 years of old legacy code and sites into the Cloud

This talk provides defensive instruction in relation to the OWASP Top Ten to aid developers in authoring secure software.

-Identification and Authentication Failures


-Security Logging and Monitoring Failure


The OWASP Top Ten 2022 Release

In this talk we'll address new defensive strategies such as modern JavaScript framework defense in Angular, React, Vue and other frameworks. We'll also look at how CSP deployment has changed in the past 7 years illustrating the progressive use of content security which supports CSP v1, v2 and v3 concurrently. 

We will then look at advances in HTML sanitization on both the client and server and focus on sanitizers and defensive libraries that have stood the test of time in terms of maintenance and security. We'll also look at interesting design topics such as how HTML injection is still critical even in the face of rigorous XSS defense, how HTTPOnly cookies are largely ineffective, and how Trusted Types is making your favorite frameworks more secure. 

NDC { Porto }

Agenda

09:00 - 10:00 (UTC+01)

Keynote: Building Teams Through Systems Thinking and Stories

Scott Hanselman

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

Programmable Software Architecture

Scott Haney

Secure Open Source Practices

Jillian Ratliff

A gentle introduction to Deep Learning

Laurent Bugnion

Part I - Advanced Bounded Context Design With The Bounded Context Canvas

Maxime Sanglan-Charlier

Nick Tune

The OWASP Top Ten 2022 Release

Jim Manico

The Art of Documentation and Readme.md

Ben Hall

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

What’s next for Blazor, and .NET on WASI

Steve Sanderson

Mocking in Front-end and Back-end TypeScript Tests

Rob Richardson

Build and deploy production ready PyTorch models

Henk Boelman

Part II - Advanced Bounded Context Design With The Bounded Context Canvas

Maxime Sanglan-Charlier

Nick Tune

Implementing async with coroutines and fibers - project Loom in C#

Adam Furmanek

OAuth – the good Parts

Dominick Baier

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

Fractal architecture

Mark Seemann

Managing Event Driven Architectures

Ian Cooper

Securing SPAs and Blazor Applications using the BFF (Backend for Frontend) Pattern

Dominick Baier

Exploring the Wonderful World of Python on Devices

Brandon Satrom

Change wings on the fly: replace a system that handles 50 million euro turnover with zero downtime

Tatiana Kolesnikova

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

Developing for Linux on Windows with WSL and Windows Terminal

Scott Hanselman

Developing and Deploying a Static Web App with Blazor and Azure Functions

Matthias Koch

Building modern applications with GraphQL 2021 and beyond in ASP.NET Core 6

Michael Staib

Realities & Misconceptions about Enterprise Applications of AI/ML and Data

Brooke Jamieson

Come listen to me, I’m a fraud! A story on success, impostor syndrome and self-inflicted, perpetuall

Joep Piscaer

16:20 - 17:20 (UTC+01)

Domain-Driven Refactoring

Jimmy Bogard

What's new in C#? Exciting new features in C# 8.0, 9.0 and 10!

Filip Ekberg

Cost cutting strategies for Azure Cosmos DB

Hasan Savran

The Last XSS Defense Talk

Jim Manico

Mixing Paradigms Using the Latest C# Language Features

Zoran Horvat

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

Moving 17 years of old legacy code and sites into the Cloud

Scott Hanselman

Looking Back - The Last Twenty Years of Software Development

Richard Campbell

Share Pie: The DDD Treasure Hidden in Plain Sight

Nick Tune

Open Source at commercial organisations

Nikos Katirtzis

Daniel Albuquerque

The Bizarre Quantum World with Q# and Azure Quantum

Filip w