Writing code with performance in mind makes your application more responsive for users, and can lower hosting costs for cloud-based deployments.

Load testing for APIs and web applications

Patterns and framework features for writing efficient C# code

Making performance testing part of your CI/CD pipeline


Attendees will be expected to be familiar with .NET and C#.

2 Days

High Performance .NET Development

.NET

In this course we'll take an existing .NET application available in GitHub and work our way through securing it's supply-chain. Starting with code, depedencies, building and releasing our software. This training will be a combination instructions followed by a lab to putting it into practice.

Working with source and Git commit signing

Understanding used 3rd party libraries and used containers using SBOM and OpenVEX

Working with Software-Bill of Materials (SBOM) using CycloneDX and Syft/Docker for Containers

Google SLSA (Supply-chain Levels for Software Artifacts)

Microsoft Secure Supply Chain Consumption Framework (S2C2F)

Google GUAC: Graph for Understanding Artifact Composition

Oh no our supply-chain got hacked! Now what?


The attendee needs to bring their own .NET development machine with .NET9 SDK, Docker Desktop, your favorite IDE installed and have access to GitHub.

Although most of this workshop is driven from GitHub, I'll make sure to also share similar examples/references how same can be achieved on different platforms (e.g. GitLab/Azure DevOps/Tekton).

Securing your .NET application software supply-chain

Security

This workshop is here to give you the skills you need to make your APIs secure. We're going to think like an attacker to test APIs and like a defender to figure out the best ways to protect them. With deep-dive talks, real-world demos, fun quizzes, and hands-on labs, you'll learn how to lock down your APIs.
During this hands-on training, we'll explore:

The security model of API-based web applications

Recognizing and addressing authorization failures

Understanding Broken Object Property Level Authorization (BOPLA)

Fixing Broken Object Level Authorization (BOLA)

Testing the security of APIs that use JWTs

Best practices for making JWTs secure in modern APIs

Identifying, exploiting, and fixing Server-Side Request Forgery (SSRF) issues

Understanding Cross-Origin Resource Sharing (CORS)

Configuring secure CORS policies for various use cases

Tracking user authentication securely with sessions or tokens

Relying on OAuth 2.0/2.1 for securing APIs

Q & A throughout the workshop to clear up any doubts


This workshop is about more than theory. We're all about giving you practical security tips you can use right away as an API developer. We dig into the root causes of API threats and how to handle them. We don't just skim the surface of problems and solutions - we get into the why's and how's, looking at common fixes, why some fall short, and which ones are currently the best way to go.
By the end of this workshop, you'll be up-to-speed on the best practices for API security. You'll also leave with a handy list of steps to check and boost the security of your applications.




This training is perfect for developers and architects who work a lot with APIs. If your role involves building, testing, or designing modern apps, this workshop will give you a thorough, up-to-date understanding of the best ways to keep things secure. We'll often use NodeJS, Flask, and Spring Boot in our code examples and demos, but you'll easily be able to apply what you learn to other languages and frameworks.




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 some experience with building API-based applications. Knowledge of application security can be helpful, but is not required.




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


Bulletproof APIs: Hands-On API Security

Our comprehensive workshop is designed to assist new and emerging tech leaders in understanding their new roles and gaining the skills to make them confident, happy and effective leaders.




Less stress, more confidence: Focus on what you need to do by learning how to build trust and relationships, delegate work, empower others, and influence stakeholders whilst balancing strategic business and engineering objectives.

Lead with more ease: Know how to overcome challenging situations, difficult conversations and tasks with frameworks, worksheets and algorithms.

Progress your career: Invest in yourself with leadership skills that will help you bridge the gap between leading the tech and leading the people.




Participants can anticipate walking away with a rich repository of knowledge, tips, worksheets and practical strategies to embark on their leadership journey.

From Engineer to Leader: A Workshop for First-Time Tech Leaders

Soft Skills

Cross-Platform

Ethics

People

Work skills

What if it didn't have to be like that? What if you could write code that never fails? Believe it or not - you can.

Functional programming is a style of writing code that has been around since the 1960s, and has been becoming increasingly popular in recent years, with the advent of technologies like Serverless and async.

It's a style of code that removes side effects and unpredictable behaviour from your applications, making them just about impossible to break in production.

