Table of Contents for Programming Languages: a survey

Pascal and Oberon

Because of its historical popularity, its importance as an exemplar of a style of computer language, its readability, Pascal gets its own chapter. Because it is a successor to Pascal, and because of its minimalism, that chapter is also about Oberon.

The designer, Wirth, is known for an emphasis on simplicity [1] [2] [3] [4] [5].

Oberon

Goals: "...The language Oberon was born out of the ambition to simplify language to the essentials....Tempted to design a version of Modula stripped down to essentials, we also wanted to identify those features that were indispensable to encompass object-orientation" (cite http://www.swissdelphicenter.ch/en/niklauswirth.php )

Pros:

• "The result turned out to be a considerably more powerful and more elegant language than its predecessors The defining report of Pascal required 30 pages, that of Modula grew to 45 pages, Oberon's could do with 16 [12]. Not surprisingly, implementations profited substantially from this achievement after 25 years of experience in language design, from a continuous evolution." (cite http://www.swissdelphicenter.ch/en/niklauswirth.php )
• "Modula and Oberon are much more mature and refined designs than Pascal. They form a family, and each descendant profited from experiences with its ancestors." (cite http://www.swissdelphicenter.ch/en/niklauswirth.php )
• Spec is only 17 pages

The minimal extensions present in Oberon for OOP are:

• type extensions (subclassing). Type extensions in Oberon only allow one to add additional fields to a subclass of a record type (i think) and to upcast and downcast to and from a base type and a subtype.
• type test (IS) operator

Oberon already has first-class functions, so 'methods' may be implemented manually by assigning function values to fields of a record.

People: Niklaus Wirth

Types: Basic types (boolean, char, integer, real, byte, set), arrays, records, pointers, procedures

Retrospectives:

• http://www.swissdelphicenter.ch/en/niklauswirth.php
• https://people.inf.ethz.ch/wirth/Miscellaneous/Styles.pdf
• Modula-2 and Oberon
• https://folk.ntnu.no/haugwarb/Programming/Oberon/oberon_vs_cpp.htm

Misc notes: "its successors Modula and Oberon are much more mature and refined designs than Pascal. They form a family, and each descendant profited from experiences with its ancestors....Why, then, did Pascal capture all the attention, and Modula and Oberon got so little? Again I quote Franz: "This was, of course, partially of Wirth's own making". He continues: "He refrained from ... names such as Pascal-2, Pascal+, Pascal 2000, but instead opted for Modula and Oberon". Again Franz is right. To my defense I can plead that Pascal-2 and Pascal+ had already been taken by others for their own extensions of Pascal, and that I felt that these names would have been misleading for languages that were, although similar, syntactically distinct from Pascal. I emphasized progress rather than continuity, evidently a poor marketing strategy. ... But of course the naming is by far not the whole story. For one thing, we were not sufficiently active -- today we would say aggressive -- in making our developments widely known." -- http://www.swissdelphicenter.ch/en/niklauswirth.php

As of this writing, the latest in Wirth's Pascal/Modula/Oberon family of languages. Latest version as of this writing: Oberon-7

Tutorials:

• https://rsdoiel.github.io/blog/2020/04/11/Mostly-Oberon.html
  • see also other Oberon stuff on that blog, https://rsdoiel.github.io/blog/
• passing arrays of arbitrary size to procedures (Conformant Arrays; the array sizes are additional parameters passed to procedures): https://lobste.rs/s/flcjqg/wirth_language_evolution#c_rt9vr2

Links:

• http://www.inf.ethz.ch/personal/wirth/Articles/Oberon.html
• www.inf.ethz.ch/personal/wirth/Oberon/Oberon07.Report.pdf ('Revised Oberon')
  • [Differences between Revised Oberon and Oberon http://people.inf.ethz.ch/wirth/Oberon/Oberon07.pdf]
• short remark on the status of various Wirth language
• short remark on Oberon and its competitors back in the day
• short remark on Juice, a VM for running Oberon applets in the web browser
• announcement of Juice
• https://miasap.se/obnc/
• https://cseweb.ucsd.edu/~wgg/CSE131B/oberon2.htm
• https://en.wikipedia.org/wiki/Comparison_of_Pascal_and_C
• http://www.edm2.com/index.php/Oberon
• http://oberon07.com
• https://oberon.org/en

Oberon the language is part of an entire computer system, Project Oberon:

• http://www.projectoberon.com/
• https://en.wikipedia.org/wiki/Oberon_%28operating_system%29
• video showing the extensible nature of the system and its integration with Oberon and an IDE
• comparison between Project Oberon and Plan 9
• Project Oberon is relatively easy to port due its focus on simplicity [6]
• http://www.ethoberon.ethz.ch/WirthPubl/ProjectOberon.pdf
• http://worrydream.com/refs//Wirth%20-%20Project%20Oberon.pdf
• ftp://ftp.ethoberon.ethz.ch/Oberon/
• day 12 of http://www.qemu-advent-calendar.org/
• https://github.com/pdewacht/oberon-risc-emu
• https://github.com/rochus-keller/oberonsystem
• https://lobste.rs/s/1i3dwy/oberon#c_1wc5u7

Oberon-07 is also used in the Astrobe system for programming Cortex M boards [7] [8].

Opinions:

• "The lack of enumerations is a pain (indeed, in the extended Oberon dialect we use, we added them back)...Professor Wirth said he couldn't see a good way to do it, and that's why he removed enumerated types from the language...Wirth was a purist; he decided it was better to lose the type safety of enums for extensibility and orthogonality. We write a lot of code that benefits from type checking of enums, where co-incidental value collisions would otherwise introduce subtle errors. In short, since we control both the entire Oberon code base, and the compiler, we do without type extension on enums, in order to prevent a class of extremely irritating program errors." [9]
• "> a loop construct you can't exit The looping issue is because modelling it - that is, giving it clear and simple formal semantics - was not trivial. > single-return procedures/functions The single-point of exit stuff is also there for the same reason. I'd agree that it's possibly not a good choice given the alternatives if you are doing non-verified code, but he had his reasons." [10]
• Less is more. Why Oberon beats mainstream in complex applications
• https://news.ycombinator.com/item?id=11628874
• https://news.ycombinator.com/item?id=22205755
• "I find all the Wirth languages and their derivates to have a sort of sedative effect on me. The only one I personally tried to use at any point was actually Eiffel, which doesn’t suffer from the same capitalization regime but still requires many lengthy keywords to get anything done...These are important systems to know about and to study, but the modern conveniences are pretty convenient." -- [11]
• "I found myself unable to (voluntarily) code in Oberon. Mostly because the syntax just irked me. I know it sounds petty, but all the little things just bugged me. Capitalization rules. Having to write out BEGIN and END all the ing time. Typing in general, and the syntax. Having to write out "POINTER TO INTEGER", for some reason, while "VAR" is abbreviated. No metaprogramming." -- [12]

Oberon implementations and variants

• https://people.inf.ethz.ch/wirth/Oberon/Oberon.ARM.Compiler.pdf
• https://news.ycombinator.com/item?id=24479075

" The linage is more or less as follows:

Oberon => Oberon-2 => Component Pascal

                   => Active Oberon

                   => Oberon.NET => Zonnon

       => Oberon-07 (multiple iterations until 2016)

From features think Go (Oberon), D/C# (Active Oberon).

Active Oberon provides features for manual memory management (untraced references), async/await (active objects hence the name), lightweight generics, interfaces, exceptions. " -- [13]

• https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/147091/eth-26082-02.pdf
• https://concurrency.ch/Content/publications/Blaeser_Component_Operating_System_PLOS_2007.pdf
• "Oberon System 3 with its gadgets framework or the current AOS (still used as teaching tool at ETHZ) also have interesting ideas, and better support for systems programming." [14] (that comment goes on to provide some useful links; other comments in that thread also provide useful links)
• OberonScript: a safe scripting language and runtime for web apps (2007)
  • https://news.ycombinator.com/item?id=24909114
• https://github.com/tschaer/Oberon-0
  • "Oberon-0 refers to the subset language since the 1996 edition of Compiler Construction. It was extended in the 2011 edition"
• PL/0 (succeeded by Oberon-0): http://pascal.hansotten.com/niklaus-wirth/pl0/
• http://spivey.oriel.ox.ac.uk/corner/Oxford_Oberon-2_compiler
  • "Oxford Oberon-2 is the smallest Oberon compiler around. Building from source is a little convoluted, but works on Solaris, Linux, Windows." [15]
• Oberon+, also IDE and transpiler to C++ (implementation in LuaJIT? and Mono?)
  • https://lobste.rs/s/nr80x6/ide_for_oberon_programming_language
  • https://github.com/rochus-keller/Oberon/releases/tag/FFI_MVP
  • "The quality-of-life improvements from Oberon-07 to Oberon+ are absolutely remarkable." -- [16]
  • https://oberon-lang.github.io/2021/07/15/motivation-for-a-new-oberon-version.html
  • https://oberon-lang.github.io/2021/07/16/comparing-oberon+-with-oberon-2-and-07.html
  • https://lobste.rs/s/oz6qwj/oberon_exception_handling_other_new
• in reply to another comment that perhaps the heavy syntax in Rust is needed for systems languages: "System languages on the Algol/Wirth branch prove otherwise. They can be ergonomic high level, while providing the language features to go low level when needed. " -- pjmlp

Pascal

Goals: "The general idea dominating the design of Pascal was to provide a language appealing to systematic thinking, mirroring conventional mathematical notation, satisfying the needs of practical programming, and encouraging a structured approach" (cite http://www.swissdelphicenter.ch/en/niklauswirth.php)

Criteria:

• "The rules governing the language should be intuitive and simple, and freely combinable. For example, if x+y stands for an expression, x+y should be usable as a sub expression, in assignments, as procedure parameter, or as index." (cite http://www.swissdelphicenter.ch/en/niklauswirth.php)
• adherence to mathematical notational convention (cite http://www.swissdelphicenter.ch/en/niklauswirth.php)

Historically important innovations:

• Structured Programming (cite http://www.swissdelphicenter.ch/en/niklauswirth.php)
• recursively defined data types (cite http://www.swissdelphicenter.ch/en/niklauswirth.php)
• typed pointers (cite http://www.swissdelphicenter.ch/en/niklauswirth.php)
  • see http://borlpasc.narod.ru/english/faqs/pointers.htm for examples of pointer use in Pascal

Attributes:

• Structured Programming
• statically typed

Cons:

• the size of arrays must be constant and statically given (even Wirth thought this was a mistake (cite http://www.swissdelphicenter.ch/en/niklauswirth.php) )
• lack of closing symbol for nestable constructs leads to ambiguity (cite http://www.swissdelphicenter.ch/en/niklauswirth.php) )
• lack of lambdas (note: "Anonymous methods in Delphi are not lambdas. You could compare them with anonymous inner classes in Java. Lambdas are much more difficult to implement in compiler because it needs to have better type inference." -- [17])

Features:

• "many predefined types, but you can also define your own types. For this task Pascal offers you Enumerations, Sets, Arrays, Records and Classes. It is even possible to create sub-ranges of types or to rename existing ones. Pascal is very strict, so the programmer has to differ between subroutines that return values, in Pascal called functions, and subroutines that does not return something, called procedures. Functions and procedures can also be passed to variables or other functions thanks to procedural types. It is possible to overload operators for specific types. With this feature, you have the power to define, let’s say, the result of the addition operation of two or more instances of the same class." -- [18]
• "Object Pascal provides you all the tools you need for modern Object Oriented Programming (OOP). Although the language is not fully object oriented in that sense like Smalltalk or Ruby, where even the most basic data types are instances of classes, you will find all the concepts that define OOP in the Object Pascal language: encapsulation, inheritance and polymorphism. You can define complex types with the help of classes. A class can define methods, which are procedures or functions, and data, called fields in Object Pascal. It is also possible to define the way of how data is accessed by a feature called properties. Properties define which getter- or setter-methods are used to read or write a field. Classes can also inherit other classes, so you can build a hierarchical tree of the data and behaviour you have modelled within your application. The base class of all classes is TObject. Interfaces are also a part of Object Pascal as well as Exceptions. You can use the build-in standard exceptions, but you have of course the freedom to define your own exceptions. Class helpers are comparable with Extension Methods in C# or Smalltalks or PHPs traits (although not exactly the same) and let you add methods to existing classes without the need to derive a new class. Further features are Generics to define classes that apply to a wide range of types, as well as many predefined classes for advanced data structures like lists, dictionaries, streams and many many more. For an in-depth overview of all the modern OOP features, I recommend an excellent article written by Michalis Kamburelis, which is called Modern Object Pascal Introduction for Programmers." -- [19]
• "What is called packages or modules in other languages like Java or JavaScript?, is called an unit in Pascal. An unit can contain all the code that has a common relation. You can define which data, types or functions of this unit are visible to other parts of your program - this is called the interface. And you can also define which parts are not visible to others and thus are private to the unit - this is called the implementation part. You can even define code, which gets executed once when the unit is included into your program, the initialization part of the unit, and code that gets executed when the program terminates, the finalization part. Units have another advantage: they encapsulate the code in its own namespace. So you can have for example two or even more procedures with the same name in two different units without a name-collision." -- [20]

Influences: Algol, Fortran, Cobol ( http://www.swissdelphicenter.ch/en/niklauswirth.php )

People: Niklaus Wirth

Retrospectives:

• http://www.swissdelphicenter.ch/en/niklauswirth.php
• N. Wirth. Recollections about the Development of Pascal. In T.J. Bergin, R.G. Gibson. History of Programming Languages II, Addison-Wesley 1996, ISBN 0-201-89502-1 (alternate, search).

Opinions:

• Why Pascal is Not My Favorite Programming Language
  • "Does FreePascal? address any of these issues?" "It addresses very literally all of them...different implementations...did ultimately all address them the same way. In the end, Delphi and Turbo Pascal ruled everything, and the main differences between the two in terms of the language are quite limited to the object system. They both extend arrays the same way, they both handle strings the same way, they both do the same extensions to the module system, etc. And this is the same system that ultimately got used in things like GNU Pascal and Think Pascal and FreePascal?. Yeah, there are some differences left, but I think they’re not any more pronounced than e.g. GNU CC v. MrCpp? v. VC++ v. Borland C++, and we got through that just fine in the end" -- [21]
• http://www.at.freepascal.org/advantage.html
• "> Operating systems have to deal with some very unusual objects and events: interrupts; memory maps; apparent locations in memory that really represent devices, hardware traps and faults; and I/O controllers. It is unlikely that even a low-level model can adequately support all of these notions or new ones that come along in the future. So a key idea in C is that the language model be flexible; with escape hatches to allow the programmer to do the right thing, even if the language designer didn't think of it first. This. This is the difference between C and Pascal. This is why C won and Pascal lost - because Pascal prohibited everything but what Wirth thought should be allowed, and Wirth had far too limited a vision of what people might need to do." -- https://news.ycombinator.com/item?id=32784959

Pascal Variants

Pascal-S

http://standardpascal.org/pascals.html

https://web.archive.org/web/20200803113748/http://standardpascal.org/pascals.html

https://web.archive.org/web/20200803113748/http://standardpascal.org/Wirth-PascalS.pdf "Original article introducing Pascal-S by Niklaus Wirth. Contains the complete, original source of the CDC 6000 version of Pascal-S."

https://web.archive.org/web/20200803113748/http://standardpascal.org/pascals.ins Pascal-S instruction set reference] "Document gives an explanation and list of the instruction set used in the interpretation of Pascal-S."

pascals.pas "Pascal subset compiler/interpreter, modified for ISO 7185 use. This file consists of the Pascal-S from Wirths' original article, with minor corrections to run on ISO 7185 Pascal (Pascal-S proceeded the ISO 7185 by at about 10 years). This is the file you want if you are going to compile and run Pascal-S! Don't worry, the changes made are well documented inside the source. You are very unlikely to get the original version to run without the modifications made in this version! "

" A brief overview of what is subsetted in Pascal-S:

1. Curly bracket mode comments are not supported. They are recognized and dealt with as an error, however (see "insymbol").

2. Subrange types are not implemented (type a = 1..10).

3. Scalar types are not implemented (type a = (one, two, three).

4. Sets are not implemented.

5. Files other than the "input" or "output" files are not implemented.

6. Dynamic variables (pointers) are not implemented.

7. Variant records are not implemented.

8. Gotos are not implemented.

9. The predefined functions succ and pred only function on type char.

10. Packing, the "packed" keyword, and the "pack" and "unpack" procedures, are not implemented.

11. "get", "put", and file buffer variable handling are not implemented.

12. Strings are unimplemented, except for literals as parameters to write/writeln, and those cannot have field lengths applied to them.

13. The "forward" specifier, and forwarded procedures and functions, are not implemented. " -- pascals.pas

Tiny Pascal

http://www.trs-80.org/tiny-pascal/

" Tiny Pascal was a subset of the programming language Pascal. It contained most of the features of Pascal but was small enough to run well on a cassette-based TRS‑80. "

" The first version of Tiny Pascal appeared in a three-part series of articles in BYTE titled “A ‘Tiny’ Pascal Compiler.” They were written by Kin-Man Chung and Herbert Yuen and appeared in the September, October, and November 1978 issues. Those articles were also later published in The BYTE Book of Pascal that was published in 1980.

This version of Tiny Pascal was written in North Star BASIC. According to the articles, it implemented most of Pascal with some limitations:

    the GOTO statement was missing
    only integers and one-dimensional integer arrays were allowed for variable types
    there was no “structured data type, pointer type, user defined type, and file type”
    parameters were passed by value only

On the other hand, Tiny Pascal did add some extensions to standard Pascal, such as else clauses in case statements. "

Dynamic Pascal

Demo for LibJIT? code generator.

https://www.gnu.org/software/libjit/doc/libjit_3.html#Tutorials

Free Pascal

• "What I look for in a language (in no particular order):
• Yes, fast compilation.
• Generics, templates or a decent macro system
• Defer, finally or scope based resource allocation
• Some way of handling coroutines (async/await or channels)
• Supports Linux AIX/x64, Win64, ARMv7/8, Darwin
• Tooling for OSX, Android, Linux, Windows
• Supports clojures, blocks or at least inline functions
• Supports ranges, lazy iterations, generators or at least yield FPC actually comes close, except it doesn't have clojures coroutines or generics. " nurettin
  • "It's actually disappointing to see so many people looking for a cleaner C++ with faster compilation times, or a Go with generics and manual memory management, yet completely overlooking FPC." TurboHaskal
  • "It does have generics." pjmlp

Free Pascal tutorials:

• https://wiki.freepascal.org/Basic_Pascal_Tutorial

Object Pascal and Delphi

Delphi was a much loved IDE https://en.wikipedia.org/wiki/Delphi_(software)

"Delphi was good but a compiled language with manual memory management. It was very easy to write code that crashed, which would nuke the user's state leaving little evidence of what happened. It also had a lot of legacy quirks like not allowing circular dependencies between compilation units, networking support was poor (iirc TCP, HTTP and other classes required you to buy a third party library). The VCL was a wrapper around Win32, which had some great strengths but also really frustrating weaknesses e.g. extremely poor/non-existent layout management, poor support for typography and no support for styling or branding. There were many positive aspects of course." -- Mike Hearn

(the whole comment is interesting too:

"

The language and libraries situation on Windows wasn't great during this time.

Delphi was good but a compiled language with manual memory management. It was very easy to write code that crashed, which would nuke the user's state leaving little evidence of what happened. It also had a lot of legacy quirks like not allowing circular dependencies between compilation units, networking support was poor (iirc TCP, HTTP and other classes required you to buy a third party library). The VCL was a wrapper around Win32, which had some great strengths but also really frustrating weaknesses e.g. extremely poor/non-existent layout management, poor support for typography and no support for styling or branding. There were many positive aspects of course.

Microsoft gave you VB or C++, both with Win32 again. The C++ developer experience was horrid. VB was at least a scripting language with garbage collection, but, it was also constrained by the fact that B stood for "Beginners" so Microsoft were very reluctant to fix any of its legacy or add more powerful features.

Compared to that situation, scripting languages and especially Perl had some massive advantages:

1. Ran on UNIX/Big Iron which is where all the best hardware and databases could be found. Lots of devs liked UNIX because it was CLI and developer oriented.

2. Unashamedly designed for experts with tons of powerful features, quality of life stuff like integrated regex, garbage collection, proper stack traces, error logs you could view via telnet within seconds etc.

2. CPAN provided an ever growing repository of open source libraries, instantly accessible, for free! On Windows there were very few libraries, they were mostly quite expensive and closed source, no easy way to discover them (pre-Google) and only C++/Delphi devs could write them. VB was sort of a consumer-only language. Open source culture started with RMS at the MIT AI lab and so was very UNIX centric for a long time. Arguably it still is.

Really, it's hard to overstate how revolutionary proper garbage collection + CPAN was. GC is a force multiplier and CPAN is the granddaddy of all the open source library repositories we take for granted today. Imagine how unproductive you'd be without them.

The big downside was that Perl had no UI libraries and didn't really run on Windows. So how do you use it to write apps for normal people? Then Netscape started adding interactivity features to the web and it was all totally text based. Text was Perl's forte! Add the <form> tag, CGI, HTTP and now you're cooking with gas. Bye bye hateful 0xC00005 Access Violation errors and useless bug reports like "I clicked a button and the app disappeared".

The web was a huge step back for users, who went from having pretty sophisticated GUIs with fast table views, menus, shortcut keys, context menus, Office integration, working copy/paste, instant UI response etc to ... well, the web. But often users will suffer through that if it makes their devs more productive because all they really care about are features and competitive advantage. The web was crude but it let people escape the Windows ecosystem to one with open source + GC + pro languages + big iron UNIX. " -- Mike Hearn )

PL/0

https://en.wikipedia.org/wiki/PL/0

"a Pascal-like language, also developed by Niklaus Wirth, that was developed specifically for teaching compiler construction. " [22]

Implementations

• https://github.com/lboasso/oberonc
• https://schierlm.github.io/OberonEmulator/
  • https://news.ycombinator.com/item?id=27760396
• https://en.wikibooks.org/wiki/Oberon/A2

Modula-2

• https://en.wikipedia.org/wiki/Modula-2
• Modular2 -- A Solution to Pascal's Problems
• https://retrocomputing.stackexchange.com/questions/21722/what-happened-to-modula-2
• "Modula-2 was followed by Modula-3, and later by the Oberon series of languages. " -- [23]

Discussions of the advantages of various recent Pascal-lineage languages

• why Oberon+: https://oberon-lang.github.io/2021/07/15/motivation-for-a-new-oberon-version.html

" Oberon had several dialects as well, e.g. Active Oberon (experimenting with concurrency), Object Oberon (OO), and Zonnon (transporting the "spirit" of Oberon onto Microsoft's .NET platform). However, these are mostly dialects, not true successors. The mainline successor is Oberon-2, a superset of Oberon, incorporating OO features based on experiences with Object Oberon. The successor to Oberon-2 (despite its name) is Component Pascal. Component Pascal is still actively maintained by Wirth's group at ETHZ. " -- https://retrocomputing.stackexchange.com/questions/21722/what-happened-to-modula-2

• https://wiki.alopex.li/WirthEvolution

Pascal Links

• https://www.teamten.com/lawrence/projects/turbo_pascal_compiler/
• http://turbopascal.org/
• https://dubst3pp4.github.io/post/2017-10-03-why-i-use-object-pascal/