Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Learn Git and GitHub - FastTrack Your Journey to Git!

Name: Learn Git and GitHub - FastTrack Your Journey to Git!
Rating: 4.6 (34 reviews)

Learn complete Git and GitHub - The most In-demand IT Skill

Created byKarthikeya T

Last updated 3/2024

English

What you'll learn

Master Git and GitHub for your new Job role
Kick start your DevOps Journey with Git
Understand how to manage team projects on GitHub
Learn how to contribute to Open Source Projects & increase your profile credibility
Learn the best practices & avoid typical mistakes
Actively involve team
Confidently answer tricky interview questions related to Git and GitHub
Learn end-to-end Git and GitHub

Course content

19 sections • 131 lectures • 9h 57m total length

Introduction3:23
Master Git and GitHub to contribute to open source, gain real-world coding experience, and boost credibility for software development, DevOps, and cloud roles.
Need For Version Control System and Git Part 13:21
Discover why a version control system and Git matter, see how multi-file changes hinder undoing work, and learn how to revert to previous versions to keep web projects stable.
You must know this!0:51
Need For Version Control System and Git Part 26:01
Learn why a version control system is essential and how Git tracks historical changes and creates backups. See how versioning enables comparing and reversing edits across project versions.
VCS-How it works5:27
Explore how a version control system stores project history, using patch sets and file references to save changes and restore prior versions.
Distributed VCS6:12
Compare local, centralized, and distributed version control, revealing how Git and GitHub enable full history on each machine, offline work, and centralized access control.
Installing Git8:25
Download, install, and verify Git on your local environment, choosing installer or portable versions and using defaults, while learning about Git Bash, Git GUI, OpenSSH, and path setup.
Git CLI vs Git Bash vs Git GUI2:37
Compare git cmd, git bash, and git GUI, highlighting Windows, Linux, and Unix shell usage, with git bash as the preferred tool throughout the course.
Basic Bash Commands5:59
Explore basic bash commands in Git Bash to interact with the Windows file system, including mkdir, cd, pwd, ls, and rm -rf, with hands-on folder creation and deletion.
What exactly is Git Commit6:48
Explore how git commit creates a snapshot of your project, not a full backup, and how git add stages files into a local repository for separate commits.
Initializing the project and Exploring dot git folder7:48
Initialize a project with git init to create the hidden .git folder, establishing the staging area and object database for version history, and learn about hooks and excludes.
Configuring Git Credentials and exploring local global system configs6:53
Configure Git credentials to identify who commits; learn local, global, and system scopes, precedence rules, and inspect settings with Git config list.
Staging and Unstaging and checking status5:03
Learn to stage and unstage files in a git repository with git add and git reset --cached, and verify progress using git status as you prepare commits.
Understanding Commit with multiple use cases8:11
Learn to commit changes by staging files, adding, and writing meaningful messages. Track changes with git status, git log, and the master branch, tied to defect or feature IDs.
Quick Note!1:22
Rate and review this Git and GitHub course, share what you've learned, connect with the instructor's teaching style, and help future students decide to enroll.

Sha1 Hashing Algorithm3:53
Understand the sha1 hashing algorithm, producing a 40-character hash from input, with the same input yielding the same hash and data cannot be recovered; git uses hashes to identify objects.
Git Internals (All about Object Database) Part 13:37
Learn how Git stores data in the object database by building a fresh project with files and an assets directory, initializing Git, adding files, checking status, and committing changes.
Git Internals (All about Object Database) Part 2.zip4:54
Discover how Git stores data in the object database: blob objects for files, tree objects for directories, and commit objects with sha1 hashes, author details, and messages.
Git Internals - Viewing and reading Git Objects5:36
Explore how Git stores data in the object database and read commit, tree, and blob objects by inspecting their hashes with git log and git cat-file -p, -t.
How Blob Objects Behave6:56
Explore how git creates blob objects from file contents, uses hash codes to detect duplicates, and via staging and commits builds trees and snapshots of the project.
Garbage Collection and Pack Files4:42
Explore how git garbage collection compresses objects into pack files with an index, preserving access to content, and verify pack contents with git verify pack -v.
Git Snapshot - What it means to take a snapshot5:27
Understand how a git snapshot captures the index at commit time, creating a new blob and a tree entry for new files while reusing unchanged objects.
Time travel with Git2:00
Explore time travel with Git by examining commits across 1.txt, 2.txt, and 3.txt, learn how to revert to a previous version, and discover why branching is the recommended approach.
Time Travel in Practice7:20
Explore practical time travel in Git by creating commits for features, switching to past states with Git switch or Git checkout, and embracing snapshot-based version control.

