Most Active Speaker

Chris Klug

Chris Klug

Developer Badass-as-a-Service

Stockholm, Sweden

Chris Klug is a developer badass-as-a-service that either creates or solves problems depending on who you ask. He loves creating and building things. Whether it be a new application, a new kitchen or a new RC helicopter, you will see him building things all the time. Most of the time, that means writing code and solving problems for clients at a company called Active Solution in Stockholm though. Except for the many days he spends at conferences and usergroups, talking about doing things he is passionate about, and for the days he goes mountain biking, IPSC shooting, kiteboarding or RC helicopter flying.
For the last 15-something years, he has been solving problems for customers, and loving it. But if he gets to choose, he'll go to the beach and kitesurf every day!


Area of Expertise

  • Media & Information


  • Azure
  • Containers
  • Automatization
  • Pulumi
  • .NET (Core) development
  • .NET Patterns & Practices
  • C#.Net
  • .NET
  • Software Development
  • Software Architecture

Azure IaC Showdown

In this session, some of the most commonly used IaC tools will battle it out, to see which one is the best one for your Azure solutions.

Is it Terraform, the IaC kingpin from HashiCorp? It’s been around longer than most of us can remember, and It has great market penetration, but is it the best choice for Azure?

Or is it Bicep, the ARM successor, that is the beez kneez for Azure infrastructure? Sure, it’s pretty new to the scene, but builds upon years of experience. Not to mention that it is native to Azure.

Or maybe it is the new kid on the block, Pulumi? Taking a very different approach to IaC than the others, offering some really cool, new abilities sounds very interesting. But is newer, and different, also better?

Well…if you attend this session, you will find out! Or at least walk out with a better understanding of which one might suit you the best. During the session, you will see the pros and cons of each one the different tools, as well as hear about Chris Klug’s own experience and opinions about them. All, to make it possible for you to make the most informed IaC choice for your needs.

Introduction to Actor-based Development with Project Orleans

There are some domains that are really hard to model using your standard n-tier architecture. Domains like real time vehicle tracking, auctions and many IoT scenarios. Sure, they might look easy enough, and “work on my machine”, but when you start throwing some load at it, it can start to crumble quite quickly. And going down the good ol’ “Eventual Consistency Road” isn’t always an option, as consistency is actually important in some cases.

However, these aren’t new problems, and smart people have already created solutions for them. Solutions like the Actor pattern, which solves the problem by using in-memory “actors” to make life simpler. Unfortunately, the Actor pattern introduces another set of challenges. Things like instance proxying, state management, clustering, actor distribution and so on. Topics that most of us don’t feel like solving on our own. Luckily, Microsoft has already built all of this for us, in something they call Project Orleans.

Why not join Chris Klug, as he explains how Project Orleans can help you to solve scenarios like the ones described above. It might be worth noting though, that if you like slide heavy presentations with lots of theory and little practice, you should probably stay away. This session uses lots of demos to show you the practicalities of getting started building solutions using Project Orleans, and the features is offers. So please come well rested, and ready for a lot of coding.

Exploring Infrastructure as Code

Are you tired of spending hours upon hours of your life, manually setting up environments for your IT systems? Or do you skip that and try to make do with just a “dev” and “prod” environment because it is too much of a hassle to set up a new one? Or maybe it is too expensive to run another one? Or maybe you have given up on the idea of multiple environments and decided to just deploy to production? Continuous Delivery FTW!!!

To be honest, we get it! Setting up and maintaining multiple environments and their infrastructure is a hassle. However, with “the cloud” and infrastructure provisioning being available through API calls, we can now speed up this process using Infrastructure as Code (IaC). This allows us to define our environments in code, and easily spin up, as well as remove, environments in minutes. Need a new test environment? No worries, just spin up a new one! Need a temporary environment to try out something new? No worries, just spin up a new one temporarily and remove it when you have tried out your idea! Why not spin up a new environment for each pull request to verify that it works? All this is possible if you have your infrastructure defined as code. Not to mention the ability to version manage it to allow you to keep track of what has changed.

