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

Name: Git: Master Version Control with Git - Step-by-Step!: 3-in-1
Rating: 4.1 (29 reviews)

Master versioning and manage your code with Git by controlling its workflow and using it for your projects.

Created byPackt Publishing

Last updated 7/2018

English

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

3 sections • 90 lectures • 10h 23m total length

The Course Overview2:49
This video provides an overview of the entire course.
Centralized Versus Distributed14:02
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
Git Internals11:28
In this video, we look into the inner workings of Git.

Look at the plumbing and porcelain commands

Look at the Git objects
Git States4:02
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 as a Deployment Tool7:10
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
Selecting a Git Client14:55
In this video, we look at some popular Git clients.

Look at various Git clients

Discuss some resources
Configuring User Preferences and Identity Settings6:26
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
Creating a Repository8:28
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
The Basic Git Workflow5:39
In this video, we are discussing the basic Git workflow.

Explain the guiding principles
Local Versus Remote Repository2:53
In this video, we discuss local versus remote repos.

Look at remote repositories

Look at local repositories
Undoing Work at Each Stage4:46
In this video, we are discussing resetting the Git head.

Show how to reset the Git head
Understanding .gitignore6:11
In this video, we will understand what the .gitignore file is for.

Explain what is the gitignore file

Why would you use it
Creating Tags9:18
In this video, we look at the git tag concept.

What is a git tag

How do you use a git tag
Creating and Merging Branches18:03
In this video, we are discussing branching and merging topics.

Discuss the branch methodology

Look at branch types

Create and merge branches
Pull Requests12:15
In this video, we discuss the details on pull requests.

Explain what are Git pull requests

Learn to work with Git pull requests
The basic Git Workflow6:12
In this video, we are discussing the basic Git workflow.

Explain what the basic workflow is

Apply the workflow
Forking Workflow3:55
In this video, we explore the forking workflow.

Explain the forking workflow

Apply the forking workflow
Feature Branch Workflow5:01
In this video, we discuss the feature branch work flow.

Explain the feature branch workflow

Apply the feature branch workflow
Open Source Workflow5:46
In this video, we look at the open source workflow

Explain the open source workflow

Apply the open source workflow
GitFlow Workflow10:51
In this video, we look at the GitFlow workflow.

Explain the GitFlow workflow

Apply the GitFlow workflow
Test your knowledge

The Course Overview4:43
This video will give you an overview about the course.
Why Git and How It Works to Solve Major Version Control Issues3:32
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
Git Installation on Windows, Mac, and Linux5:11
Our goal is to install Git and verify the installation.

Download Git

Install Git

Verify Git installation
Configuring and Initializing a Git Repository10:37
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
Adding and Committing Changes in a Git Repository8:08
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
Checking Status in a Git Repository9:58
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
Accessing and Inspecting Commit History in a Git Repository5:38
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
GitHub –Taking a Tour!5:10
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
Forking a GitHub Repository4:11
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
Cloning a GitHub Repository6:14
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
Using Pull and Push to Interact with a GitHub Repository7:57
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
Fetch Versus Pull6:58
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
Branching in Git4:53
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
Managing Git Branches8:25
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
Git Merge with Fast-Forward Technique10:37
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 No-Fast-Forward Technique8:31
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 3-Way Merge10:03
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
Using Pull Request in a Team Collaboration Scenario14:02
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
Working with Git Rebase7:49
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
Git Pull with Rebase9:47
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
Using SSH with GitHub15:08
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
Miscellaneous File Management with Git14:01
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
BitBucket and Working with It15:33
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
Debugging with Git26:01
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.
Learning Git Best Practices6:30
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
Test your knowledge

The Course Overview6:56
This video gives an overview of the entire course.
Stash and Pop5:22
In this video, we will talk about the git stash command.

How to stash our changes

How to re-apply our changes with pop
Tracked/Indexed Files2:15
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
Multiple Stashes2:37
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
Stashing into a Branch2:07
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
Branching Basic4:41
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
HEAD and Other Names4:13
In this video, we will learn about HEAD.

Learn what is HEAD

Get to know about the different names for a commit
Branches on filesystem4:18
In this video, we will learn about branches.

How branches are stored on the filesystem

How HEAD is stored on filesystem
Git Branch Advanced Tricks – rename, track, contains3:37
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
Fast-Forward or 3-Way Merge5:47
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
Merge with Different Strategies3:35
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
Sign a Merge with GPG4:24
In this video, we will learn how to sign a merge with GPG.

Install GPG

Create your key

Sign and merge with public key
Using gitk to Show the Repository History3:48
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 Git Gui to Create a Commit3:00
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 Filemerge to Solve Conflicts4:10
In this video, we will use a gui tool to understand a diff file.

Configure git to use filemerge

Understand filemerge UI
Understand diff Format5:15
In this video, we’ll learn about the diff format

Understand what the diff format is

Generate some changes for better understanding
Understand the diff3 Format4:05
In this video, we will understand diff3 format.

Understand what the diff3 format is

Generate some changes for better understanding
diff Working Copy Versus Stage Area2:04
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 – One Single File2:32
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
Differences between rebase and merge3:40
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
Rebase with Conflicts3:28
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 Interactive – reword and edit commits5:32
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 – squash and reorder commits5:34
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
Create Tags for Important Milestones3:37
This video explains how to add a bookmark to your repository with a tag.

Introduce the tag

Create a simple tag
Lightweight Versus Annotated Tags4:27
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
Git Tag Options2:22
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 Remote and Git Tag – Do's and Don'ts4:54
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
Create and Update a Submodule6:43
In this video, we will add a submodule to a current repository.

Introduce the tag

Commit on the submodule
Use a Repository with Submodule5:49
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
Git Subtree5:29
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
Introduction to Git Hook4:03
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
Improve Commit Messages with prepare-commit-msg6:48
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
Format Your Code Before Push with pre-push6:41
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
Introduction to git bisect Command5:20
In this video, we will see how to find the commit that introduced a bug.

Introduce the bisect command

Explain the binary search algorithm
Use git bisect to Find a Bug5:28
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
Automatize git bisect4:03
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
Git Flow – A Successful Git Branching Model6:18
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 with Sourcetree9:31
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
Using Sourcetree6:31
In this video, we will use sourcetree for all your daily job.

Clone a repository from sourcetree

Stash, commit, and push from sourcetree
Repository Maintenance with Git Garbage Collection11:03
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
Git Data Recovery8:08
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 on Server7:57
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
Improve Git with Aliases7:23
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
Tools and Services8:36
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
Deploy a Web App with Git9:46
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

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.

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

What you'll learn

Explore related topics

Course content

Version Control with Git20 lectures • 2hr 40min

Hands-On Version Control with Git25 lectures • 3hr 50min

Conquering Git: Advanced Training Guide45 lectures • 3hr 54min

Requirements

Description

Who this course is for: