Version Control with Git - Concepts with Hands On Projects
4.6 (6 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.
107 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Version Control with Git - Concepts with Hands On Projects to your Wishlist.

Add to Wishlist

Version Control with Git - Concepts with Hands On Projects

Learn in-depth concepts of Git with hands-on exercies
4.6 (6 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.
107 students enrolled
Last updated 4/2017
English
Curiosity Sale
Current price: $10 Original price: $20 Discount: 50% off
30-Day Money-Back Guarantee
Includes:
  • 5 hours on-demand video
  • 1 Article
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Understand how version control systems work
  • Learn Git concepts
  • Use Git with confidence
  • Resolve conflicts, create & manage branches in Git
  • Use Github & remote Git repositories
View Curriculum
Requirements
  • Basic computer skills
  • Ability to install software on your computer
  • You may need admin rights to install software
Description

Are you completely new to version control systems & Git? Are you using Git commands but are not really sure how they work behind the scenes? Are you not able to use full power of Git?

If answer to any of these questions is yes, then this course can help you.

Git is one of the most elegant software tools that I've ever used. This is not just any other version control system. Git will change the way you work for better! Branching is the killer feature of Git that will make you more productive by allowing you to work on multiple things at same time.

To fully harness this power of Git, you need to know more than just commands. You need to understand the concepts behind those commands. Only then can you use Git with confidence and become super productive.

How this course will help you?

We have spent a lot of effort to design and record this course. We are not starting first lesson with typing commands. We spend some time understanding how version control systems work.

Then we explain the distributed version control systems. To know how Git is different than say SVN, you should know what is a distributed version control. You'll learn that here.

Then we start working with Git. We explain important concepts in separate lectures along the way just before we use those concepts. You'll learn a new concept and then immediately use those concepts with Git commands. This will teach you the concepts without getting bored.

We then learn what is a remote repository. We'll use Github for our remote repository. So you'll learn how to create a repository on Github, how to clone one from Github, create branches and much more.

This is a growing and a curated course. We've already added more than 5 Hrs of content that will get you started on any project you want. But we've a lot more to say. We'll be adding more advanced Git concepts and more lectures on them.

TL;DR;

At the end of this course you'll be armed with the knowledge about Git commands & concepts behind them, which will allow you to tackle your daily version control tasks with confidence and use Git to its full potential.

Who is the target audience?
  • This course is for anyone who wants to use version control system
  • Students who have just started using git
  • Git users who want to understand the concepts behind git
Students Who Viewed This Course Also Viewed
Curriculum For This Course
34 Lectures
05:12:48
+
Introduction to Version Control Systems
4 Lectures 26:44

We'll get an overview of what we are going to cover in this section.

Preview 01:34

Understand the version control systems in general. We'll see how a version control system works and learn some of the terminology that goes with version control system operations.

Preview 13:45

Currently there are two types of version control systems which are widely used. We'll learn what those popular types are and learn how a central repository based version control system works.

Types of Version Control Systems & Central Repository
02:12

Distributed version control systems are becoming more popular. Git is also a distributed version control system. In this lecture we'll see how such systems work without getting into commands and other internals. This lecture will help you understand the git commands we'll be learning throughout the course.

Distributed Version Control Systems
09:13
+
Starting with Local Git Repository
11 Lectures 02:04:40

This section focuses on using git on our local machine. This overview will outline the contents of this section.

Preview 01:05

Follow these simple instructions to install git on your computer. I've not added a lecture because the instructions provided on Git website are simple and easy to follow.

Install Git
00:37

Here we'll create our first git repository. We'll learn about the 'git init' command and how it behaves under different circumstances.

Create Git repository - git init
05:33

Git staging area is a source of confusion for a lot of people. This lecture will explain the concept of various logical areas in git. We'll also map git commands to these areas.

Git Concepts - Working & Staging Area
09:34

In this lecture we'll do our first commit. We'll see how we can check local working area status, how to add files to staging area in commit using git commands.

Git status, add & commit commands
13:41

Git log command shows us previous commits that are done in the repository. This lecture will explain the git log command and it's various options to customize the output.

See what's going on with git log
14:08

Checking file difference is one of the most common operation you'll be doing when working with Git or any other version control system. This lecture will explain in great detail how to use the 'git diff' command and how to read the diff command's output.

First encounter with differences - git diff
22:29

Git checkout command has various uses. This lecture will explain one of the simple uses of git checkout command.

Undo changes with git checkout
06:06

This lecture will explain the concept of references in Git. Branches, remote repositories and HEAD are some important references. We'll learn what they are and how Git uses them.

Concepts - Git references
13:16

Learn the 'git reset' command in this lecture.

Git reset
26:00

When programming, especially with a compiler, we get a lot of intermediate files. Learn how to ignore those files when we are committing our changes using the .gitignore file.

Ignore files with ignore file
12:11
+
Branching
5 Lectures 38:29

This section is all about branching in Git. Branching is the star feature of Git. This lecture will give you the overview of this section.

Preview 02:13

Before we start running commands related to branching, we'll learn the concept of branching in this lecture.

Concepts - Branching
09:35

In this lecture we'll see how a git branch works. We'll then learn the commands to create a branch and to start using it.

Create branch & switch with git checkout
12:09

Section about branching is not complete until we learn about merge. We'll learn the 'git merge' command in this lecture. We'll merge a git branch with another in this lecture.

Git merge
10:54

This lecture completes the circle by introducing the command to delete a Git branch.

Preview 03:38
+
Merge Conflicts & Resolution
4 Lectures 37:32

Whenever there is a merge, there is a good chance of conflict. This section is all about merge conflicts. This lecture will provide overview about the concepts we'll be learning in this section.

Preview 02:14

Learn the Git concept of three way merge in this lecture.

Concepts - Three Way Merge
09:08

In this lecture we'll see the three way merge in action. We'll learn how to identify when a three way merge has occurred.

Three way merge in action
08:12

This lecture will discuss the merge conflicts in detail. We'll see how to read the conflict information provided by Git. We'll then see how to resolve a Git merge conflict.

Merge conflict & resolution
17:58
+
Remote Repositories
10 Lectures 01:25:24

This section is about remote repositories. If you are working in a team then you'll be using a remote repository to share your changes with others. This lecture will outline the topics covered in this section.

Preview 02:17

This lecture will explain the concept of remote repositories. We saw them in distributed version control system lecture. In this lecture we'll see what is a common remote repository.

Concepts - Remote repositories
12:11

We'll setup a Github repository in this lecture. You'll learn how to use Github interface and setup your own repository.

Github - Setup account & create repository
05:46

We'll learn 'git clone' command in this lecture. We'll continue using Github as our remote repository.

Clone remote repository
05:41

This lecture explains two important commands when working with remote repository in Git. We'll learn how to send our changes to Github repository and get changes from Github to our local Git repository.

Working with remote repository - git push & pull
19:51

In previous lectures we used a Git repository on Github that was already initialized and had some files. This lecture tells you how to setup Github repository from your existing local Git repository.

Setup remote with existing local repository
10:05

Branching being the star feature of Git, discussion of remote repository is incomplete until we learn how to use branches with remote repository. In this lecture we'll learn how to create branch on Github using Github interface, and then get that branch into our local Git repository.

Remote branches
10:24

This important lecture will clarify the differences between 'git clone', 'git fetch' and 'git pull' commands.

Clone vs Fetch vs Pull
06:59

This lecture will teach you how to put a branch created in local Git repository into remote repository.

Put local branch on remote repository
05:44

Finally we'll learn how to delete a remote branch safely.

Delete remote branch
06:26
About the Instructor
Coffee Powered Crew
4.6 Average rating
6 Reviews
107 Students
1 Course
Excellence with Elegance to Perfection!

We are programmers and artists from UK, USA and South Africa. We met each other over the years during conferences & other work related encounters. We also brought some excellent people we knew to create Coffee Powered Crew.

Coffee Powered Crew is based on only one goal, that is, to create experts in the leading programming languages, technologies and software applications. You can move ahead of competition only if you are an expert in your field. We believe that to be an expert you need to know more than just the syntax and commands. An expert needs to understand the concepts & fundamentals behind the technology or programming language. You need a proper training & experience to become an expert. We hope to help you with the proper training.

We believe a good training needs to provide proper explanation of concepts. That means not just throwing out some word jumble while instructor is typing away the code. A proper focused lecture on each important concept before using & applying that concept makes a good training. We have hired people to create learning aids like animations & drawings to explain concepts properly.

We are hoping that we'll be part of your journey to success and we'll get a chance to help you learn something new that can help you move ahead in your career.

Good Luck!

Coffee Powered Crew

Yogesh Patil
4.6 Average rating
6 Reviews
107 Students
1 Course
Full stack Software Developer

I started out as a C++ developer & moved on to C# in year 2004 and then to Java in year 2006. Since then I've been working with all three languages and the platforms, frameworks and technologies they bring to the table.

I've been working on integrations, technology/platform migrations & all the middle-ware technologies that make it possible. Today I work as a consultant helping companies migrate legacy projects to cloud and implement DevOPs. I also work on developing new solutions that support the new & vast mobile device landscape. 

Ultimately what matters is your understanding of fundamental concepts in software development & design that help you write better code & design better solutions. And those concepts rarely change. If you know them then it really doesn't matter how long you are coding, because anyone who really understands these concepts can always write better code and design better solutions.

Today the flood of new technologies can be overwhelming and confusing. But if you learn concepts behind them then you can pick up any new technology with ease. My goal is to teach these technologies by first explaining concepts behind them thoroughly and then move to commands & syntax.

I'm here to offer my experience with hope that I can explain these concepts in a way that anyone can understand & that it'll help someone.


Cheers,

Yogesh