5 ms·
What happened are multiple factors 1. Web3 hired a lot of these people and so they had less time to work on this stuff. Shame to spend that much on a dead end
by di4na 4y ago
What happened are multiple factors
1. Web3 hired a lot of these people and so they had less time to work on this stuff. Shame to spend that much on a dead end but eh
2. Scala died with Big Data. It is still around and all but noone care anymore, which emptied the room. It also happened that the whole Implicits experiment for polymorphism, which scala was really supposed to explore, did not pan out that well
3. Effects progressed but... Mostly out of view. Ocaml shipped them with its multicore, we are seeing good work on the academic side, you see Verse wanting them, etc. Same thing with linear types.
4. Dependent types ... Never really crossed to the realm of production. And Idris and co are mostly "complete" so it slowed down
5. Oh and monad interest, mostly fueled by scala, died slowly. Effect handlers seems to be a nicer solution in practice to most of this stuff.
6. Typescript killed a lot of the need for advanced stuff, same with python and ruby shipping their stuff too. Meanwhile Rust and Elixir showed you did not need the really up there stuff to have results in prod.
In the end what happened is that a lot of the highly abstract stuff was driven by "hype domain" that died, while more pragmatic but limited implementation burgeoned and absorbed some of them. Rubber met the road and that tampered a lot of people down.
There is still work being done, but rn it is more at the "experimental language" stage. Think Rust in the mid 00s.
Oh and Rust mindshare is still growing. A lot. A looooot.
- di4na 4y agoRegarding tools affecting their career... Right now pretty limited. We mostly see move around JS and some stuff around Rust for all kind of application. Outside of this, this generation burned out maintaining stuff. And most of the (small) set of people interested in low level are already consumed by keeping the existing projects running. We have a dire lack of investment in low level tooling.
- hailwren 4y agoRust is also huge in crypto. It’s the DSL or inspired the DSL for a few chains and there is a lot of Rust work happening on Ethereum.
- packetlost 4y agoIt's really too bad too. Most of the languages we've settled on have glaring problems, but I guess "critical mass" doesn't really care. Python's packaging is a mess (and a host of other problems), JavaScript has almost as much baggage as Java with much worse design decisions, over-complicated tooling, etc. (but has arguably some of the best runtime implementations in existence). Rust is good, but has sharp edges and a steep learning curve. Both Rust and JS have adopted some FP concepts that are pretty nice, so there's that.
- eptcyka 4y agoPython's packaging mess have nothing to do with the language itself, most definitely from the perspective of programming language theory.
- packetlost 4y agoIt is related, but not in a way that matters much. My main issues with Python are related to the language itself, primarily around duck-typing, lack of good lambdas, import side-effects, etc..
- throwaway894345 4y agoAs I understand it, it's related to the decision to make the entire interpreter part of the public C extension interface which drove everyone to write C extensions for anything that was remotely performance sensitive (and the breadth of the extension interface and the pervasiveness of C extensions in the Python ecosystem made it really difficult to make substantial backwards compatible performance improvements in the interpreter). Since so much of the ecosystem is C, Python package management has had to try and figure out how to distribute arbitrary versions of C software to arbitrary target systems which is really hard in large part because C projects don't have any standard build tooling or dependency management. As far as I know, no one has figured out how to do this well given Python's constraints (the best language package managers just absolve themselves from Python's original sin--pushing the ecosystem toward FFI rather than making the core runtime model fast enough for native code).