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 touch and 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.