The Turing Tarpit remains sticky. The explosion of diversity has been in solutions. The problems have largely remained the same but for scale: Quantity has a quality all its own. [1] Containers malloc entire operating systems. React.js provides coroutines. Apps implement a consumer space evolution of IBM's leasing and licensing models.

[1]: My father always attributed it to Zhukov.

Hypertext systems existed long before WWW. It brought nothing new really.

> I don't know what a "container" might be

It's some poor man crap that mimics the IBM mainframes from 1970s.

> I have programmed in Python, Ruby, and Haskell, but if you think nothing has fundamentally changed in the last 30 years, good for you.

Smalltalk, Simula, Lisp, ML, Miranda, all are over 30 years old. Python, Ruby and Haskell did not bring anything fundamentally new.

If you want to write for IBM mainframes that's great, but if you want to write stuff in modern ecosystems there's a shed-load to learn. It's not about the underlying ideas of the fundamental technology, it's all the crap you need to learn to glue it together and make it run on science-fiction devices.

And I've programmed in Smalltalk, Simula, Lisp (of various flavors), ML, Miranda, C, BCPL, MCPL, Occam, zed (probably not the one you're thinking of), BASIC (probably not the one you're thinking of), ForTran (probably not the one you're thinking of, or that one either) and more, and to me, there's a great deal to learn to get to Haskell, OCaml, etc., and even more to learn to get into the current ecosystems.

> but if you want to write stuff in modern ecosystems there's a shed-load to learn

What exactly? If all that "new" stuff is just a poor, crappy execution of the concepts that had been around for over 30 years. There is nothing new to learn, same old stuff presented slightly differently.

> it's all the crap you need to learn

Do you really need to learn something as simple as a new syntax for the same old stuff? I hope you're not memorising APIs and command line arguments - it's always better to look this stuff up as you go.

> there's a great deal to learn to get to Haskell, OCaml

Mind naming any fundamentally new concepts introduced by Haskell or OCaml? Type classes? Not that new, and still worse than the good old SML modules. STG? Implementation minutiae. Or you're referring to "learning" the ghc command line options and things like hackage? Things you can look up in seconds are not worth any "learning".

> Mind naming any fundamentally new concepts introduced by Haskell or OCaml?

For OCaml:

- row polymorphism (in particular polymorphic variants)

- higher-order and applicative functors (not the Haskell thing).

- first-class modules

For both:

- Higher-rank polymorphism

For Haskell (and now in both):

- GADTs

By introduced here, I'm ignoring them being implemented in toy languages first (since that is simply the first step of introducing them to programming). Similarly, it is not reasonable to say that F-omega or a dependently typed calculus already had such features, because that ignores issues of type inference and efficient implementation.

While Haskell itself doesn't bring too much new things, is has been a good vehicle to explore new concepts. Mind you, all ideas need to mature before having widespread use, so is not hard to think on most of the ideas "being around for 30 years"

Applicative functors seems an example of something "new" as the paper introducing it is form 2008.

> is has been a good vehicle to explore new concepts

Which concepts exactly?

> Applicative functors seems an example of something "new"

Too small a thing to be fundamental, to require any degree of re-learning.

Of course there is a lot of new fancy syntax sugar and all that, but the nature of the lazy languages did not change a bit since Miranda. If you knew Miranda, you'll learn Haskell in no time, and 30 years in between them would not make it any harder.

for me a new-ish thing dependent types (I have a small experience with Coq)

But yeah, since Turing and Church the fundamentals of computation hasn't changed. Nil novum sub sole

Dependent types are making their way into more practical applications now, yes, but the concept itself is also not new at all, it stems from the Curry-Howard isomorphism, which is known for far more than 30 years.

So, back to the point: anyone who knew how to program 30 years ago would easily pick it up now, without any significant learning.

I guess my point is if you learned to program 30 years ago using functional programming with dependent types and category theory, it must have been an awesome place to work/study, and I envy you. Which university it was?