Practical Git and GitHub: From Basics to Pro Workflows

Set your git identity by configuring a username and email to identify commits. Run git config --global user.name and git config --global user.email, then git config --global --list to verify.

Learn the basics of Git concepts such as commits, snapshots, and commit id, from init to log, plus untracked, staged, and tracked states.

Initialize a git repository for your new project, create and add files to the staging area, and commit with descriptive messages; review progress with git status and git log.

Modify content with Git by deleting a file, creating a folder, and staging changes. Commit with a descriptive message like 'shake and bake,' and view history with Git log.

Explore using the Visual Studio Code GUI to initialize repositories, stage changes, commit, and view logs, while understanding how GUI speeds production workflows compared to terminal commands.

Navigate git commit history using git log and checkout, learn about detached head and branching, and reset history with git reset --hard, using both terminal and gui workflows.

Explain the difference between git add and git add -A, show how to stage changes across folders, and warn against nesting git repositories to avoid project bugs.

Write clear, helpful commit messages for collaborative projects on Git and GitHub, avoiding secrets and ensuring messages are short, specific, and imperative mood; keep each commit focused on one thing.

practice git basics from git init to commits, using git status, git add, and git log, and organize changes with a notes/todo.txt workflow.

Create and switch branches such as feature and bugfix to isolate work, test changes, and merge back into main only when ready, using git branch, switch, and merge.

Merge branches in git using fast forward when there are no new commits, or a three way merge for divergent history; then merge main into feature and back to main.

Delete branches after merging using git branch -d for safe deletion, or git branch -D to force delete unmerged branches. Merge main into feature, test, then merge back to main.

Understand how git rebase rewrites history to a straight line by replaying commits, avoiding merge bubbles, and why rebasing public branches is discouraged in production.

Rebase example demonstrates replaying feature commits on top of main to achieve a linear history, compares with merge, and explains when to use rebase vs merge per policy.

Learn to manage git branches and workflows with the VSCode GUI, creating main, feature, bug fix, and payment branches, then merge and rebase for clean history.

Practice this optional project reinforces git fundamentals by initializing a repository, creating and merging feature and bug fix branches, rebasing, and deleting branches to solidify workflows.

Learn to use the local git config file for project-specific settings - default branch names, merge strategies, and custom aliases - and how the global config interacts with .gitignore exclusions.

Discover how git stash temporarily saves uncommitted changes, reverts to the last commit, and uses stash list, stash pop, and apply to manage saved work across branches.

learn to use git stash to switch branches, stash changes, and reapply with stash pop on return to the feature branch; beware tracked versus untracked changes when switching branches.

Explore how git head tracks your current position and how detached head occurs, then learn the git reflog command to view head changes, checkouts, merges, and recover commits.

Explore the git reset command to undo changes, unstage the changes, and reset to specific commits, with soft and hard modes, head references, and reflog for recovery.

Learn to undo staged and unstaged changes with git reset, git restore --staged, and git checkout, and clean up untracked files using git clean with a dry run and force.

Practice real-world git workflows by initializing a repo, configuring user data, making commits, using stash, exploring detached heads and branches, and mastering resets, reflog, and cleaning untracked files.

Explore Git merge conflicts, focusing on content conflicts, their causes when branches diverge, and a setup workflow with branches, commits, and preparing for merge and rebase.

Resolve git merge conflicts by merging main into payment and feature branches, using the merge editor to decide between current, incoming, or both changes.

Apply git rebase to replay feature and bug fix commits on top of main, compare current versus incoming changes, resolve conflicts, and learn how rebasing differs from merging.

Learn how to squash commits to keep a clean history, using git merge --squash and interactive rebase, resolve conflicts, and manage main, feature, and bug fix branches.

Learn to use git cherry-pick to apply a single commit from another branch without merging the whole branch, including choosing the right hash and handling remote scenarios.

practice a hands-on git workflow, including merging, rebasing, resolving merge conflicts, squashing commits, and cherry-picking to reinforce the section topics.

Learn how git and GitHub work together to store and backup your code online, push and pull changes, manage branches, and deploy to a hosting provider.

Learn to set up ssh keys for secure, password-free access to GitHub by generating a private–public key pair, storing the private key locally, and testing the connection.

Create your first GitHub repository by initializing a local project, committing changes, and linking to a remote origin via SSH. Push to main and leverage cloud hosting for collaboration.

Create and push a GitHub repository from VS Code. Connect it to Netlify to host a static site with an index.html and main.css, enabling continuous deployment from GitHub.

Learn to create a repository, push changes, and submit your first pull request on GitHub, including branch per ticket, code review, and squash-and-merge into main.

Practice a second pull request on the ticket two two branch: add files, update code, commit, and squash via rebase, then push and resolve conflicts on GitHub.

Learn how to align local and remote git branches with fetch and pull, rebasing and squashing commits, resolving conflicts, and safely force-pushing to review and merge pull requests on GitHub.

practice real-world git and github workflows by creating three local projects, initializing repos, adding app.js, committing, pushing, and using branch names like ticket one one.

Practice end-to-end git workflows by creating feature branches for tickets, updating app.js, committing changes, pulling, and merging via pull requests, including rebases and conflict resolution.

Discover why using the -u upstream flag and keeping the same local and remote branch names streamlines push and pull, demonstrated while creating and pushing a bug fix branch.

In practical git and GitHub workflows, learn how to use git fetch to update remotes and cherry-pick a specific commit from a teammate’s feature branch.