Git Mastery: Beginner to Expert with GitHub & GitLab

Overview of chapter two: install Git across platforms, create a GitHub account and repository, practice core Git commands, and cover authentication, editors, and synchronization and backups.

Install git on linux by checking with git --version, installing via sudo apt install git, then verifying with git version (example shows 2.15.1); use distro resources for non-ubuntu systems.

Install git for Windows, download 64-bit, and choose a default editor (Visual Studio Code recommended). Configure path and line endings, use git bash, and prepare a GitHub account.

Choose your default git editor by setting core.editor via git config --global, using nano on macOS and Linux, or code on Windows, and explore other editor options.

Create a free GitHub account by signing up with a username, email, and password; verify email, set up preferences, and create your first repository with a readme, choosing public access.

Clone a GitHub repository to your local machine with git clone via the terminal, configure global user.name and user.email, and understand local versus external repositories.

Watch this crash course demonstrating creating a file, adding it to the staging area with git add, and committing with a message to form a local snapshot.

Master the git workflow by creating, staging, and committing files, using git add or git stage, then viewing status and preparing to push changes to GitHub.

Learn how to use git ignore to exclude files from tracking, create a .gitignore file, and verify changes with git status before committing.

Master the push and pull workflow: push commits to a remote repository and pull changes to keep your local copy in sync, while managing files and ignore rules.

Git log lists all commits, most recent first, showing each commit's hash code, author, date, and message; use -p for diffs and -1 to -5 for recent commits.

Master git branches by creating and switching to a new feature branch, committing changes, and cherry-picking commits, then merging into master while resolving merge conflicts.

Explore authentication for git workflows across operating systems, choosing between https and ssh, handling two-factor authentication, and navigating network constraints to balance security and usability.

Learn how Windows credential manager handles git authentication for https, manage tokens, and troubleshoot common issues when working with GitHub or GitLab.

Discover how macOS uses the keychain to manage git https authentication, storing passwords or tokens and troubleshooting by clearing and re-authenticating keychain entries.

Set up and use ssh authentication for git on Linux, Windows, and macOS by generating an ssh key, uploading the public key to GitHub or GitLab, and cloning via ssh.

Switch a local repository from https to ssh by updating the remote origin URL with git config or git remote set-url origin, then push to GitHub and handle authentication.

Explore git functions across popular editors and IDEs, including VS Code, IntelliJ, Emacs, Tortoise, and GitHub Desktop, and learn why understanding git eases editor workflows.

Install and explore Emacs, observe its version control integration, and compare built-in tools with the Magit extension, noting limitations and recommending terminal git if needed.

Learn to start git gui with git bash, switch encoding to utf-8, stage changes, and commit. Use the visualize all branch history feature to review commits and diffs.

Discover how GitHub Desktop simplifies git workflows by creating local repositories, adding a readme and license, and publishing private or public projects to GitHub, with branching and VS Code integration.

Explore IntelliJ IDE setup, choose the community edition for free, connect Git via version control, clone GitHub repositories, manage branches and commits, and customize Git settings and accounts.

Install tortoise git on Windows to access git commands from the explorer context menu and view logs with graph while performing pulls, fetches, pushes, merges, and branch and tag creation.

Use Visual Studio Code with the GitLens extension to view file history and changes, compare branches and tags, and search commit messages by author.

Learn how synchronization and backups affect git, including cloud sync risks and the routine use of git pull, commit, and push to keep repositories in sync.

Master git concepts beyond the basics, including commits, undo, branches, merging, stashing, rebasing, and remote repositories with merge conflicts. Understand how git works behind the scenes and apply the commands.

Explore core Git terms like repository, history, and branches, and learn how the default branch, master or main, serves as the baseline while noting naming discussions.

Explore the staging area, git add, and commits, then understand head versus HEAD on branches, checkout, merge, and how tags mark milestones to tidy history.

Learn how git enables decentralized version control with GitHub and GitLab, use clone, pull, and push to manage remote repositories via origin, main or master branches.

Explore git hooks that run scripts on events, and compare submodules and subtrees, revealing how external repositories integrate—whether with independent commits or a single git database.

Learn how git init creates a repository and exposes the .git structure, including HEAD, config, index, exclude, and the object store for commits, trees, blobs, and tags.

Explore git objects such as commits, trees, blobs, and tags, and learn how references, head files, and dot git directories track the latest commits on local and remote branches.

