Type systems, which the chart doesn’t address at all, are now usually considered at least as important an aspect to language’s ‘paradigm’ as the (increasingly-blurry) functional vs imperative distinction. And a lot of the examples are pretty dated, coming as it did at the tail end of the object-oriented and XML fads. And concurrency and especially parallelism are given short shrift.
Paradigms are quite orthogonal to type systems. Mozart/Oz and AliceML implement more or less the same set of paradigms. One is dynamic the other is statically typed.
Then they don’t implement the same set of paradigms. Type systems (can) fundamentally shape how computations may be expressed in a language. For example, C++’s type system was famously proved Turing-complete.
So is Java's type system [1], and Rust's and Haskell's with some modest extensions, and Scala's. Many type systems have turned out to be Turing complete.
No, that just changes where programmers can put their computations. Scheme and Rust are not more powerful for their macros than C++ is for its templates; both can put unreasonable demands on the compilers.
Typing is hardly a new thing, its lack definitely can't be blamed on the age of the chart.
It has this comment though
> Axes that are orthogonal to this chart are typing, aspects, and domain-specificity. Typing is not completely orthogonal: it has some effect on expressiveness
I don't think so. Perhaps you've changed your mind on that topic, but typed languages were always dominant in industry, modulo a few startups. That's still the case today.
I don't get what you mean here. I think statically typed languages are much less dominant now than in 2008. Python, Ruby, JavaScript have all found huge niches since then.
> Python, Ruby, JavaScript have all found huge niches since then.
And Perl has a much smaller niche, and JavaScript's niche is hard to pin down since it's often just a compilation target for typed languages (Dart, TypeScript, etc.).
Language marketshare ebbs and flows, but I don't think the overall ratio has changed much. Statically typed languages are still largely dominant.
I can't think of any domain that was dominated by a statically typed language that a dynamically typed language took over, and every new domain that cropped up with dynamically typed solutions has equally good statically typed competitors.
Most of the people I know who program in JavaScript are using JavaScript, I'm kind of the odd ball for using Typescript though I hope that's changing. JavaScript still has most of the market share for languages that compile to JavaScript. There is a huge web community out there that still haven't been exposed to very much static typing, by numbers at least.
Machine learning was done in mostly C++ before Python took pretty much the entire domain. Mind you, this is mostly cultural, I don't think it has anything to do with types (more like C++ is a PITA, python is much easier to use).
My only claim, however, is that static languages haven't really made much inroads since 2008, and it feels like there is a lot of regression going on (e.g. with machine learning).
