A Review of Post-C Languages

To start with something off-topic, I like the fact that Gemini is free from comments, likes, or whatever. If someone enjoys this post that's great, but if it's just the author re-reading it in the future that's fine too.

In a previous post I praised the Oberon programming language. However, by imposing one additional constraint, excluding "transpilers-to-C", you come to a very different conclusion (unless you want to target RISC5). It seems helpful to review things in chronological order:

1980s

There seem to have been two domains in this decade. For home/personal computing the choices were:

Assembler. Actually the best choice for most hardware in this period, but it isn't of much interest to us now.
C. In 2021 this is a nice language if your computer is air-gapped. Otherwise a security nightmare.
Pascal. A good choice for teaching, not so good for industrial use (but later descendents fixed this). *Late edit*: a nice later descendent is Object Pascal, but these all require manual memory management.
BASIC. Much-maligned, but there was nothing wrong with later revisions. Line numbers were gone, structured and object-oriented programming were in.

However, organisations with a budget had "better" choices (for some value of better):

Ada. This is actually a fine choice, but is not very well-supported nowadays. Eiffel was a minor player, and has the same problem.
Modula-2. This is probably the most minimal choice, and a nice language. But it's hard to find any compiler nowadays. *Late edit*: requires manual memory management.
C++. The elephant in the room. Wildly successful, but has the same security problems as C. Coding anything security-related or with a network surface feels like juggling hand grenades.

AdaCore

GNU Modula-2

And constantly in the background is:

Common Lisp. Standardised in this time period. Impressive libraries were written since, but the language remained the same.

1990s

Java. I'm reminded of the quote about Caesar Augustus "You have given us a desert and called it peace".

2000s

This is about when I became intersted in the field.

Cyclone. Excellent, a clear migration path from C :-) But it's 32-bit specific and won't work on any computer I have access to :-( Rust inherits a lot of ideas.
D is also a worthy effort from here, but it has gone a long time without becoming popular. Perhaps large industrial backing is required?

Cyclone

2010s

Go. Backed by Google. A successor to the Plan 9/Inferno community. Somewhat of a return to minimalism, although wilfully discarding decades of PL research may annoy some.
Rust. Has several corporations interested, e.g. Mozilla, Microsoft, maybe the Linux kernel. This is a very good choice for something acceptable to industry, but seems quite tricky to program.

Rust

Conclusion

First, what I'm looking for here is a safe language. Essentially memory-safe, but type- and thread-safety would be appreciated too.

Unfortunately, a clear choice isn't obvious. If I adopt the position of "all these later languages are just copycats", the earliest candidate is probably D. If I want a Lisp interpreter (Iris), probably Go. If I want to earn money, probably Rust.

Iris ISLisp

Back to my gemlog