Life without Branches6:49
Explore life before git branches and learn how branching helps manage multiple features, prevent partial commits from breaking code, and coordinate teamwork in a centralized repository.
What are Git Branches7:25
Explore how git branches work, including the main and master branches, how commits live independently per branch, and how switching branches and merging eventually consolidates changes into master.
How Branches Solved our Problems2:46
Use branches to work on multiple features simultaneously, switching between branches to keep changes isolated and reduce conflicts. Developers can create branch experiments, then merge to master and delete branches.
How Git Branches Work and What Exactly is a Branch4:07
Learn how git branches are references to commits, with master created automatically after first commit, and switching to a feature branch updates the working directory to the branch’s last commit.
Branches in Action (Creating Branches and exploring the git repo)8:13
Create and switch branches in a git repo and observe master and feature branches. See how commits and the working directory update as you move between branches.
Understanding 'HEAD' - Detached Head State - Head in Action.6:32
Understand how head points to a branch or a specific commit, and what a detached head state is, including how commits can be lost when switching branches.
Undo the changes with Git Reset HEAD4:35
Learn to undo commits with git reset head~n, using the soft option to keep changes in the working directory and staging area, or the hard option to discard them.
Retrieving the lost mystery with reflog4:02
Use git reflog to locate the commit hash and recover changes. Create and switch to a new branch with git checkout -b new-branch at that commit, then merge into master.

Fast-Forward Merge3:05
Perform a fast-forward merge by updating the master to the latest commits from the feature branch, enabling a clean merge and deleting the feature branch.
Fast-Forward Merge In Action3:51
See fast-forward merge in action by merging feature1 into master, viewing commits, and updating the working directory with merged files. Learn branch management basics for local and GitHub workflows.
Deleting the branch and recovering4:25
Learn how to delete and recover git branches safely, including checking out master, handling unmerged branches with -d and -D, and restoring deleted branches from a commit hash.
Understanding Three Way Merge and Merge Commit3:35
Explore how three-way merge and merge commits resolve changes from master and feature branches, why fast-forward merges are avoided, how two-parent merge commits handle conflicts, and how conflicts are resolved.
Three Way Merge in Action4:57
Demonstrates a three way merge on a git project, combining master and feature one with a merge commit, using git log, and cleaning up by deleting the feature branch.
Understanding Merge Conflicts4:14
Understand merge conflicts in git by tracing commits on master, adding a feature branch, and performing a three-way merge that requires conflict resolution before creating a merge commit.
Merge Conflicts in Action Part 15:20
See a hands-on demo of merge conflicts in action as a feature branch updates inventory.txt and product.txt changes occur in both master and feature branches.
Merge Conflicts in Action Part 25:20
Resolve merge conflicts by inspecting unmerged paths in master and feature one, edit product.txt to keep desired changes, stage and commit to complete the merge.
Installing and setting up Visual Studio Code to work on Git.mp43:51
Install and set up Visual Studio Code to manage git projects with a git extension, view history and branches, and handle merge conflicts using extensions like GitLens and Git Graph.
Exploring VS Code and performing GIT Operations8:57
Explore git operations in Visual Studio Code using the git graph extension, create and switch branches, stage and commit changes, resolve merge conflicts, and review history and merges.

Git Rebase vs Merge3:39
Compare git rebase and merge, highlighting their purposes and trade-offs, and learn how rebase creates a linear history, reduces spaghetti commits, handles conflicts, and where to use each.
Performing Rebase in VS Code & Handling conflicts6:06
Learn how to perform git rebase in Visual Studio Code, resolve conflicts between master and feature branches, and complete a fast-forward merge to achieve a linear history.
Git Rebase in Git Bash - Skipping conflicts and Aborting the Rebase3:06
Learn how to perform a git rebase in git bash, resolve conflicts, continue or skip commits, and merge feature branches back into master with clear, linear history.
Git Interactive Rebase3:16
Learn to perform an interactive rebase in Git, using the rebase todo list to pick, reword, or drop commits, handle conflicts, and update commit messages in a feature branch.
Rebase to specific commit or to another feature branch8:32
Learn to rebase a branch to a specific commit or another branch using git rebase, including switching branches, using commit hashes, and resolving conflicts.
When to use rebase and when to use Merge - use cases2:44
Explore when to use rebase versus merge in git, including rebasing a feature branch onto later commits and merging to preserve history for multiple developers.

