Essential Git - All You Need to Know to Use Git Effectively
4.7 (27 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.
531 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Essential Git - All You Need to Know to Use Git Effectively to your Wishlist.

Add to Wishlist

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
4.7 (27 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.
531 students enrolled
Created by Jorge Escobar
Last updated 3/2017
English
Current price: $10 Original price: $45 Discount: 78% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 1.5 hours on-demand video
  • 2 Articles
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • 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.
View Curriculum
Requirements
  • A computer with internet access and administrative access to install packages
  • A basic understanding of how to use the internet and text editors
Description

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 constantly 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.

Who is the target audience?
  • Software developers who want to learn Git from scratch
Students Who Viewed This Course Also Viewed
Curriculum For This Course
39 Lectures
01:22:39
+
Introduction
2 Lectures 01:50

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.

Preview 01:27

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

What is Git?
00:23
+
Installing Git
4 Lectures 05:56

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. 

Installing Git
00:18

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.

Preview 03:28

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..

Preview 01:48

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```.

Checking if Git is Installed
00:22
+
Git Fundamentals
3 Lectures 03:52
Git Fundamentals
00:15

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.

Preview 02:02

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.

Visual Workflow
01:35
+
Starting with Git
12 Lectures 35:58

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.

Starting with Git
00:16

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

Basic Operations
03:34

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. So all you need to do is to type the following command:

git init

Initializing our Git repository
02:51

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.

Preview 04:37

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.

A new commit
02:33

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.

A New File
02:15

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.

History of the Project
02:55

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.

More Git Log Options
02:25

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.

Jumping Back in Time
01:31

Let’s see other useful Git commands.

More Git Commands
05:50

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.

Undoing Things
03:42

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.

Unstaging Files
03:29
+
Git Branching and Tags
8 Lectures 19:13
Introduction to Branching
01:19

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

The Commit History
02:27

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.

Merging Branches
01:13

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.

Branching in Action
03:44

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.

Merge Conflicts
02:01

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.

Rebasing
03:57

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.

Interactive Rebase
03:37

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.

Tagging
00:55
+
Remote Repositories
7 Lectures 13:36

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.

Remote Repositories
00:35

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.

Setting up a Github account
00:20

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.

Creating SSH credentials
01:58

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

Our First Remote Repository
01:19

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.

Remote Repository Operations
03:03

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.

Git fetch and Git pull
02:56

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

Git Remote Branches
03:25
+
Final Project
1 Lecture 01:27
Final Project
01:27
+
Conclusion
1 Lecture 00:35

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.

Conclusion
00:35
+
Bonus Lecture: The Essential Git Book
1 Lecture 00:16

Get the course book with a special discount!

Bonus Lecture: The Essential Git Book
00:16
About the Instructor
Jorge Escobar
4.5 Average rating
757 Reviews
4,796 Students
5 Courses
Technologist, entrepreneur and open source fanatic

From Zero is an educational project created by Jorge Escobar, a technologist, entrepreneur and open source fanatic with more than 15 years of experience in the development of web applications in New York City.

Jorge has worked in well established companies like Yahoo!, Univision and MongoDB and has also been the technical founding member of various successful tech startups that have received multiple rounds of venture capital.

The biggest problem Jorge has experienced during his career is finding well rounded developers and he interviewed hundreds of them for positions in the teams he was leading. A constant pattern (no matter if candidates came from a good university or had a few years of experience) was the lack of practical, real world knowledge.

That’s why Jorge created From Zero, an educational project that would address those practical knowledge issues through training that builds hands-on experience and equip students with the tools required to be successful in today’s technology business needs.