Git and GitHub Complete Course - From zero to hero

Learn how version control saves file snapshots, tracks history with commits, enables parallel work, and simplifies merging to protect production and improve traceability using git.

Explore the origin of git, born from the Linux kernel and Linus Torvalds, evolving from email contributions to a fast, distributed tool for parallel development and large projects.

Install git on macOS by downloading from git echemi.com, install homebrew if needed, then run brew install git and verify with git version.

Install git on Windows by downloading the installer, running setup, and enabling explorer integration to access Git Bash here from folders. Verify the installation with git --version in Git Bash.

Configure git globally by setting your user name, email, and a default editor (vim or code). Verify with git config --global and git config --list; note main as initial branch.

Create your first git repository, initialize with git init, rename the initial branch from master to main via git config and git branch -m, and note the hidden .git folder.

Explore how to use git to track changes, create and stage files with git add, and commit with descriptive messages. Understand untracked files, edits, and basic status checks.

Explore the git lifecycle stages: untracked, unmodified, modified, and staged, and see how git add and commit move files through this cycle toward a final history.

Explore practical git workflow fundamentals using VS code, from initializing a repo and creating files to staging, committing, and discarding changes with git restore, emphasizing clear commit messages.

Learn how git diff reveals exactly what changed between files, showing additions and deletions. Then stage changes, review with git diff cached, and commit cleanly.

Capture git history with git log to view commits, identifiers, and head status; learn to display one line history, abbreviate hashes, and inspect changes with diff, stat, and patch.

Navigate the git history by examining commits with git log, move to past states with git checkout, and switch back to the latest on main using git switch.

Learn to amend a commit message with git commit --amend, view history with git log, and see how edits change the commit hash and impact shared history.

Learn to undo changes in git using git restore for modified and untracked files, including dot for all changes and restoring staged files to a clean state.

Learn how to undo the last commit using git reset --hard, review with git log, and safely remove unintended changes while understanding the head pointer and potential irreversibility.

Learn to use a gitignore to exclude untracked files like password files and binary files, and see how to add, commit, and update ignore rules using standard templates.

Explore how git clone creates a complete, decentralized copy of a repository with full history in a new folder, including origin and head on the main branch.

Explore how git branches create parallel work streams, switch between main and feature branches, commit changes, and merge updates like an about page into main.

Learn to create, switch, and delete branches using git switch and git checkout, as well as listing branches and identifying the current branch, in practical terminal examples.

Explore how git merge transfers changes from a feature one branch into the main branch using a VSCode workflow, including commits, branch switching, and post-merge cleanup.

Learn how to resolve git merge conflicts after switching branches and merging feature two into main, using accept current, accept incoming, or accept both changes, and commit the resolved merge.

Learn how to streamline your git history by using rebase to integrate main into a feature branch without creating a merge commit.

Discover how GitHub acts as a cloud repository, a social network, a development ide, a code security agent, and a team organizer, serving as a portfolio and pages host.

Learn how to create a GitHub account, verify with email, choose a username, password, and role, and set up your first repository with a readme and initial commit.

Explore GitHub's pricing options, from the free plan for solo work to team and enterprise plans, and understand private repositories on the pricing page in this course.

Create your first repository on GitHub by naming it with hyphens, choosing public visibility, deciding on readme, gitignore, and license options; learn about main versus master branches.

Learn how to clone a GitHub repository to your local machine using https, including naming clones, navigating with cd, and viewing the initial commit with git log.

Create an index.html file in the cloned project, track it with git add and git commit, then git push to GitHub using a personal access token.

Learn to update your local repository from GitHub with git fetch and git pull, after committing changes on the remote and pulling them into the main branch.

Explore origin, the remote link to your GitHub repository, and how fetch and push use that URL. Learn about multiple origins and common remote commands.

Create a local repository, add a README.md, commit changes, and set a remote origin before pushing to GitHub main. Push commands cover upstream, branch naming, and authentication with a token.

Style your GitHub homepage using the GRM tool, editing the readme, selecting themes, and adding social links and languages you code in.

Learn to clone a repository via ssh by generating and registering a public ssh key on GitHub, then successfully clone projects secured by ssh keys.

Discover how watch, fork, and stars work on GitHub, including following updates, saving projects, and forking to create a personal repository for modification.

Understand how a pull request enables collaboration by forking a project, syncing forks when needed, editing commits like updating readme, and creating a reviewable pull request for review and merge.

Manage issues, labels, and milestones in a GitHub workflow. Create issues, apply labels like bug or feature, and link milestones to track backlog and urgent work.

Create and host a simple portfolio on GitHub pages by forking a repository, editing index.html with your details, and enabling pages from the master root; ideal for front-end beginners.

