Git & GitHub - The Practical Guide

Explore command line basics and text-based computer interaction, and learn Mac users' Z-Shell and Windows command prompt through practical examples.

Explore the differences between graphical user interfaces and text-based interaction. Learn why the command line enables faster navigation, starting servers, installing tools, running code, and Git usage.

Compare macOS terminal with zsh to Windows cmd and PowerShell, and learn when to use Git Bash for a consistent Git workflow across platforms.

Learn macOS terminal basics with z shell, including pwd, ls, and cd commands. Navigate the root, users, and home directories using tilde and relative paths.

Learn to navigate directories with cd, use tab completion, and manage folders with spaces, while understanding relative and absolute paths.

Learn the difference between absolute and relative paths in the terminal. Absolute paths start at the root; relative paths start from your current location and work within the project.

Create folders with mkdir and add files with touch inside the zz space folder. Delete files with rm, remove empty directories with rmdir, and preview deleting non-empty folders using flax.

Learn how flags extend terminal commands, display file sizes and long formats in ls, and safely remove directories with rm -r while understanding potential data loss.

Copy and move files and folders using cp and mv, create folders and files, and understand recursive copying with -r, trailing slashes, paths, and renaming in the terminal and satchel.

Master Mac terminal basics in the z-shell with commands like pwd, ls, and cd. Learn to create, copy, move, and delete files using touch, mkdir, cp, mv, r, and rmdir.

Explore the Windows command prompt basics, navigate the file system with dir and cd, and switch between root, users, and home directories across drives.

Navigate the command prompt with absolute and relative paths, using cd and autocompletion from the root directory to Users, Desktop, and the git-basics folder.

Create folders and files using mkdir and echo, navigate with cd, view content with dir and type, and remove items with del and rmdir to manage a project directory.

Master copying and moving files and folders in the Windows command prompt, using relative and absolute paths, and explore basic file structure from root to home directory.

Master essential Windows command prompt basics: navigate paths with cd, list items with dir, clear the screen with cls, and manage files with echo, del, mkdir, rmdir, copy, and move.

Explore the fundamentals of Git for web development, including theory, installation, and setting up a practical environment, and learn core concepts like repositories, branches, and commits.

Understand how Git turns a plain folder into a working directory, uses commits as snapshots, and organizes changes in the master branch, enabling efficient version tracking.

Understand how the working directory and repository use the staging area (index) and objects folder to create commits and track changes efficiently.

Understand how branches and commits relate in Git, using a working directory and master branch history to manage feature work, branches, and merges without impacting the live site.

Install git on Windows by downloading the 64-bit installer from git-scm.com, running the installer, and using the command-line with default options, then verify with git --version.

Install git on macOS by using Homebrew; open the terminal, paste the Homebrew installation command, install Git, and verify with git --version.

Install and set up Visual Studio Code as a cross-platform IDE for Git workflows, then explore the interface, terminal, and creating a first project folder for Git basics.

Initialize a git repository, stage files with git add, and create your first commit with git commit. Configure user identity and work on the master branch.

Discover how git log lists commit IDs, messages, and dates, track changes with git status and add, and switch to previous commits on the master branch with checkout.

Learn how to create and switch git branches from master, add commits on a landing page branch, and prepare merging those changes back into master.

Merge the third branch into the master branch using git merge to combine feature commits. Master shows three commits and updated files from the merged branch.

Understand how HEAD points to the latest commit on a checked-out branch, switch between master and other branches, and explore detached head behavior.

Learn how a detached head occurs when you check out a commit outside a branch, leaving HEAD unattached, and how to return to a branch with git checkout.

Explore how Git switch streamlines branch creation and switching in Git 2.23, compare it to Git branch and Git checkout, and learn to reverse changes when needed.

Learn to delete data in a Git project—commits, branches, and files—and undo unstaged or staged changes, delete commits, and remove branches, with practical application and a commands summary.

Delete a file from the working directory on the master branch, manage the staging area with git ls-files and git status, then commit with git commit.

Learn to undo unstaged changes in tracked files using git checkout or the newer git restore. Revert to head and clean untracked files with git clean -d -n and -df.

Learn to undo staged changes in Git using reset or restore, moving between the staging area, index, head, and working directory, including checkout to revert files.

Learn to undo commits with git reset, using soft and hard reset to move head back and manage changes in the working directory and staging area.

Learn to delete branches in git using git branch with -d or -D, including force deletion and deleting multiple branches in one command, with confirmation that only the master remains.

Learn how to manage detached head state and save work by creating and merging branches. Merge changes back into the master branch using git basics.

Learn to use a dot gitignore to tell git which files and folders to ignore, using patterns and exceptions, and apply global ignore rules.

Master essential git commands for version management, including init, status, log, add, commit, switch, branch, and merge. Learn how to undo changes with reset, restore, and clean.

Explore deeper Git concepts by managing commits and branches, restoring deleted commits or branches, and resolving merge conflicts with practical commands.

