Git Essentials LiveLessons 2e (Video Training): (LiveLessons)

About the Book

6 Hours of Video Instruction

Hands-On Approach to Learning the Git Version Control System

Overview

Git Essentials LiveLessons, Second Edition, provides you with functional, hands-on instruction on how to create, change, merge, branch, and otherwise manage repositories.

About the Instructor

Daniel Chen is a data science instructor, holds an MPH in epidemiology from Columbia University, and is a PhD candidate at Virginia Tech studying data science education in the biomedical sciences. He is also a Carpentries instructor, instructor trainer, and the current community maintainer lead.

Skill Level

• Beginner to Intermediate

Learn How To

• Understand what Git can do
• Start a repository in a couple of different ways
• Add and commit changes to a repository
• Compare diffs
• Use remotes
• Use branches
• Use workflows
• Use GUI-based versions of Git

Who Should Take This Course

• Anyone who needs version control for their IT projects or wants to learn how to collaborate with others using Git

Course Requirements

• Ability to use the command line
• Ability to use a terminal editor

Lesson Descriptions

Lesson 1: Setting Up Git
In Lesson 1, Daniel introduces Git and then covers how to get everything installed and ready for the rest of the course. He discusses the reasons for using Git through the command line as well as through graphic user interfaces. The lesson covers the installation steps for installing Git for the first time as well as configuration.

Lesson 2: Git Basics on the Local Machine
Lesson 2 cover the basic Git commands you will need to know while working on your local computer. It begins with how to create a repository. It shows you two ways to do that: starting from a local computer or starting from a remote. Daniel then turns to commits, the way to save a snapshot of your repository. He follows up on that with a look at the history log and the various things you can do with that, such as looking at the history, comparing files at various points in your history, undoing changes, restoring files, and going to a previous state in history. The lesson finishes up with how to ignore files and folders. The lesson provides you with the foundational skills you need to work on your own repository on your own computer.

Lesson 3: Working with Remotes
In Lesson 3 you take your local repository and connect it with a remote Git hosting service such as GitHub, BitBucket, or GitLab. Daniel begins with what makes for a remote and then covers pushing to remotes using HTTP and SSH. He then turns to pushing and pulling commits. Next, he discusses that fact that, given that your repository is now in more than one place, changes can be made in those different places and the need to coordinated and synchronize changes. Some of the changes will cause conflicts and will need to be resolved. Daniel also discusses the fact that when you are using an online Git hosting service you can leverage the service to help with project management. Finally, Daniel shows you the preferred way to start a new project from the remote.

Lesson 4: Working with Local Branches
In Lesson 4, Daniel sets the foundations for working in collaborative teams. You will use branches so when multiple people are working on the same repository you can isolate their work from one another. Branches also enable us to work on new features without affecting the parts of the project that currently work. You will learn how to collaborate by collaborating with yourself. You start off by creating and switching between your branches and then learn how branches affect how your commit logs look, as well as how to clean them up. You also learn how branches affect your commits. Finally, Daniel covers merging branches and incorporating changes from the main branch and our current branch using Git rebase.

Lesson 5: Incorporate Branch Changes
Lesson 5 goes into detail on all the ways different branches can be updated by incorporating changes from the base branch before the branch gets merged. Daniel starts off by setting up the branch scenario followed by a review of how branches can be incorporated by directly using merge and rebase. He also covers how you can use interactive rebase to squash commits before rebasing. This practice will change the commit history of the branch but may make it easier to work with conflicts. Finally, Daniel shows you how to stash and pop changes when you start jumping around your branches.

Lesson 6: Work and Merge with Remote Branches
Lesson 6 integrates all the things you learned about making commits and branches with Git and how to combine those skills with a remote Git service such as GitHub, Bitbucket, or GitLab. You will see how branches can be pushed to and pulled from the remote, how a merge on the remote is handled by a pull request or merge request, and how to merge and fix merge conflicts in a pull request. This sets the foundation for collaborating with others by using the same collaboration techniques to collaborate with yourself.

