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.

2 Days

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

.NET

Security

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

Architecture

Applied individually, these patterns are useful, but are not giving you the full potential of Domain-Driven Design.


This training has a different approach. We address technical concerns in implementing the DDD patterns, but the focus is on the underlying principles and heuristics for building great domain-centric object-oriented code.


Seeing objects as containers of lifecycles and consistency

Discovering deeper domain concepts such as business rules, and lifting them into first class domain objects

The relevance of processes, behaviour, temporal modelling... for finding better Aggregate boundaries

How mutable software designs have distorted our perception of mutability in the domain

Better heuristics for understanding a complex domain, and using them to drive a more focused design

Reducing our dependence on service classes

Designing an implementation model that not only encapsulates the domain, but communicates that design to future programmers and reduces their surface area for bugs

This workshop, aimed at programmers, is designed to give you immediate benefits when modelling and implementing the most important parts of your codebase.

The workshop is programming-language agnostic. You are expected to have some experience working in an object-oriented language, and have some notions of object-oriented design patterns and principles.

DDD Design Patterns

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

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

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

You will walk away with an understanding of how Functions are made, what their inner components are, and how you can use them quickly and efficiently in your own projects. Also, learn to use Cosmos DB, and then connect it all together to get some llamas.

Using Azure Logic Apps to connect services

Deploying and configuring a Cosmos DB database

Connecting services on Azure using best practices

Understanding Azure security best practices


Developers with 1+ years’ experience that want to understand what serverless is and how it works with Azure applications.
Developers that want to get an insight into using Azure and cloud computing.



Azure Serverless Development

Azure

Serverless

Technologies like React, GraphQL and Relay play a tremendous role in shifting not only the way we build apps but also how we write code.

If you’re new to this ecosystem, don’t panic! I’ll share with you some tips and walk through some hands-on examples to show you how easy it is to get started and open a world of possibilities.

Talk (60 min)

Powering the Front-end with React, GraphQL and Relay

Front-end

JavaScript

When you publish your first HTTP API, you’re more focused on short-term issues than planning for the future. However, chances are you’ll be successful, and you’ll “hit the wall”. How do you evolve your API without breaking the contract with your existing users?

In this talk, I’ll first show you some tips and tricks to achieve that: moving your endpoints, deprecating them, monitoring who’s using them, and letting users know about the new endpoints. The talk is demo-based, and I’ll use the Apache APISIX project for it.

Evolving your APIs, a Pragmatic Approach

DevOps

Luckily, there has been much progress towards making our lives as developers a bit easier. This is done by allowing us to concentrate on writing code, instead of causing us headaches from all aspects around hosting, deployment, and management.

In this demo-rich session, we are going to build a real-time stock monitoring system using a serverless React App backed by the power of various Azure features. You will learn how to process documents from Azure Cosmos DB Change Feed, and then broadcast this newly received data to our client, all by using out-of-the-box Azure Functions bindings for Cosmos DB and SignalR.

Going real time using Azure CosmosDB and React

 - Fun/inspirational talk (more info coming) on the main stage


 - Fun talks, food and drinks continue at Vestauranten

Half-Day

NDC Party

