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)

2 Days

From Zero to Hero: Effective testing in C#

.NET

Testing

"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

Security

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

Functional Programming

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

Architecture

This hands-on workshop provides practical guidance and recommendations. We will cover architecture, technologies, tools, and frameworks. We will examine strategies for organizing your projects, folders, and files. We will design a system that is simple to build and maintain - now and well into the future.

You will leave this workshop having developed the foundation and structure for your next enterprise application, along with the knowledge to take your enterprise application development to the next level.

Required workload - ASP.NET and web development

You can also use your preferred IDE, e.g. Visual Studio Code or JetBrains Rider.

Practical Clean Architecture with .NET 7

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

Through in-depth lectures, hands-on labs, live demos and interactive quizzes, this workshop will teach you how to build secure applications for the modern web. We explore fundamental challenges that drive the design of your applications. We also introduce common vulnerabilities in frontend and backend and investigate relevant defenses. Additionally, we dive into coding guidelines and defense-in-depth strategies that allow you to increase the security of your applications.

Concretely, we will cover the following topics in this hands-on training:

The security model of modern web applications

Cross-Site Scripting problems in modern frontends

Using Trusted Types to eradicate XSS vulnerabilities

Assessing and improving your authorization policies

JWT security failures in modern applications

API security testing to avoid common misconfigurations

Server-Side Request Forgery (SSRF) attacks and defenses

At the end of this workshop, you will understand modern application security best practices and you walk away with a list of actionable items to assess and improve the security of your applications.

This security training specifically targets developers and architects building modern web frontends / APIs. Anyone involved in building, testing, and designing modern applications should be here. This training course gives you an up-to-date and in-depth look at current security best practices. 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.

These testimonials from previous workshops give you a good idea of what to expect:

Trainer is great and an expert in the domain. All of the topics are very relevant. Practical examples for most of the topics. Excellent communication and addressing of questions.

Even though the topic is broad, there was no single moment where my focus went astray. Philippe talks in a way to keep you interested to listen to him.

I liked the the pleasant and relaxed way of speaking and the fresh style of presentation of this kind of dry stuff :)

Philippe is a friendly and knowledgable trainer and delivered an interesting course that was well presented. Questions were answered promptly and in a detailed way.

To participate in this training, you should have development experience with web applications and APIs. Familiarity with the basics of security is helpful but not required. The training will include Angular / React / NodeJS / Java Spring / .NET Core examples but is just as relevant for other frameworks and technologies.

To participate in the lab sessions, participants need a computer with a full-featured modern browser installed (E.g., Chrome, Firefox).

A Builder's Guide to Securing Modern Applications

