Git- Novice to Expert

Name: Git- Novice to Expert
Rating: 4.4 (343 reviews)

Master Git by learning key topics like branching, merging, stashing and rebasing. Also teaches you the Git foundations .

Created byPradeep Kumar

Last updated 5/2020

English

What you'll learn

effectively use the git commands at work. The participant will also gain the confidence and will be able to leverage all the key features like feature branching, merging, working with GitHub and creating workflows which suits their development process.
The participant will also be able to comprehend what happens behind the scenes when a git command is executed and be in a position to mentor team mates on different key topics.

Course content

9 sections • 44 lectures • 4h 7m total length

What is VCS5:38
In this section, the we shall go though the concepts and key features of a traditional version control system. We shall first see what a version control system is, what are its features and how it is useful to us. We shall see features like branching, conflict resolution strategies and conclude with explaining what a tag is in VCS.
VCS Benefits1:14
Explore how version control provides a centralized repository with backups and full revision history, enabling restoration by fetching revisions and supporting branching for parallel development.
VCS drawbacks2:17
Explore the drawbacks of a version control system, including a single point of failure in the central repository, lost revision history, mandatory connectivity, and messy branching in large open-source projects.
Resources20:00

Git Introduction2:04
Discover git as a distributed version control system with private local repositories containing full revision history, commits, branches, and tags. Work offline, then push changes to a centralized repository.
Understanding Git buzzwords7:12
Learn core git buzzwords and workflows, including master as the source of truth, branches and heads, staging, commits, and remote operations like clone, push, pull, merge, and upstream/downstream relationships.

Installing and Configuring Git on Windows Os2:35
Install Git on Windows, run the installer with default settings, verify with Git Bash, then configure global user name and email and confirm the settings are saved.
Installing Git on Mac/Linux/Unix1:21
Git Configuration4:38
Configure git identity by setting user name and email at system, global, and repository levels; repository level overrides the others, using git config --global user.name and git config --global user.email.
Resources7:00

Git File Life Cycle2:14
Explore the Git file life cycle, distinguishing untracked, tracked, and modified states, and learn how committing updates the repository and changes status.
Basic Git commands - Part One8:50
Create and manage a local git repository, stage changes with git add, commit with messages, and track file status using git status, illustrating branches and revision history.
Ignoring files in Git5:58
Learn to manage untracked files with a .gitignore, create and update ignore rules using regular expressions, verify changes with git status and commits, and apply a global ignore across projects.
Git commands - Part two14:34
Create files and folders, stage them in the staging area, commit changes, then use status, diff, and log to manage and review repository history.
Git Tips and Tricks5:10
Git_Life_cycle7:00

Introduction to working with remote repository0:57
Learn to collaborate with remote repositories by creating a centralized repository, cloning code, pushing local changes, and fetching updates from others.
Creating remote repository on Github1:55
cloning git repository8:18
understanding git pull command14:17
Git pull command with conflict resolution10:15
Understanding Git Fetch command12:50
Learn how git fetch retrieves remote changes into local remote-tracking branches without altering your working code. Then use git merge to resolve conflicts and push updates to the remote.

Branching introduction1:55
Explore git branching by creating local branches from master, testing changes on feature branches, and merging or deleting them before updating the master, with local versus server visibility explained.
Working with git local branches5:32
Learn to view local and remote branches, create a new branch from the master, switch between branches with checkout, and commit changes to the local repository.
Git merging branches and pushing branches to remote7:26
Learn to merge a feature branch into the master branch and push the updated master to the remote repository, including switching branches and verifying the remote changes.
deleting local and remote branches4:32
Delete local and remote branches after merging changes to the master branch. Switch off the current branch, delete locally with git delete -d, then remove remote with origin --delete <branch>.
deleting local branches forcefully8:31
Learn how a new branch points to master code and how changes appear across branches, and how to forcefully delete a local branch with git branch -D.
Tagging in Git6:24
Learn how to use git tagging to freeze code after testing, create and push tags to a remote repository, verify deployment readiness, and delete remote tags when needed.

