Going out and meet the developer community while giving technical talks is something I truly enjoy. Whether it be at a big conference, a user group or at a client, I love sharing knowledge and experiences. And the best part is, it goes both ways: with every presentation, I teach something and learn something new myself.


I keep a list of my upcoming talks at conferences and user groups.

DevSum 2022
May 19–20, 2022 Stockholm, Sweden

Swetugg 2022
September 19, 2022 Gothenburg, Sweden

Techorama NL 2022
October 11–12, 2022 Utrecht, Netherlands


Here's a list of podcasts I have been a guest on:

.NET Rocks! 1680 GitHub Actions with Enrico Campidoglio

With the release of my Pluralsight course "Building Custom GitHub Actions", I talked to Carl and Richard about GitHub's CI/CD solution and how it compares to similar offerings like Azure Pipelines. We discussed topics such as GitHub's value proposition, the influence of Microsoft owning GitHub and the role of Continuous Integration in the era of DevOps. Also, the philosophical differences between cars and carpets.

.NET Rocks! 1680 — Cars and Carpets

Developer On Fire 414 Enrico Campidoglio — Clean History

I had a lovely conversation with Dave Rael about what "fires me up" and keeps me going as programmer and teacher. Some of the topics we talked about include how I got into teaching, my move from Italy to Sweden, the eternal debate of true vs. clean history in Git and, of course, some computer history with my old Olivetti M24.

Developer On Fire 414 — My First Computer

Developers! 16 The Story of Git with Enrico Campidoglio

I had the pleasure to geek out with Madeleine and Sofia about two of my favorite subjects: Git and keyboards. We gathered around the virtual campfire and talked about Git's origin story, the Unix philosophy and how to choose a workflow that fits you and your team. I also shared my top three favorite Git tips. This one is in Swedish.

.NET Rocks! 1079 Databases in Continuous Delivery

While I was at NDC London 2014, I spoke to Carl and Richard about including relational databases in the Continuous Delivery process. I had a lot of fun doing this episode and we even managed to squeeze in a few words about vintage computers — I couldn't have asked for more.

.NET Rocks! 1082 State of DevOps in .NET at NDC London

This episode was a panel discussion recorded live in front of an audience at NDC London 2014. The topic was the presence of the DevOps culture among .NET developers. During the discussion we also shared our experiences with implementing Continuous Delivery in .NET projects. The panel consisted of Ben Hall, Peter Mounce, Jeff French and myself.


Here's a selection of some of my most popular presentations from recent years. I linked to the slides and demo material as they were available. If a talk was recorded, I made sure to include a link to the video as well.

DRY TDD with AutoFixture NDC London 2021

In this talk, I show you how to write DRY tests by leveraging an open source library called AutoFixture.
AutoFixture lets you set up your test scenarios by runtime-generating data that meets your requirements.
By not repeating the same boilerplate setup code everywhere, your tests will have minimal coupling to your production code.
They will be your safety net while also giving you the freedom to refactor your production code as you see fit.

How Effective Teams Use Git
NDC DevOps 2020 NDC Oslo 2020

In this talk, I share with you what I've learned from working with people who are really good being productive using Git. I show you the things you can do to make Git more pleasant to work with and improve the way you collaborate with the rest of your team. Success starts with good habits—by seeing how effective teams use Git in their daily work, I hope you'll be inspired to pick up a new one.

Understanding Git — Behind the Command Line NDC Oslo 2019

In this talk, I show you how Git works from the ground up. I start out by going through Git's fundamental concepts and how they're implemented in the object model. From there, I work my way up to the user-facing commands and show you how to take advantage of Git's unique features to craft a beautiful history without having to compromise on your workflow. If you ever wished you knew how Git really works, then this presentation is for you.

Cake + .NET Core = Write Once, Build Anywhere NDC London 2018 Demo

In this talk, I explore how to use Cake (C# Make) to automate the build of an ASP.NET Core app from start to finish. I use it to compile, test, version, package and deploy the application — all using C#. In the spirit of the modern .NET Core lifestyle, I do the whole thing cross-platform, by developing the build script on macOS, having it run in a Continuous Integration server on Linux and using it to deploy to Azure. 🚀

The Things Git Can Do NDC Oslo 2016 WROC# 2016

In this talk, I demonstrate exactly what Git can do for you that none of the GUI tools ever tells you about. Moving chunks of commits between branches in a single command, custom history visualizations and data recovery are only some of the things I demonstrate, all 100% from the command line. If you're using Git through a GUI, you're missing out and in this talk I show you why.

Testing with No Harm NDC London 2016

In this talk, I explore the question of whether creating automated tests inhibits good design by looking at the trade-offs we are often faced with when we want to make our code testable. We look at techniques like BDD and Specification by Example and see how they use tests as a way to lead the design to fit its purpose. We also look at the balance between unit tests, integration tests and end-to-end tests in order to decouple our tests from the internal structure of the system. All to achieve the honorable goal of testing with no harm done.

Databases: The Elephant in the CD Room NDC London 2014

In this talk, I look at the challenges of continuously deploying a SQL database. I explore issues such as packaging and versioning, handling schema changes, migrating data and recovery. What tools do we have at our disposal? What strategies can we put in place to prevent us from having to bang our heads against the wall when something goes wrong?

Testing the Essential with AutoFixture Leetspeak 2014 Slides

In this talk, I show you how to get rid of dummy values in your tests by leveraging anonymous test data. By using a library like AutoFixture to runtime-generate test data that meets your requirements, you can free yourself from having to write a lot of boilerplate setup code in your tests, leaving them to contain just the essence of what is being tested. It'll also makes them more robust, since they no longer rely on hard coded constants to determine their outcome.

Why No Code Reviews? NDC Oslo 2014 DevDay 14

In this talk, I explore the social and practical reasons why code reviews aren't as widely adopted in modern software development shops as they should be. We look at a few concrete tools and techniques that teams can put in place to help them overcome the most common road blocks. In the end, we'll see how code reviews help peers leverage each other's knowledge and skills to ensure their work is as good as it can possibly be.

BDD All the Way Down GOTO Aarhus 2013 Foo Café Blog

In this talk, I show how to apply the Behavior Driven Development (BDD) cycle when developing a feature from top to bottom in a fictitious .NET web application. Building on the concepts of Test Driven Development, I demonstrate how BDD helps you produce tests that read like specifications, by forcing you to focus on what the system is supposed to do, rather than how it’s implemented.

Grokking Git by Seeing It Leetspeak 2012 Blog

In this talk, I teach you the Git zen from the inside out. Working out of real world scenarios, I walk you through Git’s core concepts and building blocks, building our way up to more advanced features. And I do it by showing you graphically what happens under the covers every time you fire a Git command. It’s my belief that this kind of deep understanding of Git’s inner workings is the key to unlock its true power: taking control of your history.

Make Your System Admin Friendly with Powershell Blog

In this talk, I show you how to enhance an existing .NET web application with a set of administrative tools, built using the PowerShell programming model. Once that is in place, I demonstrate how common maintenance tasks can either be performed manually using a traditional GUI or be fully automated through PowerShell scripts using the same code base.