Table of Contents for Programming Languages: a survey

Of historical interest

I place a language in the 'of historical interest' section if it seems to me that the language introduced important ideas or was the basis for an important language, but the language is no longer very popular (for writing new programs; there are plenty of old languages with lots of legacy code), and if it seems to me that either the language has been 'succeeded' by another, or that most of the interesting innovations in the language have been incorporated into many others.

If language still seems to me to be the best way to learn about some idea, then i did not confine it to the 'of historical interest' section, even if it is unpopular.

1990s-2000s-era CTM languages

BitC

A CTM language.

Retrospectives:

Retrospective Thoughts on BitC by Jonathan S. Shapiro
- announces that development of BitC? has stopped, and explains why: (1) lack of funding, (2) Shapiro believes that type classes won't work for a CTM language without first solving the 'instance coherence' problem, by which he seems to mean, roughly, the problem with how type class instances in Haskell aren't namespaced (the so-called 'ambient naming' problem [1]), as well as the problem of, if they are, then how do you tell if two type class instances are the same one. He then goes into great detail on these problems, on various more easily solved problems, and on mistakes made in the project management (many of which appear to be attributable to the economics of academia)
- https://news.ycombinator.com/item?id=3749860
  - https://news.ycombinator.com/item?id=3750882

Links:

https://en.wikipedia.org/wiki/BitC

Cyclone

A CTM language designed to support program control over low-level memory representations, including pointers, while using static typing to prohibit common pointer errors.

Influenced Rust.

Links:

https://en.wikipedia.org/wiki/Cyclone_%28programming_language%29
http://www.reddit.com/r/rust/comments/1osbq2/safe_manual_memory_
Region-Based Memory Management in Cyclone. Dan Grossman, Greg Morrisett, Trevor Jim, Michael Hicks, Yanling Wang, James Cheney

Other 1990s-2000s era CTM languages

Rust (see [2])
Deca
ATS https://news.ycombinator.com/item?id=3750421
Clay
Alms ( http://www.ccs.neu.edu/home/tov/pubs/alms/ )?
Habit
Tart

Links:

http://www.ccs.neu.edu/home/amal/course/7480-s12/lowlevel-notes.pdf (Cyclone, Vault, Sing#)

1960s-1980s era structured programming languages

BCPL

goals: "removing those features of (the CPL) language which make compilation difficult"

influences: CPL

people: Martin Richards

notes: predecessor of B, which led to C

See proj-plbook-plChSingleIntermedLangs.

BCPL Links

B

goals: "B was essentially the BCPL system stripped of any component that Thompson felt he could do without" ( http://en.wikipedia.org/wiki/B_%28programming_language%29 )

people: Ken Thompson, Dennis Ritchie

influences: BCPL

attributes: typeless (everything is a word)

notes: predecessor of C

Links:

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.

See chapter on Pascal and Oberon.

Modula-2

Goals: "To create a language adequate for describing entire systems, from storage allocator to document editor, from process manager to compiler, and from display driver to graphics editor. I perceived that many problems in software development stemmed from the mixing of parts written in different languages." (cite http://www.swissdelphicenter.ch/en/niklauswirth.php) )

Historically important innovations:

modules and module headers/interfaces
separate compilation

People: Niklaus Wirth

Retrospectives:

http://www.swissdelphicenter.ch/en/niklauswirth.php

Notes:

successor to Pascal (cite http://www.swissdelphicenter.ch/en/niklauswirth.php )
succeeded by Oberson (cite http://www.swissdelphicenter.ch/en/niklauswirth.php )

1950s-era languages

Fortran

1957

People: John Backus

Opinions:

http://moreisdifferent.com/2015/07/16/why-physicsts-still-use-fortran/
" FORTRAN has multidimensional arrays, and the compilers know about them and optimize aggressively. Most other languages don't. C people just do not get multidimensional arrays. They think an array of arrays is good enough. I tried to convince the Go people to put in multidimensional arrays, with no success." [3]
https://craftofcoding.wordpress.com/2022/02/11/what-fortran-does-better-than-c-like-languages/
- Exiting from a nested loop, Ranges in a case statement, Array slicing, Arrays with any indices you want, No dangling else, Few if any dangerous things
- https://lobste.rs/s/p2ewra/what_fortran_does_better_than_c_like

Tutorials:

https://www.tacc.utexas.edu/documents/13601/162125/fortran_class.pdf (modern fortran)

Algol

1958

" Another milestone in the late 1950s was the publication, by a committee of American and European computer scientists, of "a new language for algorithms"; the ALGOL 60 Report (the "ALGOrithmic Language"). This report consolidated many ideas circulating at the time and featured three key language innovations:

    nested block structure: code sequences and associated declarations could be grouped into blocks without having to be turned into separate, explicitly named procedures;
    lexical scoping: a block could have its own private variables, procedures and functions, invisible to code outside that block, that is, information hiding.

Another innovation, related to this, was in how the language was described:

    a mathematically exact notation, Backus-Naur Form (BNF), was used to describe the language's syntax. Nearly all subsequent programming languages have used a variant of BNF to describe the context-free portion of their syntax.

Algol 60 was particularly influential in the design of later languages, some of which soon became more popular. The Burroughs large systems were designed to be programmed in an extended subset of Algol.

Algol's key ideas were continued, producing ALGOL 68:

    syntax and semantics became even more orthogonal, with anonymous routines, a recursive typing system with higher-order functions, etc.;
    not only the context-free part, but the full language syntax and semantics were defined formally, in terms of Van Wijngaarden grammar, a formalism designed specifically for this purpose.

Algol 68's many little-used language features (for example, concurrent and parallel blocks) and its complex system of syntactic shortcuts and automatic type coercions made it unpopular with implementers and gained it a reputation of being difficult. Niklaus Wirth actually walked out of the design committee to create the simpler Pascal language. " -- https://en.wikipedia.org/wiki/History_of_programming_languages#First_programming_languages

https://en.wikipedia.org/wiki/ALGOL

Influential Programming Languages, Part 1: ALGOL

http://www.jemarch.net/back-to-the-future-a68.pdf (Algol 68 is Jose E. Marchesi's favorite programming language [4])

Algol 68S

https://en.wikipedia.org/wiki/ALGOL_68S https://web.archive.org/web/20150402203041/https://www.eah-jena.de/~kleine/history/languages/Algol68-RR-Sublanguage.pdf

COBOL

1959

https://en.wikipedia.org/wiki/COBOL

Beginnings of OOP; 60s-70s era

Simula

1967

Historically important innovations:

various OOP constructs:
- objects, classes
- subclasses
- virtual methods
- coroutines

Influences: ALGOL

Goals: discrete event simulation

People: Ole-Johan Dahl, Kristen Nygaard

Other notes:

some notes on this history of simula are in the middle of: http://web.augsburg.edu/~crockett/210/210%20Lab%20Set%204/Reed_OOP_Epistemology.pdf
the language BETA is "a modern successor to Simula" ( http://en.wikipedia.org/wiki/Simula )

Influential Programming Languages, Part 2: Simula

"C++, for example, was originally called "C with Classes" and was intended as a way of using Simula concepts in C, just as Objective-C was created to bring Smalltalk concepts to C." -- Influential Programming Languages, Part 2: Simula

Links:

https://www.deusinmachina.net/p/simula-the-forgotten-programming
- https://lobste.rs/s/uvh7ve/simula_forgotten_programming_language

Smalltalk

1972; due to its importance, has its own chapter, see [5]

Misc/unsorted languages

Pl/1

Ada

note: i think Ada is still used a lot for embedded systems, particularly in defence; maybe i should move it out of this chapter

Pros:

reliability

Notes:

Ada arose from a DoD?-sponsored contest to meet a detailed requirements document. The requirements document is notable in that it excludes some features as well as demanding others: http://www.dwheeler.com/steelman/steelman.htm

Inspired:

https://en.wikipedia.org/wiki/SPARK_%28programming_language%29

People: Jean Ichbiah, John Barnes, Robert J. Firth, Mike Woodger, Tucker Taft

Features:

"ALIASED is a keyword in Ada that must be explicitly used, by default the compiler prevents aliasing" [6]
"optional but enabled by default since-you-are-going-to-write-them-anyone bounds checking on parameters" [7]
real-time parallelism: https://blog.adacore.com/theres-a-mini-rtos-in-my-language
http://cowlark.com/2014-04-27-ada/

Retrospectives:

Tutorials:

Gotchas:

"In general I find the OO syntax desperately confusing. It feels like it's been shoehorned in on top of the existing record and procedure syntax, and it's never clear exactly what anything does. e.g. you need to suffix the object type with 'class in methods in order to make them non dispatching, but you need to suffix the object type with 'class in variable types if you want them to dynamically dispatch?" [8]
"there's something magic about declaring classes in packages" (see [9] for details)

Examples:

    loop
      select
        when usage < capacity =>
          accept Push(value: in integer) do
            data[usage] := value;
            usage := usage + 1;
          end;
      or
        when usage > 0 =>
          accept Pop(value: out integer) do
            usage := usage - 1;
            value := data[usage];
          end;
      or
        terminate;
      end select;
    end loop;

from [10] "The beauty here is that inside the message handler, you know that the caller is blocked" [11] "It's a real rendezvous. Either the "client" or the "server" task is running." [12]

note: this language is still liked in some quarters, and maybe should be moved out of the 'historical interest' section.

Ada opinions

https://devblog.blackberry.com/en/2021/05/learning-to-love-a-rigid-and-inflexible-language
"I like everything I’ve read about Ada, and I think SPARK is its killer feature." [13]
"Ada’s been flying under the radar doing it’s own thing, until AdaCore? started open sourcing things and pushing awareness a few years ago. GNAT is actually a mature ecosystem (gpr, gnat studio, gnatdoc, gnattest, gnatpretty, etc) and has libraries which go back decades, it’s just not well known. The issue is that there had been no unifying system for distributing libraries before, which has hampered things, but Alire is fixing that now and also streamlining working in the language as well." [14]
"Rust is doing well for good reason. It has an easy way to start, build, test and share things, which is exactly why Alire is based on the work that community (and the npm community) has done. The big philosophical difference I’ve found between writing Rust and Ada is that Rust focuses on traits/types, whereas Ada focuses on functions since it relies predominantly on function overloading and separation into packages (modules), though you can use ML-style signatures. It’s interesting because in Ada, in general (except for tasks/protected objects), types aren’t namespaces for functions, whereas Rust relies on this with traits. In this way, Ada feels more to me like a functional language like Haskell and Rust feels more like an OOP language like Java. I’ve always found this bizarre because it should be the opposite. Ada’s big advantage is how its general conceptual models are much more similar to C or C++ (think type safe C with function overriding, with classes if you want them), but it builds in a much stronger type system and concurrency types as well. Built-in pre/postcondition, invariants, and type range checks also goes a lot towards correctness, even if you don’t want to fully commit to format verification with SPARK. Note also that SPARK isn’t an all or nothing thing either with Ada code, you can verify individual components." [15]
" While I’m generally a huge user of Rust and a proponent of it for many CPU-bound workloads, Rust really doesn’t have much in the way of safety features except when you compare it strictly to C and C++. Rust has a lot of antipatterns that the ecosystem has broadly adopted around error handling and error-prone techniques in general, and the overall complexity of the language prevents a lot of subtle issues from being cheap to find in code review. Building databases in Rust is not all that different from building them in C++, except there is a bit narrower of a search scope when I discover memory corruption bugs during development. Ada (and much more so, SPARK) are a completely different tool for a completely different class of problems. The proof functionality of why3 that you gain access to in SPARK has no usable analogue in Rust. The ability to turn off broad swaths of language features is one of the most powerful tools for reducing the cost to build confidence in implementations for safety critical domains. There are so many Rust features I personally ban while working on correctness-critical projects (async, most usage of Drop, lots of logical patterns that have nothing to do with memory safety directly etc…, many patterns for working with files that must be excruciatingly modeled and tested to gain confidence, etc…) but with Ada it’s so much easier to just flip off a bunch of problematic features using profiles. Ada SPARK faces zero competition from Rust for real safety critical work. It is simply so much cheaper to build confidence in implementations than Rust. I love Rust for building things that run on commodity servers, but if I were building avionics etc… I think it would be a poor business choice TBH. " [16]
many quotes in https://people.cs.kuleuven.be/~dirk.craeynest/quotes.html are opinions on Ada being better than C
"Based on its feature set, I’d describe Ada as a mirror of C++ in the Pascal family, with many features of Rust...focusing on readability, correctness and reliability. Towards these goals it focuses on explicitness, strong typing, compile time and run time constraints on types, and minimum symbology" [17] [18]

Ravenscar concurrency profile

"In Ada, creating tasks, synchronizing them, sharing access to resources, are part of the language...For real-time and embedded applications, Ada defines a profile called Ravenscar. It's a subset of the language designed to help schedulability analysis, it is also more compatible with platforms such as micro-controllers that have limited resources....One of the advantages of having tasking as part of the language standard is the portability, you can run the same Ravenscar application on Windows, Linux, MacOs? or an RTOS like VxWorks?. GNAT also provides a small stand alone run-time that implements the Ravenscar tasking on bare metal. This run-time is available, for instance, on ARM Cortex-M micro-controllers. It's like having an RTOS in your language.

...

Tasks

you can declare and implement a single task:

   --  Task declaration
   task My_Task;

   --  Task implementation
   task body My_Task is
   begin
      --  Do something cool here...
   end My_Task;

If you have multiple tasks doing the same job or if you are writing a library, you can define a task type ... One limitation of Ravenscar compared to full Ada, is that the number of tasks has to be known at compile time.

Time

...

     a definition of the Time type which represents the time elapsed since the start of the system
     a definition of the Time_Span type which represents a period between two Time values
     a function Clock that returns the current time (monotonic count since the start of the system)
     Various sub-programs to manipulate Time and Time_Span values

The Ada language also provides an instruction to suspend a task until a given point in time: delay until.

...

Scheduling

Ravenscar has priority-based preemptive scheduling. A priority is assigned to each task and the scheduler will make sure that the highest priority task - among the ready tasks - is executing.

A task can be preempted if another task of higher priority is released, either by an external event (interrupt) or at the expiration of its delay until statement (as seen above).

If two tasks have the same priority, they will be executed in the order they were released (FIFO within priorities).

Task priorities are static, however we will see below that a task can have its priority temporary escalated.

The task priority is an integer value between 1 and 256, higher value means higher priority. It is specified with the Priority aspect:

   Task My_Low_Priority_Task
     with Priority => 1;

   Task My_High_Priority_Task
     with Priority => 2;

Mutual exclusion and shared resources

In Ada, mutual exclusion is provided by the protected objects.

At run-time, the protected objects provide the following properties:

    There can be only one task executing a protected operation at a given time (mutual exclusion)
    There can be no deadlock

In the Ravenscar profile, this is achieved with Priority Ceiling Protocol.

A priority is assigned to each protected object, any tasks calling a protected sub-program must have a priority below or equal to the priority of the protected object.

When a task calls a protected sub-program, its priority will be temporarily raised to the priority of the protected object. As a result, this task cannot be preempted by any of the other tasks that potentially use this protected object, and therefore the mutual exclusion is ensured.

The Priority Ceiling Protocol also provides a solution to the classic scheduling problem of priority inversion.

...

Synchronization

Another cool feature of protected objects is the synchronization between tasks.

It is done with a different kind of operation called an entry.

An entry has the same properties as a protected procedure except it will only be executed if a given condition is true. A task calling an entry will be suspended until the condition is true.

This feature can be used to synchronize tasks.

...

Interrupt Handling

Protected objects are also used for interrupt handling. Private procedures of a protected object can be attached to an interrupt using the Attach_Handler aspect.

" --- There's a mini-RTOS in my language by Fabien Chouteau

" Ada was designed through an iterative sequence of trials for a clean sheet implementation of a development language. It created, or popularized, ideas such as explicit module exports, tying directory and file names to classes, separate "to end of line" comments, and more." -- [19]

Ravenscar Practices

Guide for the use of the Ada Ravenscar Profile in high integrity systems

Ada variants and implementations

SPARK subset

SPARK
- "https://learn.adacore.com/ should be a good starting point to learn Spark. If you’re interested in how it’s implemented, reading https://www.adacore.com/papers might be a good way to learn." [20]

"The aim when designing the SPARK subset of Ada was to create the largest possible subset of Ada that was still amenable to simple specification and sound verification.

The most notable restrictions from Ada are related to exceptions and access types, both of which are known to considerably increase the amount of user-written annotations required for full support. Goto statements and controlled types are also not supported since they introduce non-trivial control flow. The two remaining restrictions relate to side-effects in expressions and aliasing of names, which we now cover in more detail. " -- [21]

Ada links

https://pyjarrett.github.io/programming-with-ada/

APL

https://en.wikipedia.org/wiki/APL_%28programming_language%29

People: Kenneth E. Iverson

Succeeded by J.

Retrospectives:

Opinions:

" IME, the real magic of APL, and what the numerous APL-influenced array languages have consistently lost in translation, are the concatenative, compositional, functional operators that give rise to idiomatic APL. They have taken the common usecases, but forgone the general ones. For example, numpy provides cumsum as a common function, but APL & J provide a more general prefix scan operator which can be used with any function, no matter whether primitive or user-defined, giving rise to idioms like “running maximum” and “odd parity” to name just a couple. Likewise, numpy has inner but it only computes the ordinary “sum product” algorithm while APL & J have the matrix product operator that affords the programmer the ability to easily define all sorts of unusual matrix algorithms that follow the same inner pattern.

This is not even to mention the fantastic sorts of other operators, like the recursive power of verb or the sort-of-monadic under that AFAICT have no near equivalent in numpy. " [22]

some APL stories in these comments: https://news.ycombinator.com/item?id=27460887 . One quote: "Today, APL just sounds like another exotic language. In its heyday it was radical."

Links:

FP

Short for "function programming". Created support the "function-level programming" paradigm; this paradigm is different from "functional programming"; i think it may mean restricting oneself to programs generated by combining a set of primitive functions in a point-free style).

People: John Backus

Succeeded by FL.

Influenced Joy.

Links:

https://en.wikipedia.org/wiki/FP_%28programming_language%29
Criticism of the Backus's Turing Award Lecture that introduced it: http://www.cs.utexas.edu/users/EWD/ewd06xx/EWD692.PDF
about function-level programming, and its connection to point-free style: http://stackoverflow.com/a/20710065/171761

FL

People: Alexander Aiken, John Backus, John Williams, Edward Wimmers.

Successor to FP.

Influenced J.

Links:

PL/360

The first systems programming language. Written for the purpose of implementing ALGOL W. Sort of a 'high level assembly' or 'structured assembly language'. It has block structuring and control flow such as 'if' and 'while' and 'for' and 'case', but it also affords direct access to assembly registers. Written by Wirth, Wells Jr., and Satterthwaite Jr.

Keywords/symbols:

          + - * / ( ) = < > ^
          , ; . : @ # _ " ' !
          DO IF OF OR
          ABS AND END FOR NEG SYN XOR
          BASE BYTE CASE DATA ELSE GOTO LONG NULL
          REAL SHLA SHLL SHRA SHRL STEP THEN
          ARRAY BEGIN CLOSE DUMMY SHORT UNTIL WHILE
          COMMON EQUATE GLOBAL
          COMMENT INTEGER LOGICAL SEGMENT
          EXTERNAL FUNCTION REGISTER
          CHARACTER PROCEDURE

Links:

Hypercard

Links:

https://osxdaily.com/2017/05/27/run-hypercard-macos-web-browser-emu/

todo

SNOBOL

implementation: SPITBOL
discussion: https://news.ycombinator.com/item?id=10103276

EIFFEL

Right and wrong: ten choices in language design by Bertrand Meyer
- https://lobste.rs/s/6eh9oh/right_wrong_ten_choices_language_design

Eiffel opinions: " marcellerusu 2 months ago

link

I’ve just started learning Eiffel and like what ive seen so far, just curious what do you consider its mistakes? hwayne 2 months ago

link

        CAT-calling
        Bertrand Meyer’s absolute refusal to use any standard terminology for anything in Eiffel. He calls nulls “voids”, lambdas “agents”, modules “clusters”, etc.
        Also his refusal to adopt any PL innovations past 1995, like all the contortions you have to do to get “void safety” (null safety) instead of just adding some dang sum types."

LOGO PL/1 https://en.wikipedia.org/wiki/PL/I#Teaching_subset_compilers DART OCCAM

---

https://github.com/e-n-f/if-then-else/blob/master/if-then-else.md

https://web.archive.org/web/20210301031609/http://hopl.info/

https://www.digibarn.com/collections/posters/tongues/

https://hackaday.com/2015/11/03/no-pascal-not-a-snobols-chance-go-forth/

---

https://increment.com/programming-languages/language-history/

The seven programming ur-languages (ALGOL, Lisp, ML, Self, Forth, APL, Prolog)

https://courses.cs.washington.edu/courses/cse341/02sp/concepts/families.html

" Imperative (procedural) language family:

    Fortran
    Algol family:
        Algol-60
        Pascal
        Modula-X
        Ada 
    BCPL, C
    Lisp, Scheme (both have functional subsets)

Object-Oriented Languages

    Simula (1960s)
    Smalltalk (1970s-present)
    C++, Objective C
    Common Lisp Object System (CLOS)
    Java

Functional Languages

    Miranda
    ML
    Haskell

Logic Programming Languages

    Prolog
    CLP(R)

Lots of others: APL, PL/I, Cobol, Snobol, Icon, Tk/Tcl, Perl, ZPL, ... " -- https://www.cl.cam.ac.uk/teaching/1718/ConceptsPL/lectures.pdf

" Program execution model Good language design presents abstract machine. I Fortran: Flat register machine; memory arranged as linear array I Lisp: cons cells, read-eval-print loop I Algol family: stack of activation records; heap storage I BCPL, C: underlying machine + abstractions I Simula: Object references I FP, ML: functions are basic control structure I Smalltalk: objects and methods, communicating by messages " -- https://www.cl.cam.ac.uk/teaching/1718/ConceptsPL/lectures.pdf

" Part A: Meet the ancestors II. The first procedural language: FORTRAN (1954–58). III. The first declarative language: LISP (1958–62). IV. Block-structured languages: Algol (1958–68), Pascal (1970). V. Object-oriented languages: Simula (1964–67), Smalltalk (1972). Part B: Types and related ideas VI. Types in programming languages: ML, Java. VII. Scripting Languages: JavaScript?. VIII. Data abstraction and modularity: SML Modules. Part C: Distributed concurrency, Java lambdas, Scala, Monads IX. Languages for concurrency and parallelism. X. Functional-style programming meets object-orientation. XI. Miscellaneous concepts: Monads, GADTs. " -- https://www.cl.cam.ac.uk/teaching/1718/ConceptsPL/lectures.pdf

https://www.cs.fsu.edu/~engelen/courses/COP402004/notes1.html

https://digitalcommons.newhaven.edu/cgi/viewcontent.cgi?article=1000&context=electricalcomputerengineering-books

https://madhadron.com/posts/2009-11-13-a-perspective-on-four-languages.html

https://cs.nyu.edu/~jcf/classes/CSCI-GA.2110-001/slides/session1/IntroductionToProgrammingLanguagesAndSyntax.pdf slides: Classifying Programming Languages, PL Genealogy, and nearby slides

https://en.wikipedia.org/wiki/List_of_programming_languages_by_type

proj-plbook-plChHistLangs

Of historical interest

1990s-2000s-era CTM languages

BitC

Cyclone

Other 1990s-2000s era CTM languages

1960s-1980s era structured programming languages

BCPL

BCPL Links

B

Pascal and Oberon

Modula-2

1950s-era languages

Fortran

Algol

Algol 68S

COBOL

Beginnings of OOP; 60s-70s era

Simula

Smalltalk

Misc/unsorted languages

Pl/1

Ada

Ada opinions

Ravenscar concurrency profile

Ravenscar Practices

Ada variants and implementations

SPARK subset

Ada links

APL

FP

FL

PL/360

Hypercard

todo