Introduction to Stashing1:18
Learn how stashing saves unsaved changes as you switch branches or fix urgent bugs without committing incomplete work, keeping features clean and ready to resume later.
Understanding stashing use cases1:43
In this video we shall see why we need stashing and when this command will be useful. We will look at two use cases in which we can use stashing.
Stashing changes demo2:52
In this video we will see how to stash the local changes which is not committed to the repository into a stack. We shall also see how to list the stashed changes.

Understanding git commit chain1:26
In this module we will understand what is a git commit chain and how git maintains the integrity of the repository. Once we have understood the commit chain, we will then explore different commands which needs the foundation of commit chain.
Git Commit chain demo4:57
Explore how to maintain git commit chains by ensuring each commit references its parent, how to create and recommit, and how outputs reveal the relationship between consecutive commits.
Introduction to merging1:20
This is an introduction to Merging and different options in Git for merging
Merging strategy - Fast-Forward merging6:19
Explore fast-forward merging as Git moves the head to the latest commit when the source branch has no changes, demonstrated by merging developer into master with no new objects.
Merging strategy - Recursive merging/3 way merging10:46
Explore fast-forward and three-way merging, learn how merges create a new commit with two parents, and see how master and developer branches integrate changes.
Merging strategy - Rebase5:17
Explore rebase by stacking feature branch changes onto the latest master commit to maintain a linear history, contrasted with merge, which creates a commit with two parents (fast-forward when possible).
Git rebase demo5:32
This video demonstrates a git rebase workflow: create and commit on master and a feature branch, rebase the feature onto master to stack commits, then perform a fast-forward merge.

Amending a Commit8:18
In This video we are going to learn how to amend commits in git. I am also going to show you the other variations of using this command.
Git revert command6:07
In this command we are going to learn how to revert the changes in a standard way without manual changes.
git cherry pick command2:07
Master the cherry pick command to copy a commit from a feature branch onto the current branch, and apply fixes or patches back to master.
Git soft reset3:40
In this lecture, we will look at the soft reset command. This strategy is used to amend any arbitary commit or use to squash multiple commits to a single commit.
Git mixed reset3:01
Explore how git mixed reset moves head to the previous commit, discards that commit, and leaves changes in the working directory with the staging area in sync with the repository.
Git hard reset1:53
Master the hard reset to wipe the working directory and staging area, discard changes, and move head, while verifying with git status before committing.

Requirements

The participant needs some familiarity with working on software projects and understanding of any Version control system. However, the course does not assume any prior working experience with VCS and starts from really ground up.

Description

This course is intended for developers and SCM engineers who want to learn and start using Git as their version control systems. This course is designed in a manner that this will be useful for beginners. Also the concepts will be a refresher for experienced professionals. This course takes a step by step approach right from the basics of a Version control system and then introduces to the benefits and drawbacks of a VCS. Then we introduce you to Git VCS, explain how to setup Git and run through the most useful commands. Also I have included the topic to work with remote repository using Github.

Who this course is for:

This course is designed for developers, operations engineers and Architects who want to learn and use Git in their project. Participants familiar with basics of git will also leverage from some of the inner working of Git.
Having a basic understanding of a version control system will be useful but not mandatory to take up this course.

Git- Novice to Expert

What you'll learn

Explore related topics

Course content

Introduction to Version control system4 lectures • 29min

Introduction to Git2 lectures • 9min

Git installation and configuration4 lectures • 16min

Git File life cycle6 lectures • 44min

Working with Remote Repository6 lectures • 49min

Working with branches6 lectures • 34min

Stashing in Git3 lectures • 6min

Merging strategies7 lectures • 36min

Git Advance concepts6 lectures • 25min

Requirements

Description

Who this course is for: