Sefism Linux, Terminal and Git Cheat Sheet

What it is

The Linux, terminal and Git cheat sheet is the quick-revision companion to Sefism's Linux, terminal and Git roadmap. It covers machine setup, the shell, text tools, permissions and processes, Git, GitHub, scripting and servers, in the same order as the roadmap's stages.

Each concept is short on purpose: what it is in plain words, why or when it matters, a command or snippet where one helps, and the mistake people usually make with it. It is built to sit in a browser tab while you work, so that a forgotten flag or a Git rescue is ten seconds away rather than a search and three forum threads.

Three editions, one for your computer

The sheet comes in the same three versions as the roadmap:

• Windows: WSL 2 with Ubuntu, Windows Terminal, and how the Linux and Windows file systems meet inside WSL. Everything after the first chapter runs in your Ubuntu shell. 78 concepts.
• macOS: Terminal, iTerm2 and zsh, the Xcode Command Line Tools and Homebrew, with notes where macOS tools differ from Linux. 78 concepts.
• Linux: your distribution and its package manager, then the same shared chapters. 76 concepts.

Only the first chapter differs much between them; the rest is shared, so a team with mixed laptops can use the same sheet.

Chapter by chapter

1. Your machine

Getting a Unix shell, a package manager, Git and an editor working, and the words for the parts you are using: terminal, shell and prompt, the system package manager, man, --help and tldr, Git configuration, and VS Code with the code command. Each edition adds its own setup concepts, such as WSL 2 and Windows Terminal, Homebrew and the Command Line Tools, or choosing a distribution.

2. Shell basics

Absolute and relative paths, file commands, globbing and brace expansion, quoting, pipes, redirection and the three streams, environment variables, PATH, startup files and aliases, nano and Vim, and opening files and the clipboard from the terminal.

3. Text tools

cat, less, head and tail, grep, find, sort, uniq, cut, tr and wc, regular expressions, sed, awk and jq. This is the chapter to keep open when you are questioning a log file or an API response.

4. Permissions, processes and packages

Permission bits, chmod, ownership and chown, root, sudo, users and groups, processes, signals and kill, foreground and background jobs, installing developer tools, version managers, and disk and system checks.

5. Git fundamentals

Commits and snapshots, the working tree, staging area and repository, git log and git diff, commit messages, .gitignore, branches, git stash, merge, rebase, merge conflicts, undoing changes and git reflog. Twelve concepts, the largest chapter in every edition, because this is where most people need rescuing.

6. GitHub and collaboration

Remotes, fetch, pull and push, SSH keys, GitHub flow, pull requests, code review, forks and syncing, the GitHub CLI, and keeping secrets out of Git.

7. Shell scripting and automation

Shebangs and executable scripts, exit codes, set -euo pipefail, variables and arguments, conditionals and tests, loops, functions and script structure, ShellCheck, cron and a dotfiles repository.

8. SSH, servers and debugging

SSH login and the SSH config file, scp and rsync, first steps on a new server, tmux, systemctl and journalctl, curl, DNS and reachability checks, ports and listening processes, and an environment debugging checklist you can run through when "it worked yesterday".

Each chapter links up to three library resources for depth, such as The Linux Command Line, Pro Git, Learn Git Branching, Oh Shit, Git!?!, ShellCheck and the Linux Upskill Challenge.

Rules of thumb worth remembering

The sheet ends with eleven tips, a 99-term glossary and search across every concept. A sample of the tips:

• Read the whole error message, starting from the first line, before searching for it.
• Run pwd and git status before anything destructive; they take a second and save hours.
• Preview before you delete: ls the pattern, run find without -delete, rsync with --dry-run.
• Never paste a command you do not understand, especially one with sudo, rm or a pipe into a shell.
• Use git revert on shared branches and keep reset and force-push for your own local history.
• Write it down: a setup note and a server runbook turn the next rebuild into a checklist.

Each edition adds one of its own, such as keeping projects inside the Linux file system on WSL, or running brew doctor first when a tool breaks after a macOS upgrade.

How to use it with the roadmap

• During a stage: keep the matching chapter open as you work through the checklist. The roadmap tells you what to do; the sheet reminds you how.
• After a stage: read the chapter's pitfall lines and check each one would not catch you out.
• On the job: the Git and debugging chapters are the ones people return to most once they start an internship. Before a risky Git operation, check the undoing changes and reflog entries first.
• When setting up a new machine: chapter 1 plus your own setup note from stage 1 of the roadmap is the whole checklist.

How it works on Sefism

Everything here is free to learn from. The public page lists every chapter, with the first chapters open to read. Keeping the sheet uses credits, and new members get starting credits when they join. Adding the Linux, terminal and Git roadmap to your dashboard (your first roadmap is free) opens this sheet with it. In the member area you can switch between the Windows, macOS and Linux editions.

Related on Sefism

• How to learn Git and GitHub properly
• Git: the model behind the commands
• How to get better at debugging without asking AI first
• The Backend development cheat sheet, which opens with a short terminal and Git chapter of its own

FAQ

Is this enough to learn Git from scratch? It is a revision sheet, not a course. Learn from the roadmap's picks, such as Pro Git and Learn Git Branching, and use the sheet to remember.

Does it cover Windows without WSL? No. The Windows edition assumes WSL 2 with Ubuntu, because the roadmap teaches a Unix shell.

Which shell does it use? Bash for scripts, with zsh as the default interactive shell on macOS.