Unix/Linux: Fundamental Commands & Concepts

Multiuser Environment

A setup that allows multiple individuals to simultaneously connect and run applications on the same physical machine.

"Everything Is a File" Philosophy

A unifying model in which directories, text documents, hardware devices, and sockets are all accessed using read/write operations.

Kernel

The core software layer that governs process scheduling, memory management, and direct hardware interaction.

Shell

A command-line interface that accepts user input, runs programs, and can interpret scripts for task automation.

Standard Input (file descriptor 0)

The default location from which a process reads data, generally tied to the keyboard unless redirected.

Standard Output (file descriptor 1)

The typical destination for a program's results, usually displayed on the terminal unless sent to a file.

Standard Error (file descriptor 2)

The separate pathway used to display warnings or failures, enabling distinct handling of diagnostics.

File Descriptor

A small integer assigned by the operating system to each open file, stream, or network socket.

Absolute Path

A file or directory locator string that starts at the root slash and provides the exact chain of directories to reach the target.

Relative Path

A shorter locator interpreted from the current working directory, without beginning from the root slash.

/ (Root Directory)

The top-most point of the Unix filesystem, containing every other folder within its hierarchy.

Dot (.) and Dot-Dot (..)

Special entries inside any folder representing, respectively, the current directory and the parent directory one level above.

ls

Lists the contents of the specified directory (or the current one if not provided), optionally showing details.

cd

Updates the working directory to a user-supplied path, or moves to the home location if no argument is given.

pwd

Reveals the complete path from root to the directory where the session is currently operating.

mkdir

Establishes a new folder in the filesystem at a specified path, provided the user has sufficient permissions.

rmdir

Deletes a directory that is empty; for a non-empty folder, a more advanced approach is needed (like rm -r).

cp

Duplicates a file or directory into another name or path, preserving the original while creating a new copy.

mv

Either renames an item or relocates it into a different folder, without creating a separate copy.

rm

Eliminates files or, with additional flags (-r), removes directories recursively, clearing contents.

cat

Displays the contents of a file sequentially; often used to combine multiple text files into one stream.

more / less

Shows a file's text one screen at a time; the second form allows backward navigation and is more flexible.

head / tail

Prints either the ________ or _________ ten lines of a file by default; numeric options adjust how many lines appear.

grep

Searches for text patterns in files or piped input, returning matching lines. Often combined with "-r" to scan directories.

sort / uniq

first one Reorders lines alphabetically or numerically, second one filters out adjacent duplicate lines .

diff

Compares two files line by line to highlight text differences and potential merges or patches.

locate / which / whereis

Tools to find file paths or discover the exact location of an executable; can help reveal whether certain commands are installed.

man / info

Launches manual pages or extended documentation describing command syntax, usage tips, and examples.

date / hostname

Retrieves the system's calendar/time setting or prints the machine's network identifier.

write / mesg

The first allows direct text communication with another logged-in user, while the second toggles acceptance of those messages.

Owner (User), Group, Others

Three distinct categories that define who can read, modify, or execute an object—each category may have different rights.

Read, Write, Execute (r, w, x)

Symbols representing the ability to view file contents, alter them, or run the file as a program (or traverse a directory).

chmod

Adjusts who can do what to a file or directory using either symbolic (u, g, o) or numeric (octal) notation.

chown / chgrp

first one Transfers a file's ownership to a different user: second one changes which group is recognized as the primary group for that file

Octal Permission Representation

A three-digit base-8 number that encodes read, write, and execute bits for each category, e.g., 755 means full control for the owner but read-execute for others.

Sticky Bit

A special permission bit on directories that restricts file deletion so that only the file's owner (or directory owner) can remove it.

SUID, SGID

Flags that let an executable run with the permissions of its owner or group, regardless of who launched it.

umask

A command controlling which default permissions are turned off when a new file or folder is created.

ps

Lists running processes, allowing you to see IDs, owners, CPU usage, controlling terminals, etc.

top

Continuously updates and displays processes ranked by resource consumption, with interactive commands to kill or renice tasks.

free

Reports memory usage, including how much physical and swap space is free or allocated.

kill / killall

Sends signals (like TERM or KILL) to processes, identified by PID or by name, requesting graceful or immediate termination.

background (&)

A method for launching tasks without blocking the shell; appending an ampersand runs the command asynchronously.

fg / bg / jobs

Built-ins to move a suspended or backgrounded task into the foreground, continue it in the background, or list them.

fork

A system call that spawns a new child by cloning the state of the current process.

exec

Replaces the current process image with a specified program, no return unless there is a failure to load.

wait / waitpid

Parent waits for child to end; obtains exit status for further logic or resource cleanup.

#! (Shebang)

In the first line of a script, indicates which interpreter will run the subsequent lines, e.g., /bin/bash.

environment variable

Named data that influences process behavior. Examples include PATH, HOME, and LANG.

export

Marks a shell variable so child processes inherit it, as in export MYVAR="something".

echo

Prints text to standard output; often used in scripts to show progress or results.

read

Pauses a script to take user input from standard input and store it in a variable.

if / then / else

A conditional structure that checks an expression or command's success to decide which block of instructions to run.

for / while loops

Mechanisms for repeated execution, either over a list of items or until a given condition changes.

break / continue

Control statements that exit the nearest loop or skip to the next iteration, respectively.

redirection (>, >>, 2>&1)

Diverts standard or error output into files or merges them, e.g., sending all output to a single log.

shell script execution

Typically done by granting permission (chmod +x) and invoking with ./scriptname or via the shell.

Insert Mode

A state where typed characters become file content; triggered by pressing i or a.

Command Mode

The default editing state in vi: keystrokes are interpreted as editing actions (movement, deletion, search, etc.).

Esc (Escape)

Exits insertion, returning to command mode to accept further editing commands.

Save & Quit (:wq)

Writes all modifications to disk and closes the editor session, returning to the shell.

Quit Without Saving (:q!)

Leaves the editor and discards changes made since the last write.

dd

Removes the entire line under the cursor and places it in a buffer for potential paste.

x

Deletes the single character under the cursor in command mode.

yy / p

Copies the current line and places it in a buffer; the second command pastes that buffer below.

/pattern and n

Looks for the next occurrence of it, continuing the search with it each time it's pressed.

:s/find/replace/

Replaces the first match on the current line; adding a g at the end does it globally in that line.

:%s/find/replace/g

Substitutes all instances of "find" with "replace" throughout the entire document.

G, gg, ^f, ^b

Movements: jump to last line, jump to first line, scroll forward a page, and scroll back a page, respectively.

#include Directive

A line that includes headers or library declarations so the compiler knows about functions and classes used later.

using namespace std

Temporarily allows standard library objects (like cout) to be accessed without prefixing "std::".

main Function

The required entry point of any stand-alone C++ application; returns an integer as exit status.

g++ -c

Translates a .cpp file into an intermediate .o (object) file but does not create a runnable program.

g++ -o

Links object files (and libraries if needed) into a final executable with a specific name.

-Wall

Tells the compiler to issue all recommended diagnostic warnings about suspicious code.

Makefile

A text file defining build rules so that the "make" utility can compile and link only what has changed.

Typical Makefile Rule

A structure with "target: prerequisites" on one line, followed by TAB-indented commands that build the target.

clean Target

A special pseudo-rule often used to delete all object files and temporary build artifacts so you can rebuild from scratch.

Two-Stage Build

The practice of separating compilation (per file) and final linking into distinct steps, improving efficiency and maintainability.

tar

An archiver that packages multiple files into a single bundle; can optionally compress using "-z" with gzip.

rsync

Synchronizes directories between local or remote hosts, transferring only the deltas, which is very bandwidth-efficient.

scp

Copies files securely between machines over SSH, ensuring confidentiality of data in transit.

ssh

Opens an encrypted, authenticated remote session on another system, letting you run commands from afar.

df / du

The first shows the percentage of used and free space on mounted filesystems, while the second calculates a folder's total size.

script

Captures all terminal input and output in a named file, letting you produce logs or transcripts of session activity.

Rehearsing Hands-On

Encourages typing out each command multiple times until it becomes second nature.

Checking Man Pages

Advises referencing built-in documentation for deeper usage details, examples, and option lists.

Combining Tools

Recommends piping commands together for powerful one-liners (e.g., ls | grep something | sort).

Building Basic Shell Scripts

Suggests starting with simple scripts (like a for-loop that echoes filenames) to confirm you understand fundamentals.

Current Working Directory

The directory your shell is presently "inside." Use pwd to display it, cd

to change it.

Home Directory

The user's personal directory, typically /home/ or /people/cs// on campus systems. The shell moves here on login.

ls

Lists contents of the current (or specified) directory. Common flags: -l (long format), -a (include hidden files).

Pipe |

Connects the output of one command to the input of another, e.g. ls | grep txt finds lines containing "txt."

&& and || in Shell

Logical operators. cmd1 && cmd2 runs cmd2 only if cmd1 succeeds; cmd1 || cmd2 runs cmd2 only if cmd1 fails.

$?, $#, $1, $@

Shell special parameters. $? = exit status of last command; $# = number of arguments; $1 = first arg to script; $@ = all args.

sudo vs su

the first executes a single command with elevated privileges, whereas the second switches you into another user's shell, often root.

Substitute: :%s/old/new/g

Replaces all occurrences of "old" with "new" throughout the file. Omit the % to do it on the current line only.

Navigation: h, j, k, l, or arrow keys

Moves left, down, up, right. ^f or PageDown moves forward a screen, ^b or PageUp moves back a screen.

Setting line numbers: :set nu

Tells vi/vim to display a line count on the left. :set nonu turns them off.

u (Undo), U (Restore line), CTRL-R (Redo in vim)

this one reverts the last change, and this one redoes it in vim.