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.
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
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
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.
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 stash and
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.
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.
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.
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
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 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.
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.
Git Workflows That Work is a helpful post with diagrams to show how teams can create a Git workflow that will help their development process.
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 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.
A Beginner’s Git and GitHub Tutorial shows how to perform your first commit and back it up on GitHub.
The most accurate speech-to-text API. Built for Python developers.