Git Merge 2017

In this talk we'll see what technologies GitHub has developed to handle the more challenging repositories and use-cases, from heuristics to replication and quotas, as well as what it takes to backup this data.

Over the last year, we have continued to invest in Git and have lots of exciting information to share about the work we’ve done to embrace Git across the company, for teams of any size. During this talk, we plan to discuss, in depth, how we are using git internally with a specific focus on large repositories. We’ll discuss the architecture of VSTS’s git server which is built on Azure and the customizations we’ve had to make to both it and git.exe in order to enable git to scale further and further. These customizations will cover changes that we’ve contributed back to the git core open source project as well as changes that we haven’t talked about externally yet. We’ll also lay out a roadmap for the next steps that we plan to take to deal with repositories that are significantly larger than git can scale to today.

Git is powerful but complicated, especially for novices. In this talk, we are going to apply a new theory of design, that focuses on the purposes and concepts underlying software, to explain well-known difficulties with Git---and suggest ways in which Git could be made easier to learn and use.

This talk will showcase how Git can be used for the classroom, for writers and professionals that can benefit from using Git for their work.

Facebook uses Mercurial to host some of the largest, fastest growing distributed version control repositories in the world. Over the past four years we’ve dealt with numerous scaling challenges, ranging from the number of commits per minute to creating robust, redundant server infrastructure. We’ve also introduced significant user experience improvements to make it easier to ramp up new engineers and to make power-user workflows more accessible to everyone. In this session we’ll talk about the specific technical and user experience improvements we’ve open sourced to handle our growing scale, with an emphasis on the lessons learned that could be valuable to Git and the Git community.

Git and its extensions are becoming more popular than ever. However, certain use cases may still be suboptimal. We identified a way to dramatically improve performance in a popular Git extension - LFS (Large File Storage) - that required changes in both Git Core, and the extension itself. Based on our combined experiences we’ll walk you through the process of a successful contribution to each project with the help of mailing lists and Pull Requests. If you have already a bit of Git command line knowledge then this talk will prepare you for your first contribution to Git, an extension, or both.

With five major releases this year, the Git project's incredible velocity and iron-clad backwards compatibility are something of a paradox. How does a CLI tool introduce hundreds of new features without changing its existing behavior? With command-line options of course! The downside of this is that Git now has literally thousands of options littering its main pages. The only way to master them is through the ancient art of aliasing.

We'll cover the nuts and bolts of creating aliases including parameter handling, incorporating multiple commands in the same alias, and tweaking the behavior of Git through options, environment, and inline configuration overrides. Then we'll move on to the fun part: a bestiary of aliases. These are not your mother's git config alias.co checkout! I've scoured dark corners of the web, freenode, and social media to uncover mystic aliases that perform every function from automating your team's standup meeting to I'm feeling lucky searches across your DAG. We'll break apart each alias in turn, and dissect their guts to understand how it does what it does.

Some people love it, some people hate it, and some people are even doing it: pair programming. That means two people, one computer. Git doesn't support this workflow natively, but there are workarounds and best practices how to do productive pair programming with git. This presentation will give an overview of how this works with practical insights of one of the biggest open source projects using pair programming as its primary means of development. It will include a sketch and discussion how git could get native support for pair programming.

This talk will cover the details on how to cryptographically sign your work; from PGP fundamentals and best practices, what gets signed and how to verify those signatures, to possible impacts, and benefits to your workflow. We’ll also take a look at Github’s interface changes from earlier this year that added visual cues to highlight verification status of commits and tags.