Join real life astronaut Christer Fuglesang for this inspiring festival keynote.

Evening Keynote with Christer Fuglesang

The earliest crewed spaceflights, including the Mercury, Gemini, and Apollo programs, were some of the earliest instances of software being responsible for life-or-death decisions. 

Architecting Apollo: Systems Design Lessons from the Golden Age of Spaceflight

Project management is supposed to help us build software more efficiently, so why does it often feel like more of a hinderance? Do we really need SCRUM anyway? 

A Developer's Guide to Surviving Sh*t Project Management

SASO Brings the perfect summer festival vibes as she plays her hit songs in the evening. 

SASO

While working from home during quarantine, our team launched a new service. It was important for me to keep tabs on its metrics, but I didn't have a second monitor just for displaying Grafana Dashboards like we do in the office. 

Hacking the quarantine with Grafana & Electronics

Press Play On Tape

Join in to break the binary of classical computing and start exploring the potential of quantum computing. In this session, we will explore how organisations can experiment with quantum computing on an on-demand basis and understand how far-reaching quantum will be within their industries.

Breaking the binary: Why organisations must embrace Quantum Computing now!

In this session, we will project 3-4 photos of space to generate awe and to bring our understanding of the beauty of the Universe to a deeper meaning. 

Space Awe

The 24-year-old singer and songwriter BATHSHEBA is an intriguing combination of attitude and vulnerability. Her soft and present voice puts honest words to catchy pop melodies. Although her lyrical universe can be dark, her energy is bright, and she doesn’t stray away from a strong pop anthem.

Bathsheba

You know the drill, there are a lot of fundamentals Developers disagree on. Tabs vs Spaces, GraphQL vs REST, and Majestic Monoliths vs Micro Services - get behind your preferred point of view in this live on-stage, developer vs developer Smackdown!

Developer Smackdown

In this short talk Anders Norås takes you on a trip into the world of one of the most influential software products ever. 

A Cultural History of WinAmp ⚡️

We have reached a tipping point when it comes to generative artificial intelligence, and things are currently changing so rapidly the field is almost unrecognisable from one week to the next.

Festival Keynote: Malignant Intelligence: Prompt engineering and software archeology

Guitaraoke is karaoke with guitars. Singers sing along with live guitar players – and for guitar and bass players, we can mute the lead, rhythm, and bass guitar parts from any of the songs on the list so you can play them live.

Guitaraoke: Live Guitar Karaoke!

Javascript is extremely versatile. We use it to build frontend, backend, desktop and mobile apps. But did you know you can even create music with it ?!

Beats in the Browser - Coding Music with JavaScript

Apache Kafka® is great at joining different software systems and processing their data in real time. But while event-based approaches like Kafka are growing in popularity, it can still be hard to see how a whole system fits together.

From Metrics To Music: Making Connections with Apache Kafka

Drawing from his experience with Copenhagen Suborbitals, a non-profit organization funded by donations and supporters, Mads Wilson will discuss the role of programming and technology in driving amateur space exploration.

Programming and Technology in Amateur Space Exploration

A short presentation on the math and theory of the rubiks cube including notation and algorithms for both humans and computers. Participants will then learn to solve the 3x3 and with some effort should be able to solve without a cheat sheet after completing the workshop.

Rubiks Cube Geekout

From One piece and Naruto to Neon Genesis Evangelion and DragonBall, Japanese animation is a cultural phenomena. 

What Anime Taught Me About K8s & Tech Careers

Are you tired of feeling overwhelmed because you overcommit? A recovering “People Pleaser,” I know the harm and unrest that can come with saying “yes” too often.

Learn to Say "No!" Without Being a Jerk

Whether it's paint, clay, or film, every artist has a medium. But can you create art from code and garbage? This talk goes over the intersection of art and code.

Making Art with JavaScript and Garbage

Computer programmed music has come a long way since the CSIR Mark 1 played a scratchy Colonel Bogie back in the early 1950s.

A Brief History of Computer Music

I will describe the physics, energetics, and peculiarities of the most extraordinary astronomical objects in the Universe: black holes.

Black Holes: The Most Powerful Energy Sources in the Universe

There's no conference party without The LineBreakers!

The Linebreakers

Let's shrink the web! In this high-energy talk, we’re going to be looking at some easy wins for performance improvements like image optimization and JavaScript concatenation, that can actually make your users’ life better.

Shrink The Web: How To Get Happier By Removing Crap

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

Once we have the basics, we will show you how to design and implement a graph data model and associated queries. With a mixture of instruction and hands-on practice sessions, you’ll learn how to apply the property graph model to solve common modeling problems. You’ll also learn how to evolve an existing graph in a controlled manner to support new or changed requirements.

An understanding of the labeled property graph

How to apply the property graph to common modeling problems

