LiveLessons - Git Under the Hood
English | Apr 23, 2015 | ISBN: 0134133668 | mp4 | H264 1280x720 | AAC 2 ch | 8 hrs 16 min | 2.18 GB
Git Under the Hood LiveLessons provides developers with a deeper understanding of Git so that they can use it more effectively. The fastest way to stop stumbling around in Git and to start understanding what you're doing is to learn how Git works.
When you come to really understand what’s actually happening under-the-hood, most things that you’ve found mysterious or cryptic about Git will vanish. You go from being puzzled to being a resource, and some of you will go from being users to being contributors.
This course provides viewers with knowledge of Git’s repository pieces and the right mental models for how to use those pieces. Students will be able to compare and contrast the design and performance of Git with its predecessors as well as see the design parallels between Git and Linux. With this knowledge, viewers will understand how to experiment when Git does something unexpected and how to extend Git with new commands.
In this course, all work is on the command line, so familiarity with bash is assumed, but no other programming languages are required. Each lesson calls out pause points for viewers to answer specific questions, practice what’s been explained, and explore related points.
What You Will Learn
• The varied pieces of Git's repository
• Basic Git commands and how to use those pieces
• The design and performance of Git versus its VCS progenitors
• Design parallels between Git and Linux
• How to experiment when Git does something unexpected
• How to extend Git with new commands
Who Should Take This Course
• For software developers with some experience using a version control system. Specifically, those developers who know some Git commands.
• Comfortable using a terminal window/command line
• Basic-level knowledge in working with Git
• Have root-permission access to a Linux computer or VM
Table of Contents
Lesson 1: Get Our Toes Wet covers some common Git commands, like git init and git add, and walks you through experiments to see how they actually work. You begin to build your repertoire of tools to do more sophisticated experiments, and you come to see that it’s useful to watch for analogies between Linux and Git. You look inside three of the four kinds of Git objects, and you learn that Git objects, like Linux files, have no names. Finally, you come to understand why Git can trade information with remote repos blazingly fast, as you watch it play “Go Fish” with files that have no names.
Lesson 2: See the Future by Looking Into the Past reviews how version control started by first looking at Marc Rochkind’s SCCS and its successors RCS, VCS, and SVN. SVN is considered by some to be the crowning achievement of centralized version control systems. We address whether SVN is outdated, or if there are other reasons to switch to Git–and we put them head-to-head to let you judge for yourself. Comparing and contrasting Git with other version-control systems lets you see why Git’s good but also what is missing. We talk about what’s not in Git, and what is being built today to fill those vacuums. We look at one specific new tool, Google repo, which is designed to let you juggle projects that need hundreds of Git repos at the same time.
Lesson 3: Finding Out Why Branching and Tagging Is So Fast looks at the Git repository–the .git/ directory–to understand one of the most common tasks: branching. With an under-the-hood look, you learn what a branch is and how it’s different from a tag. You learn what happens when you create and delete them, and when you should check out a tag or switch branches. Also, you learn about HEAD. Git calls branches and tags “references,” but a HEAD is a “symbolic reference.” You are reminded why analogies help you understand how Git works. Branches, tags, and symbolic references have similarities and differences. We pause to compare and contrast, reviewing how to make them, how to remove them, and how to change them. Finally, you cap off your journey into branches and tags by looking at Git’s fourth, and last, object type: tag objects. The goal of this lesson is to solidify your understanding that when you issue a Git command, you’re not just changing your working copy–you’re also doing something understandable to the contents of your repository.
Lesson 4: Filling In the Rest of .git/ goes the rest of the way through the contents of the .git directory covering logs, the staging area, and remotes. You come to see Git in a whole new way and will have a mental model of Git that will keep you from being mystified when something goes wrong. You learn how to use logs to see where your repo has been. We talk some more about names for objects and how logs let you recover when you give Git amnesia. You see how the index is where your repo is about to go–how Git uses the staging area to go even faster and how to think about what’s about to happen when you commit. You firm up your understanding by looking through a dozen or so common problems that you, or others you know, have had. You see why they now make sense, why you know what to do about them, and what’s happening when you push to or fetch from a remote. You look at a tool you’ve developed during Lessons 1 through 3, and realize you can use it as a dissecting tool to understand what’s going on under the hood whenever you’re perplexed.