What *old* programming languages are you enthusiastic about?

I was part of the team that added COBOL to the Exercism stable. It was particularly satisfying to see that COBOL got to be the 60th language, given it had had its 60th birthday back in 2019.

I have a lot of respect for old people and old things. COBOL isn’t the sexiest language but it’s still being actively developed (the last major standard being COBOL 2014) and one can still make a living with it in the banking and insurance verticals particularly.

I’ve heard folk saying that all those billions of lines should be replaced with something “better.” Whatever they say, it’s never going to happen. Think of this way: what electrician in his/her right mind would rip absolutely all of the wiring out of an existing house and then rewire it from scratch while people were still living in it? It wouldn’t be worth the cost and the disruption. Similarly large corporations with existing legacy codebases. Whether we like it or not, we’re stuck with COBOL for the foreseeable future. If you don’t like it, you don’t have to use it. But if you can swallow your pride and learn it, you can make a decent living from it.

Sadly, one can’t say the same about another old language I like: SNOBOL4. But that’s another story.

  • Sinclair BASIC - A few months ago, I discovered my mother still had her ZX Spectrum in the attic. I hooked it up to a TV, and to my surprise, it still worked! Wrote a simple “Hello World!” program, but it got me intrigued to know more. I’ve seen a few emulators, might be fun to learn a bit more about how the whole thing works and try to write bigger programs in it using one. Then save it on a cassette and try it in the real thing!


It was invented in the early 90’s as a language to embed into other programs to enable scripting capabilities. The groundbreaking event was the invention of the Tk windowing toolkit was invented, making cross-platform GUI development simple for once. Here’s a history of Tcl.

Tcl received an ACM Software System Award

for developing a software system that has had a lasting influence, reflected in contributions to concepts, in commercial acceptance, or both

Tcl was involved with a (at the time) notorious flame war.

Back in the day, Tcl was (in)famous for its “everything is a string” concept. What made the implementation simple also made it quite slow. Today, Tcl has real datatypes under the hood, but “everything can be represented as a string” still holds.

Tcl was the language that got me started in actual software development. I’ve loved it ever since.

The exercism track: Tcl on Exercism


 ?- enthusiastic(prolog).

 ?- enthusiastic(X).
 X = prolog

Turing complete?

turing(Tape0, Tape) :-
    perform(q0, [], Ls, Tape0, Rs),
    reverse(Ls, Ls1),
    append(Ls1, Rs, Tape).
perform(qf, Ls, Ls, Rs, Rs) :- !.
perform(Q0, Ls0, Ls, Rs0, Rs) :-
    symbol(Rs0, Sym, RsRest),
    once(rule(Q0, Sym, Q1, NewSym, Action)),
    action(Action, Ls0, Ls1, [NewSym|RsRest], Rs1),
    perform(Q1, Ls1, Ls, Rs1, Rs).
symbol([], b, []).
symbol([Sym|Rs], Sym, Rs).
action(left, Ls0, Ls, Rs0, Rs) :- left(Ls0, Ls, Rs0, Rs).
action(stay, Ls, Ls, Rs, Rs).
action(right, Ls0, [Sym|Ls0], [Sym|Rs], Rs).
left([], [], Rs0, [b|Rs0]).
left([L|Ls], Ls, Rs, [L|Rs]).

Given an example machine (move pointer right, then add a one, done.)

rule(q0, 1, q0, 1, right).
rule(q0, b, qf, 1, stay).

…see it works!

?- turing([1, 1, 1], Ts).
Ts = [1, 1, 1, 1] ;

(Someone asked: I did not write the turing proof. Straight from the wiki baby!)



While it has its fair share of problems that more recent languages learned from, I still find it to be a very useful and productive language for small scripts or quickly putting together a web service and things like that. For me it’s a very useful allround tool despite its age.

Hmm, I had interpreted the question to equate an “old” language with a once-popular language that has fallen out of favour. I wouldn’t have considered Python to be old, particularly as it is frequently updated.

