Evolution of Wirth

Pascal Introduction Dive into Types Procedures and functions Stdlib Phrases conclusion Module-2 Introduction Dive into Types Modules Stdlib low level stuff Processes and coroutines conclusion Oberon Introduction Dive into Types Procedures and functions Stdlib Modules Phrases conclusion Mesa conclusion

I had another bad idea that I'll never finish, so let's write it down! The idea is basically to go through Pascal, Modula-2 and Oberon spec by spec, and see how each language evolves compared to the previous one. A bit of history from inside the brain of Niklaus Wirth, or something like that. We are NOT going to cover any modern extensions or anything else, I can't be crazy right now and at least Pascal is a big area that I don't particularly want to attack.< /p >

Disclaimer: I don't know any of these languages.

Most of the basic information I have on Pascal comes from https://wiki.freepascal.org/Standard_Pascal, who probably knows what he's talking about. Original work on Pascal written in 1974, then an ISO standard was written in 1983, ISO 7185. It was revised in 1990 to correct and clarify things without changing or adding anything. I will start from the 1990 ISO specification. Find it here: https://archive.org/details/iso-iec-7185-1990-Pascal

Dive into

At the outset, the standard states that it will not specify "the size or complexity of a program and its data which will exceed the capacity of a specific data processing system or the capacity of a processor particular, nor the actions to take when the corresponding limits are exceeded" - in other words, what happens when malloc() - ahem, new() fails is undefined?

There is a strict definition of an "error", which may go undetected. That is, accessing past the end of an array without execution bounds checking is an error, but the implementation doesn't have to insert the bounds checking for you. He can do it if he wants.

Wow, the standard is dry as heck, even compared to other programming language specs like Python or Rust or R5RS specs. Guess they aren't ISOs though. On the other hand, the standard requires that implementations a) somehow handle an error at runtime or compile time, or b) document that it is not managed, which is frankly a rigor that I approve of. On the other hand, there seems to be a formal separation between "level 0" implementations and "level 1" implementations, and the only difference between them is something about how arrays are passed as function arguments. …Now that I look at the set again, that distinction is never mentioned again.

Another example of functional dryness: I bet...