Git from Basics to Advanced: Practical Guide for Developers from Udemy

What's inside

Learning objectives

Git :)
Learn the key concept of git
Perform basic and advanced git operations
Manage branches, solve merge conflicts like a pro
How to work with github
Manage local and remote repositories
Manage files with git in your filesystem
Rebasing in git

How to develop software in team using git
Step through the entire git workflow
Best practices of using git
How to keep git history clean
Real-life cases of using git
Show more
Show less

Git :)
Learn the key concept of git
Perform basic and advanced git operations
Manage branches, solve merge conflicts like a pro
How to work with github
Manage local and remote repositories
Manage files with git in your filesystem
Rebasing in git
How to develop software in team using git
Step through the entire git workflow
Best practices of using git
How to keep git history clean
Real-life cases of using git
Show more
Show less

Syllabus

Introduction

From this lecture you will learn:
• How to communicate during this course

• Where to ask questions

• How to ask questions

• Communication channels

From this lecture you will learn:

• Version Control Systems - Overview

• The most popular VCS

• Git - Overview

• Git - Main features

• How git operates

In this lesson, I’ll show you how my students get exclusive, free, no sign-up access to a one-of-a-kind AI Bot I personally built to help you deeply learn the material, reinforce your knowledge, and gain a real advantage in interviews, real-world work and career growth.

From this lecture you will learn:

• How to install Git

• Basic Git configuration

• What is a repository

• What is a Git Bash

• What is Git Gui

From this lecture you will learn:

• How to create a local Git repository

• git init

• git add

• git commit

• git status

• What is a branch

• Tracked VS Untracked files

From this lecture you will learn:
• .gitignore file

• How to ignore specific files and directories

• How to remove files from staging area

• How to remove directories from staging area

• Explore commit history

• git log

From this lecture you will learn:

• How to amend last commit

• How to change commit message

• How to unstage changes

• git restore

• Restoring original state of the file before changes

• Vi console text editor

• Autocompletion with Tab key

From this lecture you will learn:

• What is Git hosting

• Why do we need Git hosting

• Overview of the most popular git hosting sites

• Creating remote repository

• Checking remote repository

• Connect local repository with the remote repository

• Setting upstream for the master branch

• README.md

• Git clone

From this lecture you will learn:
• What is SSH protocol

• When we need to use SSH

• SSH Keys

• How to generate SSH keys

• How to configure git repository

• Known hosts

• Changing remote repository

From this lecture you will learn:
• How commits are stored in git in a nutshell

• What is a branch

• What is a HEAD pointer

• Create new branch

• git log for the specific branch

• git checkout

• git switch

• git branch

• Switch branches

• Detached HEAD state

• Basic linux terminal commands (cd, touch, ls)

From this lecture you will learn:
• What is a ‘pull request’

• Difference between ‘pull request’ & ‘merge request’

• Create the first ‘pull request’

• Add collaborators to a repository

• Assignee VS Reviewer in PR

• Merging strategies

From this lecture you will learn:

• Why do we need to update the local repository

• How often do we have to update the local repository

• git fetch

• git merge

• What is ‘fast-forward’

• git pull

• ‘mkdir’ command

• Real-life scenario of team development and demo

From this lecture you will learn:
• What is merge conflict

• When merge conflicts happen

• Real-life example of merge conflict

• How to resolve merge conflicts

• Merge conflicts during the git pull

From this lecture you will learn:
• What is git rebase

• When to apply rebasing

• Rebase VS Merge

• How to keep git tree clean

• How to resolve conflicts during the rebasing

• git rebase --continue

• Force update & --force-with-lease

• Four rules of happy work with git

From this lecture you will learn:
• What is interactive rebase

• git rebase -i

• How to change any commit message

• How to squash commits

• How to combine commits

• Best practices

From this lecture you will learn:
• What is git reset

• reset VS checkout

• git reset --soft

• git reset --mixed

• git reset --hard

• git reset to specific commit

• git reset few commits back

• git fetch --all and git reset origin branch

• Practical exercise

From this lecture you will learn:
• What is stash

• When to use git stash

• How to stash changes

• How to manage multiple stashes

• How to apply stash

• Stash untracked files

• How to apply specific change from stash

• What is stack

• git stash list

• git stash pop VS git stash apply

• git stash branch

• git stash drop

• git stash clear

From this lecture you will learn:
• What is git reflog

• When to use

• How to restore lost commits

• How to restore lost commits in the new branch

• How to restore commit on the same branch

• Filter reflog by time

From this lecture you will learn:
• What is git cherry-pick

• When to use cherry-pick

• How to cherry-pick multiple commits

• Resolve conflicts during the cherry-picking

• Best practices

From this lesson you are going to learn how to use 'git clone' command to clone remote repository to your local computer.

From this lecture you will learn:
• Explore git views in Eclipse

• How to add an existing git repository into eclipse

• Git bash in eclipse

• Review commit history in Eclipse

• Branch navigation in eclipse

• Creating a snapshot and pushing from eclipse

• Configuring toolbar

• Updating local repository from eclipse

• Resolving conflicts in eclipse

Overview of the Course Objectives
Importance of Secure, Clean, and Scalable Code
Importance of code reviews
Introduction to Effective Code Review
Impact on code quality and team collaboration

Basic principles of code review process
Goals of code review process
Different types of code reviews
Which type of code review to select
Understanding the role of code reviewer and author
Developing a Reviewer Mindset
Strategies for Efficient Code Review

Introduction to Code Review Tools
Using Automated Tools for Code Analysis
Integration of Tools into the Development Process
Best Practices for Secure and Scalable Code

Introduction to Checkstyle
Features for Checkstyle
Use cases
Purpose and Benefits of Using Checkstyle
Installation and Setup
Configuring Checkstyle Rules
Using Checkstyle Plugin During Development
Integrating Checkstyle into a Sample Project
Generating Checkstyle Report with Maven Plugin
Analyzing Checkstyle Reports

Using Checkstyle Plugin During Development
Integrating Checkstyle into a Sample Project
Generating Checkstyle Report with Maven Plugin
Analyzing Checkstyle Reports

What is PMD
Features of PMD
Benefits of PMD
PMD Role in the Development Process
Install PMD into Eclipse IDE
Check code with PMD
Analyze PMD Report
Configure PMD Rules
Integrate PMD checks into build process
PMD Maven Plugin

Establishing Code Review Guidelines and Expectations
Example of Code Review Guidelines
Contribution Policy
Code Review Guidelines VS Contribution Policy
Example of Contribution Policy

Overview of coding standards
Example of Coding Standards
Setting and Enforcing Coding Standards
Ensuring Code Quality and Consistency
Coding Standards for Different Programming Languages
Following Best Practices For Various Programming Languages

Constructive Criticism Techniques (What, Why, How)
Effective Communication During Code Review Process
Providing Fair and Objective Feedback
Creating a Positive Code Review Culture
Building Trust Among Team Members
Collaborative Code Review Process

Importance of Security in Software Development
Common Security Vulnerabilities
Integrating Security Best Practices in Code Review Process
Security Scanners

Understanding Scalability in Software Development
Best Practices for Scalable Code
Identifying and Addressing Scalability Challenges
How to identify scalability challenges during code review

What is a metric
Examples of metrics
When to use metrics
What is a KPI
Examples of KPI
When to use KPI
Metric VS KPI
What is OKR
Examples of OKR
When to use OKR
KPI VS OKR

What is RAG Status
RAG status to present KPI
Why we use RAG status for KPI

What we are going to learn in this section
Why this section is important
Overview of Engineering Excellence Metrics Library
Web Development related examples and use cases

Tech Debt Ratio
Tech Debt Index
Cyclomatic complexity.
Definition
Use cases
How to measure
How to read values and what do they mean
Recommended KPIs
Recommended Actions

