3.85 out of 5
3.85
13 reviews on Udemy

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.
Instructor:
Packt Publishing
69 students enrolled
English [Auto-generated]
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.

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.

Version Control with Git

1
The Course Overview

This video provides an overview of the entire course.

2
Centralized Versus Distributed

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  
3
Git Internals

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

  • Look at the plumbing and porcelain commands
  • Look at the Git objects 
4
Git States

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

  • Understand what are the Git states
  • Look at Git state concepts 
5
Git as a Deployment Tool

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 
6
Selecting a Git Client

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

  • Look at various Git clients
  • Discuss some resources 
7
Configuring User Preferences and Identity Settings

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 
8
Creating a Repository

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 
9
The Basic Git Workflow

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

  • Explain the guiding principles 
10
Local Versus Remote Repository

In this video, we discuss local versus remote repos.

  • Look at remote repositories
  • Look at local repositories 
11
Undoing Work at Each Stage

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

  • Show how to reset the Git head 
12
Understanding .gitignore

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

  • Explain what is the gitignore file
  • Why would you use it 
13
Creating Tags

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

  • What is a git tag
  • How do you use a git tag 
14
Creating and Merging Branches

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

  • Discuss the branch methodology
  • Look at branch types
  • Create and merge branches 
15
Pull Requests

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

  • Explain what are Git pull requests
  • Learn to work with Git pull requests 
16
The basic Git Workflow

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

  • Explain what the basic workflow is
  • Apply the workflow 
17
Forking Workflow

In this video, we explore the forking workflow.

  • Explain the forking workflow
  • Apply the forking workflow 
18
Feature Branch Workflow

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

  • Explain the feature branch workflow
  • Apply the feature branch workflow 
19
Open Source Workflow

In this video, we look at the open source workflow

  • Explain the open source workflow
  • Apply the open source workflow 
20
GitFlow Workflow

In this video, we look at the GitFlow workflow.

  • Explain the GitFlow workflow
  • Apply the GitFlow workflow 
21
Test your knowledge

Hands-On Version Control with Git

1
The Course Overview

This video will give you an overview about the course.

2
Why Git and How It Works to Solve Major Version Control Issues

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 
3
Git Installation on Windows, Mac, and Linux

Our goal is to install Git and verify the installation.

  • Download Git
  • Install Git
  • Verify Git installation 
4
Configuring and Initializing a Git Repository

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 
5
Adding and Committing Changes in a Git Repository

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 
6
Checking Status in a Git Repository

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 
7
Accessing and Inspecting Commit History in a Git Repository

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 
8
GitHub –Taking a Tour!

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 
9
Forking a GitHub Repository

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 
10
Cloning a GitHub Repository

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 
11
Using Pull and Push to Interact with a GitHub Repository

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 
12
Fetch Versus Pull

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 
13
Branching in Git

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 
14
Managing Git Branches

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 
15
Git Merge with Fast-Forward Technique

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 
16
Git Merge with No-Fast-Forward Technique

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 
17
Git 3-Way Merge

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 
18
Using Pull Request in a Team Collaboration Scenario

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 
19
Working with Git Rebase

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 
20
Git Pull with Rebase

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 
21
Using SSH with GitHub

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  
22
Miscellaneous File Management with Git

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 
23
BitBucket and Working with It

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 
24
Debugging with Git

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. 
25
Learning Git Best Practices

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 
26
Test your knowledge

Conquering Git: Advanced Training Guide

1
The Course Overview

This video gives an overview of the entire course.

2
Stash and Pop

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

  • How to stash our changes
  • How to re-apply our changes with pop 
3
Tracked/Indexed Files

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 
4
Multiple Stashes

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 
5
Stashing into a Branch

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  
6
Branching Basic

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 
7
HEAD and Other Names

In this video, we will learn about HEAD.

  • Learn what is HEAD
  • Get to know about the different names for a commit 
8
Branches on filesystem

In this video, we will learn about branches.

  • How branches are stored on the filesystem
  • How HEAD is stored on filesystem
9
Git Branch Advanced Tricks – rename, track, contains

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 
10
Fast-Forward or 3-Way Merge

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 
11
Merge with Different Strategies

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 
12
Sign a Merge with GPG

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

  • Install GPG
  • Create your key
  • Sign and merge with public key 
13
Using gitk to Show the Repository History

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 
14
Using Git Gui to Create a Commit

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 
15
Using Filemerge to Solve Conflicts

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

  • Configure git to use filemerge
  • Understand filemerge UI 
16
Understand diff Format

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

  • Understand what the diff format is
  • Generate some changes for better understanding 
17
Understand the diff3 Format

In this video, we will understand diff3 format.

  • Understand what the diff3 format is
  • Generate some changes for better understanding 
18
diff Working Copy Versus Stage Area

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  
19
diff – One Single File

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 
20
Differences between rebase and merge

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
21
Rebase with Conflicts

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 
22
Rebase Interactive – reword and edit commits

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 
23
Rebase Interactive – squash and reorder commits

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  
24
Create Tags for Important Milestones

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

  • Introduce the tag
  • Create a simple tag 
25
Lightweight Versus Annotated Tags

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 
26
Git Tag Options

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

  • List all the tags
  • Delete a tag
  • Update a tag 
27
Git Remote and Git Tag – Do's and Don'ts

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 
28
Create and Update a Submodule

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

  • Introduce the tag
  • Commit on the submodule 
29
Use a Repository with Submodule

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 
30
Git Subtree

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
31
Introduction to Git Hook

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 
32
Improve Commit Messages with prepare-commit-msg

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 
33
Format Your Code Before Push with pre-push

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
34
Introduction to git bisect Command

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

  • Introduce the bisect command
  • Explain the binary search algorithm 
35
Use git bisect to Find a Bug

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
36
Automatize git bisect

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 
37
Git Flow – A Successful Git Branching Model

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 
38
Git Flow with Sourcetree

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 
39
Using Sourcetree

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

  • Clone a repository from sourcetree
  • Stash, commit, and push from sourcetree
40
Repository Maintenance with Git Garbage Collection

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 
41
Git Data Recovery

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 
42
Git on Server

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
43
Improve Git with Aliases

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 
44
Tools and Services

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 
45
Deploy a Web App with Git

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 
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!
3.9
3.9 out of 5
13 Ratings

Detailed Rating

Stars 5
5
Stars 4
3
Stars 3
2
Stars 2
2
Stars 1
1
aac2412822fd3e5e7a694e3ee0e0da65
30-Day Money-Back Guarantee

Includes

10 hours on-demand video
Full lifetime access
Access on mobile and TV
Certificate of Completion