You are here:

What is GIT?

How does GIT differ from other version control systems?

GIT is a distributed version control system that allows every developer working on a project have their own working copy with the full history of all changes instead of keeping the project history in one single place.

GIT: Basic Facts

How does GIT differ from other version control systems?

	GIT is a version control system that treats data like a stream of snapshots: Every time you commit, GIT takes a picture of what all your files look like at that moment and stores a reference to that snapshot.
	Most operations in Git only need local files and resources to operate. In fact, you can go without a remote repository at all.
	All the changes made in files or folders are known to GIT. You cannot lose information in transit or get a corrupted file with GIT failing to detect it.
	Nearly any action in GIT actually adds data to the Git database: When you commit changes to a file, GIT doesn't replace the 1st version of the file with the 2nd one; it doesn't store both versions of the file either - it "writes down" how the initial file was changed, when, and by whom.

GIT: Pros & Cons

Like any other system, GIT has its positive and negative sides.


+	The algorithms implemented inside Git are optimized for quick and effective committing, branching, merging, and comparing versions.	-	GIT can be difficult to learn.
+	GIT focuses not on the file name but on the content of the file itself.	-	With GIT, you do not necessarily need a central, "official" repository.
+	File content as well as the true relationships between files, folders, directories, versions, tags, and commit are secured with a cryptographically secure hashing algorithm SHA1.
+	GIT supports various kinds of nonlinear development workflows.
+	With GIT, operations that affect branches and tags are also stored as part of the change history.

Places to play

With GIT, your files can be in one of three states:

modified means that you have changed your files but haven't committed them to the database yet;
staged means that you have added your modified files to index and they will go into your next commit snapshot in their current version;
committed means that your files are safely stored in your local database.

Besides, your files can also be pushed to the remote repository (if you have one).

This means that there are 4 main sections of your GIT project - 3 in your local repository and 1 in your remote repository.

Remote repository is a virtual storage of your project hosted on the Internet or network somewhere (if you work alone and do not need to share your files with anybody, you can do without it).
Local repository is a virtual storage of your project hosted on your computer. Here the metadata and object database for your project is stored. Local repository is what is copied when your clone a repository from another computer.
Working directory is a working copy of your project created when you checkout any branch of your project (typically, the folder that contains the .git folder); the directory where you modify your files and keep your changes before committing them.
Staging area (also called index) is a file that stores information about what will go into your next commit.

There is also the 5th section in your project - stash area - though we shall not speak about it yet. You can read about stash and stashing here and here.

GIT: Generalized workflow

Definite actions you perform when working on your project depend on your production work flow and development needs.

However, they can still generalized in the form of a simple diagram (given below).

The number of possible workflows is big, so it might be very difficult to choose the correct one when implementing GIT in your team.

However, there are some common ones that can be taken as a starting point:

centralized workflow,
feature branch workflow,
specified branches workflow, and
personal repositories workflow.

Here you can read about these four common workflows (includes details and examples).

Useful links

Peter Cottle (formerly, of University of California, Berkeley) has created an interactive online tutorial about GIT branching - it is here:

In this tutorial, you can play with some simple branches, experiment with training commits, test merging and rebasing, etc. The tutorial is very useful for GIT beginners though it uses GIT commands and not IDE.