No matter what the JavaScript framework flavor of choice is, a good understanding of reactive programming and state management helps us write better code that is more closely tied to business logic, is easier to read, easier to debug, and easier to scale.

Talk (60 min)

Reactive Programming, State Management, and Redux for the Modern Front End Developer

JavaScript

This workshop will give you the basics for understanding GraphQL and then dive deep into advanced concepts like subscriptions. We will do this by building together a little slack clone and exploring how we can solve the problems of such a service by leveraging GraphQL.

You will learn how to build a GraphQL server in .NET as well as how we can consume GraphQL in Blazor WebAssembly applications.

After this workshop, you will know what GraphQL is. You will know how to build GraphQL servers in .NET and various concepts of building a GraphQL schema.


We will explore what GraphQL is and what it is not and how it compares to other service API technologies like REST and gRPC.


What is the query language and how can we apply it?

- Schema Definition Language / Type System


Overview over the GraphQL schema definition language and exploration of the GraphQL type system.


We will look at design principles for GraphQL schemas.


Let’s start applying our GraphQL knowledge! We will take GraphQL for a ride and build
with it step by step a small slack clone that uses a wide range of GraphQL features like subscriptions, filters, persisted queries, and many more things.


We will try out several GraphQL tools and see what we can do with them and our slack endpoint.

- Building a GUI Blazor for our GraphQL Server


We will pick up Blazor and build with it a simple real-time UI that uses our slack endpoint.

2 Days

Getting started with GraphQL on .NET

.NET

The Rise of Software Supply-Chain Attacks – How Secure is your .NET Application?

Continuous Delivery

Security

Keynote

Observable Web Applications

Testing

When Open Source Came to Microsoft

Cross-Platform

Microsoft

Dude, where is my class?!

Architecture

Tuning web performance with just browser APIs

Building a Game Boy emulator in .NET Core!

Gaming

.NET Core Dependency Injection – The Booster Jab

Mobius – writing your own .NET runtime running on .NET Core

ReST API Design: A beginner's guide

Design

Microservices

Unleash the Power of VS Code

Tools

HTTP Security Headers You Need To Have On Your Web Apps

Good Fences Make Good Neighbours

Automating Android: Command line controls

Microsoft Q# and Azure Quantum

Cloud

Languages

TDD Revisited

Agile

Hot Chocolate: GraphQL Schema Stitching with ASP.Net Core

Building a Mobile Flight Simulator

Embedded

Web Components as micro apps.

Advanced Bluetooth® Technology - Under the APIs

Blazor & gRPC - Code-first .NET SPA developer productivity

Writing Cross Platform Games with MonoGame and .NET

Ten Things Every Voice Application Should Do

Machine Learning

Access All Areas: Making Accessibility More Accessible

Technical Principles of Developer Experience

Concurrency

People

Soft Skills

Incidents are new normal

Work Skills

DevOps

In this talk, you'll see what it's like to use the latest .NET 5 features to create a Blazor UI, and preview some exciting .NET 6 enhancements we have in the pipeline. You'll see a truly dramatic improvement in the developer experience, some runtime features that enable more robustness and performance than ever before, and helpful tips that can be applied in existing .NET 5-based applications. And of course, it’s demos all the way.

If you're new to Blazor, this will be a great way to get a sense of what it's all about. If you're already a seasoned expert, this is your chance to find out what's coming next.

Blazor in 2021

The Untruthful Art - Five Ways of Misrepresenting Data

Big Data

Ethics

REST - the ignored parts

Practical Domain-Driven Design with EF Core

DevOps with Azure Kubernetes Service

The age of applied AI

A pragmatic approach to turn your data into actionable insights

Choreography vs Orchestration in serverless microservices

Serverless

Lessons Learned from the Trenches: Connectivity and Performance Tips&Tricks

The Ultimate Guide To Building Better Azure ARM Templates

Getting Started with Unity and AR/VR for the .NET Developer

Smart home from scratch - a little C#, a little C++  and a whole lot of cheap Chinese electronics

🤖Building a Telegram bot with Apache Kafka and ksqlDB

Database

Orchestrate and build serverless solutions with Azure Logic Apps

Agile Evolution: An Enterprise transformation that shows that you can too

Building a Robot Arm with .NET 5, Raspberry Pi, Blazor and Signal R

Offline web applications don't exist anymore!

Service Principals and Managed Identities - the Identity tools every Azure developer should know

An Introduction To IoT (Internet of Toilets 🚽); Or How I Built an IoT Kitty Litter Box Using JS

Breaking the language barrier: how do we quickly add multilanguage support in our AI application?

