KILL Linux processes!! (also manage them) // Linux for Hackers // EP 7

Linux process management boils down to three practical moves: find the right process, choose whether to stop it or kill it, and control whether it runs in the foreground or background. The episode’s core workflow is command-line driven—start an app (like Firefox), inspect running processes with `ps`, locate the target process ID (PID), then terminate it with `kill` (or the convenience variants) when it freezes or misbehaves.

The session begins by launching Firefox and using `ps` to list processes. A plain `ps` only shows what’s running in the current terminal context (often the shell and the `ps` command itself), so the guide switches to `ps -u <username>` to filter by the current user. To quickly narrow results, it pipes output through `grep` (described as “global regular expression print”), for example filtering for “Firefox.” The key takeaway is that process visibility depends on the exact `ps` options—without them, the terminal can mislead you into thinking nothing else is running.

When a program stalls, the episode focuses on termination. The default `kill` command requires a PID, not a name, so the workflow becomes: use `ps` + `grep` to find the PID, then run `kill <PID>`. For faster PID lookup by name, it introduces `pgrep Firefox`, which returns the PID directly. With that, killing becomes straightforward: `kill <PID>` for a targeted stop, or `kill -9 <PID>` for a forceful termination.

The episode also maps common `ps` usage patterns. It highlights `ps -aux` as a go-to command for “all users” and broad visibility, then again suggests piping to `grep` to find a specific program. For live monitoring, it demonstrates `top` (CPU-sorted process view) and `htop` (a more interactive, visually “cooler” alternative). Exiting `top`/`htop` is done with `q`.

A major portion then distinguishes foreground vs. background jobs. A foreground example uses `ping -c 100 networkchuck.com`, which occupies the terminal until completion or interruption. Stopping it uses `Ctrl+C`. To demonstrate job control, it uses `Ctrl+Z` to suspend a running foreground job, then lists jobs with `jobs`. From there, `bg` resumes suspended jobs in the background, while `fg` brings them back to the foreground—after which `Ctrl+C` can stop them again. It also shows how to run multiple jobs (multiple `ping` and `sleep` commands), suspend them, and selectively resume/kill them by job number.

Finally, the episode drills into kill signals. It explains that `kill` without a specified signal sends `SIGTERM` (signal 15), which is a polite request to terminate. It connects terminal shortcuts to signals: `Ctrl+Z` corresponds to `SIGTSTP` (signal 19, stop), and `Ctrl+C` corresponds to `SIGINT` (signal 2, interrupt). For “no questions asked” termination, it uses `kill -9` (`SIGKILL`, signal 9). It also introduces `pkill -9 <name>` to kill all processes matching a name in one shot—demonstrated by killing multiple `ping` processes at once.

Overall, the episode matters because these commands form the backbone of troubleshooting on Linux: when something hangs, the fastest path is to identify the PID, pick the right signal (polite vs. forceful), and use job control to keep the terminal usable while processes run.