Git

Git is a distributed open source source control (also referred to as "version control") system commonly used to track and manage file changes. Git is frequently used as the version control system for Python projects.

Why is Git widely-used by developers?

Git is a distributed version control system (DVCS) compared to the centralized models previously provided by Subversion and CVS. Files would need to be "checked out" over the network by a single person at a time while she was working. The network transfer speed as well as the blocking check out model became a significant bottleneck, especially for large development teams.

Git clones a full repository and its entire history instead of just the current state of a file. Developers only require a network connection when pulling updates and pushing changes to a backup repository. The commit log and file histories are stored and transmitted far more efficiently than prior version control systems to maximize the effectiveness of the distributed version control design.

Another issue with traditional VCS was that it was difficult to create branches. Take a look at this tutorial on managing a CVS repository as an example of the confusion the existing non-distributed models could cause. Git simplified the branching process with simplified commands such as git checkout -b and faster branch merging and clean up. In contrast to earlier version control systems, Git encourages developers to create local branches and experiment in them without impacting a stable master branch.

GitHub also helped to drive Git as the overwhelming version control favorite by providing the open source community with free open remote Git repositories. GitHub's web application user interface, issue tracking and pull request features for maintainers and consumers also encouraged more collaboration than Git alone. Recently, GitHub's third-party marketplace has begun to add more features by integrating continuous integration servers like as Jenkins and code metrics services.

Beginner Git tutorials

Git can take awhile to wrap your head around, even for experienced software developers. The following tutorials can quickly get you up to speed.

• The official Pro Git book is available online for free. It is awesome both as a step-by-step walkthrough and as a bookmarked reference on specific topics.

• Git from the inside out provides a spectacular walkthrough for developers who have used Git before but want to go deeper in understanding what each command does under the covers instead of simply using the tool as a black box.

• Think like a Git is another introduction that focuses more on the graph theory and conceptual ideas behind Git to help the reader understand what's happening as they use Git commands.

• Git and GitHub in plain English is a high-level overview of both Git and GitHub. This guide is intended for both non-programmers and junior developers who want to learn everything from terminology to workflow.

• A Hacker's Guide to Git is a free ebook written for experienced developers that contains both the syntax and the conceptual ideas behind how Git works.

• A Designer's Guide to Git gives a beginner's Git overview for non-programmers. The tutorial also covers using Git clients such as the GitHub desktop application.

• Git in Six Hundred Words is a concise essay explaining what happens when you add and commit files in a Git repository.

• 19 Tips For Everyday Git Use is a laundry list of helpful Git tips on commands such as git bisect, git stash and git difftool.

• git ready presents beginner, intermediate and advanced tips for how to use Git. The example commands and their results are great for learning Git piece-by-piece.

Advanced Git tutorials and resources

You won't learn Git in an afternoon or even a few months of usage. After six-plus years of working with Git I still get tripped up and have a lot to learn. These tutorials have taught me some of the beyond-the-basics edge cases.

• Flight rules for git contains common commands that answer specific desired tasks such as "I want to discard specific unstaged files" (git checkout filename) and "I want to rename a branch" (git branch -m newname).

• Shadows Of The Past: Analysis Of Git Repositories explains how you can extract some surprising data from Git repositories' commit history, such as which developers are domain experts in certain tools, potential hot spots in the code and coupling between source code files. This is a great read once you get past the basics of using Git.

• Write yourself a Git! is a tutorial for building your own version of Git from scratch with 503 lines of Python code. The result is obviously not as full-featured as the real Git implementation but this program is awesome for understanding how Git's internals work.

• Phil Nash shows how to use the git reflog command in Git back to the future.

• On undoing, fixing, or removing commits in git is a fantastic overview of how to unscrew a whole slew of bad situations you may find yourself in if you use Git for long enough.

• High-level Problems with Git and How to Fix Them is a long-form article on how to fork properly (and how not to use them) and how to not go crazy using branches and remote repositories.

Specific Git resources

Large tutorials are great for getting started with Git. However, sometimes you need tactical support or want to learn new tricks to add to your workflow. These resources will come in handy for specific Git subjects.

