Archived video

This video is archived and won't be updated. We're keeping it online for now as a courtesy.

Introduction to the Git Series

Video loading...

  • 0:00
  • 0:02
    [Drupalize.Me] [Learn Drupal]
  • 0:06
    [Series Introduction] [Introduction to Git] [Chapter 1 with Joe Shindelar and Blake Hall]
  • 0:12
    [Joe Shindelar] In this series, Blake and I are going to be talking all about Git,
  • 0:16
    which is a version control system.
  • 0:18
    Git is what uses to track all of the source code
  • 0:22
    for Drupal core and all the modules that you download.
  • 0:26
    We're going to talk a lot about how the Git software works
  • 0:29
    and how you can use it in your own projects.
  • 0:32
    [Blake Hall] Before we get started, though, this series is pretty Command Line heavy,
  • 0:35
    so you'll probably want to take a moment to review
  • 0:37
    the Drupalize.Me Command Line series
  • 0:39
    if you're not comfortable in the Terminal window already.
  • 0:42
    There's a lot of terminology and concepts that we need to understand
  • 0:44
    in order to make the best use of Git.
  • 0:47
    So in addition to looking at how the software works,
  • 0:49
    we'll also talk about some of those things, like what is a commit,
  • 0:52
    a checkout and a repository, and all these things
  • 0:54
    that will hopefully help make Git easier to use
  • 0:57
    in your everyday workflow and also when you're working with teams.
  • 1:01
    After we get a few of the basic commands together,
  • 1:03
    like Git Init to create our repository and Git Add to track files,
  • 1:07
    we'll take a look at a few other commands, tags and branches
  • 1:11
    that help make your day-to-day workflow a little easier.
  • 1:13
    Then we'll take a look at merging and rebasing,
  • 1:16
    which allow you to integrate other people's work into your repository as well.
  • 1:21
    And speaking of making your day-to-day workflow easier,
  • 1:24
    we're also going to look at configuration options in Git.
  • 1:27
    So how you can make it color the output in your terminal
  • 1:29
    so it's easier to read when a file has modifications
  • 1:32
    or understand that this file is currently staged and ready for committing.
  • 1:37
    We're going to take a look at some of the advanced things
  • 1:39
    you can do with Git Commands, like interactive rebasing,
  • 1:42
    which allows you to rewrite multiple commits in the history of your repository,
  • 1:46
    or an interactive add, which allows you to add simple hunks from a file
  • 1:51
    rather than the whole file itself.
  • 1:53
    We'll also take a look at how you can work with multiple remote repositories,
  • 1:56
    so you can interact with things like and GitHub
  • 2:00
    and be able to push changes from one repository to another
  • 2:02
    on different machines or for different team members.
  • 2:05
    We'll wrap the series up with a lesson
  • 2:07
    that goes over all of the things that we've covered throughout the series
  • 2:11
    and demonstrates a pretty common workflow with Git:
  • 2:14
    cloning things from a remote repository,
  • 2:16
    creating branches, making changes to your files,
  • 2:19
    committing those changes, merging them back in to your master branch,
  • 2:22
    and pushing all of that back to the remote repository.
  • 2:26
    And then we'll use that as a baseline to look at some of the graphical interfaces
  • 2:30
    that allow us to work with Git as well, so we can compare
  • 2:33
    how those interfaces work with what we learned about the Command Line.
  • 2:36
    [Drupalize.Me] [Learn Drupal]
Loading ...

Introduction to the Git Series


Git is a distributed version control system (DVCS) for source code management (SCM). It's like a giant undo button for everything you've ever done on a project throughout its entire existence. Git also provides some powerful tools for collaborating with your team, browsing a project's entire history, deploying code, and so much more. Git is the version control system used for Drupal core and contributed module development and, as such, is used by most people building sites with Drupal to keep track of their client work as well. It's also the system used to track development of the Linux kernel, Ruby on Rails, Android, and many, many other projects. This is an in-depth series that starts with the basics of version control, establishes some terminology, and a base line workflow, then continues to build on that by going beyond the basics of the various Git commands to make the most out of your tools.

Joe and Blake give an introduction to the Git series giving some background on Git, and talking about the material that will be covered in the course of this series. If you aren't familiar with using the command line, you will probably want to get yourself up to speed with the basics before starting this series. We have an entire series on Command Line Basics to get you ready to go.

Additional resources: