Git and GitHub for Developers

Follow Windows, Mac, or Linux installation instructions for your machine, then proceed to the next module.

Install git on windows by downloading from dasan dot com and running the installer. Choose nano as the default text editor, configure path, line endings, and launch the bash shell.

Install git on mac using homebrew or the official binary installer; verify installation with git --version, and handle the 'unidentified developer' warning to complete setup.

Install git on Linux using Ubuntu by opening a terminal, checking the version, using sudo apt install git, and verifying the installation shows git version 2.25.1, then start using git.

Master the standard command line toolkit, including bash shell basics, cross-shell adjustments, nano/vim/emacs editors, and the less pager, to confidently use git from the terminal.

Explore the basics of using a terminal and the bash shell to run commands, manage files and directories, and script simple automation with echo, cat, mkdir, rm, and redirection.

Learn the basics of the nano editor, a simple terminal-based text editor, including opening files, navigating with shortcuts, saving, exiting, and using help and search features.

Use the less pager to read files one page at a time in the terminal; press h for help, q to exit, and navigate by lines, windows, and searches.

Master git basics to protect your existing work, organize your development workflow, and enable collaboration, starting with solo development before adding collaboration later.

Initialize an empty git repository in a directory with git init, then run git status to see untracked files and the .git directory.

Learn to turn untracked files into a committed git history by staging, committing, and inspecting logs during your first commit on the master branch.

Practice exercise one walks you through creating a directory, initializing a git repository, staging files, committing changes, configuring user details, and verifying history with git log.

Demonstrates turning a directory into a Git repository, staging untracked files, making the initial commit, and inspecting the history, highlighting the speed and clarity of using common language.

Explore how git tracks file changes with status and log outputs, including untracked and modified files, and learn to stage selective changes for commit and clean up boilerplate.

compare git commits to bank transactions to explain incremental state changes; commits have id, date, time, description, and amount, and a repository's current state is derived via parent pointers.

See how git diff reveals incremental state changes between commits by showing added and removed lines, with minus and plus sections that illustrate exact code changes.

Learn to review file changes between commits using git diff and git log with concise outputs, and use name status to identify added, modified, and deleted files quickly.

Use git diff to review uncommitted changes in the working directory and staging area, including untracked files. See how --cached shows staged changes and how diffs illustrate incremental commits.

Learn to review git diffs using graphical user interface clients inside IDEs like Android Studio, comparing commits and viewing before and after file changes.

Explore a long-standing Java unit testing framework by examining its source code, cloning or downloading the repository, using git log to locate commits, and reviewing a specific change.

Explore solving exercise two by inspecting unit four’s history with Git. Learn to view commit logs, compare diffs using Git diff or Git show, and understand the diff syntax.

Learn how to remove, move, and rename files in a git repository using git rm, git move, and staged commits, while git automatically tracks renames.

Explore the life cycle of a file in git, tracing how a file moves from untracked to staged to committed and back through modified states, including removal from tracking.

Learn to use the .gitignore file to ignore build directories, files, and path-based patterns with wildcards and double asterisks, and apply best practices to keep repos clean.

Download the Kitces app source, select a Flutter git template, copy it into the directory’s gitignore, initialize a git repository, commit, and verify ignored files are not tracked.

Learn to use git ignore to exclude the build directory and other artifacts, keeping untracked files out of commits and simplifying distribution to GitHub.

Learn how to create incremental commits by staging changes, amending the latest commit with git commit --amend, and interpreting commit identifiers and history.

Learn how to use Git help, pipe its output to less for easy viewing, and navigate high-level and detailed documentation to master the most practical Git commands.

Discover how a version control system tracks commits, reconstructs repository state from any commit, and enables reviewing and amending changes across history.

Git is a version control system that tracks changes in repositories, storing a .git directory and enabling a file lifecycle: unmodified, modified, staged, and committed.

Revert changes in git to restore your repository to a previous state, discarding unneeded edits and fixing mistakes. Compare alternative implementations and review past code to understand how bugs emerged.