Master how to save uncommitted and unstaged changes with git stash, and reapply them later with stash apply or pop, while viewing and managing stash lists.

Use git reflog to recover lost commits and branches by viewing the last 30 days of changes, selecting a hash, and re-creating the branch from a detached HEAD.

Explore how to combine master and feature branches by merging or rebasing, and understand when to apply each to incorporate feature work into the master branch.

Discover the two core Git merge types, fast-forward and recursive merge, through hands-on examples of merging feature branches into master with emphasis on when no new commits exist.

Understand fast-forward merges in git and how squash merges consolidate changes. Create master and feature branches, initialize a repository with git init, and merge with git merge.

Showcases the recursive merge (non-fast-forward) with --no-ff, producing a merge commit that preserves master and feature branch history, and contrasts it with the default fast-forward merge.

Explore how rebase applies feature commits onto the latest master to achieve a fast-forward history. Understand that rebasing creates new commits with new hashes; avoid rebasing outside your own repository.

Rebase a feature branch onto master to perform a fast-forward merge, then note how commit IDs rewrite and history changes.

Detect and fix merge conflicts between master and feature branches using VS Code, compare changes with git diff, and resolve by accepting current, incoming, or both changes, then commit.

Compare merge, rebase, and cherry-pick to combine commits across branches. Explain merge commits, non fast-forward merges, and how cherry-picking creates copies with new IDs.

Explore how Git cherry-pick selectively applies a single commit from a feature branch to master, illustrated by fixing a typo and adding new files.

Tag commits to mark milestones with lightweight and annotated tags, such as 1.0 and 2.0. Learn to list, view, checkout, and delete tags with git tag and git show.

Conclude by reviewing git stash, reflog, merge, rebase, and cherry-pick, and explain how GitHub connects with git for collaboration in bigger projects.

Explore how to move from local Git projects to the cloud with GitHub, connect Git and GitHub, and master remote, local, and remote-tracking branches along with upstreams and cloning repositories.

Explore how Git and GitHub connect to host and collaborate on repositories, branches, and commits, and learn how information exchanges between local Git and cloud GitHub enable efficient collaboration.

connect your local git repository to a remote GitHub repository, creating a remote named origin, and push your branches and commits to the cloud while learning push and pull workflows.

Create a GitHub account on github.com, explore the free plan, and learn the core interface—repositories, README, profiles, and public and private repositories—while linking a local repository to a remote one.

Create your first remote repository on GitHub, choosing the owner and repository name and whether it is public or private. Learn to connect the remote to your local repository.

connect a local git repository with a remote on GitHub, initialize and commit, add origin, and push to master or main while using a personal access token.

learn how to create and use a personal access token to push data to a remote repository on GitHub, including setting an expiration and configuring repository permissions.

Push a second commit to the master branch on GitHub, verify the update in history, and learn about upstreams, origin, and token-based credential management with Windows Credential Manager.

Push local changes to origin master creates a remote tracking branch, then updates the remote branch; pull updates the remote tracking branch and merges into the local master.

Explore how remote tracking branches mirror changes between local and remote repositories, and learn to sync with git fetch origin and git pull while managing local feature branches.

Explore how local tracking branches bridge your edits and remote branches on GitHub, using fetch, pull, and push to keep remote updates in sync.

Learn to create a local tracking branch connected to a remote branch using git branch --track, understand local versus remote tracking branches, and synchronize changes with push and pull.

Discover remote and tracking branch basics using git remote, git branch -a, git branch -r, git remote show origin, and git branch --track, plus cloning an existing GitHub repository.

Learn how to clone a remote repository into a local workspace, set up local tracking branches, and manage master and origin branches with git commands.

Learn how to use git push -u to create a local tracking branch that links to the remote feature upstream on origin, enabling aligned pushes to GitHub.

Learn to delete local and remote branches and commits using git fetch origin, git branch --delete --remote, git push origin --delete, and hard reset HEAD before force pushing.

Discover how Git and GitHub connect via repositories and branches, with local and remote tracking branches, commits, and commands like git pull, git push, and remote add origin.

Explore how to collaborate on GitHub, exchange information, and contribute to open source by understanding account types, private versus public repositories, and building a developer portfolio.

Explore the four core use cases of GitHub: single user storage and portfolio pages, plus collaboration and open source contribution, while understanding account types, repositories, roles, and access rights.

Explore GitHub account types and pricing, compare personal user and organizational accounts, and discuss free plan limitations, collaboration, and enterprise options like Team Cloud and Enterprise Cloud.

Learn how to switch a GitHub repository from public to private, and how visibility affects access. Understand the danger zone warnings and their impact on repository accessibility and published pages.

Pushing commits to a public GitHub repository requires a valid personal access token, even when cloning is possible; manage credentials to authorize pushes and understand GitHub security.

Explore how personal access tokens secure GitHub collaboration, enabling push of commits, and distinguish owner vs collaborator access while managing organization versus personal accounts.

