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

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

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


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

Our systems are filled with business processes that are anything but trivial. They exceed the boundaries of a single method- or service invocation and require us to redefine many concepts, from how we think about the domain entities and how coupling affects our designs to how we handle time-based requirements and the joys of eventual consistency. The true power of event-driven architectures surfaces when we start expressing complex business processes with intention-revealing messages (both commands and events) to reflect what's happening in the real world.

If you've moved beyond the basic building blocks of messaging and want to transition your designs from meaningless and often tightly coupled service-to-service calls to carefully designed processes that reflect your business domain, this workshop is for you.

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.

Understand concepts like idempotency, eventual consistency and Outbox.

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

Throughout this workshop, you’ll learn:

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!

How to deal with the inevitable: change...

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!

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

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

Miro account, for design exercises (a free account is sufficient)

GitHub, for access to exercises and additional material

Mastering complex event-driven 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.

We will be working with Google's Gemini models, so you will need a Google account and to be able to generate an API key from 

. We will also use DataStax Astra DB, please 


If you're looking to get started developing with LLMs and want to learn the fundamentals, this workshop is for you. We will write the code in JavaScript, but the lessons are universal across programming languages.


We'll dig into topics ranging from the basics of interacting with LLMs, to prompt engineering, the problems with LLMs, retrieval-augmented generation, and agentic applications.


We will use GitHub Codespaces for the practical parts of the workshop, all you will need is a GitHub account and a web browser.

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.

Performance Optimization: Gain insights into optimizing module communication and data flow to enhance the overall performance of your application.

Future Migration Considerations: Explore how modular monoliths can serve as a stepping stone towards a microservices architecture, and the factors to consider when planning a future migration.

Reverse migration: Understand the considerations and techniques for reverse migration from distributed system back to a monolithic architecture.

We'll also cover aspects of event-driven architecture, messaging, No-SQL databases, and various supporting design patterns.


This workshop is aimed at backend developers with some experience writing web applications using C# and .NET. The workshop will not cover .NET Framework.


This is a hands-on practical workshop where you will be writing a lot of code. You will need to have the following to effectively participate:

SQL Server 2017 or later, with SQL Server Management Studio or Azure Data Studio

Building Future-Proof Apps with the Modular Monolith 

This session aims to equip you with a personal toolbox of scripts and techniques you can rely on when dealing with performance problems. The workflow we’ll use is simple and effective:

How to solve common performance issues reactively

Dealing with resource bottlenecks (I/O, CPU, Memory)

Understanding Wait Stats and query performance

Making sense of statistics and execution plans

Proactively addressing performance issues

Best practices for database file deployments

Using Columnstore Indexes for Large Datasets

At the end of this workshop, you’ll walk away with all the demo scripts, complete with explanations, as well as an actionable checklist to help you diagnose and resolve SQL Server performance issues confidently.

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

Database

Microsoft

Unless you’re working in the front end on a daily basis, it’s hard to keep up to date and ensure that your front end is still modern. This hands on workshop covers modern front end fundamentals, enabling you to create a layout and components without the need for any third party code. You learn core concepts to make your project more accessible without having to write complex code, take shortcuts or deal with browser specific implementations.

Once that is done, we move on to testing our application, making sure that our accessibility improvements are there, watching for any unintended changes & making sure that the application works as it’s supposed to. Through automated tools that can be implemented as part of a deployment pipeline, to manual tools to check on the fly, there are plenty of options to ensure the front end is being tested as thoroughly as the back end.

After the tests are written, we’ll then integrate them as part of an approval and deployment pipeline. Automating the tests for pull requests, running through GitHub actions and ensuring that code is fully tested before it reaches the production branch of your repo.

Accessibility Testing (automated and manual tests)


This workshop involves using various testing tools, and involves getting started with the tools from the beginning without any prior experience. Where possible, open source tools are used.


This workshop is aimed at anyone who works with front end code on a regular basis and needs to keep up to date with the constantly changing world of front end development. Even if you're just brushing up on your skills, this is the workshop for you.


Some experience with front end code desirable, a basic understanding of HTML and CSS as fundamental concepts won't be covered. Some experience with JavaScript is also useful as the tests will be written in JavaScript.

NDC { Oslo }

Workshops

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

Open AI & GPT Workshop

Alan Smith

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

Mastering complex event-driven 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

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

Andrew Murphy