The workshop is structured around the following four topics.

 the foundation for architecture/microservices and team organization, using Event Storming

mapping out the strategic importance and engineering mindset to apply in each domain guided by the business model

 modeling business processes in a language that translates directly into software architecture

 mapping out the relationships and flows of socio-technical change across domains

This workshop is designed around hands-on activities and practical techniques rather than lectures and theory, so a high-level of participation and working in small groups will be involved.

This workshop is sustainable for most people working in product and tech, particularly those who are interested in bridging the gap between business and tech. Here are some example job titles that we had in mind when designing this workshop:

Senior software engineer, principal software engineer, tech lead

Software architect, engineering manager, Head of Engineering

Product Manager, Product Owner, Head of Product

No experience of Domain-Driven Design is necessary to attend this course. No programming experience is required either.

The only real prerequisite is that you are interested in collaboratively building products and designing systems. If you are interested in the idea of connecting the dots of business models, business processes, products, and architecture then you’re welcome to attend.

This workshop will be mostly in the physical space using sticky notes and whiteboards. However, we will also be using Miro, the virtual whiteboard. We therefore recommend installing the Miro application on your laptop or tablet and signing up for a free Miro account.

If you haven’t used Miro before, you may want to spend a little bit of time learning the basic controls. The Miro Academy has some short videos to help you quickly get up to speed.

2 Days

Strategic Domain-Driven Design for Product & Tech People

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.

Code That Fits in Your Head

.NET

Architecture

This workshop will get you started on the right track and teach you all the best practices you need to know to write clean and effective unit and integration tests in .NET with C#. 

It will also introduce you to the concept of performance testing and get you started with testing how your applications perform when pushed to their limits.

- Understanding the different types of testing
- Introduction to Unit testing
- Mocking
- Fakes
- Assertions
- Creating test data at scale
- Creating realistic test data
- Testing “untestable” code
- Code coverage
- Measuring code coverage
- The value of code coverage
- Introduction to Mutation testing

- Introduction to Integration testing
- Understanding the WebApplicationFactory
- Mocking third party API dependencies
- Building test-specific environments using Docker
- Databases
- APIs
- Integration testing Web UI
- Introduction to Performance testing
- Load testing
- Stress testing
- Soak testing
- Smoke testing

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

The workshop will not focus on .NET Framework at all and will only briefly touch on front end testing.

Visual Studio 2022 or JetBrains Rider or VS Code

Docker Desktop (no need for Kubernetes to be installed)

Introduction to Effective testing in C# and .NET

Testing

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

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 Maui and explore how to efficiently build fast and fluent mobile applications using Microsofts newest take on Mobile applications.

.NET, ASP.NET Core, GraphQL, Hot Chocolate, Maui

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

Exploring reactive GraphQL clients for .NET.

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

Reactive Mobile Apps with GraphQL and Maui

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

Here are a few of the topics and techniques covered in this workshop:

Record types – What are they? How do you use them? Why?

Nullable reference types – Moving towards immutability and avoiding null reference exceptions

Asynchronous Programming – Working with Streams and best practices

Pattern matching – Writing more beautiful and understandable code

Using Span<T> - Writing fast and memory efficient code

Each topic will be thoroughly covered, followed by exercises that allow you to understand and incorporate these language features in your projects. We will talk about how the application changes, benefits and drawbacks of applying the language features.

We’ll be discussing application design, leveraging new language features and try to answer any of the questions you might have!

This is a workshop you really don’t want to miss if you’re a C# developer in 2022!



Bring a laptop with the following installed:

Visual Studio 2022, Visual Studio for Mac, Visual Studio Code, or Rider

Developing with C# in 2022

Programming Languages

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

Security

This hands-on workshop will take you through an end-to-end software lifecycle, starting with GitHub Issues and Projects for planning, GitHub Codespaces for a super efficient inner loop of development, and GitHub Actions to take your applications into production.

How to effectively plan and track your work using GitHub Issues

How to manage your projects within and across repositories in your organisation

The free and paid options for coding in the cloud, including the web editor and GitHub Codespaces

How and when to use GitHub Actions for non-CI/CD automation

Techniques and strategies for safe and effective software engineering using GitHub tooling

Techniques for effective collaboration in remote teams

Software engineers, team leads, and DevOps specialists, regardless of their level of GitHub adoption.

Any laptop with a keyboard and a browser.

In fact, you could probably get by with a tablet - it's a new world!

End-to-end DevOps with GitHub

DevOps

In this workshop, you will discover best practices for building secure APIs. We investigate various techniques to implement authentication and authorization, along with their trade-offs and pitfalls. We dive deep into handling JSON Web Tokens, but also discuss the relevance of browser security features such as Cross-Origin Resource Sharing. Additionally, we discuss current best practices for securing an API with OAuth 2.0.
This course offers practical and immediately applicable security advice for architects and developers. Throughout the course, Philippe is available to answer any questions, including concrete scenarios applying to your own applications.
Concretely, we will cover the following topics:

Modern security header configurations for APIs

Understanding Cross-Origin Resource Sharing (CORS)

Making authorization decisions with access tokens


This workshop consists of a mixture of lectures, demos, interactive quizzes, and hands-on labs. The lectures provide in-depth knowledge of attacks and defenses. The hands-on labs are conducted in a custom-built competitive training environment, allowing participants to gain hands-on experience with offensive and defensive technologies.