Learn to remove untracked files and directories with git clean, using dry-run (-n), force (-f), and directory (-d) options, and optionally remove ignored files with -x and -X.

Learn how to discard unstaged changes and revert local file modifications in git using git checkout, restoring files while preserving staged changes.

Learn how to unstage changes with git reset and revert changes with git checkout, including cleaning up untracked files using git clean -f.

Learn how to reset a repository to a specific commit using git reset, choose soft or hard options, and inspect the changes with git log and git status.

Explore how git reset works across soft, mixed, and hard modes, including how each affects staged and unstaged changes, untracked files, and the working directory.

Learn how git commits act like saves in video games, enabling longer multi-session work, rollback to earlier points, and exploring alternative implementations for a project.

Learn how the head pointer tracks your current commit and how to navigate history with git reflog, git log, and hard or soft resets to restore previous states.

Practice exercise four by downloading the Sealock source, performing a hard reset, updating the version to 2.0, committing, and restoring the repository to its original state using git reflog.

Learn to use a lines of code tool to gauge a project's size by listing files, languages, code, comments, and blank lines, and navigate git history with hard resets.

learn how to revert changes from a specific commit using git revert, creating a new commit that reverses the targeted changes while preserving history and context.

Master reversing changes with git reset to move head between commits, guard uncommitted work, and use reflog to backtrack history and switches between branches in your repo.

Explore the most important git config options to boost productivity and efficiency, focusing on practical configurations rather than exhaustive coverage of git's advanced capabilities.

Explore how git configuration works across global and repository levels, locate the global config in your home directory and the repository config in .git, and edit them with git config.

Configure git editors across global and local scopes, switching between Emacs and nano with core.editor, and override global settings in specific repositories using git config.

Revisit and refine your git identity by configuring user.name and user.email, weighing global versus local settings, and adopting per-repository configuration to avoid committing with the wrong identity.

Learn to configure global git aliases to speed up common commands like status, checkout, commit, and reset, using head pointer-aware shortcuts.

Master git configuration by using local and global settings: edit .gitconfig and .git/config, learn to list options with git config --list, set with --global, create aliases, and unset options.

Explore how git branches create alternative histories to isolate bug fixes and new features, merge changes, and preserve both hotfixes and future work.

Demonstrate creating and checking out new branches with git checkout, including naming a hotfix branch, and inspecting branch state with status and log.

Explore how Git branches evolve and merge, visualizing master and hotfix histories with git log --all --graph, and compare terminal and GUI views in Android Studio.

Explore branch merging theory: decide merge targets, understand merge commits with two parents, fast-forward merges, and standard strategies for integrating hotfix and feature branches into master.

Explore how to merge branches in Git, including fast-forward merges and merge commits. See how aliases, commits, and conflicts shape the workflow when merging master and hotfix.

Resolve merge conflicts using a graphical user interface in Android Studio, merging master and hotfix changes, then test and commit the final merged code.

Resolve merge conflicts with a plain text editor by reading git markers, understanding your side and their side, and then test and commit the merged master after merging hotfix.

Download the Kitces source, create a new branch from master, merge master into it, then merge back into master, and review the commit graph with git log --oneline.

Merge multiple branches into a merge branch, resolve a conflict with a git tool, and align questions in the intended order. Finally test the app and fast-forward merge into master.

Learn how rebasing replays changes from multiple branches onto the latest master to create a linear history, comparing it with merging and fast-forward options.

Learn to rebase branches in practice, replace and reorder commits, resolve merge conflicts, and compare rebasing with merging to achieve a linear history.

Compare merging and rebasing, noting history preservation, merge commits, and potential conflicts. Decide on a team approach and apply your chosen strategy consistently.

Delete branches that have merged into master to reduce clutter, and use reflog and cherry-pick to recover or reapply unmerged work if needed.

Learn how to use detached head to quickly inspect a specific commit without altering branches, understand its limitations for development, and how to return to a branch with checkout.

