2015 was the year of FP. Haskell was all the rage, elm was hot, large scale dismissal of OOP was in the air. To be clear I don’t think FP or OOP are really fads but their popularity waxes and wanes. I’ll see y’all in 2027 when static typing is whack and everyone is going back to dynamic typing.

Employed practices change in response to pain points. As an example, the microservices movement corresponds pretty well to an era of (overly) rapid organizational growth during a tech boom where a technical response to org chart problems became necessary.

In contrast, static versus dynamic typing doesn't seem likely to be so cyclical given the significant improvements in usability for gradually typed systems. Dynamic typing became most recently fashionable when the experience of using statically typed languages was sometimes unpleasant. Static typing has improved to the point where even retrofits onto other systems are very very good.

In areas where a reasonably complete gradual typing solution has emerged for a major dynamically typed language, it's rapidly become or becoming standard practice--Python and TypeScript being the two most obvious ones, but not the only ones. (Ruby may not get there. Its core implementation doesn't seem great. I wish they went with Sorbet.)

I don't see a reason that would unwind to the point where it's a serious conversation again.

I think the most recent popular use of dynamic typing is Elixir, and IMO that's because Phoenix (especially with LiveView) is the most interesting server-side web framework to come along in a while. Yes, you can add type checking with Dialyzer, but that's optional and AFAIK not a widespread default in Phoenix projects. I wish something like Phoenix and LiveView was available in a strongly statically typed language, but for now I just make do with the dynamic typing.

Elixir projects not using Dialyzer is a major reason why I don't use it much; I use it in my code, but not enough others do to make it comfortable. At the same time, my understanding is that Elixir has some pretty interesting gradual typing stuff in the works right now.

Maybe pure FP was a fad around 2014, but practical FP, say, as embodied in React, is very much entrenched and is not going anywhere.

(To say nothing of Excel as the most widespread functional reactive programming tool, but few count it as a "real" programming environment.)

I could make more or less your exact statement, but substituting 2015 for 2004

as a whole, interest in it comes in waves, but it never seems to make it to the mainstream.

Many mainstream ideas are incubated in the fp world, and wind up in the mainstream. for exmaple: GC, closures, higher order functions. but not any of the "functional programming languages" themselves.

What you're describing is literally FP ideas and abstractions going mainstream

uhh...yeah, i thought i was clear on that?

Sounded like you were disagreeing with me on that when you said

> but it never seems to make it to the mainstream