4.45 out of 5
4.45
67 reviews on Udemy

Essential Git – All You Need to Know to Use Git Effectively

Why spend hours learning all Git and Github? Learn the parts professional developers use and get on with your coding
Instructor:
Jorge Escobar
700 students enrolled
English [Auto-generated]
You will be able to start a Git repository from an existing project or clone a project hosted on the Internet.
You will become knowledgeable with the Github portal and how to use it professionally.
You will obtain a fundamental understanding of how to manage remote repositories.
You will learn the theory of and why branches are important.
You will participate in a Git collaborative project with other developers.

This course simply teaches what you *really* need to know about Git. After working professionally with Git for more than 5 years with large and distributed teams, I will show you, step by step and cutting out all the fat, what Git is, what’s the use case behind each feature and how you can use it effectively like most professional web developers use it.

The course starts assuming you know nothing about Git and step by step explains the theory and introduces each command, progressing in a smooth, logical flow.

At the end of the course you participate in an open source project hosted in Github where you will collaborate with other student building a worldwide restaurant guide, where you will need to apply everything you learned in the course.

Additionally, you will be able to purchase a complete book of the whole course, so that you have an easy reference to all the knowledge.

The course has more than 2 hours of video tutorials and you can also purchase a book that covers all of the video content, so that you can refer any information in a printed format.

If you search on the web, you’ll find hundreds of courses, videos and other resources about Git, but it’s work that’s incredibly tedious and leaves more questions than answers. You can also buy a “Pro Git” book and try to learn all of Git as if it was your end goal. The truth is Git is only a very basic utility tool that you shouldn’t be thinking about. You should spend your valuable time learning more productive things, like computer languages. With this course you’ll get that level of comfort, knowing you will be using Git without thinking about it.

The course is divided in 8 sections:

  • Introduction

  • Installing Git

  • Git Fundamentals

  • Starting with Git

  • Git Tools

  • Git Branches and Tags

  • Remote Repositories

  • Git Workflows

Also, at the end of the course, we have a collaborative project that uses all the knowledge from the course and leverages Github as a community platform.

Additionally we’re updating the course constantly, adding lessons thanks to the feedback of our students.

So stop feeling like Git is something complicated. You need this tool to become a successful, professional developer. Git is not hard.

Enroll now and learn the essential Git and move on the important stuff… like coding.

Introduction

1
Introduction

Welcome to “Essential Git - Second Edition”. My name is Jorge Escobar and I have been managing development teams that use Git on a daily basis for many years and I know first hand how important it is to be fluent in this fundamental tool.

2
What is Git?

Git is a version control system, or VCS, that allows developers to improve the way they work on their code as well as collaborate easier with other developers in software development projects

Installing Git

1
Installing Git

There are multiple ways to install Git on each operating system. If you have Linux, Git usually comes pre-installed or just use ```apt-get install git``` on Ubuntu or ```yum install git``` on Red Hat.

Let’s check what are the best options based on your operating system, Windows or Mac. 

2
Installing Git on Windows

If you have Windows 10, the best alternative to install Git is to use [Chocolatey], a Windows package manager similar to apt-get and yum on Linux.

3
Installing Git on Mac

The best wat to install Git in Mac OS is by using Homebrew, which is a package manager similar to RedHat’s yum or Ubuntu’s apt-get.

4
Checking if Git is Installed

To verify that you have Git installed, write “git” in the Git Bash (Windows) or Mac OSX terminal. You should see a list of available commands. To see what version of Git you have, just type ```git --version```.

Git Fundamentals

1
Git Fundamentals

In this section we will be introduced to Git’s File Status Lifecycle. We will also learn why the terminal is the best way to use Git and some of the most useful command line tools for file management.

2
The File Status Lifecycle

If there is one fundamental concept that you need to understand is how Git manages its files and the stages they go through as you work on them. This “movement” between stages is called the _File Status Lifecycle_ and here’s how it works.

3
Visual Workflow

Now don’t worry if you don’t understand all of these stages immediately. Let’s try to picture the workflow with an actual file that we’re working on.

Starting with Git

1
Starting with Git

In this section we will start playing with Git. We’ll create a repository, check the history of the project and — very important — how to undo operations. But first, let’s learn some basic commands to navigate the file system In the terminal.

2
Basic Operations

Go ahead and open your terminal (Git Bash on Windows or Terminal on Mac) and you should get a prompt ready for your commands. 

3
Initializing our Git repository

Make sure you are on the testgit directory by typing pwd and confirming you are in that folder.

We are ready to initialize our first repository.

4
Our First Commit

So we’re finally ready to create a new file. Since I’m using Atom, I just write the following command to create a new file called test.txt.

