1. Learn Git
    1. Learn Git with Bitbucket Cloud
      1. Create a Git repository
      2. Copy your Git repository and add files
      3. Pull changes from your Git repository on Bitbucket Cloud
      4. Use a Git branch to merge a file
    2. Learn about code review in Bitbucket Cloud
      1. Fork a teammate's repository
      2. Copy your fork and make a change to the repository
      3. Create a pull request
  2. Getting Started
    1. What is version control
      1. Benefits of version control
    2. What is Git
      1. Performance
      2. Security
      3. Flexibility
      4. Version control with Git
    3. Why Git for your organization
      1. Git for developers
      2. Git for marketing
      3. Git for product management
      4. Git for designers
      5. Git for customer support
      6. Git for human resources
      7. Git for anyone managing a budget
    4. Install Git
      1. Install Git on Mac OS X
      2. Install Git on Windows
      3. Install Git on Linux
    5. Setting up a repository
      1. git init
      2. git clone
      3. git config
    6. Saving changes
      1. git add
      2. git commit
    7. Git Stash
      1. .gitignore
        1. Inspecting a repository
          1. git status
          2. git log
        2. Viewing old commits
          1. Undoing Changes
            1. git checkout
            2. git revert
            3. git reset
            4. git clean
          2. Rewriting history
            1. git commit --amend
            2. git rebase
            3. git rebase -i
            4. git reflog
        3. Collaborating
          1. Syncing
            1. git remote
            2. git fetch
            3. git pull
            4. git push
          2. Making a Pull Request
            1. How it works
            2. Example
            3. Where to go from here
          3. Using Branches
            1. git branch
            2. git checkout
            3. git merge
          4. Comparing Workflows
            1. Centralized Workflow
            2. Feature Branch Workflow
            3. Gitflow Workflow
            4. Forking Workflow
        4. Migrating to Git
          1. SVN to Git - prepping for the migration
            1. For administrators
            2. Basic Git commands
            3. Git Migration Tools
            4. For developers
          2. Migrate to Git from SVN
            1. Prepare
              1. Convert
                1. Synchronize
                  1. Share
                    1. Migrate
                      1. Perforce to Git - why to make the move
                        1. Migrating from Perforce to Git
                        2. Advanced Tips
                          1. Advanced Git Tutorials
                            1. Merging vs. Rebasing
                              1. Conceptual Overview
                              2. The Golden Rule of Rebasing
                              3. Workflow Walkthrough
                              4. Summary
                            2. Reset, Checkout, and Revert
                              1. Commit-level Operation
                              2. File-level Operations
                              3. Summary
                            3. Advanced Git log
                              1. Formatting Log Output
                              2. Filtering the Commit History
                              3. Summary
                            4. Git Hooks
                              1. Conceptual Overview
                              2. Local Hooks
                              3. Server-side Hooks
                              4. Summary
                            5. Refs and the Reflog
                              1. Hashes
                              2. Refs
                              3. Packed Refs
                              4. Special Refs
                              5. Refspecs
                              6. Relative Refs
                              7. The Reflog
                              8. Summary
                            6. Git LFS

                            What You Need To Know About The New Git 1.8.2 Release

                            Nicola PaolucciNicola Paolucci
                            Back to list

                            I love scouring the release notes of my favorite tools for hidden (or not so hidden) gems. It's a little bit like Christmas every time. I get that nice feeling of anticipation and curiosity when new versions are released of my faithful OSX open source window manager Slate, on Rails, Django, CoffeeScript and of course Git and many others.

                            Upgrading, upgrading, upgrading

                            So the new Git 1.8.2 release is out. Of course this means upgrading to the latest version. It should be relatively pain free:

                            • Just type brew update && brew upgrade git if you use homebrew on OSX.
                            • Use a magic apt trick if on Ubuntu based distributions (I leave other distributions as an exercise for the reader).
                            • Simply run the new installer if on Windows.

                            So what's new in Git 1.8.2?

                            As usual, a lot has been fixed. A few specific things caught my interest in this latest release.

                            Streamlined behavior for add -u and -A

                            git add -u is the flag used to tell Git to also stage deletions when adding stuff from the current directory to the index.

                            And git add -A is used to add everything and stage deletions starting from the current directory. It used to be equivalent to:

                            git add .; git add -u

                            This behavior has now changed and -u/-A flags will operate on the entire source tree to make it consistent with git commit -a and others that already work this way. This is a backwards incompatible change, though hopefully of light impact.

                            Useful **/ pattern to use in .gitignore

                            The beloved .gitignore file gains a cool new **/ pattern that matches zero or more levels of a subdirectory: E.g. "foo/**/bar" matches "bar" in "foo" itself or in a subdirectory of "foo".

                            In addition to this, Git now sports a check-ignore command that can be used to debug the .gitignore settings: E.g.

                            [4967] λ # git check-ignore --verbose dist/
                            .gitignore:1:dist       dist/

                            Improved completion script

                            If you use the command line and have setup git shell auto completion you have probably noticed how useful it is. In this release the completion script has been improved to be smart about which files to show when you git add, discarding not relevant ones like unmodified paths.

                            Colored Aliases And Script Interactions

                            I use heavily colored log commands as I showed in my alias post a while ago. This release brings in a nice tweak that automatically disables colors when the output is not used for a terminal, very useful when using Git commands in scripts.

                            How do you use it? Just pre-pend auto to the color specifier like:


                            Ancestry graph in git log now works with combined diff output

                            The --graph output of git log used to struggle if you added the -p to show the combined diff output. Now it works as expected:

                            git log -p --cc --graph

                            Better Sync Status Between Local and Remote Branches

                            This is actually something from the 1.8.1 release but neat nonetheless:

                            When "git checkout" checks out a branch, it tells the user how far behind (or ahead) the new branch is relative to the remote tracking branch it builds upon. The message now also advises how to sync them up by pushing or pulling. This can be disabled with the advice.statusHints configuration variable.


                            That's it for now. Enjoy the goodies, let me know what you think on Twitter @AtlDevTools.