Common graph structures for modeling complex, connected scenarios

Criteria for choosing between different modeling options

How to modify an existing model to accommodate new requirements

Using a movie recommendation dataset we will learn how to model and import the data.

We'll explore the imported data visually and then start our first steps with the query language Cypher.

Armed with that knowledge we can then build a recommendation engine both for content based as well as behavior based recommendations. In the end we look at building an application backend that exposes this database either as REST or GraphQL-API.

Interest and time permitting, we can finish the workshop with an overview of Graph Data Science, where we cover the most important graph algorithms (e.g. centrality or clustering) and explain basic projections.

Neo4j Workshop - graph database foundation

Database

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#

Testing

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

Architecture

"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

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

It’s 2023. .NET is a free, open-source development framework that runs on everything from Raspberry Pis to cloud data centres, server-side rendering is cool again, and despite what you might have read on LinkedIn, AI is 

 about to take away all our jobs. In this two-day, workshop, you’ll learn how to design, deliver, and test state-of-the-art web applications that harness the power of the C# language and the 

 Core platform. Alongside familiar patterns like model/view/controller and dependency injection, the latest versions of 

 Core introduced a streamlined hosting model, a new set of conventions for routing requests within our applications, and a completely new architecture known as “minimal APIs” for building API endpoints and microservices.
.NET also supports a thriving ecosystem of open source projects and packages. Entity Framework Core provides first-class abstractions over relational databases like MS SQL Server and PostgreSQL. Libraries like NodaTime can simplify and streamline your application logic. Projects like xUnit, Moq, and Shouldly let you test your applications at whatever level makes sense - from low-level unit testing to end-to-end integration tests that test your app’s entire HTTP pipeline. And on the front-end, it’s never been easier to incorporate technologies like SASS, CSS grids, responsive layouts, and even libraries like MJML for sending HTML emails.

Overview of .NET web application architecture

.NET 6 vs .NET 7 - long term support, or latest & greatest?

Deploying database changes using EF Core Migrations

Testing application behaviour and business logic

Data formatting: dates, times, currencies

Formatting data using System.Globalization

Layouts, areas, partial views, and tag helpers.

Cross-platform gotchas: what to watch out for when you’re developing on Windows or macOS and hosting on Linux

Deploying to Microsoft Azure using GitHub Actions

Application monitoring using Application Insights

This workshop is aimed at developers with some experience of the C# language, the .NET platform, and some basic web development. If you understand classes, inheritance, Console. WriteLine, and you know what the <select> tag in HTML does, then you should be just fine.


Attendees will need a computer running .NET 6 or .NET 7, Docker, and a code editor that supports .NET such as Microsoft Visual Studio 2022, JetBrains Rider, or Visual Studio Code.

Modern Web Development with C# and .NET

In this workshop you'll get your hands on using OpenTelemetry in a realistic microservice system. You'll be adding the libraries in the applications, Using the "Agents" to instrument applications without code changes, and touching various languages (whatever you're comfortable with) and more.

You'll come out of this workshop understanding:

How to implement OpenTelemetry in your language of choice (and possibly some others)

Auto-instrumentation of OpenTelemetry (where you can't change the code)

What the OpenTelemetry Collector is, when to use it, and how to use it

Finally, we'll cover Querying and using the data we see to find some hidden patterns.

Hands On OpenTelemetry

DevOps

If you're a programmer who wants to learn and apply machine learning techniques, this workshop is for you. We'll explore machine learning concepts and see 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, Scikit-Learn, a machine learning library that makes it easy to train custom models with just a few lines of code. You'll walk away understanding how to leverage machine learning to solve business problems and the libraries available to build machine learning solutions. No Ph.D. or machine learning experience is required!

Machine learning techniques: regression, classification, clustering, and more

Machine learning algorithms: Linear Regression, Radom Forest Regressor, and XGBoost

Data science libraries: NumPy, Pandas, Matplotlib, and more


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 is required.


Attendees must bring their laptops with access to Jupyter Notebooks and Python.

Introduction to Machine Learning with Python

Machine Learning

Python

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

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.

Workshops

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

From Zero to Hero: Effective testing in C#

Nick Chapsas

Introduction to Machine Learning with Python

Kesha Williams

Designing Microservices

Sam Newman

From RESTful API to gRPC

Irina Scurtu

Hands On OpenTelemetry

Martin Thwaites

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

Nick Tune

Maxime Sanglan-Charlier

Building an event sourced system in C#

Hannes Lowette

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

Scott Helme

High Performance .NET Development

Mark Rendle

Practical Clean Architecture with .NET 7

Jason Taylor

Neo4j Workshop - graph database foundation

Andreas Kollegger

Modern Web Development with C# and .NET

Dylan Beattie

Fullstack GraphQL

Michael Staib

Martin Artola