Explore how Git uses the staging area and commits to move changes from the project directory into the repository, using git add and git commit to manage three states.

Explore how git stores files as blobs, trees, and commit objects, and how commits link to parents after using git add and git commit.

Move and rename files in a git repository with git mv. Use cp and commit, since there is no copy command in git, and note past commits retain deleted files.

Explore undoing actions in the git repository and staging area, tracing commits from initial setup to commits a, b, and c, and cloning to start from a known state.

Learn how to undo commit-related changes using git reset and git restore, unstage files with git restore --staged, and restore files to the last commit, with practical examples and cautions.

Master git show and git diff to view and compare historic states of file one.txt from past commits, using hashes and tilde notation to understand changes and resets.

Learn to undo changes by restoring prior file states with git restore and diff, compare with git checkout, and save older versions using git show redirected to a new file.

Explore how to undo git commits with git revert, including reverting the last commit using head, handling the editor prompts, and applying ranges to revert multiple commits.

Git reset reverts to a previous commit, with --hard discarding changes and --soft preserving them; it rewrites history and is discouraged for team workflows.

Learn to change a commit message with git commit --amend, which rewrites the last commit and creates a new hash. Avoid amending after pushing to prevent force-push issues.

Learn to undo commits and manage the staging area with git reset, git restore, and git revert, plus viewing changes with git diff and git show.

Compare git revert with git reset --hard and --soft to undo commits and manage history. Learn about detached head state, anonymous branches, and safe practices, including avoiding forced pushes.

Master branch workflows with Git, create and switch to new branches using Git branch and Git checkout, merge changes, and support parallel development on master, develop, and feature branches.

Learn to create and switch master and feature branches with git checkout -B and git switch, and manage uncommitted changes via commit or stash.

learn how to merge changes from a feature branch into master using git merge, including normal, fast-forward, and merge conflict scenarios, with tips on commit messages and resolving conflicts.

Explore git branch management and merging workflows, including master versus feature branches, using commands like git branch --merged, git merge, git log --graph, and git rebase, with tips on cleanup.

Explore fast forward merges and the octopus merge, updating the master pointer to the latest feature commits. Use cherry pick to apply a single commit and expect possible conflicts.

Learn how to use git stash to save uncommitted changes, switch branches for quick bug fixes, and reapply them with git stash pop, including managing multiple stashes.

Explore how remote repositories work, clone with git clone, set up origin, and push and pull to collaborate on GitHub and GitLab, including pull requests.

Master remote collaboration with git push and git pull, handle fast-forward merges, and manage feature branches with upstream on origin. Create, push, and test feature branches while staying in sync.

learn how git pull fetches all new commits but merges only your active branch, and how git push affects only the current branch, with safe --all usage for fast-forward merge.

Learn how local and remote tracking branches relate to origin and GitHub or GitLab, and how to push, pull, fetch, and manage multiple remotes.

Explore how merge conflicts occur in git pull, git merge, stash pop, rebase, and cherry-pick, and learn tips to resolve them quickly by identifying changes and choosing the right edits.

Learn how to create and simulate a merge conflict, resolve it in VS Code, and commit the resolved changes on master after merging branch one.

Learn to resolve merge conflicts using merge tools like meld, compare three versions side by side, and use git merge tool with VS Code or editors.

Learn how git handles binary versus text merges, and resolve conflicts by selecting the version from the current or other branch. Appreciate whitespace handling and the role of unit tests.

Explore rebasing as a way to clean up commit history, compare it with merges and git pull --rebase, and learn when not to rewrite public history on remote repositories.

Practice hands-on git rebase by building a repo, creating master and feature commits, and replaying feature commits on top of master.

Understand how git rebase rewrites F1 and F2 as if based on M2 from the master branch. This avoids a merge commit and clarifies fast-forward behavior during rebases.

Explore squashing with git merge --squash to merge a feature into master as one commit; balance cleaner history with losing individual commit details for bug fixes, and separate commit messages.

Tag commits with git tag to create version labels such as 1.0 on GitHub and GitLab. Tags sort alphabetically by default; use format options to display dates.

Compare lightweight and annotated tags and learn when each is appropriate. See how to create, delete, and push tags to remote repositories and understand tagging behavior on GitHub or GitLab.

