O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Git and GitHub LiveLessons—Workshop (Video Training)

Video Description

Overview
 
Git and GitHub LiveLessons (Workshop) is a fast-paced, engaging video course that teaches developers the essentials of Git and GitHub. You will learn the key commands to quickly become productive using Git and best practices for using GitHub to collaborate with your team.

 
Description
 
Featuring live, step-by-step demonstrations, the lessons in this workshop cover:

  • Concise configurations—configuring just what you need to get the best out of Git
  • Your first repo—initializing a repo, three stage thinking, working with the staging area
  • Sharing your work—creating and configuring a GitHub repository
  • Additional activities—moving, deleting and ignoring files with Git
  • Building with branches—how to use feature branches effectively to work on projects. Includes merge types, merge conflicts and rebasing before merging
  • GitHub workflows—using clones, forks, feature branches and pull requests to collaborate effectively via GitHub
  • Releasing software—release tags, release branches and release workflows
  • How to undo anything—learn a range of powerful techniques, from git commit –amend through revert, reset, rebase –interactive and the famed reflog!

About the Instructor

Peter Bell is a contract member of the GitHub training team and presents internationally on using Git and GitHub effectively. He’s also the co-founder of CTO School and the startup CTO Summit and is the author of Git Distilled, to be published by Pearson in late 2014.

Skill Level

  • Beginner
  • Intermediate

 What You Will Learn

  • Starting with creating your first Git repository and committing code, you learn the key concepts and features that will allow you to quickly set up and use Git for your own projects
  • You are introduced to branching and learn how to merge a branch, create a fast forward merge, and use recursive merges
  • You also learn how to collaborate via GitHub by cloning a repository, forking a repository, or contributing to a project via a pull request from a fork
  • In addition, you are introduced to the basics of Git internals to get a sense for how Git works under the hood.

Who Should Take This Course

Course Requirements

  • You will need to have an up-to-date version of Git installed on your computer and have a GitHub user account and password.
  • You should also be comfortable using a terminal window/command line.

 
Table of Contents
 
Lesson 1: Configuring Git

  • Three levels of configuration
  • Basic configuration settings
  • Configuring line endings
  • Configuring aliases

Lesson 2: Getting Started with Git

  • Creating your first Git repository
  • Committing in Git
  • Understanding a Git commit
  • The benefits of the staging area
  • Git log for viewing history

Lesson 3: Getting Started with GitHub

  • Creating a repository in GitHub
  • Uploading your repo to GitHub
  • Creating a repository after starting to code
  • Creating the first commit

Lesson 4: Files in Git—Renaming, Deleting and Ignoring

  • How to rename a file in Git
  • Deleting a file in Git
  • Ignoring files using a .gitignore file
  • Global gitexcludes and other Git ignore options
  • Git ignore precedence
  • Git commit -a

           
Lesson 5: Branching, Merging and Rebasing

  • Introducing branching
  • Merging a branch
  • Creating a fast forward merge
  • Introducing recursive merges
  • “No fast forward” recursive merges
  • Resolving merge conflicts
  • Another merge conflict example
  • Git Diff
  • Introducing rebasing
  • Rebasing a branch
  • Handling rebase conflicts

Lesson 6: Git Internals

  • Introducing “Git under the hood”
  • Exploring the object store
  • cat-file to explore object contents
  • The benefits of Git’s use of SHA1 hashes
  • Git as a content store (how many new hashes)
  • Understanding remotes and their configuration
  • Configuring your push default
  • Fetch versus pull
  • Merge versus rebase on pull

Lesson 7: Collaborating via GitHub

  • Cloning a repository
  • Forking a repository
  • Contributing via a pull request from a fork
  • Approving a pull request from a fork
  • Use cases for fork based collaboration
  • Single repo collaboration directly on master
  • Single repo collaboration using feature branches
  • Contributing to another feature branch
  • Creating a pull request within a single repo
  • Collaborating on a pull request
  • Merging in a pull request

Lesson 8: Reviewing a Project on GitHub

  • Getting an overview of a project on GitHub using the README
  • Getting more information about a project
  • Introducing issues
  • Closing an issue automatically with a commit message
  • Viewing project state through pulse and graphs

Lesson 9: Configuring a Project on GitHub

  • Basic configuration options and renaming a repo
  • GitHub Pages
  • Adding collaborators and integrations
  • Configuring deploy keys

Lesson 10: Tags and Releases

  • Three types of tags
  • Release tags versus release branches
  • Cherry pick for reusing code across long running release branches
  • Git stash for reusing code
  • Pushing tags up to GitHub and using releases

           
Lesson 11: How to Undo Almost Anything Using Git

  • Private versus public history and git revert
  • Don’t push too often
  • Git commit --amend
  • Git reset
  • Introducing the reflog
  • Rebase interactive

Q&A

  • Question 1: Can you create a GitHub repo without using your browser?
  • Question 2: What’s the difference between global and system configuration?
  • Question 3: When dealing with merge conflict in a large file, how do you find the conflicts?
  • Question 4: Does Git show the two full, different versions of a file or just the differences?
  • Question 5: Does a merge commit always include all of the files I created on the branch?
  • Question 6: Isn’t it dangerous that you can make a bunch of changes to your code by merging in a branch?
  • Question 7: Do merges work the same way with merging into integration branches as into master?
  • Question 8: How do you handle long running release branches?

 