Unit Testing
How Unit Tests Work
Benefits of Unit Tests
Challenges and Limitations of Unit Tests
Unit Test Run Success Rate

Unit Test Code Coverage
Incremental Unit Test Coverage

Duplicate Code
Duplicated Lines
Duplicated Blocks
Duplicated Files
Density of Duplicated Lines
Commented Code Index

What is a Code Review
Code Review Feedback Loop Time
Code Reviews Amount

Rules Compliance Index (RCI)
Violations
Differences between RCI and Violations

What is Integration Testing
What is End-to-End Testing
Integration VS End-to-End Testing
Integration Test Coverage
End-to-End Test Coverage

Career center

Learners who complete Git from Basics to Advanced: Practical Guide for Developers will develop knowledge and skills that may be useful to these careers:

Software Developer

A Software Developer is at the core of creating and maintaining applications, writing code, and implementing new features. This course is an exceptionally relevant guide for an aspiring or current Software Developer, as expertise in Git, from basics to advanced concepts, is foundational for nearly all modern software development. Learners will gain practical skills in managing local and remote repositories, efficiently handling branches, resolving merge conflicts, and employing rebasing, all crucial for collaborative team development. Furthermore, the course delves deeply into code review fundamentals, establishing coding standards, and applying principles like those for secure and scalable code. Understanding software development metrics and key performance indicators also helps a Software Developer deliver high-quality, maintainable code, making this course essential for robust and professional software creation.

See salaries and explore the career path for Software Developer

Technical Lead

A Technical Lead guides development teams, ensuring technical quality, mentoring junior engineers, and making critical design decisions. This course is exceptionally well-suited for a Technical Lead, offering profound insights into not just Git mastery but also the critical aspects of software quality and team collaboration. The ability to manage complex branching strategies, facilitate pull requests, and resolve merge conflicts effectively, as taught in this practical guide, empowers a Technical Lead to maintain a clean codebase. Crucially, the extensive sections on code review fundamentals, establishing coding standards, and applying best practices for secure and scalable code provide the framework for fostering a high-quality development culture. Understanding software development metrics further enables a lead to track team performance and guide continuous improvement.

See salaries and explore the career path for Technical Lead

Software Configuration Manager

A Software Configuration Manager is responsible for identifying, organizing, and controlling changes to software components throughout the development lifecycle. This course is an exceptionally strong fit for a Software Configuration Manager, as it provides a practical, advanced, and comprehensive mastery of Git. The role inherently relies on deep version control expertise, and this course delivers exactly that. Learners will gain proficiency in all aspects of Git, including managing local and remote repositories, complex branching strategies, merge conflict resolution, rebasing, and maintaining a clean Git history. These skills are fundamental for controlling code baselines, managing different software versions, and supporting parallel development efforts. The course's real-life cases and best practices further equip a Software Configuration Manager to implement robust and efficient configuration management processes, ensuring traceability and integrity across all software assets.

See salaries and explore the career path for Software Configuration Manager

DevOps Engineer

A DevOps Engineer bridges the gap between development and operations, focusing on automating and streamlining the software delivery lifecycle. For a DevOps Engineer, this course offers highly pertinent skills by providing a practical, advanced understanding of Git. Mastery of Git operations, including managing local and remote repositories, intricate branching strategies, and resolving merge conflicts, is paramount for configuring continuous integration and continuous delivery pipelines. The course's emphasis on best practices for keeping Git history clean, along with real-life team development scenarios, directly translates into robust deployment strategies and efficient version control for infrastructure as code. This comprehensive training helps build a solid foundation for managing code releases and ensuring system stability through disciplined version control.

See salaries and explore the career path for DevOps Engineer

Release Manager