Master how to delete, change, and undo git tags on GitHub and GitLab, and learn when to use lightweight versus annotated tags, and how to push them to remotes.

Master referencing commits and revisions in git using hash codes, reflog syntax, and head tilde at signs, with guidance on git show and related commands.

Learn to reference commits using tilde and at symbols, distinguish reflog references from pure commits, and view prior states with git show, head, and branch names.

Explore how git packs objects to save space, uses hash codes for access and integrity, and learn core commands plus low-level tools like git gc and git cat-file.

Explore how to search a repository for data using git commands such as log, reflog, tag, show, grep, blame, and bisect, plus visualize history with git stats and gitk tools.

Explore git log basics, including how it shows commits with metadata, navigation with cursor keys, and useful options like --oneline, --graph, --decorate, and --all to tailor output.

Learn to customize git log output with git log --pretty=format, showing hash, author date, and commit message. Use options like %H, %h, %aN, %ae, %ad, and %s to tailor output.

Explore advanced git log usage with --pretty formats to tailor commit summaries, including subject lines, body, hashes, dates, and author details, and customize output with color and columns.

Master git log search techniques to filter by commit messages, author, and files with --grep, --author, and --file, using --all, color, and piping for clear, focused results.

Learn to filter git log to branch-specific commits with range syntax. Two dots show commits not yet merged from the other branch; three dots include post-split commits.

Learn to filter git log outputs by date ranges with --since/after and --until/before, compare graph and date formatting, and understand how author and commit dates differ through rebasing.

Master git log time-range practice with two-dot and three-dot range syntax to compare master and feature branches, and view commits after the common base with merge history and graph formatting.

Learn how to use git tag and the reference log (reflog) to explore releases, view commits by tag with git log, and understand reflog history in large repositories.

Explore use of git tag and git reflog to inspect tags and their commits, filter git log by tag, and combine log with reflog for local history.

Learn to inspect file history with git show and git diff, compare current and old revisions, and attribute changes using git blame and git log.

Learn to use git show and git diff to view file revisions and changes, using tags and paths to access index.js and compare revisions with compact or summary output.

Master git diff and git grep with patterns, case sensitivity, line numbers, and revision ranges to search across files or directories using -G, -i, -n, and --count.

Master git diff across two revisions with compact and summary views to spot added, deleted, and modified files, then use git grep and git grab for regex-based searches.

Learn how to use git bisect to locate the first bad commit by halving the search space between a known good tag and the current commit, testing each revision.

Master git bisect to locate the exact commit that introduced a bug, using commands like git bisect start, bad, and good, and even automated testing to speed the process.

Explore repo overviews with git shortlog to count commits by author, git ref list for branches, and git diff to track changes across versions, plus file, branch, and tag counts.

Learn to use git shortlog to summarize commits, show author names and emails, and count across branches, with git log, git diff --shortstat, and branch/tag listings.

Explore visualizing Git activity with tools like gnuplot and Git stats, generate repository insights from commits and files, and compare views with gitk.

Explore a quick overview of GitKraken, its visual git flow charts, and how it integrates with GitHub and GitLab for branches and pull requests.

Master GitHub and GitLab essentials like pull requests, collaborators, organizations, protected branches, project boards, issues and labels, markdown, actions, pages, and Dependabot plus CodeQL.

Explore pull requests as the formal merge mechanism on GitHub and GitLab, enabling feature branches to merge into main with a transparent, web-based workflow that requires minimal git knowledge.

Create a personal repository, invite collaborators, and manage access; learn to open and review pull requests, merge changes to main, and handle branches and basic collaboration workflows.

Configure branch protection to require one approved pull request before merging, enable code-owner reviews, and learn the end-to-end pull request workflow from creation to squash merge in GitHub.

Learn how to manage pull requests in a personal repository, including changing the base branch to main, requesting reviewers, applying labels, and understanding merge rules on GitHub and GitLab.

Create a new organization on GitHub, invite a member, and assign roles to control access and privacy. Learn how to view, name, and manage organization settings and upcoming repositories.

Explore permission levels for organization members, focusing on owner versus member capabilities like creating repositories, inviting and removing people, managing teams and the project board, and security settings.

Organize a GitHub or GitLab organization by creating a repository, assigning it to front-end teams, and configuring permissions such as read, write, admin, and triage through inheritance.

Discover team permission levels for repositories and the actions each level allows, from issues and reviews to pushing and editing, and see how admins protect branches.