Evolutionary history of the RabbitMQ .NET Client towards concurrency

I know what you did last project (common mistakes we make in Azure)

How to secure your GitHub Actions

The leadership balancing act - achieving success without burning out.

Application Autoscaling Made Easy With Kubernetes Event-Driven Autoscaling (KEDA)

When to go from collaborative modelling to coding?

OpenTelemetry 101

Software and Database Refactor Patterns

Observability in a Serverless World

Infrastructure *is* Code with the AWS Cloud Development Kit

Advanced Dapr

The top 10 best new features in C# version 6 to 9

NodeJS, ML, K8s and Unethical Face Recognition

Docker

Retrospectives Antipatterns

A Tour of Go for the C# Developer

Synchronous vs asynchronous microservice architecture

The Implementation and Practice of DevSecOps

The Git Time Travellers

Postponing architectural choices and start developing first with Dapr

Securing Multitenant Databases with Entity Framework Core

In this talk, Scott Helme and Troy Hunt will discuss the flaws within so many of these implementations. They’ll dive into what makes them ineffective and we’re we keep going wrong with them. It’s a very pragmatic, real-world look into the practical value of many of these technologies. Many of them are fantastic but misunderstood, whilst many others are outright cyber-broken.

Everything is cyber-broken 2

Seth Juarez TBA (maybe Getting Started with Computer Vision?)

The Art and Craft of Type Development

Functional Programming

Finding System Boundaries with Domain Storytelling

The Mario Kart™ guide to building a career

But It was Logged!  Practical Logging & Monitoring with .NET

How To Make Your Website A Progressive Web App (And Why You Might Want To)

Why you should consider Web Assembly in your next frontend project

Redis Cluster for Write Intensive Workloads

Gaining Confidence with Cypress Tests

Intro to Blazing Web Accessibility (*)

Getting Started with GitHub Actions

How to develop to be compliant with OAuth 2.1 out of the gate

Power your .NET application with the new generation of diagnostics

Authentication and Authorization in Blazor

Running PHP apps on .NET 5

Little Fluffy Clouds

Why your company needs an internal API and what you should do about it

Blazor, GraphQL and a headless CMS

In this session, I'll show you how to write DRY tests by leveraging an open source library called AutoFixture. AutoFixture lets you set up your test scenarios by runtime-generating data that meets your requirements. By not repeating the same boilerplate setup code everywhere, your tests will have minimal coupling to your production code. They will be your safety net while also giving you the freedom to refactor your production code as you see fit.

Don't think that's possible? Join me in this session and see for yourself

DRY TDD with AutoFixture

TestCafé: Web Testing Made Easy!

.NET on Google Cloud Functions

CI/CD and beyond with GitHub Actions

Along the way, we'll use partial application, functional dependency injection, validation with Success/Failure results, the Result/Either monad, the State monad, agents with message queues, event sourcing, stream processing, capability-based design, and the interpreter pattern (aka free monad). Phew!

If you're an FP-curious developer, I hope this will be a useful way to get a quick overview of functional programming in practice.

Thirteen ways of looking at a Turtle

Designing composable functional libraries, not just for data visualization

The terms coupling and cohesion come from the world of structured programming, but they are also thrown about in the context of microservices. In this session, I look at the applicability of these terms to microservice architecture, and also do a deep dive into the different types of coupling to explore how ideas from the 1970s still have a lot of relevance to the types of systems we build today.

I cover a number of topics in the context of microservices, including:

What is the importance of information hiding, and how do you apply it

Different types of coupling, what kinds of problems they can cause, and how you can avoid them

How a surprising amount of good ideas came out of the 1960s and 1970s, but we just forgot them

Hiding The Lead

"Hack Yourself First" is all about building up defensive skills in developers. It looks at security from the attacker's perspective and takes them through the steps necessary to exploit vulnerable software on the web so that they can experience hacking first hand. Workshop participants are set specific goals they must complete that involve probing for risks and then exploiting discrete vulnerabilities in a specially built vulnerable application. The interactive nature of the workshop means that multiple attack vectors are usually identified across the spectrum of participants and each person contributes their own unique perspective as to how specific risks are exploited.

The objective of the workshop is that each person walks away with demonstrated experience across a broad spectrum of specific risks. They not only learn about but also demonstrate practical experience across a range of different vulnerabilities targeted to the specific needs of the group.

Courses run for two days on the following schedule:

The first day build fundamental security skills that all technology professionals delivering applications on the web should posses:

- Discovering Risks via the Browser
- Using an HTTP proxy
- XSS
- SQL Injection
- CSRF
- HTTPS
- Framework Disclosure

