Things That Turbo Pascal Is Smaller Than (2011)
Comparisons between the tiny Turbo Pascal compiler of the 1980s and today’s much larger tools and binaries spark a broader look at how software has grown in size and complexity as hardware limits vanished. Commenters weigh the tradeoffs between minimal, efficient systems and feature-rich modern utilities like GNU coreutils, arguing over whether current bloat is justified by portability, safety, and ergonomics or reflects a loss of engineering discipline. The thread also traces Pascal’s influence and decline, and speculates about future languages and OS designs optimized as much for AI-driven development and strong typing as for human programmers.
Future of programming with LLMs and OS design
- Thread speculates about building simple, efficient OSes from first principles, possibly using sandboxed engines for isolation instead of heavyweight stacks.
- With iteration cost near zero (fast compilers, LLMs), people wonder what new paradigms become viable: much richer type systems, invalid states being inexpressible, and toolchains that enforce entire classes of properties mechanically.
- Some envision declarative, BDD-like specs written by humans, with AIs generating implementations and more detailed specifications from them.
- Disagreement on whether we’ll get a new human-readable language balancing efficiency, AI-friendliness, and auditability, or end up with AIs emitting lower-level IL/bytecode “for themselves.”
- Counterpoint: many abstractions exist not only for human comprehension but to make long-term evolution and safe iteration easier.
Pascal’s legacy, evolution, and “death”
- Multiple explanations for Pascal’s decline: lack of a strong, evolving standard; incompatible dialects; being tied to proprietary environments; and missing the web and cross-platform waves.
- Transition path described: classic Pascal → Object Pascal/Delphi → J++/J# → C#/.NET, with lawsuits and runtime strategy shaping outcomes.
- Borland’s missteps (heavy client/server focus, proprietary middleware, weak Linux strategy) are seen as accelerating Object Pascal’s irrelevance despite its technical merits.
- Others argue Pascal lives on: Delphi is still sold; FreePascal/Lazarus and niche dialects (industrial control languages, legacy environments) persist; many modern languages borrow Pascal-like syntax or ideas.
Bloat, coreutils, and binary size debates
- Comparisons like “Turbo Pascal is smaller than coreutils touch” spark strong reactions.
- One side: simple tools should be tiny; repeated boilerplate (arg parsing, error handling) per binary is wasteful; a monolithic shell or shared libs could reduce overhead.
- Other side: modern
touchand friends do much more (rich date parsing, multiple timestamps, symlink semantics, localization, help/version output, security integration). Most size comes from these features, libc, and binary format overhead. - Contributors note massive growth in RAM and storage drastically changes the cost–benefit of hand-optimizing for size. Some see today’s code as less “bloated” relative to available resources than 80s software.
80s constraints, nostalgia, and complexity
- Several reminisce about developing substantial software within tens of kilobytes of RAM and on floppies or tape.
- This is used both to argue modern software is irresponsibly sluggish and bloated, and to argue that today’s complexity reflects vastly more ambitious systems.
- There is disagreement on whether we are actually “good at managing complexity” or merely tolerating it.
Tone and meta-discussion
- Some enjoy the article’s playful comparisons and irony; others find the size juxtapositions “senseless” or misleading.
- There is visible tension between those celebrating lean, low-level craftsmanship and those defending modern, feature-rich, resource-hungry software as appropriate to current constraints and needs.