It enables nearly 100% unit test coverage, increasing the quality of the code that you deploy.

It doesn't have issues of resource contention or race conditions relating to state, making it ideal for asynchronous & distributed processing of data.

All of this is accomplished with out-of-the-box C#. No need to pay for new software licences or install additional software packages.

Using the techniques from this workshop, you will be able to immediately improve the quality of your production code, without it costing anything!

Write Code that NEVER Fails - Functional Programming With C#

Functional Programming

We start immediately with working programs so that abstract concepts can be made concrete. Testing is integral to our approach and many of the exercises are 'test driven'. Students will be able to work on Windows, Linux or Mac OS X.



Packaging and distribution of Python packages

Callable objects, lambdas, and extended argument syntax

Properties, class methods, and static methods

Multiple inheritance, method resolution order, and super()

Collection protocols and implementing collections

This workshop requires that you bring a laptop with the following software installed:

An editor for Python code. Attendees can use whatever editor they prefer, but we recommend PyCharm which is a full-featured Python IDE : 

The ability to either connect to the Internet or accept USB flash drives so we can distribute course materials on the day.

Python Properly

Python

Programming Languages

This workshop will teach you everything you need to know to start building distributed systems in .NET and ASP.NET Core and how to combine multiple services to choose the right tool for each use case you might encounter. We will define clear requirements for a system and proceed to build the entire system using all the services and tools you will use to build your own systems later at your company.

Defining the system we need to build with clear requirements

Understanding Monoliths and Microservices

Understanding what “cloud native” means

Implementing observability with OpenTelemetry

Using .NET Aspire to run our system locally

This workshop is for backend developers with some experience writing web applications using C# and ASP.NET Core. You must be able to read, write, and debug C# at a decent level and have some experience with ASP.NET Core.

Visual Studio 2022 or JetBrains Rider or Visual Studio Code with the C# Dev Kit installed

Building scalable, cloud native, distributed systems in .NET

Multi-platform, multi-client, and highly-mobile users bring a new set of challenges, so the approaches of the past are no longer appropriate for modern applications. This two-day workshop is your chance to dive into all things security related to these new technologies. Learn how to securely connect native and browser-based applications to your back-ends and integrate them with enterprise identity management systems as well as social identity providers and services.


.NET Core, ASP.NET Core, MVC, Web APIs, Claims, OpenID Connect, OAuth 2.0, WS-Federation, SAML, JSON Web Tokens, Single Sign-on and off, Federation, Delegation, Home Realm, Discovery, CORS

Social Logins (e.g. Google, Facebook, Twitter, etc.)


Attendees will need to bring a computer with the latest .NET Core SDK and the IDE of your choice (e.g. Visual Studio) installed.

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

In this workshop, we will design APIs with respect to the non-functional requirements that are paramount to any serious application running in production.

We will cover the design process of several API types, including REST, and then we will transition towards messaging, always with an eye on the Cloud.

This is a hands-on workshop, so be prepared to write code! We will start by designing an API with all the production-ready quality attributes. Then, we expand the feature set so that, in the end, we have an overview of the steps we have to take to have robust APIs that are reliable and capable to effortlessly manage heavy loads without breaking a sweat.

By the end of the workshop, you will know how you can evolve your architecture from simple to complex that has the most sought-after quality attributes, from RESTful to messaging-based. We will deep dive into a new world that covers queues, topics, brokers, different abstractions, and patterns like outboxes or sagas specific to distributed systems.

We will see what the usual steps are to do that and what transformations we have to make in our architecture to accommodate everything.

This is a hands-on workshop, so be prepared to write code!


In this section we delve into intricacies of REST-based APIs, the client/server nature of it and we explore the decision-making process behind choosing REST, by offering a detailed guide to the API design process, documenting and the most common usage scenarios.

Media-type selection, design & custom media types


This section we cover gRPC and we outline the RPC API design process. We start by exposing and defining operations, particularities of consuming these APIs and document them. This succinctly summarizes the key components covered in this part, providing an overview of the gRPC protocol, considerations for RPC, and the step-by-step process for designing RPC APIs.


In this section we take our previously designed API, and we start doing the necessary changes to make use of asynchronous messaging.