Git branches serve as pointers to commits, enabling parallel feature development, hotfixes, and collaboration; merge or rebase options shape a clean, linear or merged history.

Explore git remotes to back up your work securely with remote repositories on external drives or over the internet, and enable collaboration among developers.

See how cloning creates a remote-tracked, lightweight repository that excludes ignored build artifacts, contrasts with copying all files, and shows origin and master branches.

Learn how to keep your local git clone up to date by fetching from origin and fast-forwarding or merging with the remote master, without re-cloning the entire project.

Use git pull to fetch and merge updates from origin master into your local master. Compare git pull with sequential git fetch and git merge to see the same result.

Learn how to configure git pull to use rebase instead of merge, compare rebasing with merging, and set a default rebase strategy with local or global git config.

Push-based backup flow shows how to push changes from the work repository to a backup remote, keeping backups updated without leaving the work repository.

Add a new remote and configure your local master to track the backup remote master, then push with confidence while understanding why bare repositories matter.

Understand bare repositories, their use as backups, and how to clone, set remotes, and push to backup repositories while working with the work tree and dot git.

Learn to clone the Kitces app, add a backup remote, and set master tracking; create and push a new branch with a file, then verify the remote branch.

Learn how to clone a repository, configure remotes and upstream, fetch and track remote branches, create and push a feature branch, add a new file, and safely delete merged branches.

Collaborate with a central repository using Git remotes and multiple developers. Push merged changes, resolve conflicts, and keep local and origin branches synchronized.

Explore end-of-line characters and the interoperability problem across Windows, Mac, and Linux, and learn how git auto converts line endings with core.autocrlf and renormalize to keep repos consistent.

Explore how remote repositories enable backup and collaboration, differentiate local, remote, and tracking branches, and learn when to fetch to keep your local copy up to date.

Discover how GitHub provides git hosting, central repositories, and cloud hosting for remote collaboration, issue tracking, and open source projects.

Explore the GitHub interface to sign up or sign in, browse repositories, view readme files, and learn how issues, pull requests, and branches support collaboration.

Sign up for a GitHub account to complete exercise seven, or skip the step if you already have one, then proceed to the next lecture.

Learn how to create a new private GitHub repository, choose whether to use a template or start clean, and push local code via the command line or GitHub desktop.

Learn to back up a local git repository by setting a GitHub remote, changing the origin URL, and using a personal access token instead of a password to push changes.

Learn to authenticate with GitHub using a personal access token, copy and store it securely, and set scopes and expiration to control push and fetch access.

Learn to authenticate to GitHub using SSH: generate a new key pair, configure SSH to use the private key, register the public key, and switch remotes to SSH URLs.

Generate a new ssh key, configure ssh and GitHub remote settings, authenticate with GitHub, export your public key, create a repository, and push your project with git push -u.

Clone a private project from GitHub with git clone using ssh authentication, then configure your user name and email and verify origin master.

Discover how to invite GitHub users as collaborators, manage access in a private repository, and differentiate between owners and collaborators in GitHub projects.

Push a new branch to GitHub and track it remotely, switch branches locally, and note that pull requests will be covered next.

Learn feature branches and how they merge into a mainline via merging or rebasing, plus continuous integration with pull requests on GitHub.

Learn how pull requests on GitHub enable code review before merging branches into master, compare diffs, resolve conflicts, and choose merge strategies such as squash and merge, or rebase.

Create a new local branch, make changes, commit, and push to your GitHub repository; open a pull request to master or your mainline branch, then leave comments and merge.

learn how to handle merge conflicts in pull requests when multiple developers push changes to the same project, using git commands and IDE tools to resolve conflicts and merge safely.

Explore how GitHub is the most popular git hosting service, offering project management, issue tracking, collaboration, and authentication, plus a social network for developers and open-source hosting.

Learn how git protects your work, organizes development into steps, and enables collaboration through branches, repositories, merging, and rebasing, while embracing a command-line workflow and seeking help when needed.