Git Basics: In Theory and Practice

Learn Effective Source Control Management with Git. Taught by Tony Hillerson. Learn how to use Git practically.
3.2 (11 ratings) Instead of using a simple lifetime average, Udemy calculates a
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
287 students enrolled
$20
Take This Course
  • Lectures 31
  • Contents Video: 3 hours
    Other: 4.5 hours
  • Skill Level All Levels
  • Languages English
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

About This Course

Published 7/2011 English

Course Description

Have you heard of Git? Have you been wondering what all the buzz is about? Have you heard about all the open source software projects moving to Github? Have you been thinking that it's time to give Git a try yourself? We think it is too, and we think this course will help.

This course is a different approach to learning Git than, say, reading online documentation or buying a book on Git because you'll see not only how Git works, but how you should work with Git. We'll show you the situations that you probably find yourself in as a developer all the time and how Git can help you work faster, work with more confidence, and save yourself and your teammates time by supporting a good workflow. We'll show you how Git works in practice, and also how to practice Git.

Session One: Git and You

In this first session we'll cover getting started with Git and daily workflow which will become second nature to you. We'll get it in your fingers. Not only that, but all the operations we'll use Git for will be completely local to our own systems.

One of the things that first piques people's interest in Git is that it's distributed. They wonder what that means and how it affects them. In later sessions we'll understand the answers to questions about the distributed nature of Git, but one side effect of it is that many of Git's operations are completely local to your own computer. A Git repository can live out a useful and completely local life all on one computer, and we'll see that side of working with Git.

When this session is complete you'll understand:

Theory:
  • What does Git do?
  • Who came up with Git, and who works on it?
  • How Git keeps a history of your project over time
  • How Git stores your files
  • What are all those really long strings of letters and numbers?
  • How a Git repository is structured
  • What is Git's index for?
  • The components of Git: trees, refs, and blobs
Practice:
  • Working with files in Git
  • The standard workflow when committing changes to the repository
  • Commits in Git
  • Working with git log
  • Querying the Git repository
  • How to get help on Git
Session Two: Git and Your Team

Git has no particular need to work with any repository than the local one on your computer, unlike many other version control systems but that wouldn't be very fun would it? Git really becomes useful when you and your team members use it to facilitate collaborating on a project. We'll start to understand what it means that Git is distributed.

One of the first things people wonder when they hear that Git is distributed, or that Git doesn't need a central server, is "Can I still have a central server for my team?". Of course you can, and many teams still work the same way they have with other versioning systems. We'll see how to do that as well as share changes with another computer directly. We'll set up an account on Github and use that to learn how to deal with remote repositories.

We'll also learn about very important concept in version control systems: branching. Git makes branching so easy that it's time to learn how you should be integrating branching into your workflow.

When this session is complete you'll understand:

Theory:
  • What are remotes?
  • What are some strategies for collaboration with Git?
  • How does Git transfer changes?
  • How does pulling changes work?
  • How does branching work in Git?
  • What does rebase do?
  • What is the Git stash?
  • How does tagging work in Git?
Practice:
  • Cloning a repository
  • Pushing, pulling, and fetching changes
  • Creating branches
  • Pushing and pulling from branches
  • Setting up a tracking branch
  • Merging and dealing with conflicts
  • How and when to rebase
  • Seeing who did what with git blame
Session Three: Git in the Real World

Session three is all about the how Git works and how you work with Git out there in the wild.

Chances are you first heard about Git and Github almost in the same sentence. In fact sometimes it's easy to forget that Github is just a logical extension to Git itself.

Github is a wildly popular way to host and collaborate on Open Source software projects using Git. Some of the most important software tools you may use every day are now hosted or mirrored on Github, such as Rails, jQuery, or Postgres. Github's unique philosophy on forking, or branching off developement on a software project, makes it easy for anyone to contribute to their favorite open source tools. We'll dig deeper into how to work with Github.

Next we'll go over a whole list of interesting tools Git gives you work a lot faster. Interactive adding, adding using patch mode, interactive merging, and some advanced logging and querying techniques for finding exactly what's been going on in your repository.

We'll also cover a very important topic in software development: "screwing things up". Not only do we often really mess up the project we're working on, we can also make mistakes in Git itself. Luckily Git is there to help with both of those kinds of problems. Git provides ways to not only commit changes, which is helpful in itself to any software project, but also to fix, reorder, play back, cherry pick, and recover lost commits.

When this session is complete you'll understand:

Theory:
  • How can I get exactly what I want out of the log?
  • How can I find exactly what I want in the repo?
  • What is the reflog and what does it do?
  • Does the repository require any maintenance?
  • How does forking work on Github?
  • How can I stay up to date with the original repository?
  • How do I submit my commits back to the original repository?
Practice:
  • git add -i
  • git rebase -i
  • git commit --amend
  • git reset, hard and soft
  • git revert
  • git cherry-pick
  • git gc
  • git reflog
  • Forking a repository on Github
  • Submitting a pull request on Github

What am I going to get from this course?

  • The normal Git workflow
  • How to collaborate with your team members using Git
  • Productivity tips
  • Also, how to save your bacon with Git!

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.

Curriculum

Section 1: Getting Started
Installing Git For Mac
Preview
01:38
Installing Git For Windows
Preview
03:02
Article
Git uses your default command line editor when editing a commit message. Given the way I have you set up Git, on both systems this turns out to be Vim. Vim is a modal editor, which means that it has a few different modes. It starts out in the "Normal" mode. In Normal mode your keystrokes invoke Vim…
Section 2: Session One: Git and You
Session One Introduction
Preview
00:52
Diving Right In
Preview
06:56
What Is Git?
02:29
The Git Workflow
10:10
Working With Git: Commands and Configuration
03:04
Under The Hood
13:40
Session Recap
02:29
Session One Slides
63 pages
Section 3: Session Two: Git and Your Team
Session Two Introduction
00:37
Diving Right In To Remotes
11:04
Remote Workflow
14:36
Working With Git
04:58
Branching
12:57
Branching In Action
07:33
Under The Hood: Remotes and Branches
06:10
Session Two Recap
00:59
Session Two Slides
89 pages
Section 4: Session Three: Git in the Real World
Session Three Introduction
01:00
Git Productivity Tools Part I
06:13
Git Productivity Tools Part II: Interactive Add Demo
12:10
Git Productivity Tools Part III
10:20
Fixing Things Part I
19:26
Fixing Things Part II: Reflog And Fsck Demo
04:00
Fixing Things Part III: GC And Recap
02:44
Github Part I
04:58
Github Part II: Forking Demo
06:23
Github Part III: Recap
02:14
Session Three Slides
128 pages

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Tony Hillerson, Nerd Extraordinaire

Tony Hillerson is a Partner and Developer at Tack Mobile. He graduated from Ambassador University with a BA in MIS. On any given day he may be working with Rails, Objective-C, Java, HTML, Coffeescript, Javascript, or shell scripts. Tony has spoken at RailsConf, AnDevCon, 360|Flex, and has created the popular O'Reilly Android screencasts: ( http://oreilly.com/catalog/0636920004240/ and http://oreilly.com/catalog/0636920010289 )

Tony is interested in all levels of usability and experience design, from the database to the server to the glass.

In his free time Tony enjoys playing the bass and Warr Guitar, making electronic music, making beer, learning Latin, and studying philosophy. Tony lives outside Denver, CO with his wife Lori and sons Titus and Lincoln.

Ready to start learning?
Take This Course