We deep dive into a new world that covers queues, topics, message brokers, different abstraction and patterns and we will see what changes are needed to adapt our previous architecture.

In this section we will see how we can introduce patterns like Outbox, Competing consumers, Sagas, Routing Slips and learn what we gain from using them, as well as looking at how we can monitor our system.

Versioning strategies for backwards and forward compatibility

Performance, Optimization and Scalability  


This is a Bring Your Own Device (BYOD) workshop. Therefore, attendees are required to bring their own device with the necessary software already installed:

Need to have Visual Studio, or an IDE you are familiar with

RabbitMq installed as standalone instance or we will install it in Docker

The workshop targets .NET Software developers that want to have a more architecture-focused approach

C# developers that want to understand what are the communication patterns, and the best practices for APIs in distributed architectures.

At the end of this workshop you will be able to:

understand which APIs are best suited for which scenarios

understand what are the non-functional requirements needed for a production-ready APIs

evolve a ‘traditional’ architecture to a more complex one that uses asynchronous messaging

Understand what asynchronous messaging brings to the table and where it can benefit our distributed systems

Designing APIs

This workshop will challenge that assumption. It will show you how Rust isn't just a low-level systems programming language that requires a deep computer science background and how you can use it to build modern business applications. Throughout the workshop we'll take a practical approach to learning Rust. Instead of focusing on language internals, you'll learn practical skills to help you be a productive Rust developer. Along the way parallels will be drawn with building applications in .NET to help you transfer your existing knowledge to working with Rust.

Getting set up with Rust tooling on your machine

Core ideas, principles and syntax for building applications in Rust

Dependency Injection in Rust applications

Containerizing and getting "production ready"

No prior Rust knowledge is necessary for this workshop. However, it is designed for backend developers with experience building web applications with C# and ASP.NET core. As ideas are introduced in Rust parallels will be drawn to similar ideas in C# and ASP.NET.

Rust for .NET Developers

Rust

As engineers, or managers or both - we are required not only to write the code or manage the project but also to present it to management, other teams and publicly share our knowledge.

While there are plenty of public speaking tutorials, this practical workshop will provide you with the tools to leverage the *Tech-Talk Algorithm* for creating high-quality technical presentations with minimal effort.

This algorithm has been used by me for creating my own deep dive technical presentations for big conferences, used by my clients for presenting to high level management in big well known corporates and by senior developers, tech leads and principal engineers who participated in my workshop.

By the end of this 2-day workshop, you will have a reusable presentation template and the skills to simplify complex ideas and engage any audience.



Tech-Talks Algorithm: Explaining technical ideas clearly

50% content for 100% results: What to include or skip

The Baby Shark Principle: Simplify ANY complex project


Design for non-designers: Quick, professional templates

Memory-proof slides: Decks your audience won’t forget

The Infographics Magic: Simplifying graphs, data & code


If you're ready to turn your ideas into unforgettable presentation - all you need to do is register to this workshop!

Talk Nerdy To Me - Creating Effective Technical Presentations

Tools

The world runs on email. Book a plane ticket? Get an email. Order a new laptop? Get an email. Forgotten your password? Hey, no problem - we’ll send you an email. The wonderful thing about email is that it’s a free, open standard that isn’t controlled by anybody. The terrible thing about email is that… yep, it’s a free, open standard that isn’t controlled by anybody. To get it right, we need to learn about a dizzying combination of specifications and standards - SMTP, MIME, DNS and MX and DKIM records - and then figure out how to incorporate all that into our own application code.

In this 2-day, hands-on workshop, Dylan Beattie will show you everything you need to know to design, build, test and monitor systems which send email using C# and .NET. Not one or two plain text “hello world” emails: real emails, like the ones you get in your inbox every day. We’ll learn about SMTP, MIME, email authentication and DNS. We’ll explore the .NET packages and libraries we can use to build and send mail messages.

We’ll learn what makes HTML email so complicated - and what we can do about it. We’ll learn how to use modern .NET architectural patterns to scale email delivery, learn how to send thousands of messages as fast as possible without slowing down your application - and how to monitor production systems so that if email stops getting through, you know about it before your customers do.

Sending our first email: SmtpClient, MailKit and MimeKit

.NET templating engines: RazorLight, Razor Components, Fluid (6m)

