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.
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.
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.
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 threefavoriteGit tips. This one is in Swedish.
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.
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.
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.
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.
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.
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. 🚀
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.
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.
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?
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.
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.
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.
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.