What features from old programming languages are worth studying today?

I'm no CS student, but getting familiar with Lisp was useful for a deeper understanding of a bunch of stuff. I resisted looking into Lisp for a long time because of the HN hype.

I still don't use Lisp for any real world projects, but it was useful for helping me better understand concepts in other languages, particularly JavaScript and Python.

Learning SmallTalk was also helpful with regard to message passing.

I think that the "color" aspect of ColorForth[2] could have wider use. I view it as a lightweight version of literate programming[1], in that you can intersperse code with the description of it. It makes it quite clear what is code, comment, constants, etc.

I think that the ideas that were brought forth in MetaMine[3] where quite interesting. The ability to mix declarative and imperative code in the same program, without melting your brain doing so, was a very powerful tool. I'm sad that it hasn't resurfaced. (I did find a fork of it on GitHub though[4])

[1] https://en.wikipedia.org/wiki/Literate_programming

[2] https://en.wikipedia.org/wiki/ColorForth

[3] http://web.archive.org/web/20201014024057/https://www.youtub...

[4] https://github.com/caminadab/metamine

That depends on what we mean by feature of course.... let's assume we mean concepts... here's my list: Believe it or not, Cobol's formatting for printed reports -- we still do print and formatted output worked well there. Modula-2s imports -- C++ is getting there, but imports just worked. Lisp's macros had their day. I think we could benefit from stepping away from "make a better C++" and ask "what is this language trying to do?" There's no universal "best" language, but one immediate benefit I'd like to see -- let's finally agree on a universal calling convention, at least on Linux for example, so every language can call another? Let's give credit to Microsoft's CLR on that one. Also, golang's getting the idea with structure tags, but how about structs that serialize to a universal format -- see Corba is not dead!

I would focus on "lisp without the parentheses" languages like F# or OCaml. Even when I write in any other language, I think by composing and chaining operations without considering the runtime machine (the internal hows). Eliminating time from cognitive load is the greatest cheat. Being able to write programs like correct SQL result set first, then refine for performance would be nice. Most processes can be modelled as input, acyclic series of boxes, output. Put persistence at the ends and the language is largely an implementation detail, as is the choice of persistence.

Assembly language might be interesting. Here's a free e-book, Assembly Language Succinctly, that will give you a quick overview:

https://www.syncfusion.com/succinctly-free-ebooks/assemblyla...

See https://en.wikipedia.org/wiki/PL/I which was IBM's attempt to make a language that would take the place that C did.

I think the language that has really caught my attention is the APL family. J, K, BQN etc