Rendering idiosyncrasies, unsupported HTML, Table-based layouts, dark mode

Introducing Mailjet Markup Language (MJML)

MIME revisited: how attachments actually work

DNS for email: MX records, SPF, DKIM, DMARC

Guaranteed Single Delivery (and why it’s impossible)

Channels, BackgroundWorkers and feedback loops

Building a heartbeat monitor with POP3 and IMAP

Building a mail sender microservice with RabbitMQ and EasyNetQ

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

The workshop can be run in person or online. Attendees will be writing and running .NET code during the workshop, so will need a computer running Windows, macOS or Linux, and the Microsoft .NET 8 or 9 SDK from 

. An internet connection will be required for most of the exercises.

The sample application and examples used during the workshop all run on .NET 8, and are tested on Linux, macOS and Windows.

The ideal class size for this workshop is between 10–25 people. If you’d like to run it for a smaller or a larger group, please get in touch and let’s chat.

Sending Millions of Beautiful Emails with .NET


This workshop teaches advanced, cutting edge techniques based on ongoing research that are designed to identify and decrease risk, improve confidence in decision making and protect your architecture when the domain is characterized by uncertainty.

The workshop introduces ideas on the philosophy of architecture, forcing participants to think outside of the technology and relate decision making to markets, culture, economic and societal concerns. It teaches practical techniques in stressor analysis and the use of matrices to make component decisions and gives participants the chance to work with these techniques in labs and groups.


This workshop is suitable for senior developers who want a head start into the world of architecture, for teams embarking on large, risk filled projects, and for seasoned architects seeking new techniques. It has also been successful in unting teams around a common definition of architecture.

Concrete Complexity for Software Engineering

Modelling stress: socio-economic architecture

Contagion analysis and component decisions


Good understanding of software design. A laptop with Excel will be necessary.

Advanced Software Architecture with Residuality Theory

Architecture

Microservices

Many developers, data scientists and companies are rushing to adopt and leverage these developments in their business process, products and solutions.

What do I need to consider when developing an LLM based solution?

What is a generative pre-trained transformer, and how does it work?

How can these models be leveraged by application developers to deliver real business value?

In this workshop, you will explore how to leverage the OpenAI and 3rd party models to develop AI enhanced solutions. You will learn options for hosting and consuming different models and develop code and prompts to explore their capabilities. The integration with company knowledgebases to provide a ChatGPT experience tailored to your business requirements will be covered along with the concepts of using prompt engineering to influence the outputs generated by the model.

Hands-on labs using the latest LLM frameworks will be available in C# and Python, ranging from walk-through exercises to advanced challenges and group activities.

Open AI & GPT Workshop

Machine Learning

Guix supports features such as development environments (think python virtualenv but for all languages), a better container builder than docker, time travel, and handles cross-language dependencies. Users and operators should not care about cargo, pip, npm, go, cpan, or maven, etc., but they should, and do, care about the integrity of the supply chain and ease of getting programs to run. All powered by simple package recipes in Scheme (Guile), all easily version controlled.

This course will be a primer on software packaging and some history, a tour of some very neat guix features, and plenty of time to get our hands dirty by writing some packages of our own.



Basic Guix usage, such as package installation and generations, disposable shells, development environments, and building containers

Package management with Guix

Cloud

DevOps

These business processes are usually non-trivial, exceed the boundaries of a single method- or service invocation, and require us to redefine certain concepts, including coupling and time.

If you've been exposed to the basic building blocks of messaging and want to transition your system from a collection of meaningless and often highly-coupled service-to-service calls to one composed of carefully designed processes that reflect your business domain, this workshop is for you. Throughout this workshop, we'll discuss numerous real-world scenarios based on years of experience in the banking and retail domains, making you better equipped to recognize patterns in whichever domain you may be working on.


Have a foundational understanding of messaging as an architectural style and the benefits it offers.

Understand the basic message-based communication patterns, including request-reply and publish-subscribe.

Have experience using message brokers, such as Azure Service Bus, RabbitMQ, or other queuing or broker technologies.


Throughout this workshop, you’ll learn to:

How to identify complex business processes within your domain

Techniques to help identify the right service boundaries

Coordinate complex business processes with orchestration and choreography