The second day delves deeper into online risks, covering more advanced topics in greater depth:

- Password Cracking
- Account Enumeration
- FiddlerScript
- Content Security Policy
- Session Hijacking
- Subresource integrity
- Brute Force Attacks
- Automating Attacks and Review

Attendees will get taught the mechanics of each of these risks and of course the defensive patterns required to defend against them. But more than that, they get exposed to how to think about security; how to apply it in depth via multiple defences, how to choose appropriate controls based on the specific risk of the feature and how to have the discussion about what makes sense in different circumstances.

Above all though, security is just one factor in delivering working software and it has to be applied appropriately. Sometimes it comes with a trade-off against usability or cost and decisions have to be made about not what's just most secure, but what's in the overall best interests of the product being built. This workshop helps those who attend have the right discussions about when and where to invest in security.

- Software Developers
- System Administrators
- Testers

This workshop is aimed at any software developer, system admin or tester who wants to get a better understanding what is going on in cyber space if it comes to hacking and cracking of systems. This workshop enables you to take a pro-active approach and you learn how hackers will try to break your system. This workshop will be an eye opener for most attendees and it is the starting point of becoming a better developer. It all starts with awareness and improving your own habits. So start hacking yourself first, to become a better developer!

Attendees will need to use their own computer with one of following software options installed: Fiddler: 

https://portswigger.net/burp/communitydownload

If possible please also bring your smartphone.

Hack Yourself First: How to go on the Cyber-Offence


Monday: 09:00-17:00
Tuesday: 13:00-17:00
Wednesday: 13:00-17:00

This will be a hands-on workshop designed for beginners in functional programming. We'll do lots of domain modeling exercises starting with some simple models and then enhancing them with constraints, state machines, error handling, commands and events, and so on.

The core concepts of functional programming and how they can be applied to Domain Driven Design

How to represent the nouns and verbs of a domain (e.g. the ubiquitous language) using types.

Why representing the domain model using types is better than UML or other documentation (hint: it can never get out of sync)

How to capture constraints and business rules in the domain model itself instead of being buried in the implementation

How to treat errors as a part of the domain

How to build a complete business workflow from smaller components using composition

How to design a functional architecture with bounded contexts, validation, I/O and on.

At the end of the workshop you'll know how to accurately represent a rich domain using some simple code which can then be used as the starting point for an implementation.

Domain Modeling Made Functional

What if I told you there was a way to migrate one page at a time, keeping everything else running normally? Well, there is. In this talk I’ll show you how to include Microsoft’s reverse proxy in an ASP.NET Core MVC application to proxy requests to your old ASP.NET app, but intercept specific pages and render them using shiny new Razor. With this approach, you can gradually migrate and upgrade your application at the same time as maintaining and supporting it. It may take years, but you’ll get there in the end!

Migrate your Web Apps to ASP.NET Core, one page at a time

ASP.NET Core 5, 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#, and bring a computer with the latest .NET Core 5 SDK and an IDE (VS2019, VS Code or Rider). For day two a local Docker installation that supports Kubernetes is strongly recommended (e.g. Docker Desktop for Windows or Mac).

Modern distributed systems with gRPC in ASP.NET Core 5

This 2-day workshop will guide you through from beginning with creating containers all the way to running your containers on a Kubernetes cluster in the cloud.

We’ll cover the basics before moving onto more advanced topics, with a combination of slides and hands-on exercises the attendees will learn the fundamentals of containers and by the end of the workshop will have a good understanding of Kubernetes, how to run it and how to run their applications on Kubernetes.

Windows containers (*hands-on exercises will require a Windows laptop)

Windows 10 Pro with Hyper-v and Docker for Windows (with Kubernetes cluster setup)

Macs with Docker for Mac installed (with Kubernetes cluster setup)

Local development environment (Visual Studio 2016+ / Visual Studio Code)

https://docs.docker.com/docker-for-windows/

NDC { London }

Agenda 2021

09:00 - 17:00 (UTC±00)

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

Dominick Baier

Brock Allen

Modern distributed systems with gRPC in ASP.NET Core 5

Mark Rendle

Practical Messaging Workshop

Ian Cooper

Docker and Kubernetes Workshop

Shahid Iqbal

Practical Clean Architecture with .NET Core 5

Jason Taylor

Hack Yourself First: How to go on the Cyber-Offence

Scott Helme

Getting started with GraphQL on .NET

Michael Staib

Domain Modeling Made Functional

Scott Wlaschin

Building a scalable backend with Akka.NET

Hannes Lowette

Web Development with React and Redux

Damjan Vujnovic