Explore protecting branches in GitHub organization repositories by configuring branch rules, requiring code owner reviews, and managing who can push or merge to the main branch.

Learn to collaborate on someone else's repository by forking, proposing changes through a pull request, and navigating forks, branches, and merge decisions on GitHub.

Learn to use GitHub issues as tickets, link them to pull requests to track progress and auto-close on merge. Organize work with labels, assignees, and basic markdown.

Learn to use GitHub project boards in an organization, with automated Kanban templates that move issues and pull requests across todo, in progress, review, and done, and link repositories.

Master markdown syntax for GitHub and GitLab by exploring headers, bold, italic, strikethrough, code blocks, and quotes; create lists, task lists, and nested structures, and use mentions, emojis, and escapes.

Learn markdown syntax 02, which teaches creating tables with pipes, code blocks with backticks, and syntax highlighting, plus referencing issues and pull requests on GitHub.

Explore GitHub actions fundamentals by creating a public repository and a greetings workflow. Learn yaml syntax, triggers on issues and pull requests, runners, and secret management.

Learn how to set up a GitHub actions workflow that creates a new branch when an issue is assigned, and explore automation with tokens, secrets, Slack, and Jira.

Set up a GitHub Actions workflow from scratch to check HTML syntax on push to the main branch, using prettier and checkout.

Explore how to use the GitHub wiki to document your project with a home page, markdown content, and multiple pages; manage access, revisions, and community contributions via pull requests.

Learn to create a customizable GitHub Pages site from a repository, choose a theme, use HTML or Jekyll, and publish with HTTPS or a custom domain.

Explore GitHub security features like Dependabot and code scanning, activate dependency graph and security updates, review vulnerability alerts, and understand how forks, pull requests, and actions integrate with security workflows.

Explore GitLab essentials in chapter six, including creating projects, merge requests, issues and labels, groups and permissions, project boards, CI/CD basics, and GitLab Pages, with a comparison to GitHub.

Create a GitLab project from scratch or from a template, explore import options from GitHub or Bitbucket, initialize with a readme, and set up SSH keys and collaborators.

Learn to create merge requests (pull requests) on GitLab and GitHub, including drafting, selecting target branches, writing commit messages, and configuring approvals, milestones, labels, and protected master branches.

Manage GitLab issues with labels, milestones, confidentiality, and permissions. Use markdown, emojis, time tracking, and export or import via csv or Jira.

Explore GitLab project member permissions, from guest to maintainer, and learn who can clone, view files, comment, manage issues and merge requests, push branches, and adjust CI/CD settings.

Fork a public repository, create a new branch, and submit a merge request to contribute changes; manage access, permissions, and review decisions in GitLab.

Explore how GitLab groups organize projects, manage inherited permissions, and override access at the repository level to control who can create issues, merge requests, and push changes.

Explore milestones and boards on GitHub and GitLab, manage versioned boards with labels and milestones, and track how issues and merge requests move from open to closed.

Explore code snippets and wikis in a GitHub and GitLab repository, create and manage HTML snippets and wiki pages, and navigate markdown features for documentation.

Explore GitLab's ci/cd pipeline basics, comparing to GitHub actions, creating a gitlab-ci.yml, and configuring build, test, and deploy jobs with templates, variables, and manual steps.

Learn to create GitLab pages by building a static site with index.html and a multi-stage pipeline. Deploy pages via settings to serve a public folder as a static website.

Navigate the GitLab web IDE to edit files, review diffs, and commit changes in the browser, create and merge branches with merge requests, and compare its capabilities to VS Code.

Demonstrates GitLab markdown syntax, including headers, italics, quotes, code blocks, links, bullet lists, numbered lists, and task lists, with diagrams, flowcharts, and guidance referencing GitHub documentation.

Master Azure DevOps basics: create a project repository, clone with SSH, manage work items, and create pull requests with branches and merges.

Explore Azure DevOps boards and repositories by creating branches, pull requests, work items, and queries, while configuring permissions, branch policies, pipelines, and dashboards.

Explore Bitbucket as a git hosting option, create a new repository with a readme and gitignore, invite a collaborator, and submit a pull request while noting pipelines and Jira/Confluence integration.

Explore how to manage repository permissions and branch protections, configure pipelines, reviewers, and merge strategies in Bitbucket. Learn to set reviewers, enable pull requests, and use starter pipelines with variables.

