Training

Git has become the de facto version control system of our industry, and for good reason. But for all its power and flexibility, Git has a terrible flaw: its complexity. A myriad of awkwardly named commands and options have earned it the reputation of being hard — and unnecessarily so — both to learn and to use.

I don't believe Git is hard to understand, though. Git is surprisingly simple at its core. If you don't believe me, type man git and read the very first line:

git — the stupid content tracker

Git is nothing more than a simple, yet very efficient, content tracker for your files. The key to its power is to understand it at a fundamental level — and the best way to do that is to actually see what's going on behind all those cryptic commands. That's exactly what this workshop is about.

What you will learn

Git from the inside out: you'll understand how the commands work by watching a real-time visual representation of Git's internal object model. Each time you create a branch, merge or rebase, you'll see how it affects your history. Once you have that mental model, the magic disappears and you'll make Git work for you instead of the other way around.

Topics

• ›The Git Parable
• ›Git's object model
• ›Anatomy of a commit
• ›Customising the way you view history
• ›What the index is and what it's good for
• ›Branching, a visual explanation
• ›Rebasing, a visual explanation
• ›Different kinds of branches
• ›Different ways of merging
• ›Branches vs. tags
• ›Resolving conflicts
• ›Choosing a Git client that works for you

Audience

Developers with little to no experience with Git. The only prerequisite is some familiarity with a command-line shell; I'll show you how to work with Git from either PowerShell or Bash. You don't have to keep using the command line afterwards — it's a learning tool to understand how Git works. Once you master the concepts, pick any Git client you like.

You've been using Git for a while and feel comfortable with the basics: committing, branching, merging. But something is missing — maybe you're not taking full advantage of what Git has to offer; maybe you occasionally end up with an entangled history and would like to know how to avoid that. If that sounds like you, this workshop is for you.

Mastering Git is about going beyond the basics and learning to use Git to support your working style, both individually and within your team — and picking up a few tricks along the way that will directly improve your day-to-day workflow.

What you will learn

The value of a clean history and how Git was designed to let you keep one: what makes a good commit, when and how to rewrite history, readable vs. true history. Then branching strategies — GitFlow, GitHub Flow and when each makes sense — submodules for dependencies between projects, and the techniques that make you faster: recovering lost commits with the reflog, parallel work with multiple working directories, and finding the commit that introduced a bug by binary search.

Topics

• ›The importance of a good-looking history
• ›ACID commits
• ›Consistent line endings and whitespace
• ›When and how to rewrite history
• ›The many ways to use git rebase
• ›Choosing a branching strategy
• ›GitFlow vs. GitHub Flow vs. Your Own Flow™
• ›Dependencies between projects with submodules
• ›Searching history
• ›Recovering lost commits
• ›Reusing conflict resolutions (git rerere)
• ›Multiple working directories (git worktree)
• ›Debugging (git bisect)
• ›Taking care of your repository (git gc)

Audience

You should feel confident with Git's fundamental concepts. If you'd like to strengthen that first, take Understanding Git and have this as a continuation — both workshops share the same visualisation techniques. You should also be comfortable with a command-line shell; I'll use PowerShell or Bash, based on your preference.

Modern web applications consist of an ever increasing number of moving parts: JavaScript frontends, web APIs, microservices, cloud environments — the list goes on. Building and deploying them means juggling a complex set of tools and services and making them come together in one unified, fully automated process, from source code to production servers.

As a .NET developer living in a DevOps culture, how do you achieve that without investing in a whole new set of tools and languages? Meet Cake: an open source, cross-platform build automation tool with a rich ecosystem of integrations — and a C# DSL that will make you feel right at home.

What you will learn

Everything you need to automate a complete build and deployment pipeline for a modern ASP.NET Core web application using nothing more than C# and Cake — and, as a bonus, how to write maintainable build scripts that adapt as the needs of the software change.

Topics

• ›Compiling using MSBuild and the .NET CLI
• ›Running automated tests and measuring code coverage
• ›Versioning based on the Git history of the project
• ›Packaging with NuGet or as regular Zip files
• ›Publishing the application as a Docker container
• ›Deploying to an on-premises web server using Octopus Deploy
• ›Deploying to an Azure Web App using Kudu
• ›Deploying to a containerised Azure Web App with Docker and ACR
• ›Integrating with CI servers such as TeamCity, Azure DevOps and GitHub Actions
• ›Troubleshooting the pipeline with logging and debugging

Audience

C# developers who want a CI/CD pipeline without learning a completely new set of tools and languages. If you've worked with other Make-like build tools before, great; if not, we'll cover the basics of writing a solid build script.