Interesting history, from Wirth's perspective. A little strange though that he mentioned Java and C# as inheriting the legacy of Pascal, but left out Delphi, through which C# indirectly inherits from Pascal. FreePascal is also worth mentioning but perhaps not academically very interesting.
Other, more modern, languages that come to mind as inheriting from Pascal are Go and OCaml. OCaml more directly inherits from Modula-2's notion of separate interface and implementation, and gains similar parallel compilation speed benefits from that: https://dev.to/yawaramin/ocaml-interface-files-hero-or-menac...
If you look at the imperative and some other parts of OCaml, the Pascal heritage is clear, e.g. comments (* ... *), for loop, while loop, mutable assignment with x := y, etc.
Delphi and Free Pascal are a bit too far removed from Wirth's idea of simple languages which is probably why he didn't mention them. Delphi 1 (let alone the modern variants) added more stuff to Turbo Pascal than the entirety of Wirth's Pascal and it is more of a new language that has his Pascal as roots - after all programming languages affect how you think about the solutions of the problems you are trying to solve and the way you'd write a Delphi/Free Pascal program would be very different than the way you'd write a Wirth Pascal program.
Notice that he sees Oberon as the successor to Pascal and Oberon is an even simpler language than Pascal was.
My respect for Wirth only grows over time. He has this philosophy that strikes me as Bauhaus, a focus on futurism w/o complexity, clean lines and modern technology.
> A little strange though that he mentioned Java and C# as inheriting the legacy of Pascal...
Java? That boggles my mind. Pascal was about simplicity, and Java is... very much not in the spirit of Pascal in that regard. Or so it seems to me. I would have expected Wirth to shudder when he looked at Java.
Delphi is a transition point between Pascal and C#, so.
In any case, I bet he wasn't that found of Delphi. You will also not find much love from him on the Oberon descendants, namely Oberon-2, Active Oberon, Oberon.NET, Zonnon, Component Pascal.
Modula-2 isn't that much big influence on OCaml, its modular ideas were already present in CLU, ML and Mesa.
Also OCaml, is actually Objective Caml, back when I was in the university Caml Ligth was still their stable ML implementation, with Objective Caml being released a couple of years later.
I'd argue that Turbo Pascal was that transition point not Delphi. The last incarnation of Turbo Pascal was Borland Pascal and it had much that was in Delphi thoughg OOP was improved on in Delphi. Delphi was just Turbo Pascal for Windows.
Delphi had a ton of features that you'd find in C# but were absent from Borland Pascal 7, like:
1. The 'class' defined objects which were always allocated on the heap
2. Classes themselves being values with their own metaclass types
3. Classes having their own class procedures which could also be virtual (belonging to their metaclass)
4. Being able to instantiate an object instance dynamically using a class value (metaclass instance)
5. Classes having properties with getters and setters
6. A rich (for its time) RTTI with classes exposing properties to it and being able to alter at runtime (you can query a class for the exposed properties, their types, etc and there are utilities for setting them by their name as as string) - this was the basis for automatic form and component serialization ("streaming")
7. "Fat" pointers for method callbacks that could be used to associate event handlers
And a bunch of other stuff i certainly forget. Even at version 1 Delphi's Object Pascal was a much more powerful language than any Pascal dialect before it (the Object Pascal in BP7 was a very small improvement on the one introduced in TP5.5 which AFAIK was mostly the same as Apple's Object Pascal - though i think one difference is that in Apple's objects must be allocated on the heap like in Delphi whereas in TP5.5/6/7 they can be allocated either in the heap or live in the stack).
> Even at version 1 Delphi's Object Pascal was a much more powerful language than anything before
Only if we ignore that many of its new features were already present in Eiffel, including those 7.
Here is another two Eiffel features that we still don't have in modern languages as widespread as it should, design by contract, and non nullable types.
Language archeology is an interesting subject, unless you are comparing Delphi with TP.
By the way, I really hated that with Delphi I had to deal with class and legacy object to express parallel concepts, and that OWL was thrown out of the Window and I had to rewrite everything back into VCL.
Sorry i meant anything when it came to Pascal, not in general. Many of the features found in Delphi 1 can also be found in other languages like Smalltalk (in fact sometimes i wonder if the reason of the massive changes between BP7 and Delphi 1 is Anders learning Smalltalk in-between :-P).
About objects, i agree that the two systems are weird and IMO it is made even worse with the introduction of 'advanced records' in Free Pascal and recent Delphis which also act as objects-except-not-really.
IMO the 'object' types should have been extended with the new stuff and have 'class' just be syntax sugar for 'pointer to object' and 'record' be just a synonym for 'object' for backwards compatibility (so that everything is really an 'object' - it is "Object Pascal" after all :-P).
I do not know how Delphi handles this nowadays but in Free Pascal 'class' has the most advanced features but must always be heap allocated (meaning you can't embed them in other compound types or allocate them on the stack), 'object' has a lot of the 'class' and/or 'record' functionality but arbitrarily missing some (e.g. support for management operators, so you can't have RAII-like objects) and 'record' (after explicitly enabling support for advanced records) does have more functionality available (e.g. management operators) but does not support inheritance.
You can work around it (e.g. put all your data of an object inside an advanced record with management operators and then put that record inside the object so that you can write code that does any cleanup when the object is declared on the stack and goes out of scope) but it can be annoying - and maddening when you work on the compiler itself and notice that all these compound data structures are implemented internally the same way and the compiler explicitly disables support for some!
Except you are forgetting the little detail that Object Pascal was born out of a collaboration between Apple and Niklaus Wirth for their Lisa OS, later picked up for Mac OS, and Borland picked up from there, and kept adding C++ like features to it.
So Wirth was influential in Object Pascal's birth, but cared very little with what happened later on.
Well, different purposes and target audiences. Pascal was very much intended to be used in education, including as first programming language, while Delphi clearly targeted small-shop / individual professional software developers.
Honestly, the concept of a 'teaching' language (except maybe for primary school), is such an arrogant concept. It draws a distinction between master(teacher) who knows real languages and the student. It also wastes a lot of time for the student.
Other, more modern, languages that come to mind as inheriting from Pascal are Go and OCaml. OCaml more directly inherits from Modula-2's notion of separate interface and implementation, and gains similar parallel compilation speed benefits from that: https://dev.to/yawaramin/ocaml-interface-files-hero-or-menac...
If you look at the imperative and some other parts of OCaml, the Pascal heritage is clear, e.g. comments (* ... *), for loop, while loop, mutable assignment with x := y, etc.