Git / Github


Category: Tags: ,
Product Description


  • Background
    The Birth of Git
    What’s in a Name?

Installing Git

  • Using Linux Binary Distributions
    Other Binary Distribution
    Obtaining a Source Release
    Building and Installing
    Installing Git on Windows
    Installing the Cygwin Git Package
    Installing Standalone Git (msysGit)

Getting Started

  • The Git Command Line
    Quick Introduction to Using Git
    Creating an Initial Repository
    Adding a File to Your Repository
    Configuring the Commit Author
    Making Another Commit
    Viewing Your Commits
    Viewing Commit Differences
    Removing and Renaming Files in Your Repository
    Making a Copy of Your Repository
    Configuration Files
    Configuring an Alias

Basic Git Concepts

  • Basic Concepts
    Git Object Types
    Content-Addressable Names
    Git Tracks Content
    Pathname Versus Content
    Pack Files
    Object Store Pictures
    Git Concepts at Work
    Inside the .git Directory
    Objects, Hashes, and Blobs
    Files and Trees
    A Note on Git’s Use of SHA1
    Tree Hierarchies

File Management and the Index

  • It’s All About the Index
    File Classifications in Git
    Using git add
    Some Notes on Using git commit
    Using git commit –all
    Writing Commit Log Messages
    Using git rm
    Using git mv
    A Note on Tracking Renames
    The .gitignore File
    A Detailed View of Git’s Object Model and Files


  • Atomic Changesets
    Identifying Commits
    Absolute Commit Names
    refs and symrefs
    Relative Commit Names
    Commit History
    Viewing Old Commits
    Commit Graphs
    Commit Ranges
    Finding Commits
    Using git bisect
    Using git blame
    Using Pickaxe


  • Reasons for Using Branches
    Branch Names
    Dos and Don’ts in Branch Names
    Using Branches
    Creating Branches
    Listing Branch Names
    Viewing Branches
    Checking out Branches
    A Basic Example of Checking out a Branch
    Checking out When You Have Uncommitted Changes
    Merging Changes into a Different Branch
    Creating and Checking out a New Branch
    Detached HEAD Branches
    Deleting Branches


  • Forms of the git diff Command
    Simple git diff Example
    git diff and Commit Ranges
    git diff with Path Limiting
    Comparing How Subversion and Git Derive diffs


  • Merge Examples
    Preparing for a Merge
    Merging Two Branches
    A Merge with a Conflict
    Working with Merge Conflicts
    Locating Conflicted Files
    Inspecting Conflicts
    How Git Keeps Track of Conflicts
    Finishing Up a Conflict Resolution
    Aborting or Restarting a Merge
    Merge Strategies
    Degenerate Merges
    Normal Merges
    Specialty Merges
    Applying Merge Strategies
    Merge Drivers
    How Git Thinks About Merges
    Merges and Git’s Object Model
    Squash Merges
    Why Not Just Merge Each Change One by One?

Altering Commits

  • Caution About Altering History
    Using git reset
    Using git cherry-pick
    Using git revert
    reset, revert, and checkout
    Changing the Top Commit
    Rebasing Commits
    Using git rebase -i
    rebase Versus merge

The Stash and the Reflog

  • The Stash
    The Reflog

Remote Repositories

  • Repository Concepts
    Bare and Development Repositories
    Repository Clones
    Tracking Branches
    Referencing Other Repositories
    Referring to Remote Repositories
    The refspec
    Example Using Remote Repositories
    Creating an Authoritative Repository
    Make Your Own Origin Remote
    Developing in Your Repository
    Pushing Your Changes
    Adding a New Developer
    Getting Repository Updates
    Remote Repository Development Cycle in Pictures
    Cloning a Repository
    Alternate Histories
    Non–Fast-Forward Pushes
    Fetching the Alternate History
    Merging Histories
    Merge Conflicts
    Pushing a Merged History
    Remote Configuration
    Using git remote
    Using git config
    Using Manual Editing
    Working with Tracking Branches
    Creating Tracking Branches
    Ahead and Behind
    Adding and Deleting Remote Branches
    Bare Repositories and git push

