Speaking

Going out and meeting 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 the best part is, it goes both ways: with every presentation, I teach something and learn something new myself.

---

Podcasts

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.

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.

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.

---

Presentations

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.

Git Hidden Gems — Copenhagen Developers Festival 2023

There is more to Git than meets the eye. On the surface, it's a version control system. Underneath, it's a virtual file system built to track your files. And right in between is a wealth of productivity features very few people know about.
As a Git enthusiast, I feel it's my duty to spread the knowledge about these hidden Git gems. From automating common daily tasks, to better handling of merge conflicts, these features are the quality of life improvements you always wished you knew about.

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 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 — 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: Write Once, Build Anywhere — NDC London 2018

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

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?

Why No Code Reviews? — DevDay 2014

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é

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