git – Megan Coyle Senior Software Engineer

The command line interface (CLI) is a powerful tool that developers can leverage to streamline their workflow and boost productivity. While graphical user interfaces (GUIs) are user-friendly, the command line offers a more efficient and flexible way to interact with your computer.

Here are some useful commands to keep in your developer toolbox:

Navigating the File System:
- cd <directory>: Change directory. Use this command to navigate between folders (add the directory path in the place of <directory>).
- ls: List the contents of a directory. Add options like -l for a detailed list or -a to show hidden files.
- pwd: Print working directory. Prints the file path of the directory you’re currently in.
File Operations:
- cp: Copy files or directories. Helpful for duplicating files (use cp <file> <directory> to copy a file to a directory – which can possibly overwrite files).
- mv: Move or rename files and directories (to move files, use mv <file> <directory>, to rename a file, use mv <file-old> <file-new>).
- rm: Remove files or directories (rm <file> for files or rm -r <directory> for directories). Exercise caution, as this command is irreversible.
- mkdir <directory>: Create a directory (add the name of the directory in place of <directory>).
- touch <file>: Create a file (add the file name in place of <file>).
Text Manipulation:
- cat <file>: Concatenate and display the content of files.
- grep: Search for specific patterns in files.
- sed: Stream editor for filtering and transforming text.
File Inspection:
- file: Determine the file type.
- wc: Count words, lines, and characters in a file.
- head and tail: Display the beginning or end of a file.
System Information:
- df: Display disk space usage.
- free: Display amount of free and used memory.
- top and htop: Show real-time system statistics.
Version Control:
- git: Essential for version control. Commands like git clone, git pull, git push, and more are crucial for collaborative development.
Package Management:
- npm or yarn (for Node.js): Manage packages and dependencies for JavaScript projects.
- pip (for Python): Install Python packages effortlessly.
Network-related Commands:
- ping: Test the reachability of a host.
- curl and wget: Download files from the web directly in the terminal.
Process Management:
- ps: Display information about active processes.
- kill: Terminate a process. Use with caution.
User and Permissions:
- sudo: Execute a command with superuser privileges.
- chown and chmod: Change ownership and permissions of files.

Mastering the command line is a key skill for developers. These essential commands empower developers to perform a wide range of tasks efficiently and are particularly valuable in server environments and automation scripts. As you become more comfortable with the command line, you’ll discover its potential for enhancing your development workflow and troubleshooting capabilities.

Git is a version control system that tracks changes in a set of files, which is used by developers to coordinate work done for various projects. Here are some useful git commands that can help with your workflow:

General Commands

git status to see what changes have been made locally
git add . to commit all locally edited files in the repo
git add <file> to add a file to the next commit
git rm <file> to delete a file in the next commit
git mv <file> to rename a file in the next commit
git add -p is useful if you’ve done too much work for one commit, ? is a useful command to print all
git cat-file -p <sha> prints the contents of blobs (sha refers to the SHA or hash that git assigns to each commit)
cat .git/HEAD to see what HEAD is pointing to

Stashing

Stashing your work is useful if you’re moving between branches when you’re in the middle of work. It’s a safe, non-destructive way to save your work.

git stash to save uncommitted work
git stash list to view the current stashes that are available
git stash apply applies the last stash
git stash apply stash@{0} to apply a specific stash (in place of the 0 you can add the number associated with the stash from your git stash list that you’d like to apply)
git stash --include-untracked to keep untracked files in your stash
git stash save "WIP: working on recent bug fix" in place of the text in the quotes here, you can add a name for easy references when viewing the list of your stashes and figuring out which stash to apply on your current branch
git checkout <stash name> -- <filename> grabs a single file form a stash
git stash show stash@{2} to show the files changed

Keeping Your Stash Clean

git stash drop to remove the last stash
git stash clear to remove all stashes

Logging

git log to view an overview of the most recent git commits
git log --since="yesterday" to view commits from a specific time period. You can also pass arguments like git log --since="2 weeks ago"
git log --name-status --follow -- <file> to log files that have been moved or renamed
git log --diff-filter=R --find-renames to find files that have been renamed
git show <commit> to show commit and its contents
git show <commit> --stat show files changed in commit
git show <commit>:<file> look at a file from another commit

Fixing Mistakes

git checkout -- <file-path> overwrites the working area file with the staging area version from the last commit (this operation overwrites without warning so use with caution)
git clean will clear your working area by deleting untracked files (this operation cannot be undone). Use the --dry-run flag to see what will get removed
git reset moves the HEAD pointer, modifies files for commits (can change history)
git revert <commit> is the safe reset (creates a new commit that introduces the opposite changes from the specified commit, the original commit stays in the repo)
git reset --hard HEAD use this command if your staging area has gotten really messed up and you want to blow away all of your local work
git commit --amend if you need to amend your latest commit
RERERE (Reuse Recorded Resolution) is a tool that remembers a previously used solution for a merge conflict. Set git config rerere.enabled true within a project to have access to this tool. You can also set it globally with git config --global rerere.enabled true

Rebasing

Rebasing your feature branch with main will help keep your development work up-to-date with the latest changes that have been committed to the repo. This will help make merge conflicts more manageable whenever it’s time to merge in your feature work.

git rebase main makes history of current branch cleaner and makes managing merge conflicts easier
git rebase -i <commit to fix> addressing specific commits

Working with GitHub

git clone <project reference to clone a GitHub repo locally
git pull performs a git fetch && git merge to ensure the latest version of a branch has been updated on your machine
git push origin <name-of-branch> to push any changes to the remote repo
git pull --rebase will fetch, update your local branch to a copy of the upstream branch, then replay any commits you made via rebase (this doesn’t work well on branches with local merge commits, it works best when branching off master and working on a feature)

Local Destructive Operations

When performing a destructive operation, make sure you properly stash your work so you don’t accidentally delete any of your work in progress. Use git stash --include-untracked to include working area changes in your stash.

git checkout --<file> if file is presnt in staging, it will be overwritten
git reset --hard overwrite changes that are staged and in working area
rebase, amend, and reset can rewrite history (if your code is hosted or shared, never run git push -f which forces a push of your changes)

Configuring Your Editor

To customize which editor git opens when you run a commit with no -m flag, a merge, or rebase, run the following command:

git config --global core.editor <your_editor>

In the place of <your_editor>, add the command associated with your editor of choice:

atom: atom --wait
emacs: emacs
sublime: subl -n -w
vi: vi or vim
vscode: code --wait

Megan Coyle

Tag: git

Essential Command Line Commands for Developers

Handy Git Commands