Explore how to use the GitHub wiki as detailed project documentation, beyond the readme, by creating a home page, multi-page navigation, sidebars, external links, and a footer with contact info.

Explore gist on GitHub by creating and sharing code snippets and notes; publish public or secret gists, copy links, and manage your gists from the gist homepage.

Learn what git tags are, how they label commits with versions such as v1.0 and v2.0, and attach release notes describing fixes and new features for deployments.

Learn to create and compare lightweight and annotated tags in git, using commands like git tag and git show to view tag details such as v 1.0 and v 2.0.

Create tags on commits, including annotated tags, delete tags locally, and push specific tags or all tags to GitHub.

Navigate between version tags, such as v0.2 and v2.0, with git checkout and git switch, and compare their differences using git diff, since tags are more user friendly than hashes.

Master the git flow model by coordinating master, develop, release, and hotfix branches, managing merges with feature work for production-ready code and controlled deployments.

Create a public GitHub repository, clone it, rename main to master, set the default branch, and create a develop branch to implement git flow with pull request protections.

Protect master and develop branches by blocking deletion and force pushes, require pull requests with approval, and validate changes with a test push.

Learn to create a feature branch from develop, push to GitHub, open and review a pull request, and merge changes into develop following git flow.

Learn to deploy an application using git flow: create a release branch, update version to 1.0, merge into master and develop, and manage pull requests and deployment.

Learn to create and push a release tag in git, including tagging master, updating readme.md, and verifying the v1.0 tag on GitHub, finishing deployment and preparing for a hotfix.

Create a hotfix branch from master, fix the bug, commit, push, and deploy with version 1.1. Open pull requests from hotfix to master and to develop, then merge.

Practice Git and GitHub by creating and submitting a pull request to the lesson repository, updating the Readme or version, and receiving feedback to improve the decentralized development workflow.

Master git stash to save in-progress changes without committing, name stashes with descriptions, list them with git stash list, and apply a chosen stash with git stash apply.

Learn how the Git cherry-pick command merges only a specific commit across branches, using commit hashes, and compare it with full merges from develop.

Learn to create and manage git aliases to shorten commands, such as setting s for status and l for log --online, and to unset aliases, speeding workflow and reducing typos.

Learn to use Husky, a node-based tool that runs precommit checks on every commit to prevent broken code, with setup steps using npm init and npx husky init.

Learn to bypass husk by using the dash n (no verify) option for git commit to skip running tests, build, ESLint, and code formatting.

Explore Husky's possibilities beyond precommit, using pre validation in scenarios like pre rebase and pre push with lightweight shell scripts to ensure builds and tests pass on GitHub for teams.

Learn to automate git workflows with a shell script project called auto git, enabling quick branch switching, merges, conflict resolution, and branch cleanups, with GitHub integration and pull requests.

Discover shell script basics, the fzf tool for interactive use, and cross-platform installation steps with brew on macOS, Linux apt and dnf commands, and a git clone with depth one.

Learn to install fzf on Windows by cloning the repository and running the install script. Enable autocomplete, shortcuts, and updated shell configurations.

Install fzf on macOS with brew, use the fuzzy finder to list files, and prepare a shell-script driven app for the next project.

Learn the basics of shell script in bash, including the interpreter, echo commands, variables with the dollar sign and quotes, and running a script with a shebang.

Learn to use fzf to list and select git branches, customize height and layout, and capture the selection in a shell script as groundwork for switching branches.

Switch branch demonstrates selecting a git branch with a fuzzy finder, cleaning the name with tr to remove spaces and asterisks, then switching between main and develop with git switch.

Enhance the fuzzy finder integration by adding height, reverse layout, border, and a right-side git log preview, plus color customization with hex values 222222 and 333333.

Learn to debug shell script errors by interpreting exit codes, using if conditions to handle nonzero statuses, and managing user input with fuzz finder options to ensure single selections.

Learn how to define and call shell script functions to organize code, including naming, parentheses, and curly braces, then call and test the function to manage project responsibilities.

Parameterize the error handling by extracting the conditional into an exit exception function, then test the program to verify the changes.

Build and test a git merge function by adapting the existing switch branch logic, add colorized diff previews, and verify merges between main and develop to automate workflows.

Learn to delete a git branch by creating a feature delete function, switching to develop, and validating the deletion through commits and a merge workflow.

Create a startup menu for a tool by building an options array, wiring it to fzf, and handling switch branch, git merge, delete branch, and exit with a case statement.

Learn to refine a git menu by displaying the selected option, adding headers with fuzz finder, and validating switch, merge, and delete operations while running the program via dot slash.

Learn to run your git automation program from the terminal without calling the file. Place it in dot local bin, update the path, and create bash aliases for quick access.