Learn how to add collaborators to a GitHub repository using manage access, invite a collaborator, and grant push access without sharing personal access tokens.

Explore how collaborator access works when a public repository becomes private, showing that collaborators retain read and write rights and can push commits.

Compare owner and collaborator rights on GitHub, highlighting owner actions, collaborator write access in private repos, limit interactions, and the impossibility of read-only access in personal accounts.

Limit interactions in GitHub by configuring account-wide and repository-specific moderation settings, restricting new users, interaction types, or collaborator-based access for private and public repositories.

Explore organization accounts to manage collaborator access and member roles, assign repository permissions, and scale security for small personal projects or larger teams.

Create a new GitHub organization from your personal account using profile settings and the new organization option. Set the organization name, choose the free plan, and provide a contact email.

Create an organization repository, manage access, and set base permissions for members and outside collaborators, exploring read, write, and admin rights and other organization-wide settings.

Invite outside collaborators to a GitHub organization, set read or write access, manage repository permissions, and verify access by cloning and pushing changes.

Learn how to add organization members on GitHub and assign roles such as owner or member. Manage repository access with read or write permissions through organization settings and people tab.

Discover how to manage access in GitHub organizations by assigning repository-specific permissions, testing read-only vs write access, and exploring granular team-based controls.

Create a GitHub course team, assign repositories with read or write access, and invite members to collaborate within the organization.

Explore managing team repository access in GitHub by configuring write, read, and no-permission settings, testing access across the organization, teams, and external collaborators.

Explore forks and pull requests on GitHub, showing how open source contributions create forked repositories, propose changes via pull requests, and enable owner review and merging.

Explore forking a public repository to your personal account, clone and push a new feature, then prepare to merge changes back into the original master branch.

Create and manage pull requests between a fork and the base repository, selecting base and head branches and validating a merge. Review changes, add comments, and merge to update master.

Explore how issues, forks, and pull requests operate on a real open source project, learn to create and close issues, describe reproduction steps, and manage labels and projects.

Create a new GitHub project with a kanban board, to-do, in progress, and done columns, and manage issues by dragging cards, using automation and pull requests for collaboration.

Create a readme file to communicate your repository's purpose, usage, and contribution guidelines, guiding users with setup steps and markdown formatting on GitHub.

Present yourself as a developer on GitHub by updating your profile with a bio and website, and creating a repository readme to display a compelling starting page.

Learn what GitHub stars are and how they act like likes, signaling project popularity while not proving anything, and guide you toward learning new skills.

Wrap up covers GitHub basics—account types, repository visibility, collaboration models, and security with personal access tokens—plus forks, pull requests, issues, and projects for team work.

Kick off this module by building a complete project with Git and GitHub to manage code locally. Collaborate by pushing to GitHub and merging branches into main with pull requests.

Prepare a simple food order UI project to practice Git and GitHub by working with provided code, adding features, and managing a mock cart, with Node.js required to run locally.

Set up a React JS project in Visual Studio Code, install dependencies with npm install, run npm start, preview at localhost:3000, and track changes with Git and GitHub.

Initialize this project as a local git repository with git init, add a .gitignore to exclude node_modules, and commit the initial changes.

Learn to track local code changes with git, create a feature branch, and implement a React use state to show or hide a shopping cart overlay in App.js.

Push your local code to a GitHub remote by connecting with origin, then push main, using a personal access token for authentication, to enable collaboration.

Clone the public repository with git clone, install dependencies with npm install, and modify App.js to add a cart overlay using components/cart in a React project.

Create a feature branch, stage and commit changes, push the feat/cart branch to the remote, and resolve authentication hurdles by coordinating collaborator access.

Learn to add a collaborator to a GitHub repository via settings, invite Manuel by username, and enable push and pull without sharing access tokens before merging feature branches into main.

Learn how to create a personal access token, configure Visual Studio Code for pushing to a shared GitHub repo, and push a feature branch while collaborating with a project owner.

Pull the latest state from GitHub with git pull to fetch Manuel's status branch and the new feat/cart-logic, then merge your changes into main and prepare to merge Manuel's updates.

Resolve merge conflicts in git by merging a feature branch into main, choosing changes, and updating code to implement a cart toggle with onClose, plus collaborative workflows.

Fork a public repository to your account, clone it locally, and push changes via a pull request. Manage branches on your fork—main or a separate branch—after installing dependencies with npm.

Implement quantity controls by updating add and remove item logic in cart.js, test with npm start, and push a commit with a pull request to Max.

Push commits to your fork, set up access with a personal access token, and compare across forks to create a pull request.

Learn how to review and accept pull requests on GitHub by inspecting commits and files changed, commenting, and merging into the main branch when there are no conflicts.

Apply what you learned to day-to-day projects and build demo projects to solidify your skills after this course. Use that foundation to advance in everyday work and explore more courses.