Engage in thorough tradeoff analysis to get to the right design

Manage requirements that need to occur at different points in time

Test complex, long-running processes in an automated way

Leverage observability to troubleshoot issues where they matter most: in production!

Throughout this workshop, we'll divide into smaller groups for design exercises that require nothing more than your imagination and something to write with. Later, we'll switch gears and get more hands-on with some coding exercises to bring those ideas to life using C#.

Join me and unlock the secrets of messaging's real-world superpowers!

In addition, it's helpful to have accounts ready to use for:

Microsoft, so that you can access the Azure portal

GitHub, for access to exercises and additional material

Untangle complex business processes with message-based architectures

This workshop will give you an understanding of how to build with GenAI as a developer. We will go from making a simple API call to an LLM to building interfaces and data pipelines to feed context to your bot. Over 2 hours we will build an application that will give you a basis for creating bots that work with your data and you will leave with a bit of inspiration for what else you can manifest with GenAI.

Build with generative AI in JavaScript

JavaScript

This is all in, fast paced, intense workshop where I will teach you and guide you through learning a wide variety of topics. This will not just be simple SQL Injection or Email Phishing. We will go deep! So grab your laptop and join me to learn and get started on your journey towards becoming a full fledged hacker.

Here are some of the topics we will cover:

These topics are subject to change, because the threat landscape always changes and evolves.

You be learning and performing hacks, some of which are designed around some of the modern vulnerabilities that have been disclosed.

I am your drill sergeant, The Working Class Hacker, and you will be my army of recruits!

"I don't know, but I've been told! Hacking is fun, and don't get old!"




You will need a computer where you have enough privileges to install software, access to Linux either through native installed OS, WSL2, or a VM. Either solution is fine.

WCHs - Web Hacking Boot-camp

Testing

Introducing the modular monolith; all the benefits of a monolith such as reduced complexity, ease of deployment, easier debugging, and so on - but ready to be easily decomposed into services as required.

Join us as we explore the principles, patterns, and practices that empower developers to build robust, flexible, and extensible applications without prematurely involving the complexities of microservices and distributed systems.

In this workshop, we will use the fictional case study of a thriving business aspiring to expand, exploring key topics.

We'll investigate the different requirements that need to be met, starting with a code kata and how we can apply various design patterns to our way of thinking.

We'll then move on to actually building out a functioning, all-be-it, contrived application in .NET 8 and C#, learning as we go.

Modular Design Principles: Learn how to break down your application into cohesive modules that encapsulate distinct functionalities, promoting code reuse and easier maintenance.

Dependency Management: Discover techniques for managing dependencies between modules, ensuring clear boundaries and minimising tight coupling.

Scalable Architecture: Explore strategies for designing monoliths that can scale vertically and horizontally to accommodate growing demands.

Architecture enforcement: Dive into architecture testing and other approaches that help with maintaining the architecture and design.

NDC { Oslo }

Workshops

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

Securing your .NET application software supply-chain

Niels Tanis

Write Code that NEVER Fails - Functional Programming With C#

Simon Painter

Rust for .NET Developers

James Eastham

Building Future-Proof Apps with the Modular Monolith

Layla Porter

Advanced Software Architecture with Residuality Theory

Barry O'Reilly

Untangle complex business processes with message-based architectures

Laila Bougria

Bulletproof APIs: Hands-On API Security

Philippe De Ryck

Building scalable, cloud native, distributed systems in .NET

Nick Chapsas

Designing APIs

Irina Dominte

High Performance .NET Development

Rendle .

Talk Nerdy To Me - Creating Effective Technical Presentations

Mey Beisaron

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

Anders Abel

Roland Guijt

Python Properly

Austin Bingham

Build with generative AI in JavaScript

Phil Nash

WCHs - Web Hacking Boot-camp

Espen Sande-Larsen

0 (Zero) to Hero: Essential SQL Server Performance Tuning

Pinal Dave

Modern Front End Fundamentals

Amy Kapernick

Package management with Guix

Jørgen Kvalsvik

From Engineer to Leader: A Workshop for First-Time Tech Leaders

Andrew Murphy

Open AI & GPT Workshop

Alan Smith

Sending Millions of Beautiful Emails with .NET

Dylan Beattie