Explore git workflows for teams and solo development, covering feature branches, long-running git flow, trunk-based development, and pull requests to guide workflow choice.

Learn practical, team-friendly git workflows to coordinate collaboration. Define rules, then pull changes, create feature branches, stage and commit, fetch and rebalance from origin master, and merge back to master.

Develop solo projects with git by using feature branches and the master branch, merge when ready with fast-forward merges, and back up code on GitHub or GitLab.

learn how feature branches reduce merge conflicts by dividing work away from master branch and use git, fast-forward merges, or no fast-forward merges, with pull requests on github or gitlab.

Learn how feature branches use merge or pull requests on GitHub or GitLab, with mandatory reviews and branch protection to ensure safe, reviewed merges.

Explore the long running branches git flow, where master and develop stay ready and synchronized, feature branches merge into develop, and release and hotfix branches manage production changes.

Push updates to the main branch via trunk based development, use short lived feature branches, feature flags, pair programming, and a robust CI/CD pipeline to keep the code release ready.

Assess team experience, size, and infrastructure to choose a workflow; prefer feature branches with pull requests or merge requests on GitHub or GitLab, while considering trunk-based or git-flow variants.

Explore chapter 9 basics of Git hooks, including pre-commit, post-commit, and pre-push, plus best practices for commit messages, submodules and subtrees, Git aliases, and two-factor authentication.

Explore git hooks, including local pre-commit, prepare-commit-message, and post-commit, plus remote push hooks, and learn how scripts enforce policy and styling in the dot git directory.

Explore pre-commit hooks in git by building a local repository, reviewing .git/hooks, and scripting a pre-commit check that blocks commits with untracked files.

Learn to use git hooks with pre-commit and post-commit scripts to block commits to the master branch and run actions after commits, including working on feature branches.

Learn to enforce commit message quality by building a commit-msg hook: initialize a repo, write a bash script with regex validation, set executable, test commits, and explore pre-push hooks.

Learn how to create a pre-push git hook that blocks pushes to main and on weekends, using a bash script in .git/hooks, tested from a local repo clone.

Master concise, meaningful commit messages with three rules: a brief subject under 50 characters, a blank second line, and optional detailed body, avoid spamming commits.

Master multi-line commit messages with -m, using a subject line and a blank-line body, and push changes to GitHub or GitLab. Understand how the subject line shapes log views.

Link issues and merge requests in git commit messages by referencing issue numbers with a hashtag and merge requests with an exclamation mark, enhancing traceability across GitHub and GitLab.

Explore conventional commit conventions used by Angular, including prefixes like build, fix, docs, and tests, and learn to reference tickets or pull requests in concise, actionable commit messages for teamwork.

Explore how git submodules act as pointers to external repository commits, compare them with subtrees, and practice adding, updating, and pushing submodules using init, clone, and push workflows.

Learn how submodules work and why forgetting to push changes creates a remote hash mismatch, causing clone failures. Compare submodules with subtrees as a simpler alternative for team workflows.

Explore git subtree to embed another repository into your project using the --prefix option, squash commits, and push or pull changes, while the subtree appears as a normal directory.

Explore how git subtree creates a prefixed folder from a remote repository, squashes commits, and merges changes, then push and pull to keep your project in sync.

Master git aliases and oh my zsh to streamline commands like git log and git status, explore global and local aliases, and enhance workflow with zsh extensions.

Enable two-factor authentication on GitHub and GitLab, choosing between SMS or an authenticator app, manage recovery codes, and understand SSH vs HTTPS authentication.

Learn how etckeeper integrates git with /etc configuration, enabling daily backups and automatic pushes to a private remote repository on GitHub or GitLab.

Learn to manage dotfiles on Linux with git by isolating them in a custom dot cfg repo, using git dir and work-tree options, and a config alias for streamlined commits.

Import your dotfiles to a new system with a bare git repo and the config alias; selectively add dot files like the bash rc and ssh keys, then checkout.

Learn how git large file storage (lfs) manages binary files by storing them in an lfs store and using pointers in the repository. Install, enable, and track png files.

Discover how to use Visual Studio Code with git to clone repositories, stage and commit changes, manage branches, and resolve merges with built-in tools.

Learn how to install GitLens in VS Code and explore its core features, such as blame, diffs, commits, branching, and GitHub integration.