About LiveLessons Video Training
 
LiveLessons Video Training series publishes hundreds of hands-on, expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. This professional and personal technology video series features world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, IBM Press, Pearson IT Certification, Prentice Hall, Sams, and Que. Topics include: IT Certification, Programming, Web Development, Mobile Development, Home and Office Technologies, Business and Management, and more.  View all LiveLessons on InformIT at: http://www.informit.com/livelessons

Table of Contents

  1. Introduction
    1. Git and GitHub LiveLessons—Workshop: Introduction 00:02:13
  2. Lesson 1: Configuring Git
    1. Three levels of configuration 00:02:21
    2. Basic configuration settings 00:05:02
    3. Configuring line endings 00:03:40
    4. Configuring aliases 00:02:33
  3. Lesson 2: Getting Started with Git
    1. Creating your first Git repository 00:03:11
    2. Committing in Git 00:05:14
    3. Understanding a Git commit 00:02:21
    4. The benefits of the staging area 00:05:15
    5. Git log for viewing history 00:02:08
  4. Lesson 3: Getting Started with GitHub
    1. Creating a repository in GitHub 00:03:02
    2. Uploading your repo to GitHub 00:01:44
    3. Creating a repository after starting to code 00:02:18
  5. Lesson 4: Files in Git—Renaming, Deleting and Ignoring
    1. How to rename a file in Git 00:09:48
    2. Deleting a file in Git 00:02:42
    3. Ignoring files using a .gitignore file 00:06:37
    4. Global gitexcludes and other Git ignore options 00:04:30
    5. Git ignore precedence 00:04:02
    6. Git commit -a 00:01:54
  6. Lesson 5: Branching, Merging and Rebasing
    1. Introducing branching 00:04:54
    2. Merging a branch 00:02:10
    3. Creating a fast forward merge 00:05:34
    4. Introducing recursive merges 00:04:07
    5. “No fast forward” recursive merges 00:04:30
    6. Resolving merge conflicts 00:14:39
    7. Another merge conflict example 00:08:09
    8. Git Diff 00:04:50
    9. Introducing rebasing 00:02:44
    10. Rebasing a branch 00:06:06
    11. Handling rebase conflicts 00:09:42
  7. Lesson 6: Git Internals
    1. Introducing “Git under the hood” 00:00:59
    2. Creating the first commit 00:01:35
    3. Exploring the object store 00:01:47
    4. cat-file to explore object contents 00:05:02
    5. The benefits of Git’s use of SHA1 hashes 00:01:26
    6. Git as a content store (how many new hashes) 00:06:53
    7. Understanding remotes and their configuration 00:05:53
    8. Configuring your push default 00:02:26
    9. Fetch versus pull 00:08:14
    10. Merge versus rebase on pull 00:06:08
  8. Lesson 7: Collaborating via GitHub
    1. Cloning a repository 00:05:11
    2. Forking a repository 00:07:20
    3. Contributing via a pull request from a fork 00:03:23
    4. Approving a pull request from a fork 00:01:43
    5. Use cases for fork based collaboration 00:02:04
    6. Single repo collaboration directly on master 00:05:39
    7. Single repo collaboration using feature branches 00:04:50
    8. Contributing to another feature branch 00:01:52
    9. Creating a pull request within a single repo 00:02:28
    10. Collaborating on a pull request 00:03:39
    11. Merging in a pull request 00:02:01
  9. Lesson 8: Reviewing a Project on GitHub
    1. Getting an overview of a project on GitHub using the README 00:02:03
    2. Getting more information about a project 00:02:29
    3. Introducing issues 00:05:02
    4. Viewing project state through pulse and graphs 00:05:50
  10. Lesson 9: Configuring a Project on GitHub
    1. Basic configuration options and renaming a repo 00:02:40
    2. GitHub Pages 00:02:16
    3. Adding collaborators and integrations 00:03:46
    4. Configuring deploy keys 00:00:55
  11. Lesson 10: Tags and Releases
    1. Three types of tags 00:06:12
    2. Release tags versus release branches 00:05:38
    3. Cherry pick for reusing code across long running release branches 00:05:02
    4. Git stash for reusing code 00:03:41
    5. Pushing tags up to GitHub and using releases 00:02:08
  12. Lesson 11: How to Undo Almost Anything Using Git
    1. Private versus public history and git revert 00:03:50
    2. Don’t push too often 00:01:27
    3. Git commit --amend 00:03:53
    4. Git reset 00:06:21
    5. Introducing the reflog 00:05:36
    6. Rebase interactive 00:03:02
  13. Q&A
    1. Question 1: Can you create a GitHub repo without using your browser? 00:00:36
    2. Question 2: What’s the difference between global and system configuration? 00:00:41
    3. Question 3: When dealing with merge conflict in a large file, how do you find the conflicts? 00:00:39
    4. Question 4: Does Git show the two full, different versions of a file or just the differences? 00:00:44
    5. Question 5: Does a merge commit always include all of the files I created on the branch? 00:01:19
    6. Question 6: Isn’t it dangerous that you can make a bunch of changes to your code by merging in a branch? 00:01:09
    7. Question 7: Do merges work the same way with merging into integration branches as into master? 00:01:11
    8. Question 8: How do you handle long running release branches? 00:00:49