I can see that but then COBOL wouldn’t be considered old either according to Bruce’ description, so I interpreted it mostly as old by age, which Python certainly is. I guess Python is also old in the sense that it has inspired a lot of languages that came after it and that have become very popular on their own.

Machine code          1949       72    years
Assembly              1949       72    years
Fortran               1957       64    years
ALGOL 58              1958       63    years
Lisp                  1958       63    years
COBOL                 1959       62    years
BASIC                 1964       57    years
Pascal                1970       51    years
C                     1972       49    years
Prolog                1972       49    years
TeX                   1978       43    years
Ada                   1980       41    years
VHDL                  1980       41    years
Verilog               1984       37    years
C++                   1985       36    years
Erlang                1986       35    years
Perl                  1988       33    years
Bash                  1989       32    years
Haskell               1990       31    years
Python                1991       30    years
AppleScript           1993       28    years
HTML                  1993       28    years
R                     1993       28    years
Common Lisp           1984       37    years
Batch Script          1995       26    years
JavaScript            1995       25    years
Delphi                1995       26    years
Java                  1995       26    years
PHP                   1995       26    years
Ruby                  1995       26    years
Netwide Assembler     1996       25    years
CSS                   1996       24    years
ECMAScript            1997       24    years
C#                    2000       21    years
D                     2001       20    years
Jython                2001       20    years
Apache Groovy         2003       18    years
PowerShell            2006       15    years
Clojure               2007       14    years
Cython                2007       14    years
Processing.js         2008       13    years
GoLang                2009       12    years
Rust                  2010       11    years
Dart                  2011       10    years
Elixir                2011       10    years
Kotlin                2011       10    years
TypeScript 1          2012       8      years
Swift                 2014       7     years

I think that you are saying that @glennj is disqualifying COBOL as an old language, but based on age, I would say that it is indeed old.

I think being frequently updated does not disqualify something as old. It just isn’t stale or stagant, perhaps.

I would say that as a language, COBOL, being 62 years old would be considered old. And while Python may be mature, it perhaps would not be considered old.

So what is the line we draw to make that old something we can measure?

(The apparent “off by one” for the number of years is because of a specific month or month/date being known, rather than the simpler math of one year to the other.)

@axtens - your thread, your rules! How do you define “old”?


Number of years since first release. This makes Clojure an adolescent.


@glennj I worked with Tcl professionally a few decades ago. I liked it at the time, but don’t remember it much anymore. I never worked with tk, but it was fun to say “tickle teekay!”

Because of Carbon, I’m spending more time with C++ lately by taking some of the lessons from the C++ path on Pluralsight. It’s both old and new, with a distinction between the old (which I used professionally a bit) and “Modern” with some of the functional idioms accreted to it, and some things deprecated.

1 Like

In one of my many, ironically, wasted efforts to be more time-efficient, I wrote a Pomodoro app in tcl/tk

1 Like

According to this StackOverflow posting, MSDOS batch files were invented in 1981.

“This is not the web page you are looking for.” :frowning_face:

Okay, here’s a wikipedia page about MSDOS which discusses, in the “1981 August” row of the timeline the AUTOEXEC.BAT file.

While I can’t say I use its original implementation, LISP is still one of my favorite languages. Its conciseness and minimal syntax are so great to work with.

And I love Prolog too!


Oh, and while we’re disparaging Batch Files, do check out all the interesting techniques demonstrated at RosettaCode.

I’d like to learn those two someday

I recently was forced to learn (common)-lisp for work (because a colleague determined that it was the best language to implement some of our business requirements, and then was out sick with new requests come in) and I actually like it.

It is also far more accessible than something completely different such as prolog. So if you’re looking for a language more like others, that’s also a good choice to be enthusiastic about!

1 Like

I got about a third through the Common Lisp track. The for construct really sticks out like a sore thumb to me. I suppose it’s a success of the macro feature, but I was leaning on it like a crutch (with my procedural mindset). Now that I’ve actually gotten through a functional language track (elixir) I’ve been meaning to go back to a lisp track again.

Which begs the question : which lisp-derived track? Why are there so many?

1 Like