The Linux kernel is the largest collaborative software development project ever. This talk will discuss exactly how Linux is developed, how fast it is happening, and how we all try to stay sane keeping up with it (hint, git is the reason).

The GitHub Systems team provides Git as a fast and reliable service, both as the backend for GitHub.com the website, and directly to users. To do that, we first make Git itself fast and reliable. But we also must consider Git as a distributed application, at the scale of billions of operations per day. Hear about the challenges that presents, and learn about the bespoke tools GitHub has built to monitor, shape, cache, and replicate transactions in our Git service.

Git is hard to grasp. This is especially true if you've worked for decades with centralized version control systems such as Perforce, CVS or SVN. This talk is about our journey to on-board 4000+ engineers with 200+ different code bases to Git at Autodesk. Amongst other things I will cover how we manage the Git client setup at that scale as well as our experiences with large Git repositories.

For over a decade Emma Jane Hogbin Westby has been teaching people how to use version control systems. Most people she's encountered still find Git hard to learn on their own. In this session you will learn why most approaches to teaching Git fail to appropriately address the adult learner, and what you can do to make the on-boarding experience easier for others. She will touch on adult education best practices, and also share the secrets that make it easier for very large (and corporate) teams to transition to Git.

Git was designed with the command line in mind, but does that hold the application back? John Haley, Product Owner of Axosoft GitKraken and Hamid Shojaee, Founder of Axosoft, argue that the CLI can be complicated and confusing, with a steep learning curve even for developers. That’s why they’ve created a Git client that is not only beautiful and easy-to-use, but actually translates Git concepts into visually understandable processes.

In this talk, they’ll describe the creative (and oftentimes argumentative) process of development. You'll learn how the process of developing and using a GUI can actually strengthen your knowledge of underlying concepts of Git; and how listening to your team and trusting them to experiment produces software that can advance, and ultimately change, the landscape.

Analyzing objects, rewriting history and migrating your team to a healthier repository. Many people have heard that Git does not handle large files or binary files very well and that it needs extensions to do things properly. But how true is this, how large is large, and what is special about "binary" files? In this talk I'll show how to use a new option to 'git cat-file' to analyse what is taking up the space in your repository and how effective Git's delta compression is in your repository.

There are many tools and lots of information available on how to rewrite a repository's history, should you decide that this is necessary. I shall demonstrate one way to rewrite history and talk about the merits of a number of the other options including erasing objects, replacing objects and migrating objects to alternative storage, including migrating to a solution such as Git LFS.

Rewriting history is inherently disruptive for shared team repositories but sometimes the cost is worth the benefit. Learn about techniques and tools for letting all team members - especially those less familiar with advanced uses of Git - easily migrate their work in progress to the new history.

Developers love Git for its raw speed, powerful history traversal, distributed nature, and the fact that it was built by uber developer Linus Torvalds. What we don't love is the fact that, out of the box, Git has somewhat lacking support for tracking large binary files.

Fortunately, developers from GitHub, Atlassian, and Visual Studio Online have teamed up to work on an open source (MIT licensed) project to solve this problem: Git LFS (Large File Support). This means researchers, web designers, game developers, multimedia producers and all other developers who need to work with large data and rich media can move off legacy centralized systems and start using modern version control.

In this session I'll cover the computer science behind Git LFS' internals & architecture, CLI usage and how to build an effective Git LFS workflow for a development team. Attendees will take away an understanding of how Git LFS works under the hood, and some practical advice on using Git LFS with their software projects and teams.

Streamlining your static website development workflow is easy with Git. Learn the benefits of “going static” for everything from simple Jekyll blogs hosted on GitHub Pages to prime-time commercial marketing websites. We’ll survey the static website landscape, including Jekyll, Gulp, and automated deployment with Git and Heroku. We’ll also explore practical use cases like automatically purging your CDN’s cache with GitHub hooks and containerizing your static site with a backend API.

Learn about a number of neat tricks used on the command line to make git experiences more straightforward. Most of these tricks compose the standard unix utilities. Only one or two require any packages outside of the standard set. At least one of these tricks will wow you so much that you’ll add it to your .bashrc on the spot. Discover the patterns used construct these small utilities and you will start creating and using your own.

Now is the time to bring the collaborative DVCS workflow to your deployments. This talk will walk you through the essential steps of making the collaborative DVCS workflow a reality at your company. Then discuss the strategies GitLab utilizes to make the most of this process.

To make the DVCS workflow a reality, teams must have their infrastructure described in the application git repository. The deployment process and all its stages and environments are a critical part of this. Your revision control software should have a container registry and your docker images created per each commit. Finally, updating configuration management cookbooks, manifests, playbook, and modules should not require a script but should be handled directly by the configuration management software.

In this talk, we’ll explore and use Git’s plumbing commands to dissect what is going on behind the scenes at a low level when you use Git.

We’ll walk through the underlying structures that constitute Git as we go spelunking in the .git folder, and explore its various parts: the objects directory (where we’ll inspect blobs, tree objects, and commit objects and how they relate to one another), the HEAD file, and finally, the refs folder, where we’ll look at heads and remotes. As we examine the general layout, we’ll discuss how Git is essentially structured as a Merkle Tree. Finally, we’ll look at Git’s garbage collection and how it ties into the system’s general structure.

Along the way, we’ll solidify our conceptual understanding of Git, exploring questions such as: How does Git store our information? What is at the heart of a branch? What is actually happening when you do a Git checkout? Or a reset?

Microsoft is in the middle of moving the majority of its own product development onto Git. Yes, that Microsoft. From small codebase to large. Over 15k developers are already using Git today, with 10’s of thousands yet to come. The journey to get there has been an interesting one, full of ups and downs. We'll discuss our journey and the challenges along the way, both social and technical.

Public recipes are the original open source, and for hundreds of years cooks have not only shared their source but also built incredible schools in their kitchens. Cooks of all levels face the constant pressure of staying relevant, and just like the best engineers, they do this by doggedly practicing the basics while experimenting on the bleeding edge. In this talk, we’ll learn to stay relevant by looking at the surprising parallels between modern kitchens and effective engineering teams.

Grab your badges and some breakfast

This workshop will cover several ways to write Git scripts. We will start by using the command-line client and Git's plumbing commands in shell scripts. Following that, we will demonstrate how to write Git scripts in scripting languages, by using libgit2 and the various bindings to it (the workshop examples will focus on Ruby and Rugged). Attendees should understand the basics of Git internals.

If you're starting a new project, using Git LFS is easy. For existing projects, however, converting a project can present a few challenges. In this workshop, we'll adapt an existing sample project to use Git LFS with Git's filter-branch command as well as the BFG Repo Cleaner. We'll also talk about the implications of these approaches on your project and your collaborators. Attendees should have a general understanding of Git internals and be comfortable working on the command line.

One of the big advantages of version control is knowing you have a safety net in case anything goes awry. In this workshop, we'll explore common predicaments and discuss how to use the best tool for the job to get out of different those tight spots. While the material we'll cover can help the beginner and the seasoned professional alike, attendees should have a basic working knowledge of Git and be comfortable on the command line.

git-imerge reduces the pain of merge conflicts to its unavoidable minimum, by finding and presenting the smallest possible conflicts: those between the changes introduced by one commit from each branch. It lets you interrupt, save, and publish in-progress merges — allowing you to test partially-merged code, or even collaboratively fix conflicts. In addition, it offers a straightforward method for preserving history while rebasing. This workshop will teach you how to use git-imerge to do all of this. It is intended for reasonably experienced users, though it requires no expertise in Git.