Mastering Git and GitHub Online Course
Mastering Git and GitHub Online Course
In this professional online course on mastering Git and GitHub, you’ll gain a comprehensive understanding of version control with Git and collaboration through GitHub. The course begins by explaining the need for a Version Control System and how Git works, followed by installation on your local system. You’ll dive into advanced topics like SHA1 Hashing, Git internals, blob objects, and Git snapshots. The course covers essential concepts such as branching, merging, rebasing in VS Code, and stashing, along with hands-on experience in resolving merge conflicts. You will also learn to use GitHub for effective collaboration, including commits, cloning repositories, adding collaborators, and pushing changes. The course further explores Git fetch, Git pull with three-way merges, and branching strategies in real-world scenarios. By the end, you’ll be equipped to fork, clone, and contribute to public repositories, and understand digital signatures and signed commits. This hands-on course prepares you to master Git and GitHub for efficient development workflows.
Key Benefits
- Gain a strong foundation in core Git concepts, enabling efficient version control and code management.
- Enhance collaboration skills by managing and contributing to projects on GitHub, fostering effective teamwork and streamlined development workflows.
- Develop the expertise to contribute to open-source projects, expanding your involvement in the global development community and enhancing your professional portfolio.
Target Audience
This course is ideal for individuals who are beginning their journey as developers, as well as managers and team leads overseeing projects who wish to gain proficiency in version control and collaboration. It is also suited for those interested in starting their DevOps career or enhancing their existing skills. Additionally, the course is perfect for passionate learners seeking to improve their expertise and boost job prospects through mastering Git and GitHub. No prior programming experience is required to enroll, making it accessible to all levels of learners.
Learning Objectives
- Grasp the importance of version control, Git, and the role of branches within Git for effective code management.
- Gain a deep understanding of the SHA1 hashing algorithm and its application in Git operations.
- Learn how to clone a private repository and manage project collaborators on GitHub for seamless team collaboration.
- Master the process of creating remote branches and pushing changes using Git Bash to maintain an organized workflow.
- Acquire the skills to sync a forked repository with the original repository, ensuring up-to-date code across both local and remote systems.
- Learn how to make signed commits and verify them on GitHub, ensuring code integrity and security.
Course Outline
The Mastering Git and GitHub Exam covers the following topics -
Module 1 - Introduction to Git and Version Control
- The Necessity of Version Control and Git (Part 1)
- The Necessity of Version Control and Git (Part 2)
- How Version Control Systems Function
- Understanding Distributed Version Control Systems
- Installing Git on Your System
- Git CLI vs. Git Bash vs. Git GUI: A Comparison
- Basic Commands in Bash
- What Does a Git Commit Really Mean?
- Initializing Projects and Inspecting the .git Directory
- Configuring Git Credentials and Understanding Local, Global, and System Configurations
- Staging, Unstaging, and Checking the Status of Changes
- Committing: A Deeper Look with Use Case Scenarios
Module 2 - Git: An In-Depth Exploration
- The Role of SHA1 Hashing Algorithm in Git
- Git Internals: Introduction to Object Database (Part 1)
- Git Internals: Understanding the Object Database (Part 2)
- Investigating Git Objects: Viewing and Reading Them
- Behavior of Blob Objects
- Managing Unused Objects with Garbage Collection and Pack Files
- Snapshot Concept in Git: What It Means to Create One
- Time Travel with Git: A Conceptual Overview
- Practical Time Travel Using Git
Module 3 - Mastering Git Branches
- Operating Without Branches in Git
- Understanding Git Branches
- How Branches Provide Solutions to Complex Issues
- Git Branching: How It Works and the Concept of a Branch
- Branches in Action: Creating and Navigating Git Repositories
- The Significance of HEAD in Git: Detached State and Its Impact
- Reverting Changes with git reset HEAD
- Recovering Lost Changes with reflog
Module 4 - Merging in Git
- The Process of a Fast-Forward Merge
- Demonstrating a Fast-Forward Merge in Practice
- Removing Branches and Recovering from Deletions
- Three-Way Merge: Concept and Understanding Merge Commits
- A Practical Guide to Three-Way Merges
- Resolving Merge Conflicts: What You Need to Know
- Handling Merge Conflicts in Practice: Part 1
- Handling Merge Conflicts in Practice: Part 2
- Setting Up Visual Studio Code for Git Operations
- Performing Git Operations in VS Code
Module 5 - Git Rebasing: An Advanced Approach
- Rebase vs. Merge: Key Differences
- Rebasing in VS Code and Conflict Resolution
- Using Git Bash for Rebase: Skipping Conflicts and Aborting Rebase
- Introduction to Interactive Rebasing
- Rebase a Specific Commit or Branch: Step-by-Step Guide
- Rebase vs. Merge: When to Use Each Method
Module 6 - Understanding Git Stashing
- What is Git Stashing and Its Use Cases?
- Applying Stashes Across Multiple Branches
- Retrieving Specific Stashes and Handling Conflicts
- Stashing Selective Changes: Working with Hunks
- Using Stashing Features in Visual Studio Code
- Deleting a Stash in Git
Module 7 - Managing .gitignore in Git
- Why .gitignore Is Crucial for Git Repositories
- Practical Guide to .gitignore with Global Exclude Configurations
- Overriding .gitignore Rules and Debugging Patterns
- Ignoring Files That Were Previously Committed
- How to Generate .gitignore Files for Your Projects
Module 8 - Introduction to GitHub
- Why Choose GitHub? GitHub vs. BitBucket vs. GitLab
- Setting Up a GitHub Account
- Exploring Public and Private Repositories on GitHub
- Committing Changes and Understanding the ReadMe File on GitHub
- Branch Creation and Management on GitHub
Module 9 - Collaborating on GitHub
- Cloning Public Repositories and Other Options
- Cloning Private Repositories and Adding Collaborators
- Understanding Tracking Branches and the Default Branch
- Exploring Tracking Branches and Configuring Default Branches
- Understanding Remotes: Adding, Editing, and Deleting
Module 10 - Git Fetch
- Understanding the Purpose of git fetch
- Using git fetch (Part 1): Command Variations and Checking Status
- git fetch in Action (Part 2): Exploring References and FETCH_HEAD
- Switching States Between Local and Remote Repositories
- Merging Changes Using FETCH_HEAD
- Fetching and Merging Changes in Visual Studio Code
- Keeping Local References Up to Date with git fetch
Module 11 - The Git Pull Process
- Git Pull Explained
- Observing the Functionality of Git Pull in Practice
- Git Pull and Three-Way Merge: How It Works
- The Rebase Option in Git Pull: What You Need to Know
- Conflict Management with Git Pull and Rebase
- Using Stashing and Hard Reset in Conjunction
Module 12 - Pushing Changes to Remote Repositories with Git
- Preparing for Contribution: Adding Collaborators and Setting Credentials
- Pushing Changes to Remote Branches: Using Git Bash and VS Code
- Raising and Managing Pull Requests
- Protecting Branches: Branch Protection Rules and Code Reviews
- Reviewing and Approving Changes, Publishing New Updates
- Exploring Merge Options and Understanding Commit Squashing
- Deleting Remote Branches Locally
- Resolving Conflicts via GitHub: Best Practices
- Understanding the Consequences of Force Pushes
Module 13 - Forking and Contributing to Open-Source Projects
- What Is Forking and Why It’s Important
- Forking a Repository and Cloning to Local Machine
- Contributing Changes to a Forked Repository
- Syncing a Forked Repository with the Original Repository
- Pushing Changes to a Forked Repository
- Raising Pull Requests and Merging Updates in the Original Repository
- Exploring Existing Open-Source Projects
Module 14 - Branching Strategies and Git Tags
- Explaining Branching Strategies
- Real-Life Scenarios for Branching Strategies
- Semantic Versioning in Git
- The Role of Tags in Git
- Implementing Branching Workflows
- Hot Fix Workflows in Git
- Creating and Managing Tags: Annotated vs. Lightweight
- Pushing Tags to Remote Repositories
- How Tags Are Stored and Detached Head State in Relation to Tags
- Creating Releases and Tags on GitHub
Module 15 - Protecting Branches with Rules
- Dismissing Stale Pull Request Approvals
- Configuring Code Owners with Patterns and Automatic Review Requests
- Mandating Resolution of Conversations Before Merging
- Exploring Additional Branch Protection Rules
Module 16 - Digital Signatures and Verified Commits
- The Importance of Verified Commits
- Understanding Digital Signatures and Signed Commits
- Generating Public and Private Keys Using GPG
- Exporting Public Keys and Updating GPG on GitHub
- Making Signed Commits and Verifying Them on GitHub
- Mandating Signed Commits in Git Repositories
- Signing Commits from VS Code