On the practical side, you'll see how to work with Event Storming to map out business needs, and discover new opportunities in the domain. Then, you'll see how to use Event Storms as the basis for slicing up the business into domains and subdomains which are the candidates for software architecture and team boundaries (using various flavours of Event Storming (big picture, process modelling, software-design).


You'll also get a chance to analyze scenarios presented in other formats like Domain Message Flow Modelling and the Bounded Context Canvas. And you'll get to switch into the architect role and design architectures with these techniques yourself.


Throughout this course, you'll get to experience a diverse number of scenarios from different domains, based on the real world experiences of Max and Nick. While the course is largely hands-on, you will also learn the necessary theory even if you have no previous experience of Domain-Driven Design.

Strategic Domain-Driven Design: Analysis, Architecture, and Modelling

In this workshop, we will be upgrading your skills on a whole catalog of systems and features in .NET and the surrounding ecosystem, including:

API versioning, caching, and rate-limiting

When you walk out of this workshop, you will have a set of new skills, a knowledge of when to use them, and the ability to integrate them into your existing workflow without causing problems.

C# Web Project Types and When to Use Them

C# Desktop Project Types and When to Use Them

C# Mobile Project Types and When to Use Them

Tips and Tricks for Building Powerful Applications

This will be a practical workshop with hands-on learning. Each section will have multiple steps to practice in order to help you target what you want to focus on. This workshop will not require the use of the Internet or any cloud resources. An updated version of Visual Studio 2022 for Windows or Mac or VSCode with the .NET 7 SDKs installed will be sufficient. Having Docker desktop installed will be necessary to practice those lessons.

This workshop is aimed at developers with some experience building applications. Regardless of your skill level, though, you will come away with quite a few upgrades to your existing skillset.

A development environment – Demonstrations will be done in Visual Studio 2022 with .NET 7 if you would like to follow along.

Upgrading Your C# Skills in .NET 7

In this tutorial, we will look at distributed systems, such as microservices, and how we integrate them. We will understand why we would prefer to messaging, the fundamentals and key concepts of messaging and how to build an event driven architecture. If you have ever been put off moving from HTTP or 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 of how to build event driven architectures, this workshop will help you understand how to succeed with reactive approaches.



The material is presented in four parts: integrating distributed systems, an introduction to messaging (hands-on exercises), advanced messaging, and event driven architectures.

Hands-on exercises are offered in C#, JavaScript, Python and Go.



Messaging Architectures and Simple Patterns

Insights from Paper Offices and Flow-Based Programming

Commands or Event? Orchestration and Choreography.


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.

The exercises are self-paced and you will find it helpful to have headphones to listen to the material that accompanies each exercise (though scripts are provided for those who cannot use headphones).

Practical Messaging

DevOps

Python

In this workshop, we'll share some framing for microservice architectures that explore the various forces that can drive the design and evolution of microservices, and then you'll participate in a series of interactive architectural kata exercises to put your newfound knowledge to the test. Afterwards, you'll have a series of tools to take back to your own organisations to put into practice.

Understand what makes a good microservice

Learn how to use concepts from domain-driven design to define service boundaries

Understand how to plan and manage a migration from a monolith to the microservice architecture

Understand how technical choices can impact the architecture itself

Learn about managing change and governance in a microservice environment

This is a participatory workshop. You won't get to just sit there and watch – the more you participate in the workshop, the more you'll get out!

Designing Microservices

Architecture and Design

Microservices

In this workshop, I will introduce machine learning using cloud services. We'll explore machine learning concepts and see first-hand the steps to process and prepare data for machine learning, train and deploy a machine learning model, and generate real-time predictions. We will explore Amazon SageMaker, a tool used to build, train, deploy, and manage models at scale. You'll walk away understanding how to leverage machine learning to solve business problems and the services available to build machine learning solutions. No Ph.D. or prior cloud or machine learning experience is required!

Amazon Web Services (AWS), Amazon SageMaker, Amazon S3, AWS Lambda, and Amazon CloudWatch

The workshop is intended for developers and software engineers looking to transition to machine learning.

The ability to read basic Python code is necessary, or familiarity with another programming language is strongly recommended. No prior experience with machine learning or AWS is required.

This workshop requires attendees to bring a laptop. Attendees are strongly encouraged to create an AWS Free Tier account before the workshop to take advantage of the two-month free trial of Amazon SageMaker.

NDC { London }

Workshops

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

From Zero to Hero: Effective testing in C#

Nick Chapsas

Introduction to Distributed Systems with C# and .NET

Dylan Beattie

Reactive Mobile Apps with GraphQL and Maui

Michael Staib

Brandon Minnick

Strategic Domain-Driven Design: Analysis, Architecture, and Modelling

Nick Tune

Maxime Sanglan-Charlier

Introduction to Machine Learning with AWS

Kesha Williams

A Builder's Guide to Securing Modern Applications

Philippe De Ryck

Practical Clean Architecture with .NET 7

Jason Taylor

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

Scott Helme

Designing Microservices

Sam Newman

Upgrading Your C# Skills in .NET 7

Tim Corey

Domain Modeling Made Functional

Scott Wlaschin

Practical Messaging

Ian Cooper