Command and Tool Comparisons
Practical comparisons for commands and tools developers often confuse in real workflows.
Git Merge vs Rebase
When to use merge, when to use rebase, and the tradeoffs between them.
Docker Run vs Exec
A practical explanation of the difference between starting a container and running a command inside one.
Git Cherry-pick vs Revert
How to choose between replaying a commit elsewhere and undoing one where it already exists.
Git Fetch vs Pull
What changes locally with fetch, and when pull is the better shortcut.
Git Reset vs Revert
The practical difference between rewriting local history and undoing shared history safely.
Docker Compose Up vs Run
When to start a service stack and when to launch a one-off command with Compose.
kubectl apply vs create
When declarative updates are better than one-time object creation in Kubernetes.
kubectl rollout restart vs delete pod
Two ways to refresh running workloads in Kubernetes and why they are not equivalent.
npm install vs npm ci
Which command to use for local dependency changes and which one is better for consistent installs.
npm vs npx
The difference between the package manager itself and running package binaries on demand.
grep vs ripgrep
Why both tools still matter and when ripgrep is the better default search tool.
find vs fd
How the classic file walker compares to a faster, friendlier modern alternative.
git restore vs checkout
When to use the newer restore command and when checkout still makes sense.
git switch vs checkout
How the newer branch-switching command compares to the older multi-purpose checkout behavior.
docker build vs docker compose build
When to build a single image directly and when Compose is the better fit.
kubectl get vs describe
How to choose between a quick object listing and deeper object inspection.
ssh vs scp
The difference between connecting to a remote shell and copying files over SSH.
curl vs wget
Which network CLI is better for APIs and which one is better for download-oriented workflows.
tar vs zip
When to use archive-first tar workflows and when zip is the simpler cross-platform choice.
rsync vs scp
The difference between simple file copying and efficient sync-oriented transfer.
cp vs rsync
When a simple local copy is enough and when rsync is worth the extra syntax.
vim vs nano
How to choose between a powerful modal editor and a simpler terminal editor.
brew vs apt
How Homebrew and apt differ in ecosystem, target platform, and package expectations.
pnpm vs npm
When pnpm's dependency model is worth the switch and when npm remains the simpler default.
yarn vs npm
How to think about Yarn today compared with the default npm workflow.
git log vs reflog
How to choose between project history and your local reference history when investigating Git state.
git tag vs branch
When to mark a fixed point in history and when to create a moving line of development.
git stash vs commit
How to choose between temporary local cleanup and recording real history.
git commit --amend vs new commit
When to revise the last commit and when to add another commit instead.
docker stop vs kill
The difference between graceful container shutdown and immediate termination.
docker cp vs volumes
When to move files in and out of containers directly and when to rely on mounted storage.
kubectl delete vs scale to zero
How to choose between removing a workload entirely and temporarily stopping it.
ps vs top
When a snapshot of process state is enough and when you need a live process view.
chmod vs chown
How to distinguish file permission changes from ownership changes.
less vs cat
When to page through content and when to dump it directly to output.
jq vs grep for JSON
Why structured JSON parsing is usually better than text-matching raw output.
sort vs uniq
When sorting is enough and when uniq is the right follow-up for duplicate handling.
sed vs awk
How to choose between stream editing and field-oriented text processing.
xargs vs while read
When to fan out arguments efficiently and when a shell loop is safer or clearer.
systemctl vs service
Which service-management command to use on modern Linux systems and why both still show up.
journalctl vs tailing log files
When systemd journal access is better than reading raw log files directly.
ssh-agent vs direct key usage
When an SSH agent simplifies authentication and when direct key paths are enough.
crontab vs systemd timer
How to choose between traditional cron scheduling and systemd-native timers.
ls vs tree
When a flat directory listing is enough and when a recursive visual structure helps more.
du vs df
When you need filesystem-level capacity information and when directory-level usage matters more.
head vs tail
How to choose between the start and end of a file when inspecting text quickly.
tee vs shell redirection
When to duplicate output to both screen and file and when simple redirection is enough.
kill vs pkill
How to choose between signaling a known PID and matching processes by name or pattern.
ssh vs mosh
When normal SSH is enough and when a roaming-friendly remote session tool is worth using.
make vs just
How traditional build automation compares to a simpler modern command runner.