linux

Linux is a free, open-source, Unix-like operating system kernel — first released by Linus Torvalds in 1991 — that today powers everything from smartphones (Android) and web servers to supercomputers and embedded devices. Understanding it deeply means understanding how processes, memory, files, and permissions actually work under the hood.

Linux Architecture

Linux follows a layered design. At the very bottom sits the kernel, which talks directly to hardware; above it sit system libraries and utilities; and above that, the applications you actually run.

• Kernel Space — the core: process scheduler, memory manager, device drivers, and the networking stack. Runs in a privileged CPU mode.
• System Call Interface — the boundary between user programs and the kernel (e.g. open(), read(), fork(), execve()).
• Shell / User Space — where your programs, shells (bash, zsh), and daemons run in unprivileged mode.
• Monolithic but Modular — the Linux kernel is monolithic (everything runs in kernel space for speed) but supports loadable kernel modules (.ko files) so drivers can be added/removed at runtime without a reboot.

Filesystem Hierarchy Standard (FHS)

Almost everything in Linux is represented as a file — including devices and process information. The FHS defines a standard directory layout so that software behaves predictably across distributions.

Users, Groups & Permissions

Every file has an owner, a group, and a permission set for owner / group / others, each with read (r), write (w), execute (x) bits. Permissions can be represented symbolically (rwxr-xr--) or numerically in octal.

# view permissions
ls -l file.txt
# -rw-r--r-- 1 dipansu dipansu 512 Sep 26 10:00 file.txt

# change permissions
chmod 755 deploy.sh        # numeric mode
chmod u+x deploy.sh        # symbolic mode: add execute for owner

# change ownership
chown dipansu:dev file.txt

# add a user to a group
sudo usermod -aG docker dipansu

# check current user & groups
whoami
groups

Process Management

A process is a running instance of a program. The kernel scheduler decides which process runs on the CPU and for how long, using priority/nice values and scheduling classes.

• PID / PPID — every process has a unique Process ID and a Parent Process ID; process 1 (init/systemd) is the ancestor of all others.
• fork() + exec() — the classic way new processes are created: fork() duplicates the calling process, then exec() replaces its memory image with a new program.
• Zombie & Orphan Processes — a zombie has finished but its exit status hasn't been read by its parent yet; an orphan's parent has died and it gets re-parented to init.
• Signals — asynchronous notifications sent to processes (SIGTERM, SIGKILL, SIGINT, SIGHUP) to request termination, interruption, or reload.
• Foreground vs Background — append & to run a job in the background; use jobs, fg, bg, and nohup to manage them.

# list running processes
ps aux
ps -ef --forest         # show process tree

# live resource usage
top
htop                     # nicer, interactive (may need install)

# send signals
kill -15 1234            # SIGTERM: ask process 1234 to terminate gracefully
kill -9 1234              # SIGKILL: force kill (uncatchable)
pkill -f "python app.py"  # kill by matching command name

# run in background / detach from terminal
long_task.sh &
disown
nohup long_task.sh &> out.log &

# change scheduling priority
nice -n 10 ./batch_job.sh
renice -n 5 -p 1234

Shell & Scripting

The shell is both an interactive command interpreter and a scripting language. Bash scripts let you automate repetitive sysadmin and dev tasks.

#!/usr/bin/env bash
set -euo pipefail   # exit on error, unset var, or failed pipe

SRC_DIR="/home/dipansu/projects"
DEST_DIR="/backup/$(date +%Y-%m-%d)"

mkdir -p "$DEST_DIR"

for file in "$SRC_DIR"/*.log; do
    if [[ -f "$file" ]]; then
        cp "$file" "$DEST_DIR/"
        echo "Backed up: $file"
    fi
done

echo "Backup complete -> $DEST_DIR"

• Pipes & Redirection — | chains commands together; >, >>, 2>, and &> redirect stdout/stderr to files.
• Variables & Quoting — always quote variables ("$var") to avoid word-splitting and glob expansion bugs.
• Exit Codes — every command returns a status ($?); 0 means success, non-zero means failure — essential for chaining with && / ||.
• Text Processing Trio — grep (search), sed (stream editing), and awk (pattern-based field processing) form the backbone of shell text pipelines.

Package Management

Different distributions use different package managers, but the underlying goals — installing, updating, and removing software with dependency resolution — are the same.

Networking Basics

• Interfaces — ip addr show lists network interfaces and their IP addresses (replaces the older ifconfig).
• Routing — ip route shows the routing table; traceroute/mtr trace the path packets take to a destination.
• DNS — dig or nslookup resolve hostnames; /etc/resolv.conf and /etc/hosts configure resolution.
• Sockets & Ports — ss -tulpn (or the older netstat) lists listening ports and the processes bound to them.
• Firewall — iptables/nftables for low-level packet filtering, or ufw/firewalld for a friendlier front-end.

ip addr show                  # list interfaces & IPs
ip route                      # routing table
ss -tulpn                      # listening TCP/UDP sockets + owning PID
curl -I https://example.com    # quick HTTP HEAD request
ping -c 4 8.8.8.8               # basic reachability test
dig example.com +short          # DNS lookup
scp file.txt user@host:/path/   # secure copy over SSH

systemd & Services

Most modern distributions use systemd as PID 1 — it manages the boot process, services (units), sockets, timers, and logging (via journald).

systemctl status nginx          # check service status
systemctl start nginx           # start a service now
systemctl enable nginx          # start automatically at boot
systemctl restart nginx
journalctl -u nginx -f          # follow live logs for a unit
journalctl -xe                  # recent logs with explanations

# a minimal custom unit file: /etc/systemd/system/myapp.service
# [Unit]
# Description=My App
# After=network.target
#
# [Service]
# ExecStart=/usr/local/bin/myapp
# Restart=on-failure
#
# [Install]
# WantedBy=multi-user.target

Command Cheat Sheet

External Learning Resources

Reading is only half the battle — these are the resources I'd genuinely recommend for actually internalizing Linux internals and daily-driver skills:

• Interactive Linux Journey — a free, beginner-friendly, structured walkthrough of Linux fundamentals.
• Reference The Linux Documentation Project (TLDP) — HOWTOs and guides covering nearly every corner of classic Linux administration.
• Reference man7.org Linux man-pages — the canonical, always-current source for man pages and system call documentation.
• Book "The Linux Programming Interface" by Michael Kerrisk — the definitive deep-dive into Linux/UNIX system programming (processes, IPC, sockets).
• Course Introduction to Linux (Linux Foundation, edX) — free, official course covering the essentials for using and administering Linux systems.
• Reference The Linux Kernel Documentation — official kernel internals docs, straight from the source tree.
• Practice OverTheWire: Bandit — a wargame that teaches Linux command-line and shell skills through hands-on SSH challenges.
• Reference explainshell.com — paste any shell command and get an annotated breakdown of every flag and argument.
• Cheat Sheet cheat.sh — instant command-line cheat sheets: curl cheat.sh/tar.
• Video The Linux Foundation (YouTube) — talks and tutorials from LF events and official training programs.