This security training specifically targets API developers. Anyone involved in building API-based systems or managing development teams should be here. This training course is not just any training course. It is packed with in-depth and up-to-date content. We do not merely brush over a threat and defense but focus on the underlying cause and consequences. Why do we have this problem? Which mitigations are often used? Why are some ineffective? Which one is the current best practice? These are the questions that will be answered throughout the training.

To participate in this training, you should have development experience with APIs. Familiarity with the basics of security is helpful, but not required. The training will use examples from the Spring Boot and NodeJS ecosystems, but also applies to other environments.

To participate in the lab sessions, participants need an internet-accessible laptop with a modern browser installed (E.g., Chrome, Firefox).

API security for developers

In this workshop, developers and other non-design team members can learn essentials, and walk out with some tangible techniques and skills to immediately start addressing routine app design. The session is interactive, with hands-on exercises as well as presentation of design techniques, principles, and a lightweight process for incorporating design into development. 

The focus is on interaction design and user-centric design, not aesthetics and layout. We’ll discuss how to facilitate design meetings, reach group decisions, probe user work and task flows, fit design tasks to those flows, and evaluate designs to enter production coding with fewer blind alleys, backtrack, and rework. Some exercises will be in groups – bring others on your team if you would like to experience this workshop together.

Design Thinking for Software Development Teams

Design


Why does Scrum work and what are its core principles? How are the Scrum principles different from those of more traditional software development approaches, and what is the impact?


How Scrum theory is implemented using time-boxes, roles, rules, and artifacts. How can these be used most effectively and how can they fall apart?


Scrum is different: what does this mean to my project and my organization? How do I best adopt Scrum given the change that is expected?


A system isn't just developed; it is also sustained, maintained and enhanced. How is the Total Cost of Ownership (TCO) of our systems or products measured and optimized?


Scrum Teams are self-organizing and cross-functional; this is different from traditional development groups. How do we start with Scrum teams and how do we ensure their success?


Plan a project and estimate its cost and completion date.

Predictability, Risk Management, and Reporting


Scrum is empirical. How can predictions be made, risk be controlled, and progress be tracked using Scrum.


Scrum works great with one team. It also works better than anything else for projects or product releases that involve hundreds or thousands of globally dispersed team members. How is scaling best accomplished using Scrum?

Those who will be Scrum Masters on a Scrum project, leaders, change agents, process owners, and anyone involved in helping the organization adopt Scrum.

The Professional Scrum Master course is primarily targeted at those responsible for the successful use and/or rollout of Scrum in a project or enterprise.

Attendees will be able to make the most of the class if they:

Understand the basics of project management.

Understand requirements and requirements decomposition.

Have been on or closely involved with a project that builds or enhances a product.

Want to know more about how Scrum works, how to use it, and how to implement it in an organization.

Professional Scrum Master with Certification

Scrum

Agile

In this tutorial, we will look at why asynchronous messaging is often the preferred solution to the problems of integrating and distributed solution, and look at the implementation of common messaging patterns.

If you have ever been put off moving from RPC-based solutions to messaging because of the need to learn how to implement messaging based solutions, this workshop will get you started. if you have been using messaging but want to gain a firmer understanding

The session will be a hands-on introduction and take you from simple messaging scenarios like "Hello World" through to more complex ideas like routing, brokers, and publish-subscribe.

Day 1: Messaging Architectures and Simple Patterns

Day 2: Distributed Systems Advanced Patterns

There will be hands on coding exercises in C#, JavaScript, Python and Go enabling you to implement simple and more complex messaging scenarios.


We will use Rabbit MQ for examples. You need not have the latter installed on your machine, but you should have Docker installed on your machine, as exercises will use Docker Compose.This is a Bring Your Own Device (BYOD) course. At BYOD courses delegates are required to bring their own laptop with the necessary software installed

Practical Messaging

Python

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

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

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

This hands-on workshop covers modern front end fundamentals, enabling you to create a layout and components without the need for any third-party code. You learn core accessibility concepts to make your project more accessible without having to write complex code, take shortcuts or deal with browser-specific implementations.

Once that is done, we then move on to testing our application, making sure that our accessibility improvements are there, watching for any unintended changes and making sure that the application works as it's supposed to. Through automated tools that can be implemented as part of a deployment pipeline, to manual tools to check on the fly, there are plenty of options to ensure the front end is being tested as thoroughly as the back end.

This workshop is aimed at anyone who works with front end code on a regular basis and needs to keep up to date with the constantly changing world of front end development. Even if you're just brushing up on your skills, this is the workshop for you.

Some experience with front end code desirable, a basic understanding of HTML and CSS. Some experience with JavaScript is also useful, but not essential.

NDC { Oslo }

Workshops

09:00 - 17:00 (UTC+02)

Introduction to Distributed Systems with C# and .NET

Dylan Beattie

Code That Fits in Your Head

Mark Seemann

Modern distributed systems with gRPC in ASP.NET Core 6

Mark Rendle

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

Dominick Baier

Developing with C# in 2022

Filip Ekberg

API security for developers

Philippe De Ryck

Professional Scrum Master with Certification

Maarten Hoppen

End-to-end DevOps with GitHub

Damian Brady

Michelle Mannering

Reactive Mobile Apps with GraphQL and Maui

Michael Staib

Brandon Minnick

Machine Learning from the Cloud to the IoT

Brandon Satrom

Rob Lauer

Introduction to Effective testing in C# and .NET

Nick Chapsas

Design Thinking for Software Development Teams

Billy Hollis

Practical Messaging

Ian Cooper

Front End Web Fundamentals

Amy Kapernick

Strategic Domain-Driven Design for Product & Tech People

Nick Tune