A History of C Compilers – Part 1: Performance, Portability and Freedom

Original Article ↗ Hacker News Discussion ↗

Retro C, CP/M, and Small Compilers

  • Several comments reminisce about CP/M-era tools: Aztec C, Hi-Tech C, BDS C, Whitesmiths, and Turbo Pascal 3.x, emphasizing how small and fast they were compared with modern toolchains.
  • People describe writing or using Z80/CP‑M emulators and compilers, debugging missing BDOS/syscalls, and cross‑compiling from modern machines (e.g., with SDCC).
  • There is interest in niche languages and compilers targeting CP/M and DOS (e.g., T3X, Dice, vbcc), often praised for compactness and decent code generation.
  • Some report rough edges with old toolchains (e.g., include handling, odd errors) and highlight just how manual and brittle builds could be.

Commercial vs Free Unix Compilers and GCC’s Role

  • Multiple posts argue that commercial C compilers (Sun cc, IBM xlc, others) historically produced faster code and had advanced features (e.g., profile‑guided optimization) compared to GCC.
  • Cost and licensing hurdles for vendor compilers are cited as a major driver of GCC adoption, especially after Unix vendors unbundled their toolchains.
  • There is disagreement on GCC reliability in the late 1990s: some recall it as the stable default; others report serious bugs around 2.8/2.95 and point to the egcs fork as a response.
  • GCC’s portability and zero price are consistently credited for its eventual dominance.

C++ and Other Influential Compilers

  • The thread debates which was the “first native C++ compiler”: an early GNU C++ (g++) beta in 1987 versus a commercial Zortech C++ release in 1988.
  • One side notes g++ used the GCC backend and was available earlier on the net; the other stresses that Zortech was the first shrink‑wrapped, widely impactful native C++ compiler on PCs.
  • Datalight C is highlighted for pioneering data‑flow analysis optimizations that aggressively removed dead code, influencing later compilers.
  • Other notable historical compilers mentioned include Metaware HighC, Watcom C/C++, UCSD Pascal, Free University Compiler Kit, and Tiny C.

Microsoft C and Lattice C

  • There is discussion over how much early Microsoft C derived from Lattice C.
  • Ads and historical material are cited indicating that Microsoft C 1.0 and 2.0 were essentially rebranded Lattice C, with Microsoft moving to its own implementation by later versions.
  • Exact version boundaries and timelines remain somewhat unclear in the thread.

Licensing, “Freedom”, and Economics

  • Several comments discuss how “freedom” in the GNU sense interacted with practical concerns: many users initially cared more about cost and availability than philosophy.
  • There is a long subthread contrasting copyleft (GPL/AGPL) and permissive licenses (BSD/MIT), arguing over whether most people value software freedom or primarily financial freedom.
  • Some argue permissive licenses still deliver the core freedoms (study, modify, redistribute), while others see them as enabling “wealth transfer” to companies.
  • Opinions diverge on the long‑term sustainability of GPL projects versus permissively licensed software and on how much corporate capture will shape major projects.

Language Longevity: C, Rust, and Predecessors

  • Participants note that in 1983 predictions of C’s permanence seemed premature, yet C remains near the top of language popularity decades later, with many C‑syntax descendants widely used.
  • One line of argument holds that Rust’s safety guarantees and maturing ecosystem are pushing organizations away from C, especially for security‑sensitive, internet‑facing code.
  • A skeptical line compares Rust to PL/I: powerful but complex, slow to compile, and prone to intricate feature interactions; predicts an eventual, simpler “C‑like with safety” successor.
  • A counterpoint stresses that many of Rust’s complexities are required for static memory‑safety guarantees and that even if a theoretically better design appears, adoption inertia will be strong.
  • There is agreement that safety often comes from forbidding dangerous capabilities, but disagreement on how minimal a “safe C” can be in practice.