If you’re wondering how to develop a data model with document databases (or if it's even necessary!), or wondering how to leverage its flexibility (rather than be hindered by it), wonder no more! In this session, we'll:

- Examine a methodology that helps us develop a data model using document databases.
- Put the methodology we learn into practice by walking through a use case, phase-by-phase.
- Understand not only HOW to develop a model, but WHAT to model for, including the tradeoffs of each option.

At the end of this session, you’ll leave understanding the best practices for developing a document data model and be confident in your ability to continuously improve it as your application evolves!

The Developer's Guide to Data Modelling with Document Databases

Have you ever thought "I really love dealing with this ginormous node_modules folder." No, and no one else has either! With Yarn Berry and PnP you can forever be free of node_modules. PnP dispenses with the node_modules folder entirely and creates an opportunity for perfect module resolution, faster startup, and instant package installs. Imagine cloning a node app and running it immediately, no install step required. With PnP and Yarn Berry, this dream is a reality.

Come away with an overview of all the new features and the knowledge you need to migrate your app to Yarn Berry.

Yarn Berry: a next generation package manager

One of my pet hates is writing enhancements that involve copying and pasting blocks of code, changing a variable name, then leaving everything else the same. I hate having to consider each and every possible null reference exception, and adding in a whole ton of boilerplate to handle it. I hate having to spent ages jumping back and forth in a legacy codebase, trying to understand what it actually does!

What's the alternative? In this talk, I'll demonstrate a way of working that avoids all this unneccesary work, and gives you more time to do something more productive.

We'll look at:
* Functional Programming - what benefits does this increasingly popular paradigm bring us to cut down coding effort
* Linq & Generics - These have been a part of C# for a long time now, and are some of the most powerful features available in the language, but hardly anyone seems to be using them effectively
* MetaProgramming - break open C# and take it to the next level with code that describes how to generate code

Our goal is to write code in as few lines as possible that provides the greatest amount of impact. We also want code that's readable, and easily maintainable. We want to think smart, and think...Lazy.

Hacking C#: Development for the Truly Lazy

Traditional computer science education focuses on algorithms and languages while largely ignoring the human aspect of software and the sociology of organizations. Fear not friends, there are patterns and approaches that can help you win trust quickly, create allies, set expectations and effectively communicate during the ups and downs of project life!

Dodging the pitfalls of software implementation can be taxing. How do we navigate the existing social complexity and interpersonal dynamics found in every organization? How do we earn trust, maintain rapport and turn clients into advocates? This talk will explore the challenges of building and maintaining software using examples from within and beyond the software industry to help give you the tools to chart a path to more than just a successful launch but a team that speaks highly of the journey.

Codezillas: The Universal Truths of Building Trust

Domain Storytelling (www.domainstorytelling.org) means that we let our users tell us stories about their work. While listening, we record the stories using a pictographic language. The experts can immediately see if we understand their story. After very few stories, we understand the language of our users and find different areas of the domain. Each of these areas (called a subdomain) is a good candicate to become a microservice in our architecture.

In this talk I show how to find subdomains and which heuristics can help us.

Carving Microservices out of the Monolith with Domain Storytelling

In this session, we will walk you through the design decisions of our Azure infrastructure during the last years. We will start by discussing the flaws and challenges of our early architecture before we introduce our current setup of immutable infrastructure and why we are still not happy. Finally, you will learn why and how we favor a multi-cluster architecture in Azure.

The target audience is Azure administrators and architects who want to learn from Vipps' experiences with Azure services, in particular AKS. We assume that you have some basic understanding of Azure and Kubernetes.

Stretching for Zero Downtime Upgrades in Azure.

Continuous Delivery

Microsoft

You can schedule services or make them more resilient with task queues. You can even combine serverless orchestration with serverful services. In this talk, we’ll look at the serverless landscape beyond simple functions and explore some patterns that help with serverless applications.

Serverless landscape beyond functions

Microservices

Over the last two years, GraphQL has become more and more mainstream. The ecosystem has grown phenomenally, and major players like Amazon, Twitter, Facebook, and more are all committed to GraphQL.

But what is GraphQL? What are the benefits of using GraphQL it instead of REST?

Together, we will look at the core problems that we are facing with the traditional REST service layers, which still power most of the Web.

After we have a better understanding of GraphQL, we will explore how we can build a GraphQL API with Hot Chocolate on ASP.Net Core. We will look at Prisma filters and how we can get your existing infrastructure under this new service layer. We will merge data from different sources like you did not think was possible by using the power of the GraphQL resolver concept.

Getting started with GraphQL in .NET

This is an introduction to 4 valuable mapping techniques and models that build clarity, alignment, and confidence in teams using a combination of collaboration, visibility and measurement.

I'll introduce 4 powerful maps: Outcome, Value Stream, Dependency, and Capability, that you can co-create with your teams to uncover hidden insights and opportunities. I'll show you how to take those insights and create a powerful roadmap of actions and experiments to dramatically improve flow and deliver continuous value.

Flow Engineering builds on the lean practice of Value Stream design and improvement as a framework of techniques you can use right now to reveal your biggest opportunities to eliminate hours of friction every week, so you can invest in what's next.

Use it to improve your:
- Development process
- Planning and shaping
- Delivery/Data/Testing/Analytics/Logging Pipeline
- Employee/Customer Onboarding
- Support/Failure Recovery/Incident Management
- Workflow of choice
…and start spending more time on what's next

Flow Engineering - Boost velocity, quality and happiness through your entire value stream

Agile

Fortunately, some other teams recognized the value of applying the Small Batches idea from Lean to the PRs.

But, what if I told you that teams doing small PRs with async code reviews, actually have way lower throughput than teams doing big PRs?

I got this surprising systemic insight by analyzing tens of thousands of PRs across a bunch of repositories.
On the bigger PRs side of the spectrum, we tend to lose quality, while on the smaller PRs end of the spectrum we lose throughput. We're forced to make a trade-off between speed and quality.

But! There's a parallel universe of ways of working where you get to have your cake and eat it too. Where you can have both throughput and quality. Universe called co-creation patterns (Pair and Mob programming).

Join me on a journey where I'll show you the data invalidating the assumption that two or more people sitting at the same computer will hurt team's throughput and why the opposite is actually the case.

Async Code Reviews Are Killing Your Company’s Throughput

Much of this is because C# developers are spoiled with a great language and smart IDEs, and they don't like missing their buddy for code-completion, ease of debugging, refactorings, and code formatting. NUKE brings your build automation to an even level with every other .NET project. How? It's a regular console application allowing all the OOP goodness! Besides, it solves many common problems in build automation, like parameter injection, path separator abstraction, access to solution and project models, and build step sharing across repositories. To conclude your build revolution, NUKE can generate CI configurations (YAML, etc.) that automatically parallelize build steps on multiple agents to optimize throughput!

Come to this session to make your build scripts loveable!

Build Automation Revolution with NUKE

Tools

The Cloud and the emergence of micro-services pose two challenges to the Selenium Grid based solution for concurrent execution of UI automation tests. Having to keep a tab on the cost of Cloud is also another challenge faced.

First one is, in the world micro-frontends, teams want to run all UI automation tests they have for a project, against every deployment of their Git branches (as part of validating a Pull Requests before they are merged). This problem is multiplied by the number of micro-frontends an organisation has.

Speed will be an important factor in the pre-merge pipeline(Shift Left) as described above. Speed here is the speed of the feedback cycle. What was acceptable last year, is no longer acceptable this year. Hence the speed of the feedback cycle, which is the total time taken, starting from a commit to a Git branch triggering the pipeline, deploying it to a fully stack environment, run UI automation tests against the deployed stack, delete the full stack environment and ends with the availability of the automation results for the said branch.

Hence for the first problem, Kubernetes with Docker and Helm will be the most suitable for pre-merge pipelines.

Regarding cloud cost optimization, Kubernetes gives the flexibility to fine tune CPU/Memory individually at Pod level.

The Kubernetes, Docker, Traefik and Helm based solution will fix all the identified problems above – on demand unique grids per pre-merge pipelines, faster creation/deletion of hubs/nodes, accessible from anywhere, more cost optimized compared to pure EC2.

My talk is about describing the above problem and how I have implemented the solution. I’ll share all the learnings I had when implementing this solution. For example, how to fine tune the CPU and Memory per browser Pod. How to configure CPU/Memory for small scale hubs which will run less than 100 test vs for hubs that will run 300 tests or more in parallel.

Selenium Grid using Kubernetes, Docker, Traefik and Helm will be useful to many companies who are planning to or in the midst of moving to Cloud, so they can have a long term solution and learn from our journey.

Kubernetes and Selenium Grid for highly scalable browser and device farm

Concurrency

Cross-Platform

Docker

Mobile

Testing

What should be our first, second, and third steps to lay a foundation of success when transitioning from ideation to implementation. Attendees will learn from engaging stories, discussion, and fun activities practical with action focused debreifs - ways to implement great ideas into your organization.

Attendees will:
- Gain understanding about the trends and cycles of effective team implementation
- Learn how to effectively lead change initiatives by addressing challenges in logistics, resources, and team dynamics.
- Engage in a series of action focused activities related to specific ideation projects
- Walk away with a action plan in hand to successfully go from ideation to implementation

How to Effectively Move from Ideation to Implementation

In this talk, James explores the relationships between team structure, software architecture and the emergent phenomenon of complexity science.

Keynote: Software Architecture, Team Topologies and Complexity Science

When you work in software, you spend your life working with text. Some of those text files are source code, some are configuration files, some of them are documentation. Editors, revision control systems, programming languages - everything from C# and HTML to Git and VS Code is based on the idea of "plain text files". But... what if I told you there's no such thing? When we say something is a "plain text file", we're relying on a huge number of assumptions - about operating systems, editors, file formats, language, culture, history... and, most of the time, that's OK. But when it goes wrong, "plain text" can lead to some of the weirdest bugs you've ever seen... why is there Chinese in the event logs? Why is the city of Aarhus in the wrong place? And why does Magnus Mårtensson always have trouble getting into the USA? Join Dylan Beattie for a fascinating look into the hidden world of text files - from the history of mechanical teletypes to encodings, collations and code pages. We'll look at some memorable bugs, some golden rules for working with plain text - and we'll even find out the story behind the mysterious phrase "pike matchbox" and what it has do with driving in Belarus.

Plain Text

In this talk, you will learn how to bring the power of Tailwind CSS to your Blazor applications. We’ll start off with an introduction to Tailwind and how it differs from other CSS frameworks. Then we’ll get into some code and see how we can integrate Tailwind with Blazor. For the rest of the time, we’ll explore the various features of Tailwind and see how just how beautiful we can make our Blazor app!

Building beautiful Blazor apps with Tailwind CSS

But there’s more to building reliable systems than just writing good code. Reliability isn’t just about software engineering, it’s about systems engineering; about taking a holistic view of services that includes software, hardware, networks, and people. 

Join Dylan Beattie for an insightful look at the history of systems engineering, at some of the strategies and design patterns that we can use to build reliability into our systems, and at what happens when the software that runs the world has a bad day.

Failure is Always an Option

Where Lucene comes into play and where you run into it like with segments

Node balancing (CPU vs. storage) and lifecycle management

Node types like data nodes, ingest nodes / coordinating nodes

Scaling for memory / throttling and how to benchmark it

Common tuning options like the refresh_interval

Elasticsearch Under the Hood

Big Data

Database

These days, few things get me more excited than writing code that can control something, anything, in the physical world. Whether it’s gathering temperature data from a sensor, remotely controlling a servo, or building a low-power Machine Learning solution, it’s empowering to write Arduino or Python code to build a connected IoT project.

But I've always had this nagging feeling, like how I’d prefer to use the languages, IDEs, and skills I've honed during my years as a .NET developer. Enter the world of the "tiny" .NET frameworks! Using the .NET nanoFramework or TinyCLR, we can build low-power apps on constrained devices like tiny microcontrollers, using the same C# and Visual Studio we know and love.

In this session, we’ll walk through the tiny .NET frameworks, blink some “Hello World” LEDs, and see examples of how .NET developers can build connected applications for the Internet of Things.

.NET Developer? You're an IoT Developer Too!

From a conceptual point of some of these concepts are relatively easy to understand, but as always, the devil is in the detail.

In this session we will look at some of the challenges you will encounter _before_ you get to the cool algorithms of machine learning.

Can you calculate an average? Do you know what conditional probabilities are? And why does the earth have to be round?

Machine Learning in the Real World

People

The way we do software design is different. It’s non-linear. By designing solutions, we learn to understand the problem. Through domain modelling, we look for novel abstractions, new metaphors, new solutions that reframe the original problem in a way that makes it solvable.

In this talk, I’ll tell stories from working on real world cases, like smart copyright claims systems and oil rig monitoring systems, to illustrate how with a richer understanding of the design process, we can create better solutions.

Design & Reality

In this talk, I will explain and demonstrate some of the many options you have in Azure for testing every part of your development life cycle. I go through everything from A/B testing to performance testing to architecture testing, all sprinkled with animal photos.

NDC { Copenhagen }

Agenda

09:00 - 10:00

Keynote: Software Architecture, Team Topologies and Complexity Science

James Lewis

10:30 - 11:30

Hacking C#: Development for the Truly Lazy

Simon Painter

Evolving your APIs, a Pragmatic Approach

Nicolas Fränkel

Flow Engineering - Boost velocity, quality and happiness through your entire value stream

Steve Pereira

The Developer's Guide to Data Modelling with Document Databases

Adrienne Braganza Tacke

11:50 - 12:50

Build Automation Revolution with NUKE

Matthias Koch

Carving Microservices out of the Monolith with Domain Storytelling

Henning Schwentner

Machine Learning in the Real World

Karsten Strøbæk

Stretching for Zero Downtime Upgrades in Azure.

Sven Malvik

13:40 - 14:40

Plain Text

Dylan Beattie

Building beautiful Blazor apps with Tailwind CSS

Chris Sainty

Async Code Reviews Are Killing Your Company’s Throughput

Dragan Stepanović

Powering the Front-end with React, GraphQL and Relay

Martin Artola

15:00 - 16:00

Getting started with GraphQL in .NET

Michael Staib

Kubernetes and Selenium Grid for highly scalable browser and device farm

Ragavan Ambighananthan

Elasticsearch Under the Hood

Philipp Krenn

.NET Developer? You're an IoT Developer Too!

Rob Lauer

16:20 - 17:20

Codezillas: The Universal Truths of Building Trust

Nathaniel Schutta

Whitney Lee

How to Effectively Move from Ideation to Implementation

Amber Vanderburg

Serverless landscape beyond functions

Mete Atamel

Who tests their cloud code anyway?

Lars Klint

17:40 - 18:40

Design & Reality

Mathias Verraes

Failure is Always an Option

Dylan Beattie

Yarn Berry: a next generation package manager

Michael Richardson

Going real time using Azure CosmosDB and React

Olena Borzenko

18:40 - 22:30

NDC Party

Dylan Beattie