What is Stashing - It's use cases - Example of Stashing5:10
Learn how Git stash temporarily stores uncommitted changes to switch between branches, including stashing tracked and untracked files, and restoring them with Git stash pop.
Applying the stash across multiple branches2:00
Learn how to stash uncommitted changes and apply them across multiple branches using git stash apply, preserving the stash for reuse and enabling consistent edits on feature branches.
Retrieving a specific stash - Listing stashes - Handling conflicts4:36
Learn to view and retrieve stashes with git stash list, apply or pop a specific stash by its ID with a descriptive message, and resolve conflicts with uncommitted changes.
Stashing Selective Changes and retrieving them - Understanding Hunk3:59
Learn to stash selective changes with git stash -p, review hunks, answer y or n for inventory.txt and product.txt, and reapply the latest stash when needed.
Exploring stashing in VS Code - Deleting a stash3:09
Explore stashing in Visual Studio Code, applying or popping stashes (including untracked files), and dropping or clearing stashes with git stash drop or git stash clear.

Git Ignore and it's significance (Crash course)4:40
Learn how git ignore patterns prevent accidental commits of log files, compiled code, and local dependencies by using dot ignore files, global patterns, and precedence rules.
Git Ignore in action - Global exclude config6:10
Learn how to use a local and global ignore strategy with git ignore, excluding log files and info logs using .gitignore and core exclude file, and commit the changes.
Precedence order - overriding - Pattern debugging4:12
Explore gitignore precedence, overriding, and pattern debugging across root and subdirectories, including how patterns are resolved, when to stage files, and using check-ignore for troubleshooting.
Ignore files that were already committed7:13
Add a .gitignore to prevent future log files from being tracked, and use git rm --cached to remove already committed log files, then commit the cleanup.
Generating the Ignore files for your project2:11
Use a gitignore generator to quickly create ignore patterns for your project. Explore generated patterns for Android and Node, including build directories, dot gradle, local properties, and log files.

Why GitHub - GitHub vs Bit Bucket vs GitLab3:34
Discover why GitHub serves as a centralized code hosting service for teams, enabling commits and pushes to a repository with distributed version history, and compare it to Bitbucket and GitLab.
Creating GitHub Account3:01
Create a GitHub account and set up repositories by following sign up steps, solving a captcha, and verifying via code, while exploring welcome-page options like a readme file.
Creating and understanding Public and Private repositories in GitHub5:56
Create public or private GitHub repositories, name and describe them, choose visibility for contributors, include readme, .gitignore, and license, and review commits and access.
Making Commits in GitHub and Understanding ReadMe file5:53
Make your first commit on a public GitHub repository by creating a readme file, exploring project structure, and tracking commits, branches, and contributor information.
Creating Branch and committing changes - Managing branches in GitHub4:33
Create and switch branches in GitHub, commit changes in a feature branch, and manage active, stale, and all branches, including deletion and restoration.
Check this out!1:22
Rate this course and write a short review to share your journey, what you’ve learned, and your view of the teaching style to help others decide to enroll.

Cloning a public repo and exploring other options7:09
Clone a public repository with git clone using the https option to simplify access. Explore options like ssh, GitHub CLI, and GitHub desktop, plus remotes and distributed version control.
Cloning a Private Repository and adding project collaborators on GitHub5:18
Add Luke as a collaborator in the private repository and accept the invitation, then clone the project using git with code-based authentication to complete access.
Understanding Tracking Branches and Default branch2:40
Understand tracking branches, local pointers to remote commits created on clone. Learn how fetch or pull updates them and how origin names the remote with main as the default branch.
Exploring Tracking branches - Configuring Default branch - Understanding Or4:06
Explore tracking branches in Git and how remote branches from origin map to commits, using commands like git branch -r and git checkout to work on the new feature branch.
Understanding origin remote - adding, editing, deleting remotes4:32
Understand origin as the shorthand for the remote you cloned from, and learn to add, rename, or remove remotes with git remote add, git remote rename, git remote remove.
Can you do this?1:22
Rate this Git and GitHub course and share your review to help others decide. Reflect on what you learned and how the teaching style connected with you.

