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

 - The NDC Comedy Party Quiz Show in Room 1


 - 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.

Cloud

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

Architecture

Microservices

Serverless

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

.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!

Machine Learning

From a conceptual point of view 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.

Who tests their cloud code anyway?

In this talk, I’ll discuss a formal method for deciding what to log, and what you don’t need to log. Learning from functional programming, distinguishing between pure and impure code holds the key to such decisions. Examples will be mainly in C#, with some Haskell as well. No knowledge of Haskell is necessary.

Repeatable Execution

We will follow by exporting the AutoML model as an ONNX file and see how to use it in a .NET application using ML.NET.

Azure Machine Learning & ML.NET: Better together

Join Mark on a tour through some of the worst mistakes in the history of programming. Learn what went wrong, why it went wrong, how much it cost, and how things are really funny when they’re not happening to you.

Programming’s Greatest Mistakes

This presentation focuses on the common pitfalls of testing and what we have been doing wrong while also teaching you how to test your brand new hooks using components, all this while using the React Testing Library.

React Hooks broke my tests, now what?

In this talk, we will take you through our Serverless adoption, the journey we took to modernize the platform, the growth of our team and services, and the challenges we faced. We will talk about our architectural principles, serverless patterns, and development lifecycle. As well as our DevOps journey and how we maintain service quality and a secure platform with a rapidly growing team.

Serverless is an evolving technology. We must be prepared to move along with it. We will close the talk by looking at ways in which we can keep up with Serverless.

The Adoption and Operation of Serverless at LEGO.com

Security

In this session, Sjoukje will guide you through all the features and capabilities that are provided by Microsoft Graph, and shows you how you can build these powerful, secure, and intelligent applications yourself. A session with lots of demo's!

The Microsoft Graph: the way to build secure and intelligent apps

I will introduce the Kubernetes Ingress and how you can use it in your applications.
Next, we will talk about the Kong Ingress Controller, an open-source implementation of the Kubernetes Controller that can be installed and managed precisely as any other Kubernetes resource.
You will learn how to easily expose Kubernetes services to the outside world with Kong Ingress Controller.
During this talk, you will also learn about the vast plugin ecosystem of Kong Gateway to declaratively enable security, API rate limiting, etc.
As a bonus, I will show native gRPC support!

Supercharge your Kubernetes Ingress with Kong Ingress Controller

In this talk, I will walk you through creating comprehensive insights into your request against federated GraphQL solutions with OpenTelemetry and Elastic Observability, which will enable your team to act ahead of time.

GraphQL Observability with Elastic and OpenTelemetry

But even then – working with device hardware still requires not only error-prone platform-specific code but also developers familiar with each of the target platforms to maintain it. What if there was a framework, which would allow you write all your code in C# and XAML, with unlimited styling and templating capabilities, and a single API to access device hardware and APIs? And what if you could use this framework to target all mobile and desktop devices and even the web? Meet the Uno Platform - your C#/XAML apps on Windows, Android, iOS, macOS, Linux, and WebAssembly!

Uno Platfrom: Your Apps Everywhere

This session tells the story of how we solved the problem using micro-frontends to integrate components between multiple applications, meeting industry regulations and improving productivity of our teams.

In this talk about our unique take on the benefits of micro-frontends we aim to give developers one more tool in their toolbelt to work constructively within these constraints to create great applications.

We cover the following topics in the format of both business/functional explanations and a live coding demo …
- Background to the problem and how it impacts our productivity and creativity
- Different technical options we investigated to arrive at the solution
- Impediments we met along the way
- A coding demo to show how the integration is achieved using Vue.js and Single-SPA micro frontend framework

Audience:
Content is aimed primarily at developers and architects to show how micro frontends can solve real issues. More generally, the following groups should be interested in the content:
- Anyone who wants to integrate product features between a suite of products
- Developers working in regulated environments (e.g. Pharma, aerospace)
- Micro frontend fans
- Micro frontend sceptics

Micro-frontend magic in a regulated environment

HTTP is the most common protocol used to consume APIs and serving JSON over HTTP is probably the most popular way of consuming APIs. But there are multiple ways or API patterns to serve JSON over HTTP, each very different and each having its pros and cons. In my session, we will look at the three ways of serving JSON over HTTP - HTTP API, GraphQL and gRPC JSON Transcoding(a .NET 7 preview feature, previously gRPC HTTP API, an experimental feature). We will understand the basics and also see how to implement an API using all the three patterns and finally run a comparison between the three of them.

JSON over HTTP Multiple Ways

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

Functional Programming

In this session we explore current best practices for authentication in a modern environment using BFF (Backend For Frontend) with frontend applications, APIs and micro services.

The Return of the Authentication Cookie

Ever since, though, there’s barely been a new version of the language that didn’t borrow concepts and features from functional programming; most recently with records. Let’s trace out this history, and also look at some functional concepts that we have yet to fit in nicely – but might in the future! No C# experience required.

The functional journey of C#

Languages

In this talk I'll introduce you to Roslyn, explain things like Workspaces, SyntaxTrees, SyntaxNodes and symbols, and show you some of the fun things you can do with it, both in console applications and as Visual Studio extensions.

If you also go to a talk on Machine Learning you will probably be able to create an artificial intelligence to write code for you and take the rest of your life off.

Automate yourself out of a job with Roslyn

While the classical models still work and have their own merits, some of them rely heavily on documentation, extensive coordination between teams or code-sharing. We use shared libraries, and over time our projects become intertwined with dependencies. In these cases, we need something to untangle those and reduce coupling. Welcome gRPC.

gRPC has been around for a while and .NET Core 3.0 welcomes it as a first-class citizen. It is contract-based, performant - with smaller response/request bodies, perfect for polyglot environments and supports different models – from client-server, to bi-directional streaming out of the box.
In this session, we will look at how to use gRPC and its 4 models and what are the benefits and or downsides of using gRPC compared to the traditional models.

Embracing gRPC in .NET

Luckily, there's a new(ish) project that is here to help, and provide familiar hooks into your applications to get the vital information you need to have confidence in your production environment.

We'll walk through what distributed tracing is, how it relates to Observability (o11y), and then run through some examples of how to get started with it in your .NET Core applications.

Finally, we'll demo a few different backends for storing and visualizing the data, Jaegar (OpenSource) and Honeycomb.io (Hosted)

Distributed Tracing in .NET 6 using OpenTelemetry

In this talk we explore what happened to this bunch of intrepid engineers as they self-organised themselves into a lean, mean, lego-building machine. Along the way exploring key concepts from lean software engineering including cycle-time, the importance of batch size to throughput, continuous process improvement, stopping the line, work-in-progress limits, Systems Thinking and the Theory of Constraints.

So, have you ever been a child? Ever played with lego?

If so, come along and learn how Han Solo, Luke Skywalker and Chewie turned 5000 bits of brick and a 300 page manual into a ship that can do the Kessel run in less than 10 parsecs…

Lean & Lego: Building the Millennium Falcon Redux

Methodology

Couple of months later, I started to help a friend on an open-source project that was deployed manually. Playing around with Azure deployment center, I “stumbled” upon this “new feature”, or at least new for me. This presentation is about my learning journey what made appreciate this hidden gem.

Azure CI/CD with GitHub Actions

We’re also adding list patterns to pattern matching, a mechanism to require initialization of members, and “raw” string literals to avoid escaping, just to name a few. Finally we'll peek a little further into the future at some features we’re working on that will take longer to get right.

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

18:40 - 22:30

NDC Party

Dylan Beattie

Mark Rendle