• How to Write a Git Commit Message provides strong advice that will help you write consistent, concise and contextual messages on your commits. Commit messages are especially important when working with others on a long-lasting project where you dive through the commit history via git log and related commands.

• How to squash Git commits explains how to use the git rebase command in interactive mode to consolidated the number of commits in your history. This technique is useful when a group of commits are related and it's easier to understand them as a single commit rather than a collection of smaller commits.

• Oh shit, Git! is a profanity-filled description of tips to get you out of binds you may find yourself in when you get too tricky with Git commands.

• Tips for a disciplined git workflow is less about workflow and more about how to write self-explaining commit messages, self-containing each commit and modifying branch history when you muff up before it is merged into master.

• Another Git catastrophe cleaned up goes through a difficult merge scenario that required deep Git understanding to properly fix.

• Erlang's source code provides a concise explanation on writing good commit messages that any programming ecosystem can learn from.

• Git internals is a presentation that covers how Git stores data, how to work with the Git history, and good practices for using Git based on the knowledge of how it works internally.

• Chasing a bad commit examines the git bisect command and how it can be used in either interactive mode or on its own with git bisect run to find the problematic code commit that needs to be fixed.

• GitTips is a list of pro tips to clean up common issues and how to dive through Git history to find specific text.

• Git allows command aliasing, which allowed one developer to create his own list of lesser known Git commands that alias more complicated Git lines.

• Little things I like to do with Git has some nice tips such as easily viewing branches you recently worked on and generating a changelog from your commits.

• Git from the inside out demonstrates how Git's graph-based data structure produces certain behavior through example Git commands. This is a highly recommended read after you've grasped the basics and are looking to go deeper with Git.

• How I configure my git in a new computer shows how to handle a .gitconfig file, with an example Gist that the author uses for his own environment.

• How to Quickly and Correctly Generate a Git Log in HTML is an interesting look at how string processing on *nix systems works by generating an HTML page from a Git log. If you need to output your Git commits somewhere and are having trouble writing your own script you should check out some of the interesting solutions the author presents.

• Better Git configuration explains global config options, revisions and merging along with several other commands that can be customized to your taste.

• Why does Git use a cryptographic hash function? explains that the SHA-1 hash isn't used for security on Git, it's a consistency check. SHA-1 has been broken in practice so Git needs to transition to a stronger hash without proven collisions but it's not quite as big of a concern compared to security-related projects that use SHA-1.

• The anatomy of a git commit digs into the tree and commit objects that underpin the Git source control system. This is an awesome read to get a view on how Git works under the commands you're using to manipulate these objects.

• How to Undo Mistakes With Git Using the Command Line is a video that covers topics like resetting a file to an old revision, recovering deleted commits, squashing multiple commits into one with interactive rebase and recovering deleted branches.

Git Workflows

Teams of developers can use Git in varying workflows because of Git's distributed model and lightweight branching. There is no "right way" to use Git, especially because development teams can range in size from a single developer up to entire companies with thousands of developers in a repository. The only correct answer is to let the developers decide on a workflow that maximizes their ability to frequently commit code and minimize merge conflicts.

• git-flow shows one possible way for small teams to use Git branches. GitHub Flow explains why at GitHub they do not use the git-flow model and provides an alternative that solves some of the issues they found with git-flow.

• Comparing workflows provides a slew of examples for how developers on a team can handle merge conflicts and other situations that commonly arise when using Git.

GitHub resources

GitHub is a software-as-a-service application owned by Microsoft that makes it easier to collaborate with other developers on centralized Git repositories. The site also provides a remote backup location for repositories as well as secure, private repository storage. The following tutorials show how to get started using Git on GitHub.

• Introduction to Git and GitHub for Python Developers covers basic usage for Git and working with repositories locally and on the GitHub service.

• Hello World: GitHub edition and Git and GitHub learning resources are GitHub's official guide and learning resources.

• A Beginner’s Git and GitHub Tutorial shows how to perform your first commit and back it up on GitHub.

What else do you want to learn about?