A Release Manager coordinates the planning, scheduling, and control of software releases, ensuring that new features and updates are delivered smoothly and efficiently. For a Release Manager, a thorough understanding of Git provided by this course is exceptionally useful. The course's practical guide covers fundamental and advanced Git operations, including managing branches, tags, and remote repositories, which are all critical elements in defining and executing a release strategy. The ability to understand clean Git history, perform rebasing, and resolve complex merges directly supports the integrity of release branches and the ability to pinpoint changes for auditing. This expertise helps a Release Manager oversee the version control aspects of the release pipeline, ensuring consistent and controlled deployments from development to production environments.

See salaries and explore the career path for Release Manager

Engineering Manager

An Engineering Manager leads engineering teams, fostering professional growth, managing project delivery, and ensuring high-quality software output. For an Engineering Manager, this course is highly relevant, providing a deep understanding of the technical bedrock of software development and its quality aspects. While not performing daily Git operations, an effective manager benefits immensely from knowing Git's advanced concepts like branching strategies, rebasing, and merge conflict resolution to better understand team challenges and facilitate efficient workflows. Crucially, the extensive coverage of code review fundamentals, setting coding standards, fostering a positive code review culture, and understanding software development metrics and KPIs (like tech debt and code coverage) equips an Engineering Manager with the tools to assess team performance, drive quality initiatives, and ensure delivery of maintainable and scalable software.

See salaries and explore the career path for Engineering Manager

Process Improvement Specialist Software Development

A Process Improvement Specialist in Software Development identifies, analyzes, and optimizes workflows and practices within software engineering teams to enhance efficiency and quality. This course is remarkably tailored for a Process Improvement Specialist Software Development, offering a deep dive into practical aspects of the software development lifecycle. The comprehensive coverage of Git best practices for team development, including managing branches, pull requests, and maintaining a clean history, provides concrete areas for process optimization. Furthermore, the extensive modules on code review fundamentals, establishing clear coding standards, and implementing automated code analysis tools (Checkstyle, PMD) offer direct insights into improving code quality and collaboration. Crucially, learning about software development metrics and KPIs empowers this specialist to measure process effectiveness, identify bottlenecks, and drive data-informed improvements across the engineering organization.

See salaries and explore the career path for Process Improvement Specialist Software Development

Full-Stack Developer

A Full Stack Developer is responsible for building both the front-end user interface and the back-end server-side logic and databases of web applications. For a Full Stack Developer, this course is incredibly practical and directly applicable, providing comprehensive mastery of Git. Developing across multiple layers of an application requires diligent version control for codebases that often span different technologies and teams. The course's emphasis on managing branches, resolving merge conflicts, working with remote repositories like GitHub, and clean Git history is vital for seamless collaboration and efficient development cycles. Additionally, the intensive sections on code review fundamentals, refactoring skills, and adhering to coding standards directly contribute to writing high-quality, maintainable, and robust code for all parts of a full stack application.

See salaries and explore the career path for Full-Stack Developer

Software Quality Assurance Engineer

A Software Quality Assurance Engineer ensures that software products meet specific standards and requirements, preventing defects and improving overall quality. This course may be useful for a Software Quality Assurance Engineer by providing a deep understanding of the version control system developers use daily. Knowledge of Git operations, including managing changes, branches, and merges, helps in understanding the development workflow and investigating code versions when bugs are discovered. More significantly, the course's comprehensive modules on code review fundamentals, automated code analysis tools like Checkstyle and PMD, and advanced code review strategies are directly applicable. Learning about software development metrics and KPIs, such as unit test coverage and duplicate code, allows a Quality Assurance Engineer to contribute to and monitor the technical health of a project, reinforcing a proactive approach to quality.

See salaries and explore the career path for Software Quality Assurance Engineer

Automated Test Engineer

An Automated Test Engineer designs, develops, and maintains automated test scripts and frameworks to ensure software quality and functionality. This course offers highly relevant skills for an Automated Test Engineer. Proficiency in Git, including managing branches, merging code, and understanding commit history, is crucial for version controlling test scripts and integrating them into continuous integration pipelines. More importantly, the course's deep dive into code review fundamentals, establishing coding standards, and applying automated code analysis tools like Checkstyle and PMD are directly applicable to writing high-quality, maintainable, and robust test automation code itself. Furthermore, the sections on software development metrics, particularly unit test coverage, integration test coverage, and end-to-end test coverage, provide an Automated Test Engineer with the knowledge to measure and report on the effectiveness of testing efforts, ensuring comprehensive quality assurance.