5
A New Commit

So now, let’s go ahead and make a change to the file. You should still have the Atom editor open, and if not, open the test.txt file again and insert a new line Test #2 and then save it.

6
A New File

Ok, so now we’ll do something a bit different. We will modify our test.txt file but also add a second file to the repository. So open Atom again and add a third line to the test.txt file and save it.

7
History of the Project

As we have seen from our interactions with Git, there’s a concept of history built in as we move along in the development of the project. Each commit is like a photograph of an organism as it grows and grows.

8
More Git Log Options

If we want to see just the last x commits, you can pass that number after the Git log command with a dash, for example, to see the last two commits, you can do the following.

9
Jumping Back in Time

If you want to see what the codebase looked like at the time of these snapshots, you can do so by using the git checkout command.

10
More Git Commands

Let’s see other useful Git commands.

11
Undoing Things

There are things we want to undo after we have pressed the Enter button on our keyboard and Git allows us to undo a lot of them. Let’s see some of the ways we can undo things in Git.

12
Unstaging Files

So let’s say you created a new file, called bar.txt and you add it to the repository. The file is now on the Staged status, ready to be included in the next commit.

Git Branching and Tags

1
Introduction to Branching

A basic component of Git is its branching capabilities. It used to be very complicated to do branching in other version control systems and Git really brought this capability to developers in a seamless way.

2
The Commit History

Let’s quickly review the commit process. Let’s say you have a repository with three commits. We can visualize it as follows.

3
Merging Branches

Continuing with the example, let’s say that we have completed the work on the newfeature branch. We did a checkout on the branch, did one more commit, and now we need to incorporate those changes back to the the master branch. This is what we have at this moment.

4
Branching in Action

Now let’s try doing these operations in our terminal. Go to your home folder by doing cd ~, create a new folder and initialize the repository.

5
Merge Conflicts

Often you will find yourself with merge conflicts. When Git tries to merge the content of a file from two different branches where it doesn’t know exactly how to merge it, it will throw an error. Don’t worry, this is easily fixed.

6
Rebasing

There is another method to merge two branches, called rebasing. The theory behind rebasing is that your commit history is cleaner and that it appears more linear to people looking at the history. It’s a little bit like writing a book; think of merging as putting out the book with the drafts and the different corrections to the chapters, versus rebasing which looks more like a finished book with each chapter telling a story in a logical fashion.

7
Interactive Rebasing

Let’s say that you don’t want to show the two commits for the newfeature branch when we rebase into master, because the two commits are related. You can actually edit the history by doing an interactive rebase.

8
Tagging

Git offers us a way to create special pointers called tags. Tagging is useful to mark points in your commit history that are important. Most of the times, tags are used to denote versions of your application.

Remote Repositories

1
Remote Repositories

Most of the times you will be working with a remote repository that you and your team are using as a pseudo centralized repository, although we already know that Git is a distributed version control system that doesn’t need a central server.

2
Setting up a Github account

So head over to Github.com and create an account with them. Typically you’ll need to provide a username, email and password. Github is completely free for public repositories but if you want to keep some of them private, you will need to pay them a monthly fee.

3
Creating SSH credentials

The first thing we want to do is create an SSH key to be able to push and pull code from your repositories. Think of SSH as a key and lock pair that allows Github to know that you are who you say you are.

4
Our First Remote Repository

Let’s create our first remote repository. Go back to your profile, click on Repositories  and then click on the green New button.

5
Remote Repository Operations

Make sure you’re in the test-remote-repo directory and do a git status. You’ll see you are in the master branch and that nothing has been committed yet.

6
Git fetch and Git pull

When you’re working with a team of developers, often times they will be pushing code to the remote repository and you will need to get those changes incorporated to your codebase as you work along your own timeline.

7
Git Remote Branches

We can also have local and remote branches. These can be pushed or pulled just like we did with the master branch.

Final Project

1
Final Project

Conclusion

1
Conclusion

This is the end of our Git journey. Now the only thing you need to do is play with Git and learn some of the remaining tricks it has under its hood. Believe me, I still learn a new feature every other week.

Bonus Lecture: The Essential Git Book

1
Bonus Lecture: The Essential Git Book

Get the course book with a special discount!

Bonus Section

1
Course Promo
You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
4.5
4.5 out of 5
67 Ratings

Detailed Rating

Stars 5
45
Stars 4
13
Stars 3
7
Stars 2
1
Stars 1
2
06063f31905d141af6659772bde04526
30-Day Money-Back Guarantee

Includes

1 hours on-demand video
2 articles
Full lifetime access
Access on mobile and TV
Certificate of Completion