In this workshop, we will have a look at the 3 most popular Infrastructure as Code (IaC) solutions available for creating infrastructure in Azure, ARM/Bicep templates, Terraform and Pulumi.

The goal of this workshop is to have you define, create up, update, and remove whole system environments using all three IaC solutions. This will allow you to get a feel for how they work, where they differ, and which one would suit your situation the best. All 3 have strengths and weaknesses depending on what you are trying to do, so having a general knowledge of all 3 gives you the best chance to make a successful choice when you start your journey to define your infrastructure as code!

I'm just trying to keep my head above water

I'm a lucky guy, and I know it! I'm a middle-aged white male with a good job, a great wife, and all of that. Life is pretty good! Or at least it should be...

The other side of the story is that I have spent most of my career struggling mentally. I've not only questioned myself professionally since day one, but I have also had to take time off work because I couldn't even get out of bed in the morning. Still, most people around me don't have a clue about my situation. When they find out, they generally go "What? You? I would never have thought that"... A response that probably indicates how well I manage to hide it from the world. But I am more and more certain that that is not the right way to handle it...

I have spent a LOT of time trying to find ways to cope with the struggles in my life. Trying to balance my private life and work. Something that is much harder than it sounds in our industry. And I think we need to talk about it.

I want to talk about some of the things I have experienced, and some of the things I have done to try and make my life…well…a life for me. I also want to explain how getting a book about living with ADHD from my parents when I was 40 became a life altering experience. Not to mention what I think we as an industry could do to make life better for the people in it.

The not-so-SOLID Principles of Software Development

Most developers have probably, at some point, been told that the SOLID principles are the foundation that all good software stands on top of. The presenter of this session has even traveled around the world and told thousands of people this at various conferences and usergroups. However, is it really so?

After years of talking about, and thinking about the SOLID principles, Chris Klug has started to question the validity of them. Are these principles still valid 20+ years after they were formulated? Or have we moved beyond these principles and found other "truths" or pillars to build our software on top of?

In this talk, Chris will walk you through each one of the principles and explain what they are supposed to mean, as well as what they actually mean. He will also try to shed some light on whether they may or may not be valid anymore. And as you might have guessed by now, telling developers to strictly follow the SOLID principles might not be the most solid advice anymore.

The top 10 best new features in C# version 6 to 9

There is a lot of cool, and usable new features being added to C#. However, way too many of us are too busy building stuff, and fixing/creating bugs, to have the time to sit down and look take it all in. So why not let Chris Klug walk you through his top 10 new features that have been added in C# version 6 to 9.

Sure, C# has gotten a LOT more than 10 new things since version 6. But if you are a busy developer, like most of us are, getting an introduction to the top 10 ones in just an hour, could be a great start.

In this talk, Chris will show, and explain, his personal top 10 favorite features that have been added to C# in the last few years. Everything from awesome time savers and stability contributors, to syntax changes that allows your code to be denser and/or easier to read.

Infrastructure as Real Code - An Intro to Pulumi

Infrastructure as code has been a thing for quite some time now. Being able to version control the definition of infrastructure that you are running your system on is great! However, as a developer, I'm not sure I agree with the "code" part of the name when it comes to a lot of the tools out there.

Yeah, sure, it is kind of code... But it is often not so much code, as a bunch of configuration in JSON. And honestly, I'd call that "Infrastructure as Config".

Take Azure for example. Their solution to the whole thing is ARM templates. A technology that does the job, but it is pretty hard to understand, and not very flexible. And Terraform isn't much better in my opinion. Both technologies depend on a huge chunk of configuration that can be in source control. It is better than nothing. But it isn't code to me.

Pulumi takes a different approach to the problem. Instead of chunks of configuration, you get to write REAL code. You get to define your infrastructure in TypeScript. This opens up a whole heap of possibilities that a JSON-based DSL can't really compete with.

So why not come and have a look at what Pulumi can do for you?

Building a Better GitHub Pages Experience Using Azure Services, How Hard Can It be?

Have you ever looked at something and thought “I wonder how that works” or “I wonder how hard it would be to build that”? I think we all have! That’s why we are developers… And that’s exactly what I thought when I saw GitHub Pages!

Don’t get me wrong! GitHub Pages is an awesome concept! Automatically generate a static website from your version-controlled markdown files, and host it in the cloud so that it is easily accessible. I love it! But it also got me thinking, “I wonder if I can’t build a better version of that in no time using Azure, and maybe even add some features”. So that’s what I did!

In this talk, we will take a look at how easily we can build fairly complex systems using the services available to us in Azure. In this case, all I needed was a little DevOps, a container registry, some storage, a CDN, some serverless functions, a Docker container and some open source software to get it all going. And no, I didn’t spend 100 hours on it! I don’t have that much time to on stuff like this! And I’m sure you don’t either! So let me show you how you can use Azure like a set of building blocks to create weird and wonderful things in hours instead of months! And in a lot of cases, more or less for free! And who doesn’t like free stuff!?

ASP.NET Core Beyond the Basics

There are a lot of “getting started” talks in the ASP.NET Core world, but they won’t take you very far in the real world. What if you already know what the Startup class does, how configuration is handled, and what Kestrel is? Well, that’s where this talk might become interesting.

Instead of covering the basics of how to get up and running, this talk will have a look at some of the more…how to put it…complex areas of ASP.NET Core. Instead of looking at how you build a basic Hello World website, it looks at things like building custom middlewares and model binders, how we can do URL rewriting and run background tasks. And more!

With all the demos to be presented, and the limited amount of time to do it in, there will be no introduction to ASP.NET Core. There will be no “this template includes…”. Instead there will be a quick jump right into the deep end, and a big focus on expanding you knowledge of some of the more advanced abilities built into the framework!

A Developer’s Introduction to Kubernetes

Ok, so you know your Docker. You know how to create images and start containers. That’s cool, but where do we go from here? Well, all the cool kids are talking about Kubernetes and container orchestrators, and how they are like magic pixie dust to your applications. How they allow you to create solutions that are automatically load balanced, self-healing and even provides seamless rolling updates that allow you to release new versions with zero downtime. And knowing you, you probably want some of that too!

Honestly though, it isn’t magic, and It won’t “just work”! It can seem pretty close to magic though, but as long as you understand how it works, you can use it to bring your applications hosting to the next level. With the operative words being “understand it”… Unless you know what you are doing, it can’t really help you…but that’s where this talk comes in!
In this talk, we will start out by looking at how you can set up your local development environment to run Kubernetes based applications. After that, we will look at the architectural building blocks that make up Kubernetes , and then go on to look at some of the great features that Kubernetes give you, and how you can take advantage of them in your projects.
Most Kubernetes talks tend to focus on the DevOps side of things. And even if that’s where Kubernetes has the most impact, there are still quite a few things for us developers to understand before we can build applications that can be allowed in to the Kubernetes world.

SOLID – The five commandments of good software

The SOLID principles. The five commandments of the software world. Forgotten for years, as developers focused on JavaScript frameworks with stupid names and complicated patterns. Not grasping that the SOLID principles transcend beyond frameworks and patterns.
The SOLID principles are the foundation of building good software. They are the breakers of monoliths. The decouplers of coupling. The squashers of regression bugs. One might even say that they are the creators of maintainable code.
Unless you already a believer, you need to attend this session and get on the right path. Chris, the bringer of SOLID knowledge, will go through each one of the principles, explaining what it means, what it will do for you, and why you should stop breaking it. You will even be shown C# code that explains how they help you, and what problems will haunt you if you ignore them and are faced with their wrath.

Chris Klug

Developer Badass-as-a-Service

Stockholm, Sweden