Some good resources:
The starting point of using Git is the repository. A repository is a folder in which you've run the command git init. This command creates a hidden folder called .git that you basically never need to look at. Forget it exists. When working with git, you rarely need multiple folders. Compare this to the TFS where each branch gets its own folder. Instead, switching branches in a repo modifies all the files in the repo folder to look exactly like they did in the other branch. This is part of why branching in git is super fast and super useful.
The most common command you will ever run is git status. This will print some information on the current status of the repository, including the current branch, changes staged to be committed, untracked file etc.
Another informative command is git log. This will simply print a list of all the commits and some information. This command supports many different options, eg git log --oneline.
After running git init, you also need to make an initial commit. Committing can be done either by typing git commit (which will open up a prompt for the commit message) or using a shorthand like git commit -m 'my commit message'. But if you try to commit now, git will tell you it doesn't know what you want committed. Anything you want added to a commit has to be "staged" first. This is done with the command git add <filename> or optionally, if you want everything staged, git add ..
A commit contains a diff of changes, a commit message (which consists of a title and an optional description), a checksum (which is essentially an ID), and a reference to the commit that precedes it. This way, all the commits form a chain you can follow back to the original. Git's history can only go in one direction, this is important to note when you do more advanced stuff with eg git rebase.
What is a branch? A branch is a reference to a specific commit. As described above, each commit tracks the previous commit, forming long chains of data packets, diffs, that together can be reassembled into data. Every time you make a new commit, the branch starts pointing at this new commit, and the commit remembers the previous one. Although a commit history can be modified and revised, doing this with commits that have been pushed to other repos is dangerous and leads to history conflicts.
You can easily create and throw away branches. Branching takes milliseconds and switching between branches the same.
- Git is, unlike TFS or svn, a decentralized version control system.
- Branches are much more lightweight, compared to TFS, and used in a different way.
- Many possible workflows, eg merge vs rebase.
In TFS, multiple people working on the same branch can get hairy fast. Not so much in git. But most git resources recommend making a lot of branches.
- rebase -i
- cherry-pick
- add -p
- diff --stat
- stash
- bisect
- tag