Git: Master Version Control with Git - Step-by-Step!: 3-in-1
3.9 (17 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
110 students enrolled

Git: Master Version Control with Git - Step-by-Step!: 3-in-1

Master versioning and manage your code with Git by controlling its workflow and using it for your projects.
3.9 (17 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
110 students enrolled
Created by Packt Publishing
Last updated 7/2018
English
English [Auto-generated]
Current price: $139.99 Original price: $199.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 10.5 hours on-demand video
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Find out all about workflows—from basic to open source, and discover one that fits your needs.
  • Set up Git repositories, clone an existing repository, and work with local and remote branches and tags.
  • Optimize workflows by leveraging the different workflow styles to suit the needs of the project.
  • Use a Git branch to merge your file with the master branch
  • Manage Git branches in situations of multiple developments
  • Manipulate and change the Git commit history, to tackle practical workflow problems
  • Explore branching and merging and resolve merge conflicts.
  • Mark important milestones with tagging—annotated tags and comparing tags.
Course content
Expand all 90 lectures 10:23:44
+ Version Control with Git
20 lectures 02:40:10

This video provides an overview of the entire course.

Preview 02:49

In this video, we are looking at distributed vs centralized version control systems.

  • See what is centralized version control
  • Explore advantages of each type of system  
Centralized Versus Distributed
14:02

In this video, we look into the inner workings of Git.

  • Look at the plumbing and porcelain commands
  • Look at the Git objects 
Git Internals
11:28

In this video, we will be introduced to the concept of Git states.

  • Understand what are the Git states
  • Look at Git state concepts 
Git States
04:02

This video will be a help to decide if we can use Git as a deployment tool for our team.

  • Understand why to use Git as a deployment tool
  • Discuss what are some rules for using Git for deployments 
Git as a Deployment Tool
07:10

In this video, we look at some popular Git clients.

  • Look at various Git clients
  • Discuss some resources 
Selecting a Git Client
14:55

In this video, we are going to configure user preferences.

  • Set up Git for first time use
  • Look at configuring identity
  • Review the settings we created 
Configuring User Preferences and Identity Settings
06:26

In this video, we are going to create a Git repository.

  • Initialize the Git repository
  • Clone our Git repository
  • Commit the changes we have made 
Creating a Repository
08:28

In this video, we are discussing the basic Git workflow.

  • Explain the guiding principles 
The Basic Git Workflow
05:39

In this video, we discuss local versus remote repos.

  • Look at remote repositories
  • Look at local repositories 
Local Versus Remote Repository
02:53

In this video, we are discussing resetting the Git head.

  • Show how to reset the Git head 
Undoing Work at Each Stage
04:46

In this video, we will understand what the .gitignore file is for.

  • Explain what is the gitignore file
  • Why would you use it 
Understanding .gitignore
06:11

In this video, we look at the git tag concept.

  • What is a git tag
  • How do you use a git tag 
Creating Tags
09:18

In this video, we are discussing branching and merging topics.

  • Discuss the branch methodology
  • Look at branch types
  • Create and merge branches 
Creating and Merging Branches
18:03

In this video, we discuss the details on pull requests.

  • Explain what are Git pull requests
  • Learn to work with Git pull requests 
Pull Requests
12:15

In this video, we are discussing the basic Git workflow.

  • Explain what the basic workflow is
  • Apply the workflow 
The basic Git Workflow
06:12

In this video, we explore the forking workflow.

  • Explain the forking workflow
  • Apply the forking workflow 
Forking Workflow
03:55

In this video, we discuss the feature branch work flow.

  • Explain the feature branch workflow
  • Apply the feature branch workflow 
Feature Branch Workflow
05:01

In this video, we look at the open source workflow

  • Explain the open source workflow
  • Apply the open source workflow 
Open Source Workflow
05:46

In this video, we look at the GitFlow workflow.

  • Explain the GitFlow workflow
  • Apply the GitFlow workflow 
GitFlow Workflow
10:51
Test your knowledge
3 questions
+ Hands-On Version Control with Git
25 lectures 03:49:37

This video will give you an overview about the course.

Preview 04:43

Our goal is to lay the groundwork by learning the fundamental Git concepts.

  • Discuss Feature branch workflow in Git
  • Discuss Distributed Development in Git
  • Discuss Core Git extension such as Pull Requests and Quicker Release Cycle in Git 
Why Git and How It Works to Solve Major Version Control Issues
03:32

Our goal is to install Git and verify the installation.

  • Download Git
  • Install Git
  • Verify Git installation 
Git Installation on Windows, Mac, and Linux
05:11

Our goal is to configure author and email for the repository globally and learn repository initialization techniques.

  • Configure author and email
  • Initialize an empty repository
  • Initialize repository with existing unversioned artifacts 
Configuring and Initializing a Git Repository
10:37

Our goal is to learn the "git add" and "git commit" commands.

  • Adding artifacts to the index after making changes to untracked files
  • Committing changes to Git database
  • Executing an express commit for tracked files 
Adding and Committing Changes in a Git Repository
08:08

Our goal is to learn what’s happening under the hood for git add and git commit steps.

  • Checking repository status before making any changes to the repository
  • Checking repository status after staging changes
  • Checking repository status after committing changes 
Checking Status in a Git Repository
09:58

Our goal is to learn how to peek into the commit history of a Git repository

  • Checking commit history in an unformatted state
  • Checking commit history in a formatted manner for a single file and multiple files
  • Checking commit history constrained by a range of commits and a defined number of commits 
Accessing and Inspecting Commit History in a Git Repository
05:38

Our goal is to provide an overview GitHub. We will discuss basic operations such as home & landing page of GitHub website, sign ups, profile settings and creation of bare bones repository.

  • Here we discuss signup and sign-in with a basic intro of the landing and home page
  • Here we discuss and create a basic GitHub repository
  • Here we discuss profile settings and the structure of the repository page 
GitHub –Taking a Tour!
05:10

Our goal is to introduce the concept of forking a GitHub repository and actually undergo the forking process.

  • Here we discuss the concept of forking on GitHub
  • Here we discuss the fork interface.
  • Here we actually undergo the forking process and related metrics 
Forking a GitHub Repository
04:11

Our goal is to introduce the concept of cloning a GitHub repository and actually undergo the cloning process.

  • Here we discuss the concept of cloning on GitHub
  • Here we show how to clone a public GitHub repository directly
  • Here we show how to fork a public GitHub repository and then clone the same 
Cloning a GitHub Repository
06:14

Our goal is to introduce the concept of pull and push operations in a local repository in tandem with a synchronized GitHub repository and actually undergo the pull and push processes.

  • Here we discuss the concept of pull and push operations
  • Here we show how to execute a pull command
  • Here we show how to execute a push command 
Using Pull and Push to Interact with a GitHub Repository
07:57

Our goal is to introduce the concept of fetch operation and demonstrate the difference between pull and fetch operations.

  • Here we discuss the concept of fetch operation
  • Here we show to how to execute a fetch operation
  • Here we show how to execute a simple merge command after a fetch command 
Fetch Versus Pull
06:58

Our goal is to provide a quick and powerful introduction to the world of Git branches and merging tactics.

  • Explain what Git branches are and their importance
  • Create a Git branch and display existing branches
  • Discuss a typical real world Git branching model 
Branching in Git
04:53

In this video, we discuss Git commands that can be used in daily management of Git branches.

  • Demonstrate how to checkout or switch to another Git branch
  • Demonstrate how to delete a Git branch
  • Demonstrate how to rename a Git branch 
Managing Git Branches
08:25

Here we discuss and implement the simple branch merging technique called fast-forward merge.

  • Create a branch and make few commits
  • Checkout back to master branch and perform a diff
  • Merge the new branch into master branch using fast forward 
Git Merge with Fast-Forward Technique
10:37

In this video, we discuss and implement the branch merging technique called no-fast-forward merge.

  • Create a branch and make few simple commits
  • Checkout back to master branch and perform a diff
  • Merge the new branch into master branch using no-fast-forward technique 
Git Merge with No-Fast-Forward Technique
08:31

In this video, we discuss and implement the branch merging technique called 3-way merge.

  • Create a demo branch and carry out few changes in the branch
  • Checkout back to master branch, make few commits and perform a diff
  • Merge the demo branch into master branch after resolving merge conflicts 
Git 3-Way Merge
10:03

In this video, we discuss and implement a pull request which is great way to collaborate in a team environment.

  • Demonstrate how to fork and clone a repository owned by another user
  • Make some changes in the cloned repository and raise a pull request
  • Demonstrate how a user can be given write access to merge a pull request 
Using Pull Request in a Team Collaboration Scenario
14:02

In this video, we will learn about Git rebase and actually implement the same.

  • Checkout to a demo branch
  • Execute a git rebase command while staying on demo branch
  • Checkout back to master branch and inspect the log history post rebase operation 
Working with Git Rebase
07:49

Here we will learn how to perform a git pull with the "—rebase" flag.

  • Inspect the log history where remote and local repositories are not in sync
  • Execute a git pull with rebase flag
  • Execute git log command and inspect the effects of pull with rebase 
Git Pull with Rebase
09:47

In this video, we will learn how to connect and interact with a remote repository using SSH protocol.

  • Generate SSH keys, public and private
  • Add the public key to remote repository on GitHub
  • Perform few setup operations and synchronize remote and local repository using SSH  
Using SSH with GitHub
15:08

Here we will learn some basic file management operations which are extremely useful to carry out our daily version control related tasks.

  • Perform a file deletion operation for tracked and untracked files
  • Perform file renaming and moving operations for tracked files
  • Perform undo operations for staged and modified files 
Miscellaneous File Management with Git
14:01

In this video, we learn two very popular tools, SourceTree and Bitbucket and connect both the tools.

  • Create a BitBucket account and perform an initial commit
  • Download and Install Source tree and connect with BitBucket
  • Perform basic git operations such as staging, commit, pull and push to sync remote and local repositories 
BitBucket and Working with It
15:33

Here we will learn the git commands that can help us to debug our code base in the repository.

  • Execute "git grep" command to perform string search
  • Execute "git blame" command to track a faulty committer
  • Execute "git bisect command to pinpoint a buggy line of code. 
Debugging with Git
26:01

In this video, we learn some of the important best practices to be observed while working with Git.

  • Learn the best practices to be followed while doing git commits
  • Learn the best practices while performing git branch and merge operations
  • Learn the several bad practices to be avoided while working with Git 
Learning Git Best Practices
06:30
Test your knowledge
5 questions
+ Conquering Git: Advanced Training Guide
45 lectures 03:53:57

This video gives an overview of the entire course.

Preview 06:56

In this video, we will talk about the git stash command.

  • How to stash our changes
  • How to re-apply our changes with pop 
Stash and Pop
05:22

In this video, we are going to talk about tracked and indexed files.

  • How we can stash but keep the index
  • Get to know we can stash that are not tracked yet 
Tracked/Indexed Files
02:15

In this video, we will talk about git stash command and multiple stashing.

  • List all the stashes
  • Add a comment to a stash
  • Apply one stash from the list 
Multiple Stashes
02:37

In this video, we will talk about how we can stash our changes into a different branch.

  • Use git status command to look at the changes
  • Use the git stash branch command to stash all the changes  
Stashing into a Branch
02:07

In this video, we will learn about the basics of branching.

  • How to create a branch
  • Change the current branch
  • Reset a branch to a specific commit 
Branching Basic
04:41

In this video, we will learn about HEAD.

  • Learn what is HEAD
  • Get to know about the different names for a commit 
HEAD and Other Names
04:13

In this video, we will learn about branches.

  • How branches are stored on the filesystem
  • How HEAD is stored on filesystem
Branches on filesystem
04:18

In this video, we will talk about some options that we can use with the git branch command.

  • rename/delete a branch
  • track a remote branch
  • List all the branches for a commit 
Git Branch Advanced Tricks – rename, track, contains
03:37

In this video, we will talk about the difference between fast-forward or a 3-way merge.

  • When git creates a fast-forward merge
  • When git creates a 3-way merge
  • Connect the storyboard with the code 
Fast-Forward or 3-Way Merge
05:47

In this video, we will learn how to generate random values and use the text2speech API.

  • Learn how to configure strategies
  • Use AVFoundation to pronounce the number 
Merge with Different Strategies
03:35

In this video, we will learn how to sign a merge with GPG.

  • Install GPG
  • Create your key
  • Sign and merge with public key 
Sign a Merge with GPG
04:24

In this video, we will understand how to use gitk, the gui git client distributed with git.

  • See the overview of the UI
  • Execute common tasks – tag, cherry-pick, diff 
Using gitk to Show the Repository History
03:48

In this video, we will use a different gui tool specifically created to commit our changes.

  • Understand git gui
  • Use git gui to explore the filesystem 
Using Git Gui to Create a Commit
03:00

In this video, we will use a gui tool to understand a diff file.

  • Configure git to use filemerge
  • Understand filemerge UI 
Using Filemerge to Solve Conflicts
04:10

In this video, we’ll learn about the diff format

  • Understand what the diff format is
  • Generate some changes for better understanding 
Understand diff Format
05:15

In this video, we will understand diff3 format.

  • Understand what the diff3 format is
  • Generate some changes for better understanding 
Understand the diff3 Format
04:05

In this video, we will check the differences between the current state of the working copy and the content of the stage.

  • Understand how we can perform a diff working copy versus stage area
  • Understand how we can perform diff working copy versus HEAD  
diff Working Copy Versus Stage Area
02:04

In this video, we will check the differences in one single file across different commits.

  • Understand how we can generate a diff using a single file 
diff – One Single File
02:32

In this video, we will get to know the differences between the merge process and the rebase.

  • Explain pros/cons of each process
  • Start a rebase
  • Start receiving user locations
Differences between rebase and merge
03:40

In this video, we will solve conflicts during a rebase can be challenging. Also we will see how to do it.

  • Solve conflicts during a rebase
  • Abort o continue a rebase 
Rebase with Conflicts
03:28

This is the first video about the interactive rebase. In this video, we will learn how to edit an old commit or reword it.

  • Introduce the interactive rebase process
  • Edit a commit with git rebase interactive
  • Reword a commit with git rebase interactive 
Rebase Interactive – reword and edit commits
05:32

This is the second video about the interactive rebase. In this video, we will learn how to squash and reorder commits.

  • Squash multiple commits in a big one
  • Change the order of the commits as you like  
Rebase Interactive – squash and reorder commits
05:34

This video explains how to add a bookmark to your repository with a tag.

  • Introduce the tag
  • Create a simple tag 
Create Tags for Important Milestones
03:37

In this video, we will explain the difference between a lightweight tag and an annotated tag.

  • Create an annotated tag
  • Visualize the information from an annotated tag 
Lightweight Versus Annotated Tags
04:27

In this video, we will learn all the options for the git tag command.

  • List all the tags
  • Delete a tag
  • Update a tag 
Git Tag Options
02:22

In this video, we will see how to work with tag and a remote repository, what should be done in case of wrong tags.

  • Fetch and push local tags
  • Solve common mistakes when deal with git remote and tag 
Git Remote and Git Tag – Do's and Don'ts
04:54

In this video, we will add a submodule to a current repository.

  • Introduce the tag
  • Commit on the submodule 
Create and Update a Submodule
06:43

In this video, we will see how to use a repository that contains one (or more) submodules.

  • How to clone the repository
  • Keep submodule updated 
Use a Repository with Submodule
05:49

Git submodule are not a silver bullet. The alternative is called git subtree. In this video, we will learn how to use them.

  • Introduce the subtree model
  • Add a subtree to our repository
  • Keep the subtree updated
Git Subtree
05:29

In this video, we will understand what the git hooks are, where the store are, and what’s possible to do with them.

  • Create a simple hook with Ruby
  • Create a simple hook with Python 
Introduction to Git Hook
04:03

In this video, we will see how to apply our custom validation to the commit message.

  • Abort the commit if the message include WIP
  • Prepend the commit message with the branch name 
Improve Commit Messages with prepare-commit-msg
06:48

In this video, we will see how to apply our custom validation before pushing.

  • Write a script to ask for a confirmation before pushing
  • Abort the push if the code is not formatted
Format Your Code Before Push with pre-push
06:41

In this video, we will see how to find the commit that introduced a bug.

  • Introduce the bisect command
  • Explain the binary search algorithm 
Introduction to git bisect Command
05:20

In this video, we will understand git bisect process in detail.

  • Mark commits as bad or good
  • Visualize the bisect process with gitk
  • Save and reply the bisect history
Use git bisect to Find a Bug
05:28

In this video, we will see how to make the bisect process even faster and how to write a script for it.

  • Create a script to automatise the bisect process 
Automatize git bisect
04:03

In this video, we will see the history and analysis of the git flow approach.

  • See the history of git flow
  • See the usage of master and develop branch
  • See the usage of feature, release, and hotfix branch 
Git Flow – A Successful Git Branching Model
06:18

In this video, we will use gitflow can be tedious, not if done from a gui and sourcetree has a support for git flow built in.

  • Configure sourcetree to use git flow
  • Start or complete a new action on sourcetree 
Git Flow with Sourcetree
09:31

In this video, we will use sourcetree for all your daily job.

  • Clone a repository from sourcetree
  • Stash, commit, and push from sourcetree
Using Sourcetree
06:31

A repository can take more space of what it requires. In this video, we will learn how to save space and delete useless objects.

  • Understand in detail the git object model
  • Execute the garbage collector to reduce the size of the repository 
Repository Maintenance with Git Garbage Collection
11:03

Git is really safe, but a mistake can happen. In this video, we will learn how to restore commits that you thought were lost.

  • Restore data from reflog
  • Restore data from fsck
  • Restore data from git objects 
Git Data Recovery
08:08

In this video, we will learn how to setup in a few minutes a minimal git server.

  • Configure ssh to use a public key
  • Create a bare repository
  • Secure the server with git-shell
Git on Server
07:57

In this video, we will see the use of git aliases.

  • Look at the list of aliases
  • Understand how git can be used better with aliases 
Improve Git with Aliases
07:23

In this video, we will look at the tools and services.

  • Take a look at the various tools and services
  • See how we can use these services to improve git 
Tools and Services
08:36

In this video, we will learn how to deploy a web app with git.

  • Understand the process of using git to trigger a deploy with a simple push 
Deploy a Web App with Git
09:46
Requirements
  • Prior basic knowledge of GIt is assumed.
Description

Version control is a system that records changes to a file or set of files over time so that you can recall specific versions later.Git version control gives developers the capability to manage, version, release, and share a code base, free from the nightmare of breaking code. With an enhanced workflow and a faster release cycle, it makes agile software development much easier.

Controlling your projects (small or large) is easier now, owing to the advanced functionalities that Git supplies! It performs fast, is easy to manage, and makes Source Control Management uncomplicated and effortless for you. It will help you implement that perfect workflow you have been looking for!

This comprehensive 3-in-1 course is an easy-to-follow guide full of examples to help you gain knowledge and expertise in Git. Master the essential commands to manage artifacts within a Git repository. Hook up a local repository with a remote repository such as GitHub in order to prepare for a team collaboration scenario. Delve into the advanced features of Git to enhance your mastery of it. Explore branching, merging, rebasing, tagging, and also how to resolve conflicts and resolutions while using them in your projects. Get acquainted with best practices in Gitalong with managing, recovering, and handling your data and troubleshooting!

Contents and Overview

This training program includes 3 complete courses, carefully chosen to give you the most comprehensive training possible.

The first course, Version Control with Git, covers guidelines to deliver great code using TFS and Git. Dive into version control using Git. After explaining the difference between centralized and distributed version control, you’ll configure your Git environment. Once we have configured the environment, work with Git in your day to day activities. Set up the workflows in Git. You’ll learn Basic Workflow, Forking Workflow, Feature workflow, open source workflow and Gitflow Workflow.

The second course, Hands-On Version Control with Git, covers better project workflows with Distributed Version Control. Explore the Git data model and how you can navigate through databases with simple commands. Debug your application with Git and use various techniques to find faulty commits. Go remote with your repository with GitHub, updating and cloning remote repositories. Set up your repositories in BitBucket cloud. You will set up your own Git repositories, configure access, find and recover from repository errors, and perform repository maintenance and troubleshooting. Finally you will work with centralized and distributed version control systems and see how to use Git to bring order to the chaos of collaborative software development. By the end of the tutorial you'll have figured out how to use Git, mastered workflows (from basic to open source), and adopted the one that fits your needs

The third course, Conquering Git: Advanced Training Guide, covers mastering versioning and managing your code with Git by controlling its workflow and using it for your projects.. Delve into more intriguing features of Git such as rebase, stash, aliases, and patches. Explore several examples of these commands to improve your efficiency in using Git. Finally, when you have mastered the various tools provided byGit, you'll be provided with some suggestions to help you to move forward with Git. By the end of the course, you'll have a solid understanding of Git and version control so you can use them in your own projects; perhaps you will be the one providing answers to others in trouble!

By the end of the course, you’ll master versioning and manage your code with Git by controlling its workflow and using it for your projects.

About the Authors

  • Paul Hacker, a Principal Consultant with AgileThought, has over 15 years of application architecture, design, development, and management expertise in Microsoft technologies. Paul has a depth of experience in ALM, Process Improvement, and Team Foundation Server. Having distinguished himself as a leader in the IT industry he has been awarded the distinction of Microsoft MVP in the ALM category every year since 2006.
  • Bibhash Roy is a hardened Software Developer and Professional turned entrepreneur, with over 25 years of rich industrial experience (17 years in Software Development) in diverse fields. However, he is passionate about teaching whatever he has learned in his career, spanning an array of prestigious stints at large Global Corporate powerhouses such as PricewaterhouseCoopers and Siemens. Over the years, he has gained deep knowledge and expertise in programming languages such as Java, C, C++, PL/SQL, Scala, and Python to name but a few. He has worked extensively in various frameworks and tools such as Spring, Struts, Hibernate, Oracle, MongoDB, Cassandra, Hadoop, Spark, and others. DevOps intensely interests him. He has been working with Git and GitHub since their inception. As a part of his engineering responsibility, he has developed and architected numerous highly scalable and mission-critical applications for many Fortune 500 companies. Currently in the role of founder and CEO, he is spearheading Whitepeak Software, a cloud-based software development company deeply involved in domains such as big data, mobile, and the Internet Of Things (IoT)!
  • Ignazio Calo is a Software Developer with long experience developing both on the backend side and mobile side. He likes to work in an agile environment with visibility on the entire software life cycle. He tries always to do his best to share knowledge across the team he works with. He is a Senior iOS Developer with eBay, and has worked on eBay Kleinanzeigen (the German version of eBay App), ZipJet app, Foodoora (food delivery iOS App), and Lyke (shopping app to discover and shop for the latest trends and styles), and more. He has worked for customers such as Ferrero or Pirelli creating an application for integrating their SAP backend system into custom applications. He has been using Git extensively to handle his everyday projects with Git.
Who this course is for:
  • Software professionals including developers, testers, architects, configuration analysts, and release managers who want to understand the capabilities of Git.
  • Software engineers, developers, programmers, and designers who want to use version control to track, modify, and share content in their projects.
  • Developers who have a basic knowledge of Git and want to go beyond a basic tutorial.