Remix.run Logo
▲ gxd 2 hours ago

If you haven't lived through this era, try one day to download DOSBOX and run Turbo Pascal. You will be impressed with how fast it compiles on an old machine... Often faster than most modern projects on our modern computers.

▲cowlevel an hour ago | parent [-]

Probably no optimization though, right?

▲hnlmorg 8 minutes ago | parent | next [-]

Optimisations existed back then. But what Pascal did differently to a lot of modern languages was it only required a single-pass compiler and no macros.

On slow systems of the era, that vastly reduced the amount of work a compiler had to do to turn ASCII into machine code.

These days, compilers run macros, multiple passes of the source code. Often then building their own byte code or an interim machine representation, before turning that into machine code.

Those layers of abstraction aren’t without benefit. You get greater composability of code, greater portability, and so on and so forth. So they exist for a reason.

▲OskarS 24 minutes ago | parent | prev | next [-]

Optimizations is one reason for modern languages to compile slowly, but it's certainly not the only reason. Even at -O0, C++ and Rust are much slower to compile. The culprits are more likely much more advanced type-systems and monomorphization passes for generics. Slow compile times are much more inherent to the languages (compared to Turbo Pascal, certainly).

▲pjmlp 15 minutes ago | parent [-]

Not even, regarding type systems, see D or Ada compilers.

Or if you prefer to travel back to 1993, here is a developer experience using C++ as if it was Lisp Machine/Smalltalk environment with incremental compilation and hot code reloading.

"Lucid Energize Demo"

https://www.youtube.com/watch?v=pQQTScuApWk

With one of the very first ideas of a LSP could be like,

https://dreamsongs.com/Files/Energize.pdf

We got into a culture that accepted slow compilers is normal, it doesn't have to be.

▲pjmlp an hour ago | parent | prev | next [-]

There were optimizations already available.

Even if the basic ones that tend to be part of university compiler assignments, .e.g. peephole optimisations, constant propagation, inlining, bounds checking removal, redundant loads removal,....

See chapter 21 from Turbo Pascal 7 Language Guide, to use the last one for MS-DOS as example.

Similar build performance available in other languages, alongside a small set of optimisations.

It is a urban myth that we cannot have both, only because folks experience is tainted with C and C++ compilers.

If you want a good example of fast compilation times with optimisations enabled, check D reference compiler dmd, or to keep on the subject, FreePascal or Delphi 13.

▲muyuu an hour ago | parent | prev [-]

they are pretty minimal

the game back then was to use inline assembly for the critical bits, this really worked a treat for the meta of the 90s, with computers that were being asked for multimedia processing with slow CPUs, little RAM and typically no hardware acceleration

▲summa_tech 33 minutes ago | parent [-]

As a positive side of that tradeoff, inline assembly in Turbo Pascal was extremely pleasant to write. Because the optimizations were so light, it did not require complex constraint specifications on the values passed in and out, so you could just refer to local variables directly.