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

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

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


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


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

- Schema Definition Language / Type System


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


We will look at design principles for GraphQL schemas.


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


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

- Building a GUI Blazor for our GraphQL Server


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

2 Days

Getting started with GraphQL on .NET

.NET

"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


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

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

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

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

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

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

How to treat errors as a part of the domain

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

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

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

Domain Modeling Made Functional

Functional Programming

ASP.NET Core 5, gRPC, Protobuf, Visual Studio, .NET CLI, Docker, Kubernetes, services meshes, monitoring, distributed tracing

Day 1: Building gRPC applications in ASP.NET Core

Day 2: Security, Deployment and Observability

Service mesh (using Linkerd as an example)

Attendees will be expected to be familiar with .NET and C#, and bring a computer with the latest .NET Core 5 SDK and an IDE (VS2019, VS Code or Rider). For day two a local Docker installation that supports Kubernetes is strongly recommended (e.g. Docker Desktop for Windows or Mac).

Modern distributed systems with gRPC in ASP.NET Core 5

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

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

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

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

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

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

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

Docker and Kubernetes Workshop

Docker

Kubernetes

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.

Practical Clean Architecture with .NET Core 5

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 5

Akka.NET, and its implementation of the actor model, promise you just that: highly parallelizable code that scales beautifully as machines are added to the cluster. But there are more advantages than just scaling. Actor models can make your backend very robust, because of their self-healing nature. The code is also easy to reason about, and easy to test.

But the patterns for designing such a system are different from what you might be used to writing object-oriented code. And there are a few pitfalls that you might want to avoid altogether.

During this workshop, you will build your own backend for dealing with the meter readings coming from an electricity meter. Everything from ingesting large quantities of data, over shaping and cleaning your data, storing it, and generating alerts under certain conditions. You will not need any knowledge about Akka.NET to attend this workshop. All concepts are handled during the course.

All the concepts you will encounter will be just as valuable in building other types of backend systems as well.

Using Akka.Remoting to send messages to your central ActorSystem

Designing an actor hierarchy without bottlenecks

Data normalization techniques and what they can do for your codebase

A theoretical introduction to Akka.Cluster

To attend this workshop, you should be a developer with:

Working knowledge of the C# programming language

An understanding of basic threading concepts

A basic knowledge of how to use a SQL Server database from code

You will spend a lot of time coding during this workshop. I will present concepts for the whole class, which you will then apply in code on your own. This workshop will be very hands-on. If you prefer watching slide decks for most of the day, this workshop might not be for you.

Your .NET IDE of choice (Visual Studio or Rider)

A working SQL server instance (LocalDB will do just fine)

Building a scalable backend with Akka.NET

Write robust, elegant, testable and maintainable code

Think about the state of your application

Appreciate immutability, pure functions and composability

Use hooks to manage component state, work with React context and perform side-effects

Make your application talk to the server and tame the complexity of asynchronous code

Leverage modern JavaScript features and tools to super-charge your development


Stateful components (useState & useReducer)

Other hooks (useCallback, useMemo, useRef)

Encapsulating cross-cutting concerns and building reusable abstractions with custom hooks

Performance - memoization and pure components

Modern JavaScript features and best practices

Using Redux store to encapsulate and manage application state

Combining reducers using divide-and-conquer approach

Encapsulate store usage with Provider/connect


If you are an experienced Web Developer and you want to learn how to design, create and maintain complex and modern rich web applications using React & Redux, this is the course for you!


This is an introductory React/Redux course but in order for you to benefit from it, you should have some experience using JavaScript and be familiar with HTML, DOM and CSS.

Prior exposure to a JavaScript framework/library is be helpful but is not essential.


This workshop is a combination of lectures, discussions and practical exercises.


Bring your own laptop with the following installed:

Google Chrome (or any other modern web browser)

Visual Studio Code (or any other text-editor/IDE)

Web Development with React and Redux

Mobile

React

JavaScript

In this tutorial, we will look at why asynchronous messaging is often the preferred solution to the problems of integrating and distributed solution, and look at the implementation of common messaging patterns.

If you have ever been put off moving from 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

The session will be a hands-on introduction and take you from simple messaging scenarios like "Hello World" through to more complex ideas like routing, brokers, and publish-subscribe.

Day 1: Messaging Architectures and Simple Patterns

Day 2: Distributed Systems Advanced Patterns

There will be hands on coding exercises in .NET and Python enabling you to implement simple and more complex messaging scenarios.


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

NDC { London }

Workshops

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

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

Dominick Baier

Brock Allen

Modern distributed systems with gRPC in ASP.NET Core 5

Mark Rendle

Practical Messaging Workshop

Ian Cooper

Docker and Kubernetes Workshop

Shahid Iqbal

Practical Clean Architecture with .NET Core 5

Jason Taylor

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

Scott Helme

Getting started with GraphQL on .NET

Michael Staib

Domain Modeling Made Functional

Scott Wlaschin

Building a scalable backend with Akka.NET

Hannes Lowette

Web Development with React and Redux

Damjan Vujnovic