Repository Management

  • A Word About Servers
    Publishing Repositories
    Repositories with Controlled Access
    Repositories with Anonymous Read Access
    Repositories with Anonymous Write Access
    Publishing Your Repository to GitHub
    Repository Publishing Advice
    Repository Structure
    The Shared Repository Structure
    Distributed Repository Structure
    Repository Structure Examples
    Living with Distributed Development
    Changing Public History
    Separate Commit and Publish Steps
    No One True History
    Knowing Your Place
    Upstream and Downstream Flows
    The Maintainer and Developer Roles
    Maintainer–Developer Interaction
    Role Duality
    Working with Multiple Repositories
    Your Own Workspace
    Where to Start Your Repository
    Converting to a Different Upstream Repository
    Using Multiple Upstream Repositories
    Forking Projects


  • Why Use Patches?
    Generating Patches
    Patches and Topological Sorts
    Mailing Patches
    Applying Patches
    Bad Patches
    Patching Versus Merging


  • Installing Hooks
    Example Hooks
    Creating Your First Hook
    Available Hooks
    Commit-Related Hooks
    Patch-Related Hooks
    Push-Related Hooks
    Other Local Repository Hooks

Combining Projects

  • The Old Solution: Partial Checkouts
    The Obvious Solution: Import the Code into Your Project
    Importing Subprojects by Copying
    Importing Subprojects with git pull -s subtree
    Submitting Your Changes Upstream
    The Automated Solution: Checking out Subprojects Using Custom Scripts
    The Native Solution: gitlinks and git submodule
    The git submodule Command

Submodule Best Practices

  • Submodule Commands
    Why Submodules?
    Submodules Preparation
    Why Read Only?
    Why Not Read Only?
    Examining the Hashes of Submodule Commits
    Credential Reuse
    Use Cases
    Multilevel Nesting of Repos
    Submodules on the Horizon

Using Git with Subversion Repositories

  • Example: A Shallow Clone of a Single Branch
    Making Your Changes in Git
    Fetching Before Committing
    Committing Through git svn rebase
    Pushing, Pulling, Branching, and Merging with git svn
    Keeping Your Commit IDs Straight
    Cloning All the Branches
    Sharing Your Repository
    Merging Back into Subversion
    Miscellaneous Notes on Working with Subversion
    svn:ignore Versus .gitignore
    Reconstructing the git-svn Cache

Advanced Manipulations

  • Using git filter-branch
    Examples Using git filter-branch
    filter-branch Pitfalls
    How I Learned to Love git rev-list
    Date-Based Checkout
    Retrieve Old Version of a File
    Interactive Hunk Staging
    Recovering a Lost Commit
    The git fsck Command
    Reconnecting a Lost Commit

Tips, Tricks, and Techniques

  • Interactive Rebase with a Dirty Working Directory
    Remove Left-Over Editor Files
    Garbage Collection
    Split a Repository
    Tips for Recovering Commits
    Subversion Conversion Tips
    General Advice
    Remove a Trunk After an SVN Impor
    Removing SVN Commit IDs
    Manipulating Branches from Two Repositories
    Recovering from an Upstream Rebase
    Make Your Own Git Command
    Quick Overview of Changes
    Cleaning Up
    Using git-grep to Search a Repository
    Updating and Deleting refs
    Following Files that Moved
    Keep, But Don’t Track, This File
    Have You Been Here Before?

Git and GitHub

  • Repo for Public Code
    Creating a GitHub Repository
    Social Coding on Open Source
    News Feed
    Creating Pull Requests
    Managing Pull Requests
    Finding Users, Projects, and Code
    GitHub Pages (Git for Websites)
    In-Page Code Editor
    Subversion Bridge
    Tags Automatically Becoming Archives
    Social Coding on Closed Source
    Eventual Open Sourcing
    Coding Models
    GitHub Enterprise
    GitHub in Sum
Print Friendly, PDF & Email