See salaries and explore the career path for Automated Test Engineer

Site Reliability Engineer

A Site Reliability Engineer focuses on the reliability, availability, and performance of large-scale systems, often by writing code and automating operations. This course provides highly relevant skills for a Site Reliability Engineer by offering an advanced, practical understanding of Git. SREs frequently manage infrastructure as code and deploy services, making strong Git knowledge, including remote repository management, branching, merging, and rebasing, essential for reliable deployments and rollbacks. The course's emphasis on real-life team development scenarios and best practices for clean Git history directly supports maintaining robust and auditable operational environments. Furthermore, the sections on code review fundamentals and software development metrics may be useful for ensuring the quality and maintainability of operational scripts and automation code, contributing to overall system stability and performance.

See salaries and explore the career path for Site Reliability Engineer

IT Consultant

An IT Consultant provides expert advice and solutions to organizations on technology strategy, implementation, and optimization. Given the instructor's background, this course is particularly relevant for an IT Consultant specializing in software development practices. A deep, practical understanding of Git, including advanced operations, team collaboration workflows, and best practices for version control strategy, enables an IT Consultant to advise clients on efficient development processes. Beyond Git, the comprehensive sections on code review fundamentals, establishing coding standards, automating quality checks with tools like Checkstyle and PMD, and understanding software development metrics (KPIs) equip a consultant to assess client development maturity, recommend cutting-edge solutions for code quality, and help implement robust engineering excellence practices. This breadth of knowledge is vital for guiding clients towards modern, effective software delivery.

See salaries and explore the career path for IT Consultant

Software Architect

A Software Architect defines the overall structure of a software system, ensuring it meets functional and non-functional requirements like scalability and maintainability. While a Software Architect may not perform daily Git commands, this course is highly relevant. Understanding advanced Git concepts, such as branching strategies, rebasing, and managing a clean history, helps an architect design systems that facilitate efficient team collaboration and future evolution. More significantly, the comprehensive modules on code review fundamentals, establishing coding standards for different programming languages, and implementing best practices for secure and scalable code are directly applicable to architectural principles. Knowledge of software development metrics further empowers the architect to guide teams towards high-quality, maintainable solutions, ensuring the long-term health and adaptability of the software system.

See salaries and explore the career path for Software Architect

Systems Administrator

A Systems Administrator manages an organization's computer systems, ensuring their smooth operation, security, and maintenance. While primarily focused on infrastructure, a Systems Administrator often interacts with configuration files, scripts, and automation tools, making version control increasingly relevant. This course, "Git from Basics to Advanced", may be useful for a Systems Administrator who needs to track changes to system configurations, manage scripts, or collaborate on infrastructure as code projects. The practical lessons on creating and managing local and remote Git repositories, understanding branching, and resolving simple conflicts directly apply to maintaining an auditable history of system changes. This can significantly enhance control, enable easier rollbacks, and facilitate collaboration in managing complex IT environments.

See salaries and explore the career path for Systems Administrator

Technical Writer Software Documentation

A Technical Writer Software Documentation creates clear, concise, and accurate documentation for software products, including user manuals, API guides, and system specifications. While the primary focus of this course is on development, it may be useful for a Technical Writer Software Documentation by providing a practical understanding of Git. Technical writers often work closely with development teams and may need to access or track changes in codebases or documentation stored in version control systems. Learning how developers use Git, including managing repositories, branches, and checking commit history, helps the writer navigate code, understand development cycles, and collaborate effectively on projects. This insight ensures documentation accurately reflects the latest software versions and features, and helps writers manage their own documentation versions efficiently.

See salaries and explore the career path for Technical Writer Software Documentation