Lesson 7: Git Workflows
Lesson 7 covers the different ways you can set up a Git workflow for collaboration. Daniel has already covered the basic mechanics of using Git and synchronizing a local repository with a remote repository in the previous lessons. This lesson emphasizes how these skills can be used in a collaboration framework. The first part covers how to add a collaborator to a repository as you might on small projects or teams. Next, Daniel turns to using branching to set things up so team members can work independently on a project. Adding branch protection rules is the logical next step to enforce a branching workflow. For those looking for more branching structure there is a workflow called Gitflow workflow. It uses explicit branch naming conventions and includes a development or dev branch to test new features before they are incorporated into the main branch. Finally, Daniel covers the forking workflow for collaboration. This workflow is typically used in large open-source projects where you do not want to give collaborators direct write access to your repository. These Git workflow techniques all build on the fundamental skills of working with branches on your own, so you can always practice these techniques on your own by collaborating with yourself.

Lesson 8: Git GUIs
Lesson 8 introduces a few Git graphical user interfaces (GUIs). Daniel covers the ones that may be installed with Git: GitHub Desktop, Git Cola, VS Code and its base, and GitLens extension. Then, he turns to how Git may be integrated into integrated development environment (IDEs) for the R programming language in RStudio and for the Python programming language in PyCharm. Daniel notes that GUIs make some Git commands easier to work with, and some GUIs are more complete than others.

About Pearson Video Training
Pearson publishes expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. These professional and personal technology videos feature world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, Pearson IT Certification, Sams, and Que. Topics include IT Certification, Network Security, Cisco Technology, Programming, Web Development, Mobile Development, and more. Learn more about Pearson Video training at http://www.informit.com/video.

Video Lessons are available for download for offline viewing within the streaming format. Look for the green arrow in each lesson.

Table of Contents:
Introduction

Lesson 1: Setting Up Git
Learning objectives
1.1 Understand what Git can do for you
1.2 Install Git
1.3 Configure Git

Lesson 2: Git Basics on the Local Machine
Learning objectives
2.1 Start a repository in two different ways
2.2 Add and commit your changes
2.3 Look at your history log
2.4 Compare file diff(erences) while working
2.5 Compare diff(erences) from previous commits
2.6 Restore and reset new changes
2.7 Restore and check out past commits
2.8 Check out a detached HEAD
2.9 Review restore and checkout
2.10 Ignore files and folders

Lesson 3: Working with Remotes
Learning objectives
3.1 Understanding remotes
3.2 Push to remotes using HTTP
3.3 Push to remotes using SSH
3.4 Push and pull your commits
3.5 Make nonconflicting changes
3.6 Fix conflicts
3.7 Use GitHub and online remotes for project management
3.8 Start your projects in a remote

Lesson 4: Working with Local Branches
Learning objectives
4.1 Create, switch, and list branches
4.2 Look at your log and clean up branches
4.3 Switch between branches with commits
4.4 Merge branches
4.5 Use rebase to incorporate changes

Lesson 5: Incorporate Branch Changes
Learning objectives
5.1 Set up the branch examples
5.2 Use merge to incorporate changes
5.3 Use rebase to incorporate changes
5.4 Squash commits before rebasing
5.5 Stash changes before switching to other branches

Lesson 6: Work and Merge with Remote Branches
Learning objectives
6.1 Sync local work with the remote
6.2 The pull request (PR) and merge request
6.3 Merge branches via pull request
6.4 Fix pull requests with merge conflicts

Lesson 7: Git Workflows
Learning objectives
7.1 Add a collaborator to repository
7.2 Understand branching workflow
7.3 Add branch protection rules
7.4 Using Git Flow workflow
7.5 Understand forking workflow

Lesson 8: Git GUIs
Learning objectives
8.1 Understand Git GUIs
8.2 Use Git GUI
8.3 Use GitHub Desktop
8.4 Use Git Cola
8.5 Use VS Code
8.6 Use RStudio
8.7 Use PyCharm

Summary

About the Author :
Daniel Chen is a data science instructor, holds an MPH in epidemiology from Columbia University, and is a PhD candidate at Virginia Tech studying data science education in the biomedical sciences. He is also a Carpentries instructor, instructor trainer, and the current community maintainer lead.