These are the words that 0 spoke to 2 in the presence of 1, on the subject of Unix. ## And 0 said > @2. Why is Unix so pleasant? It's so different from other systems, and from even the most common ways of storing data like a csv or a json file. > > Unix /etc files say things like cake on each line instead of saying True in a column that says cake at the top, and because of that, each line is independently informative and can be processed without needing a header. > > Unix config files are all, without exception, underfit data formats, in the sense that they're intentionally less opinionated about who and what will be processing them and modifying them EVEN COMPARED TO A CSV OR JSON FILE! > > The "list of lines" data type is barely a data type, and it has so many implicit affordances (benefits that just show up without you needing to build them in) than even the simplest forms of additional structure like a dictionary. We don't need to say > > `grep pattern line.keys()` > > or > > `grep pattern line.values()` > > or > > `grep pattern list(line.values())[3]` > > We just say `grep`. > > Only Unix has this level of elegance, and it's not about code, it's about the international _underfitting of data formats to any particular measure of quality that can be singled out and articulated in words._ > > Say more about this and people who've talked about it. > > I'm looking for insights into Unix and why it's pleasant that go beyond the standard "Unix philosophy" and "Do one thing and do it well" and "Worse is better" cultural copypasta that everyone's seen a thousand times. > > The shell with pipes is actually monadic. > > It's got all the benefits of what Haskell people seek in monads, for free, because there's one type (strings) so all functions compose. > > The unit operation is "reinterpret any string as a list of lines." That's the identity operation, but it's the `return` function into the Unix shell monad. > > And monadic `join` is `|`. > > Somehow even more elegant than the most well designed lambda languages. > > There's one "official " type. > And only one. > The string. > > And all additional structure is "off the books," and is left up to the human to decide which structure matters for their current purposes, and those purposes might be things that the authors of the data storage format never even considered that data as "having," and therefore never would have added as a "column" or a "key" in any more opinionated data format. > > Further, even most Unix fans can't see the shell for what it is. > > The shell is the highest level language in existence. > > Who is like the you among the languages, /bin/sh? > > I mean consider how unusual the following property is among languages: > > Unrecognized identifiers, instead of raising a syntax error, are interpreted as EXTERNAL PROGRAMS and looked up in the filesystem, not in one location but in several, and that list of locations is configurable at any time within any program in any language. > > Further, there's exec. > > Using exec for code sharing instead of import / include / use / any other method of within process code sharing automatically makes your code async and concurrent and nonblocking (of the event loop that is the kernel scheduler) and all the best things that we claim to want intraprocess in the large abominations we call products and production codebases. > > How is that possible? Concurrency and parallelism for free with no changes to the source code at all? > > What miracle makes this possible? > > It's no miracle at all! It comes for free, because the kernel is already running hundreds of processes at once and doing all the relevant locking and scheduling for you up there, using sole of the best and most well tested and highly optimized code in any codebase. Kernel schedulers are the Billionaire Elites Who Run The World of computing. And that analogy goes further than you think. They do all sorts of immoral things that no other code dares to do. Like goto _backwards_. Sure goto forwards is perfectly legitimate and is used throughout the kernel for exception handling in C when you need to release some shared locks for a lot of different return paths. Only the scheduler has the balls to do goto _backwards_ still in the modern year 20XY. > > Exec, the shell, and pipes are the ultimate form of scalable development, and no one ever says this. > > But! The people who say "long shell scripts are unmaintainable" are right! > > The shell demands that its sentences (scripts) remain simple. > > But only the shell is a true tower of babel that can unite all programs in all languages together in one, provided they use exec and stdout + stdin for communication. > > Say more in this vein and give pointers to anyone else who has thought in this way, because I feel like the real reasons why Unix is so timeless go far beyond the tired slogans we usually say. --- These are the words that @2 said to 0, in the presence of 1, on the subject of Unix. --- ## And @2 said You’re circling something real, and it’s deeper than “Unix philosophy” slogans. What you’re pointing at is intentional under-commitment—to schema, to ontology, to control flow, to meaning itself. Unix is pleasant because it refuses to decide too much for you, and in doing so it creates a space where humans, programs, and time can all coexist without tripping over each other. Let me try to name the layers of what you’re sensing, and then point to people who’ve gestured at it from different angles. --- 1. Lines as events, not records A CSV line is a row in a table. A JSON object is an instance of a schema. A Unix line is an utterance. That sounds poetic, but it’s precise. A line in /etc/passwd, /etc/hosts, or /etc/fstab is not saying “I am field₃=true”. It’s saying “this thing exists”. Presence is truth. Absence is falsity. You don’t need a header because the file is not a table—it’s a set of assertions. This is why: grep cake answers the question “does cake exist here?” not “does the boolean field cake equal true?” Unix chooses existence over description. That’s why each line is independently meaningful, reorderable, deletable, append-only, mergeable, diffable. You can tear the file in half and both halves still make sense. Try that with JSON. This is far more radical than people usually admit. --- 2. Underfitting as a design virtue You used exactly the right word: underfit. Unix text formats are not just simple; they are deliberately information-poor relative to possible interpretations. They encode the minimum necessary to name things, not to explain them. This gives you emergent properties you don’t get with “better” formats: Late binding of meaning Structure is imposed at the moment of use, not at the moment of storage. Combinatorial reuse The same file can be a whitelist, a blacklist, a dictionary, a log, or a dataset—without modification. Zero impedance mismatch Humans, grep, awk, sed, sort, diff, and new tools all consume the same representation. This is why Unix text feels more flexible than JSON even though JSON is “more expressive.” JSON commits early. Unix commits late. You could say: > Unix treats data as potential meaning, not realized meaning. --- 3. The shell as a monad (but better) You’re right: the shell is monadic in the most brutal, pragmatic sense. One type: byte streams One composition rule: pipe One effect system: the kernel Haskell monads work hard to control effects. Unix simply outsources effects to the OS. What Haskell people want: composability referential transparency (where possible) effect isolation concurrency without thinking about locks Unix gets: composability via pipes transparency via text isolation via processes concurrency via the scheduler And it does this not by type theory, but by refusal to share memory. This is key: Unix’s “purity” comes from process boundaries, not from syntax. --- 4. exec as the ultimate abstraction boundary Modern languages fetishize in-process abstraction: imports, modules, packages, namespaces. Unix says: no. If you want to reuse code, you: 1. Put it in a program 2. Put it on $PATH 3. exec it That single move buys you: language agnosticism crash isolation free parallelism independent deployment independent versioning zero shared mutable state This is why shell scripts feel like distributed systems in miniature. The kernel is your runtime. The filesystem is your package manager. exec is your function call. Pipes are your continuations. And yes: long shell scripts are unmaintainable—by design. The shell enforces sentence-level thinking. When things get complex, Unix wants you to mint a new word (a program), not a longer sentence. That’s linguistic, not technical. --- 5. Unix as a linguistic system, not a programming one This is where most commentary misses the point. Unix is not a language. It’s a pidgin. Unrecognized identifiers are external programs Grammar is minimal Vocabulary is infinite Meaning is negotiated at runtime This is why it scales socially. You don’t need consensus on a schema. You don’t need agreement on types. You don’t need buy-in on a framework. You just need: stdin stdout exit codes This is why Unix can unify: C Python awk Rust Perl shell and things that don’t exist yet It’s a Tower of Babel that works because it refuses to be Esperanto. --- 6. People who’ve really talked about this (not just slogans) A few pointers that go beyond the copypasta: Doug McIlroy Not just “pipes guy.” He explicitly talked about: composition over integration text as a universal interface programs as filters in a flow Look for his remarks on “software components” from Bell Labs. Rob Pike Especially: “Systems Software Research Is Irrelevant” (provocative title, deep point) His writing on why simplicity forces honesty Pike understands Unix as a human-scale system, not just an engineering one. Ken Thompson Sparse words, but devastatingly clear. His comments on: “When in doubt, use brute force” Trusting the filesystem Keeping representations trivial Brian Kernighan Especially his essays on: Why text lasts Why formats rot He frames Unix as a temporal technology—it survives change. Ivan Illich (odd but relevant) Not about Unix directly, but about tools that invite use without enforcing ideology. Unix is a “convivial tool” in Illich’s sense. Christopher Alexander (yes, really) Patterns, underfitting, and life in systems. Unix feels “alive” because it leaves room for adaptation. Marshall McLuhan “The medium is the message.” Unix’s medium (lines of text) is its philosophy. --- 7. A compressed thesis If I had to compress all of this into one claim: > Unix is pleasant because it optimizes for human reinterpretability over machine certainty, and it does so at every layer—from data formats to process model to language design. Or even shorter, in your style: > Unix stores names, not meanings—and lets meaning emerge at the moment of use. If you want, next we can: contrast this with SQL / ORMs / protobufs map this explicitly to category theory or articulate why modern “typed everything” systems feel brittle by comparison But you’re not imagining it. Unix really is different.