tag
30 posts
Full-screen terminal applications like htop and vim don't just print text — they take over the entire screen, redraw parts of it selectively, and read your keystrokes one at a time. Here's the layer that makes that possible.
Re-running the last command with sudo, or fuzzy-searching back through everything you've typed today, both rely on the same underlying mechanism — a persisted, indexed log of your previous commands.
An unquoted variable works fine in testing, then silently breaks in production the first time it holds a value with a space in it. This is the single most common category of real-world shell scripting bug.
Pressing Tab and getting a sensible list of filenames, commands, or flags looks simple from the outside. Underneath, it's a programmable system matching the word you're typing against rules specific to the command you're running.
'Terminal' and 'shell' get used interchangeably constantly, but they're genuinely separate programs with separate jobs — one draws characters on screen and manages input, the other interprets commands.
That colorful prompt showing your git branch, exit code, and current directory isn't a separate program running alongside your shell — it's a string your shell re-evaluates before every single command.
Ctrl-Z, bg, fg, and the & at the end of a command all touch the same underlying mechanism — a shell feature that manages which processes can read your keyboard input at any given moment.
FreeBSD's default shells didn't evolve from the Bourne shell lineage Bash and Zsh belong to — they descend from an entirely separate design philosophy, one built to feel more like C than like a scripting language.
By the time a command you typed actually runs, the shell has already rewritten it — expanding variables, substituting command output, and turning wildcard patterns into real filenames. Here's the exact order that happens in.
They all accept most of the same basic commands, which is exactly what makes their real differences easy to miss until a script written for one breaks silently on another.
Each WSL2 distro's filesystem lives inside a dynamically-expanding .vhdx file on your Windows drive. It grows automatically as you use it — but deleting files inside WSL doesn't shrink it back down, and that's expected, not a bug.
Training a machine learning model inside WSL2 using your actual GPU sounds like it shouldn't work through a virtual machine layer at all. Here's the specific virtualized GPU mechanism that makes it possible.
For years, WSL distros ran without systemd — meaning services expecting it simply failed. Here's why that gap existed, and what changed architecturally to finally close it.
Installing Ubuntu via the Microsoft Store feels like installing any other app. Underneath, WSL distros are root filesystem tarballs registered with a small platform layer — and that model is what makes import/export and custom distros possible.
WSL2's lightweight VM claims memory dynamically as Linux processes need it — but historically gave that memory back to Windows only reluctantly. Here's what's actually happening, and what you control via .wslconfig.
Running notepad.exe from a Bash prompt, or a Linux tool from Windows' own command line, works because of a specific interop layer translating between two completely different executable formats and process models.
Running a Linux GUI application inside WSL and having its window appear alongside your native Windows apps looks like magic. It's actually a full Wayland compositor and audio system, tunneled over RDP, running invisibly.
WSL2's original networking design put it behind its own virtual network, invisible to the rest of your LAN by default. Mirrored networking mode, added later, takes a fundamentally different approach — and each has real tradeoffs.
Linux and Windows filesystems handle permissions, case sensitivity, and paths in fundamentally different ways. WSL's cross-OS file access works by translating between them at the protocol level — and that translation has real performance costs.
WSL2 doesn't borrow a distro's kernel — Microsoft maintains its own fork, patched specifically for the virtualized environment WSL2 runs in, and ships it independently of both Windows and any Linux distro's own kernel.
A computer once filled a room and required a specialized staff to operate. The path to a device that fits in a pocket wasn't one invention — it was a compounding sequence of separate breakthroughs across decades.
Two-digit year fields threatened to make systems worldwide misinterpret 2000 as 1900. Billions were spent fixing it in advance — which is exactly why, to many observers afterward, it looked like the whole thing had been overblown.
Internet companies with no profits, and sometimes no meaningful revenue, reached billion-dollar valuations through the late 1990s. The Nasdaq's collapse starting in 2000 erased trillions in value in under two years.
A college student's file-sharing tool lasted barely two years before a court order killed it — but it permanently broke the assumption that music had to be sold as a physical or per-track purchase.
A graduate student's experiment to measure the internet's size instead knocked out an estimated 10% of it in a single night. The Morris Worm produced the first felony conviction under US computer crime law.
US video game revenue collapsed by roughly 97% in under two years. It wasn't one bad game that caused it — it was market oversaturation, and the rebuilding afterward reshaped the industry's structure permanently.
ARPANET was one research network among several incompatible experiments in the 1970s. TCP/IP is the specific technical decision that let it absorb all the others into a single, unified internet.
A moth taped into a 1947 logbook is one of computing's most-repeated stories — and one of its most-garbled. Here's what the primary source, the logbook itself, actually shows.
IBM built the 5150 quickly, using off-the-shelf parts and an open architecture, expecting a modest niche product. Instead it became the template every PC-compatible computer still traces back to today.
In the mid-1990s, which browser you used determined how much of the web actually worked for you. Here's how a startup's early dominance collapsed against a bundled competitor in under four years.