Understand Git Fetch and it's use cases3:07
Learn how git fetch downloads objects from the remote repository without changing your working directory, updates tracking branches, and lets you compare local and remote status for ahead or behind.
Git Fetch in Action Part1 (Command variations - Checking status with comman8:15
Demonstrate how git fetch downloads remote objects and updates tracking branches, creating a new feature branch and aligning local commits with the remote.
Git Fetch in Action Part2 (Exploring refs - FETCH_HEAD)4:06
See how git fetch downloads commit objects, updates tracking branches, and uses fetch head and refs, revealing when references reside in packed-refs or in a directory structure.
Switching to Remote Repo State2:25
Switch to a remote repo state by fetching and checking out a commit to enter a detached head state, experiment with changes, then preserve work by creating a new branch.
Merging the Changes - Using FETCH_HEAD3:29
Learn how to bring remote changes into your working directory using fetch and a fast-forward merge, including when to perform a three-way merge or rebase.
Using Visual Studio code to Fetch and Merge3:04
Learn how to fetch remote changes in Visual Studio Code using the source control panel, interpret fetch status, and merge remote features into your local branch with a right-click merge.
Updating Local References with Git Fetch3:19
Learn how to manage remote branches with git fetch, prune, and tracking branches, including when to delete a remote branch and how to restore it.

Requirements

You will learn everything you need to know about Git and GitHub
Commitment and dedication to learn GitHub in it's entirety
You need a laptop or a computer to practice what is taught in the course

Description

Git is a Version Control System, where as GitHub is a centralized repository to host the code and enable team collaboration.

In this course, you will learn about Git and GitHub and all the concepts pertaining to them. This course also talks about the use cases and workflows that you need to know as a developer.

You will not only understand the core part of Git and GitHub and how it works under the hood, but we will also explore a host of concepts that are crucial for you to understand before you start contributing to Git projects.

Why learn GitHub?

Contribute to open-source projects and build credibility for your next job application or attract new opportunities.
Host and manage your personal projects on GitHub to create a portfolio.
GitHub plays a significant role in the cloud and DevOps ecosystem.
GitHub is a must-have skill and the starting point to kick-start your cloud and DevOps journey.
Willing to enter an IT role but don't have experience? Showcase your GitHub contributions and make yourself eligible for IT roles without prior experience.

Who can take this course?

Individuals seeking to advance their careers in IT or enter a new job role where knowledge of git and github is required.
People who are getting started with their software developer journey
Managers or team leads who lead a project
People who want to get started with their DevOps journey
Passionate learners who want to upgrade their skills for better job prospects

In this course, you will also learn how to contribute to open source projects and build your online presence or credibility.

This course will teach you everything you need to know about Git and GitHub, and you don't have to refer to any other sources.

This course comes with a 30 day refund policy. If you didn't like the course for whatever reason, you can ask for a full refund.

Few reasons to learn Git and GitHub:

GitHub has over 100 million repositories (source: GitHub).
Over 72 million developers from around the world use GitHub (source: GitHub).
GitHub is home to over 40 million registered users (source: GitHub).
The most popular programming languages on GitHub are JavaScript, Python, Java, TypeScript, and Ruby (source: GitHub).
Over 31 million GitHub repositories are public (source: GitHub).
The most popular license for GitHub repositories is the MIT License, followed by the GNU General Public License (source: GitHub).
Microsoft acquired GitHub in 2018 for $7.5 billion (source: The Verge).

These statistics demonstrate the popularity and widespread use of GitHub among developers and the programming community.

What is GitHub?

GitHub is a web-based platform for software developers to store and share their code with others. It provides version control through Git, which allows developers to keep track of changes to their code, collaborate with others, and easily roll back to previous versions if needed. GitHub also offers a range of features, such as issue tracking, project management tools, and code review capabilities, to help teams work together more effectively. It has become a popular platform for open-source software development and hosts millions of projects, ranging from small personal projects to large enterprise software.

Why GitHub is used for software development:

Version Control: GitHub uses Git, which is a powerful and widely used version control system. It allows developers to keep track of changes to their code and collaborate with others, ensuring that everyone is working on the same version of the code.

Collaboration: GitHub provides a platform for developers to work together on projects, whether they are in the same office or on opposite sides of the world. Teams can easily share code, review changes, and collaborate on new features.

Community: GitHub is a hub for open source projects, providing a platform for developers to contribute to projects created by others. This fosters a community of developers who can share knowledge and collaborate on projects.

Code Review: GitHub provides tools for code review, allowing team members to easily review and comment on each other's code. This helps ensure that code is of high quality and meets the project's requirements.

Project Management: GitHub provides tools for project management, including issue tracking and milestones. This allows teams to keep track of project progress, identify and prioritize issues, and set goals for the project.

Integration: GitHub can be integrated with many other tools and services, such as continuous integration and deployment (CI/CD) tools, which help automate the development process and ensure that code is deployed to production environments quickly and efficiently.

High-level overview of what you will learn:

Git: Git is a popular version control system that allows you to track changes to code and collaborate with others. Understanding how Git works and how to use it is essential for working with GitHub.

Repositories: A repository is a central location for your code. You can create a new repository on GitHub, and then upload your code to it. Repositories can be either public or private, and they can be used to collaborate with others or manage your own projects.

Branches: Branches are used in Git to isolate changes to code and work on new features or fixes. Understanding how to create and manage branches is important for working with Git and GitHub.

Pull Requests: Pull requests are a way to propose changes to code and collaborate with others. They allow you to submit changes to a repository and have them reviewed by others before they are merged into the main codebase.

Issues: Issues are used to track bugs, feature requests, and other tasks. They can be used to manage projects and prioritize work, and they can be assigned to specific users to ensure that work is distributed effectively.

Collaborating with others: GitHub provides a range of tools for collaborating with others, including pull requests, code reviews, and issue tracking. Understanding how to use these tools is essential for working with others and ensuring that code is of high quality.

Project management: GitHub provides tools for project management, including issue tracking and milestones. Understanding how to use these tools can help you manage your own projects more effectively, as well as contribute to larger projects that use GitHub for project management.

This is only a high level overview. Below are the topics covered in this course (By the time of this writing)

Section 1:

Introduction

Need For Version Control System and Git Part 1

Need For Version Control System and Git Part 2

VCS-How it works

Distributed VCS

Installing Git

Git CLI vs Git Bash vs Git GUI

Basic Bash Commands

What exactly is Git Commit

Initializing the project and Exploring dot git folder

Configuring Git Credentials and exploring local global system configs

Staging and Unstaging and checking status

Understanding Commit with multiple use cases

Section 2:

Git Deep Dive

Sha1 Hashing Algorithm

Git Internals (All about Object Database) Part 1

Git Internals (All about Object Database) Part 2

Git Internals - Viewing and reading Git Objects

How Blob Objects Behave

Garbage Collection and Pack Files

Git Snapshot - What it means to take a snapshot

Time travel with Git

Time Travel in Practice

Section 3:

Git Branches

Life without Branches

What are Git Branches

How Branches Solved our Problems

How Git Branches Work and What Exactly is a Branch

Branches in Action (Creating Branches and exploring the git repo)

Understanding 'HEAD' - Detached Head State - Head in Action.

Undo the changes with Git Reset HEAD

Retrieving the lost mystery with reflog

Section 4:

Merging

Fast-Forward Merge

Fast-Forward Merge In Action

Deleting the branch and recovering

Understanding Three Way Merge and Merge Commit

Three Way Merge in Action

Understanding Merge Conflicts

Merge Conflicts in Action Part 1

Merge Conflicts in Action Part 2

Installing and setting up Visual Studio Code to work on Git

Exploring VS Code and performing GIT Operations

Section 5:

Git Rebase

Git Rebase vs Merge

Performing Rebase in VS Code & Handling conflicts

Git Rebase in Git Bash - Skipping conflicts and Aborting the Rebase

Git Interactive Rebase

Rebase to specific commit or to another feature branch

When to use rebase and when to use Merge - use cases

Section 6:

Stashing

What is Stashing - It's use cases - Example of Stashing

Applying the stash across multiple branches

Retrieving a specific stash - Listing stashes - Handling conflicts

Stashing Selective Changes and retrieving them - Understanding Hunk

Exploring stashing in VS Code - Deleting a stash

Section 7:

Git Ignore

Git Ignore and it's significance (Crash course)

Git Ignore in action - Global exclude config

Precedence order - overriding - Pattern debugging

Ignore files that were already committed

Generating the Ignore files for your project

Section 8:

Git Hub

Why GitHub - GitHub vs Bit Bucket vs GitLab

Creating GitHub Account

Creating and understanding Public and Private repositories in GitHub

Making Commits in GitHub and Understanding ReadMe file

Creating Branch and committing changes - Managing branches in GitHub

Section 9:

Getting Started as Collaborator

Cloning a public repo and exploring other options

Cloning a Private Repository and adding project collaborators on GitHub

Understanding Tracking Branches and Default branch

Exploring Tracking branches - Configuring Default branch - Understanding Or

Understanding origin remote - adding, editing, deleting remotes

Section 10:

Git Fetch

Understand Git Fetch and it's use cases

Git Fetch in Action Part1 (Command variations - Checking status with comman

Git Fetch in Action Part2 (Exploring refs - FETCH_HEAD)

Switching to Remote Repo State

Merging the Changes - Using FETCH_HEAD

Using Visual Studio code to Fetch and Merge

Updating Local References with Git Fetch

Section 11:

Git Pull

Understanding Git Pull

Git Pull in Action and observing what it does

Understanding Git Pull with 3way merge

Git pull with rebase and it's implications

Dealing with conflicts with Git Pull --rebase

Using Stashing and Hard reset

Section 12:

Contributing to the remote repository

Setting up everything for contributing - Adding collaborator - Setting cred

Creating a remote branch and pushing changes using Git Bash and VSCode - Pu

Understanding Pull Request - Raising a Pull Request

Understanding protected branches - Applying branch protection rule - Mandat

Reviewing and approving the changes - Working on review comments and publis

Exploring the merging options - Understanding Squashing commits - Deleting

What Git Pull Actually Does

Resolving conflicts on GitHub the right way - Force pushing changes and it'

Divide and Conquer Strategy

Resolving Conflicts by merging main in to feature branch

Section 13:

13 Forking and Contributing to Opensource Projects

What is Forking and why forking

Forking a public repository and cloning it in our local machine

Contributing the necessary changes

Syncing the Forked repo with original one and updating local

Syncing the Forked repo with original from local repo

Pushing our changes to the forked repo

Raising the pull request and merging the changes in upstream repository

Exploring Existing Public Project

Section 14:

Branching Strategy and Tags

Branching Strategy Explained

Branching Strategy with Realtime Scenario

Semantic Versioning Explained

Understanding Git Tags

Braching Workflow in Action

Hot Fix workflow in Action

Creating Tags - Annotated vs Lightweight Tags - Pushing tags to remote

Understanding how Tags are stored - Detached head state with tags

Releases and Creating Tags on GitHub

Section 15:

Branch Protection Rules

Dismiss stale pull request approvals for new commits

Configuring Code Owners with patterns - Automatic review request

Mandating conversation resolution before merging

Exploring all other branch protection rules

Section 16:

Digital Signatures and Verified commits

Mimicking the Commits and the need to have verified commits

Understanding Digital Signatures

Understanding Signed Commits

Creating Public and Private Keys Using GPG

Exporting Public Key and updating GPG key on GitHub

Making Signed Commit - Setting global config - verifying signed commits on

Mandating Signed Commits - Signing commits from VS Code

Section 17:

Git Hooks

What are Git Hooks

Demonstrating Git Hook

Standardizing Hooks across teams

Explore Other Hooks

Section 18:

Other Concepts

Bug Tracing with Git Bisect

Git Diff to compare and visualize differences

Git Diff to compare branches

Advanced Git Log

All About GitHub Pages

Who this course is for:

Anyone who wants to learn Git and GitHub in it's entirety
Anyone who wants to know how to contribute to open source projects
Anyone who aspire to start their career in Cloud/DevOps

Learn Git and GitHub - FastTrack Your Journey to Git!

What you'll learn

Explore related topics

Course content

Introduction15 lectures • 1hr 18min

Git Deep Dive9 lectures • 44min

Git Branches8 lectures • 44min

Merging10 lectures • 48min

Git Rebase6 lectures • 27min

Stashing5 lectures • 19min

Git Ignore5 lectures • 24min

Git Hub6 lectures • 24min

Getting Started as Collaborator6 lectures • 25min

Git Fetch7 lectures • 28min

Requirements

Description

Who this course is for: