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.

2 Days

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

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)

From Zero to Hero: Effective testing in C#

.NET

Testing

How could we deal with the explosion of code, services and applications? How do we stay clear, sane and confident when faced with the myriads of languages, frameworks, conventions and cults?

Only with simplicity in thinking, designing and communicating.

This workshop is for you if you ever question or or feel confused about popular (including "enterprise") practices, teachings, or conflicting paradigms, and seek to rise above and go beyond.

We'll build an easy but "typical" application together in a few stages. For each stages, there are choices to be made on code design. Gradually, patterns appear, ideas surface, conversations rise, and we shall arrive at something very clear.


rethink dependency injection and composition

Through this workshop you will get a clear idea on how to architect, code and test for simplicity. But beware! Your architectural bias or preferences can be challenged.

.NET Core - we'll be coding in plain C# (no fancy features). You'll manage even if this is not your daily language.

As usual, this workshop features unexpected tangents - often as inspirational as the main content.

See you there!

Simple by Design: Declutter Your Architecture, Code and Test

It is contract-based, performant - with smaller response/request bodies, perfect for polyglot environments and supports different models – from client-server to bi-directional streaming out of the box. If we sprinkle some client-side load balancing, transient fault-handling and the ability of exposing a gRPC service also as a HTTP API, we might the perfect point-to-point communication mechanism.

In this workshop you will learn the how and the whys and understand where gRPC fits in the .NET APIs ecosystem. At the end of the workshop you will be able to use gRPC in real production environments.




- What gRPC is and how it fits in an API context
- gRPC vs RESTful APIs
- gRPC vs WCF




- working with .proto files
- understanding the syntax
- defining custom types




- the 4 gRPC modes
- Implementing and consuming gRPC services
- Documenting and exposing gRPC endpoints




- Accessing the gRPC context
- Accessing the gRPC HTTP context
- Trailers
- Headers
- Status codes in gRPC
- Exceptions in gRPC




- Defining policies
- Configuring a retry policy
- Configuring a hedging policy




- Client interceptors
- Server interceptors
- Configuring interceptors
- Interceptors vs Middleware




- implementing a client-side load balancing
- Configuring client side load balancing
- load balancing policies
- Round-Robin
- Pick first
- Implementing our own policy




- what is is gRPC transcoding
- exposing our services as HTTP
- Consuming methods from the browser
- How routing works with gRPC transconding
- gRPC JSON transcoding vs gRPC-Web
- grpc-gateway - alternative to transcoding




- Testing with Postman
- Unit testing service operations




Attendees will require a laptop with the latest version on .NET SDK and their editor/IDE of choice: Visuals Studio 2022

From RESTful API to gRPC

Let us venture on a journey into the wonderful world that is software exploitation and learn how to use gamified safe environments to build skillsets to help us write better and safer software. Because once you learn how to hack, you never go back.

In this workshop, we go in-depth and learn and perform exploits.

How hacking works - Workshop edition

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

You will not only learn how to use Azure Active Directory to protect your apps, but also to protect the environment they run in and how to use Azure AD to enforce policies for resource access.




* The basics of OAUTH/OpenID.
* Identity concepts in Azure Active Directory.
* How to integrate your applications with Azure AD and use single-sign-on (SSO).
* How to secure your APIs using Azure AD.
* Several ways of granularly granting permissions to various resources, both by role, application or user.
* What is the difference between an app registration and a service principal?
* Getting rid of passwords and using managed identities.
* Using identity to access Azure resources.
* Role-based access control.
* Granting access to external collaborators.
* Implementing just-in-time, auditable permissions for protected resources.
* Using Azure B2C for regular consumer apps.

There will be hands-on labs you can do on-site and take home with you to reinforce the concepts and techniques you learn.




Developers who want to get a better understanding of how Azure Active Directory identity works and how to use it to secure their apps and environments.

While the concepts can be used with any language, the workshop examples will be in C# on the .NET platform. No prior knowledge about Azure Active Directory or identity assumed.

Basic programming skills necessary to follow hands-on labs.




You will need to bring a computer with the latest .NET SDK and the editor of your choice (for instance Visual Studio 2022, JetBrains Rider or VS Code).

Awesome Azure Authentication Adventures

Security

Cloud

Here are a few of the topics and techniques covered in this workshop:

Record types – What are they? How do you use them? Why?

Nullable reference types – Moving towards immutability and avoiding null reference exceptions

Asynchronous Programming – Working with Streams and best practices

Pattern matching – Writing more beautiful and understandable code

Using Span of T - Writing fast and memory efficient code

Each topic will be thoroughly covered, followed by exercises that allow you to understand and incorporate these language features in your projects. We will talk about how the application changes, benefits and drawbacks of applying the language features.

We’ll be discussing application design, leveraging new language features and try to answer any of the questions you might have!

This is a workshop you really don’t want to miss if you’re a C# developer in 2023!

Visual Studio 2022, Visual Studio for Mac, Visual Studio Code, or Rider

Developing with C# 

Programming Languages

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 7

Participants will learn how to set up and configure an AWS account, use Terraform to create and configure Amazon Elastic Container Service for Kubernetes (EKS), and deploy and manage applications on EKS using Flux GitOps. 

The workshop will also cover best practices for securing and scaling a Kubernetes cluster on AWS. 

By the end of the workshop, participants will have a solid understanding of how to build and manage a cloud-based Kubernetes infrastructure on AWS using Terraform and Flux GitOps.

From Zero to Production: Building and managing Kubernetes clusters on AWS using Terraform and Flux

DevOps

Tools

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

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

This is exactly the type of problems the event sourcing pattern tries to solve. If we preserve all the events that led up to the current state, we can replay history and derive the current state from that, but we also open the door for more flexibility in our system.

During this workshop we will explore all the concepts that are associated with event sourcing. We will use C# to implement our own event sourced system over the course of the workshop, so we can see things in practice. Eventually, we will look at a couple of frameworks and libraries that can be useful when you start building your own event sourced system.

During this workshop, you will learn about:

How to build this code in a test-friendly way

Enabling feature development with history applied

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

Working knowledge of the C# programming language

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, or as a group. 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 an event sourced system in C#

Event Sourcing

CQRS

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 React and explore how to efficiently build fast and fluent web interfaces using the JavaScript client Relay.

.NET, ASP.NET Core, GraphQL, Hot Chocolate, React, Relay

GraphQL client ecosystem in .NET and JavaScript (Apollo vs Relay)

You will need basic knowledge of .NET and JavaScript.

Also, you will need a computer with the .NET 7 SDK, Nodejs LTS, and Visual Studio Code.

Building Modern Apps with GraphQL in ASP.NET Core 7 and React 18

React

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.

Introduction to Machine Learning with AWS

Machine Learning

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.

NDC { Oslo }

Workshops

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

From Zero to Hero: Effective testing in C#

Nick Chapsas

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

Dominick Baier

Anders Abel

Introduction to Distributed Systems with C# and .NET

Dylan Beattie

Practical Messaging

Ian Cooper

Front End Web Fundamentals

Amy Kapernick

Building Modern Apps with GraphQL in ASP.NET Core 7 and React 18

Michael Staib

Martin Artola

Introduction to Machine Learning with AWS

Kesha Williams

From RESTful API to gRPC

Irina Scurtu

Designing Microservices

Sam Newman

Practical Clean Architecture with .NET 7

Jason Taylor

Developing with C#

Filip Ekberg

Simple by Design: Declutter Your Architecture, Code and Test

Hackle Wayne

Building an event sourced system in C#

Hannes Lowette

Awesome Azure Authentication Adventures

Glenn F. Henriksen

How hacking works - Workshop edition

Espen Sande-Larsen

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

Nelly Sattari

From Zero to Production: Building and managing Kubernetes clusters on AWS using Terraform and Flux

Jeff French