Stand-up Maths

Demoscene: The Golden Years

Who Wants to be a JavaScriptær?

The Sky(net) is Falling

The Linebreakers

No judgment, just good vibes and great tunes.

The Phil Nash Karaoke Party

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

26-27 Aug

High Performance .NET Development

.NET

The Engineering Manager doesn't need to be the most technical person in the team, a psychologist, or a bad cop. You only need to have enough leadership tools in your pocket.

In Atlassian, as one of the young industry thought leaders, engineering managers use a leadership framework called 4Cs. Using this approach can set you up for success in leading fully remote teams who work from anywhere.




Welcome to this interactive workshop which provides practical guidance and leadership recommendations and suits the following groups:

1. Techie ICs (Individual contributors like developers, OPS, architects, and computer engineers) who are keen to step up to a management role.


2. The managers who struggle with running remote teams in this new era and want to be more effective leaders

You will leave this workshop having developed the leadership skills you need and picked tools in the 4Cs framework to manage technical engineering teams. It also helps you make a determined decision on your next career path if you are hesitant.



Here are a few of the topics covered in this workshop to develop leadership skills:


- How to be a great connector to build psychological safety in the team?
- What tools and methodologies do you need to be a great conductor to contribute to the team’s success?
- What does it take to be a productive compass?
- How to be an effective coach helping with growth and performance improvement, providing feedback and making effective and constructive conversations yet difficult?

Each topic will be thoroughly covered using examples and followed by exercises that allow you to reflect and fully absorb.

Managing engineers is not magic. You need tools for that!

Work skills

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 Core 8

Security

We’ve all seen the “hello world” demos: models, views, controllers, a DbContext, maybe some minimal API endpoints. In this workshop, we’ll go beyond the basics and explore the full potential of C# 12, ASP .NET Core 8, EF Core, and the rich ecosystem of libraries and packages that’s available for building web apps with .NET in 2024.

The workshop is based around “Rockaway”, a .NET web app for selling concert tickets. Our favourite developer-themed rock bands, from Dev Leppard to Mott the Tuple, are going on tour around the world, and we're going to build the platform that'll sell tickets to all their shows. Along the way we’ll encounter dozens of real-world scenarios, from data modelling, to timezones and currencies, to responsive layouts and email delivery. We’ll use asynchronous patterns and channels to build lightning-fast web apps which stay responsive even under heavy load. We’ll look at how to extend the built-in Bootstrap libraries with Blazor and Razor Components to create beautiful, responsive frontend layouts that work seamlessly with 

, and we’ll see how to test our applications at every level, from low-level isolation testing, to end-to-end integration tests which exercise the entire HTTP pipeline.

Principles of web application architecture: areas, services, components and dependencies

 Applications: WebApplicationFactory, Shouldly, AngleSharp

Deploying web apps using Azure and GitHub Actions

Observability with OpenTelemetry and .NET Aspire

Interactive frontends with Blazor and Razor Components

Advanced EF Core: mapping conventions and custom types

Testing database code using EF Core and Sqlite

Globalisation: dates, times and currencies

Async processing with threads and channels

This is a hands-on, interactive workshop: we’ll be sharing code throughout using GitHub and VS LiveShare, you’ll go home with a fully working copy of the sample application, and all the workshop code is published under the MIT license so you can use it for whatever you like. Application code is all built on .NET 8 using C# 12, so we can use new C# language features like primary constructors and collection expressions. You’ll also get to learn about many of my favourite developer tools like zoxide, oh-my-posh, MailTrap, Papercut, Postman, and ngrok: they’re not specific to .NET, but they do make building and testing .NET applications a lot easier.

What people have said about Dylan Beattie’s .NET workshops:

“Everything was great, content, presentation, examples, answers to questions. All clear and understandable.”

“I liked the way the lecturer kept the tempo and captured attention. Everything was well prepared and worked right away or almost right away.”

“I really enjoyed the humour and that Dylan showed personality throughout the workshop.”

“Really great organization and preparation. It shows that you have experience with this kind of workshops.”

This workshop is for developers who already have some experience with 

 Core; you should already be familiar with the model/view/controller patterns, the Razor view engine, and basic data access using Entity Framework. 


Attendees will need a laptop running the .NET 8 SDK, and a code editor such as Visual Studio 2022, JetBrains Rider, or VS Code.

Beyond the Basics: Advanced Web Apps with .NET 8

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

In this workshop, we will design an API with respect to the non-functional requirements that are paramount to any serious application running in production. For this, we will use .NET 8.

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

By the end of the workshop, you will know how to enforce architectural decisions and what it means to have an API that is evolvable, reliable and ready to scale.


- Why API design matters
- How we address the NFRs


- Modular design
- What makes a good API


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.   
- Http methods
- Http status codes
- Http headers
- Endpoint naming
- Media-type selection, design & custom media types
- Caching & Conditional caching
- Input & Output formatters
- Generating clients with SwaggerGen


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 cover the concept of a Query-Based API and we explore OData and GraphQL


In this section we learn the messaging fundamentals and we deep dive into a new world that covers queues, topics, message brokers and different tools. While we are here we will have a look at what AWS and Azure has to offer in order to understand what to use.


Part 3 - Addressing non-functional requirements


- What are NFRs and why should we care?
- Designing for change
- Reliability
- Performance, Optimization and Scalability
- Observability
- Documenting the APIs
- Testing the APIs
- Protecting the API
- Maintainability


- Difference between APIs and microservices.
- Challenges
- Evolutionary architectures


- Moving from a monolith to a microservice architecture
- Identifying business capabilities
- Balance and quality attributes
- Tradeoffs


The workshop targets .NET Software developers that want to have a more architecture-focused view over designing APIs or simply 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 are the non-functional requirements needed for APIs
- Design and build APIs that are ready for production
- Address the most important “ilities” of any API

Please bring your laptop with the following installed:
-Visual studio or preffered IDE 
-.NET 8 SDK 
-SQL Server with SQL management studio (or a tool that can access databases) Or docker with a sql server image and RabbitMQ RabbitMQ

Designing APIs

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

Architecture

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

Microservices

Soft Skills

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

DevOps

Architecture and Design

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 

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 accessibility 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 then move on to testing our application, making sure that our accessibility improvements are there, watching for any unintended changes and 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.

Workshops

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

Bulletproof APIs: Hands-On API Security

Philippe De Ryck

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

Anders Abel

Beyond the Basics: Advanced Web Apps with .NET 8

Dylan Beattie

Designing Microservices

Sam Newman

Advanced Software Architecture with Residuality Theory

Barry O'Reilly

Designing APIs

Irina Dominte (Scurtu)

Managing engineers is not magic. You need tools for that!

Nelly Sattari

Building Future-Proof Apps with the Modular Monolith

Layla Porter

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

Maxime Sanglan-Charlier

Kenny Baas-Schwegler

Modern Front End Fundamentals

Amy Kapernick

High Performance .NET Development

Mark Rendle