Is it just me or was the high-water mark for interest in Haskell & FP in general around 2016-2017 ?
There was lots of discussion & debate around static vs dynamic, clojure vs haskell, oop vs fp, new languages vs established languages, conferences devoted to FP ideas, etc...
The whole debate ecosystem seems to have subsided around when rust really started taking mindshare. Now, I'm not implying here rust absolves these issues at all. It's just a co-occuring event on the timeline imho.
Although, I think it's probably obvious that devs who have free time use their attention on whats trendy. Rust probably took some wind out of the sails of haskell, but I'm not sure what trendy is moving to these days, maybe AI, but do devs really program against large AI models or just play around with chatgpt; if not, what are they interested in with regards to tools that materially affect their career?
What happened to all the debate about langs? What happened to interest (measured in frequency of online discussion) in FP? Is Rust still trendy in dev mindshare? Are these debates over/resolved?
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.
At least for me, Rust gives me the parts I like about FP (sum types, generics, type inference, limited mutability, first class functions) without the annoying parts (bad tooling, poor documentation, odd syntax, laziness, mediocre ecosystem, very circuitous routes to mutability and IO).
Basically I suspect the majority of FP users liked the type system and general guarantees of FP but didn’t care about the ideological parts like purity or laziness so when a language popped up that gave you those guarantees but also had better UX and could bind easily to C or C++, they hopped on.
Also it’s much easier to sell Rust to management as C++ but with less bugs. Who doesn’t want less bugs?
Do trends matter? At the end of the day, software is interesting for it's own sake, but not useful. If the goal is to create useful tools (i.e, a custom hammer for your particular nail), does it matter what language is used in their creation?
I was writing Haskell in 2011. I'm writing Haskell now. I'll keep writing Haskell until I find something I like better. I also write C++, Python, R, and a dozen other languages when the mood or the need strikes. Some of my favorite bits of software are written in Delphi or poorly hacked together C. They're closer to rocks than Estwings, but they do the job (and have done since the '90s).
There will always be trends. There will always be floods. Floods can take you interesting places, but having a well-sheltered hole or a firm grip on something solid is probably the better long-term solution if survivability is the goal. In the end, COBOL devs are worth more than ever.
I think a lot of Haskellers just got tired of arguing lol. I know I do so way less than back then. But I am writing Haskell more than ever nowadays (even at my dayjob!)
If we're talking HN trends then I'd say Haskell comes back around roughly every 6-7 years. There was a big push around 2008-2010, again in 2016-2017, so... maybe next year we'll start seeing it come back around?
I work in Haskell full time now and have for more than a few years at this point. The ecosystem is small because there aren't any network effects propping up Haskell's popularity. We don't have large corporations like M$, Google, etc pouring dosh into GHC development, tooling, etc. It mainly survives on the community of dedicated folks working in academia, their spare time, and contributions from the small (growing!) pool of companies investing in it. Progress happens but it's slow.
This is one factor that can contribute to the cyclic nature of FP trends, Haskell specifically; a handful of influential people discover it, learn a bunch in their free time, write about it, and then when it fails to catch on they move on.
Another factor that contributes is... well network effects. Potential new programmers aren't rushing out to learn Haskell/OCaml/F# because there aren't a whole lot of jobs using it, there aren't a lot of courses teaching it, and there aren't many people recommending it. It also means that established language ecosystems are free to adopt ideas and features from the FP community in their own languages which further prevents people from leaving their ecosystem and adopting another language. Sure, C# may not be a great functional programming language but it's good enough and you don't have to fully buy in: you can use FP patterns when it feels appropriate and OOP ones when that works better (C# has the advantage of the .NET runtime which F# uses and the two can interop well... further preventing any reason to leave that space).
The set of Haskell programmers isn't empty. It's filled with people who are rather dedicated and passionate! And sometimes people new to Haskell join, learn something, and leave for various reasons. Some stay.
As for Rust well... if you look at just HN, again, I think you see these hype cycles. The early-mid 2010's the big trend was "X written in Go." Now it's, "X written in Rust." You don't see that happen much with OCaml/Haskell/F#... probably, again, because of the aforementioned effects. Either the pool of candidates re-writing existing tools is small enough that they can't break through the current hype-cycle or they're not re-writing those things and are carrying on with their work.
Anyone know why dependent types aren't a thing in practice? They seem to eliminate a bunch of restrictions induced by phase separation. Easier proving of compile time invariants, seems good.
All the demos I've seen of Idris suggest the compile time cost is substantial. So my best guess at present is the languages take too long to compile but that doesn't seem like it should be a deal breaker.
Just a guess with no evidence, but I think a core premise of the FP movement was that mutability was the source of all of our problems. And what Rust has shown is that maybe mutability was fine along, and it was more specifically "mutability + aliasing" that was the source of all of our problems.
These debates will resurface thanks to new languages like Austral, which attempt to place Rust's overall feature set (affine types, borrowing, interior mutability, safe vs. unsafe subset etc.) on a simpler foundation and make it less ad-hoc. There's also a lot of work along these lines in recent PL research. This will also make it a lot easier to explore better and more elegant interactions with known features from Haskell or FP-like languages more generally. And then some future version of Haskell might ultimately gain the ability to express Austral programs (if not full-blown Rust) more or less seamlessly.
Anecdotally, I was toying around with Haskell around 2015 but concluded that while learning it deeply would teach me important lessons about software, I was likely never going to use it for work, and so I just dedicated myself fully to learning Rust. It's not necessarily about any debate or trendiness for me, it's just a boring choice that helps me get things done.
Implementing scheme or lisp in rust is probably a path to zero cost data movement between the two. Write the garbage collector in the abstractions rust understands, use roughly the same data types on both sides. That might be worth having.
edit: and there are lots, already, where for each one it is difficult to tell where it lies on the spectrum from vapourware to production
[+] [-] platz|3 years ago|reply
There was lots of discussion & debate around static vs dynamic, clojure vs haskell, oop vs fp, new languages vs established languages, conferences devoted to FP ideas, etc...
The whole debate ecosystem seems to have subsided around when rust really started taking mindshare. Now, I'm not implying here rust absolves these issues at all. It's just a co-occuring event on the timeline imho.
Although, I think it's probably obvious that devs who have free time use their attention on whats trendy. Rust probably took some wind out of the sails of haskell, but I'm not sure what trendy is moving to these days, maybe AI, but do devs really program against large AI models or just play around with chatgpt; if not, what are they interested in with regards to tools that materially affect their career?
What happened to all the debate about langs? What happened to interest (measured in frequency of online discussion) in FP? Is Rust still trendy in dev mindshare? Are these debates over/resolved?
[+] [-] di4na|3 years ago|reply
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.
[+] [-] hardwaregeek|3 years ago|reply
Basically I suspect the majority of FP users liked the type system and general guarantees of FP but didn’t care about the ideological parts like purity or laziness so when a language popped up that gave you those guarantees but also had better UX and could bind easily to C or C++, they hopped on.
Also it’s much easier to sell Rust to management as C++ but with less bugs. Who doesn’t want less bugs?
[+] [-] argiopetech|3 years ago|reply
I was writing Haskell in 2011. I'm writing Haskell now. I'll keep writing Haskell until I find something I like better. I also write C++, Python, R, and a dozen other languages when the mood or the need strikes. Some of my favorite bits of software are written in Delphi or poorly hacked together C. They're closer to rocks than Estwings, but they do the job (and have done since the '90s).
There will always be trends. There will always be floods. Floods can take you interesting places, but having a well-sheltered hole or a firm grip on something solid is probably the better long-term solution if survivability is the goal. In the end, COBOL devs are worth more than ever.
[+] [-] whateveracct|3 years ago|reply
[+] [-] agentultra|3 years ago|reply
I work in Haskell full time now and have for more than a few years at this point. The ecosystem is small because there aren't any network effects propping up Haskell's popularity. We don't have large corporations like M$, Google, etc pouring dosh into GHC development, tooling, etc. It mainly survives on the community of dedicated folks working in academia, their spare time, and contributions from the small (growing!) pool of companies investing in it. Progress happens but it's slow.
This is one factor that can contribute to the cyclic nature of FP trends, Haskell specifically; a handful of influential people discover it, learn a bunch in their free time, write about it, and then when it fails to catch on they move on.
Another factor that contributes is... well network effects. Potential new programmers aren't rushing out to learn Haskell/OCaml/F# because there aren't a whole lot of jobs using it, there aren't a lot of courses teaching it, and there aren't many people recommending it. It also means that established language ecosystems are free to adopt ideas and features from the FP community in their own languages which further prevents people from leaving their ecosystem and adopting another language. Sure, C# may not be a great functional programming language but it's good enough and you don't have to fully buy in: you can use FP patterns when it feels appropriate and OOP ones when that works better (C# has the advantage of the .NET runtime which F# uses and the two can interop well... further preventing any reason to leave that space).
The set of Haskell programmers isn't empty. It's filled with people who are rather dedicated and passionate! And sometimes people new to Haskell join, learn something, and leave for various reasons. Some stay.
As for Rust well... if you look at just HN, again, I think you see these hype cycles. The early-mid 2010's the big trend was "X written in Go." Now it's, "X written in Rust." You don't see that happen much with OCaml/Haskell/F#... probably, again, because of the aforementioned effects. Either the pool of candidates re-writing existing tools is small enough that they can't break through the current hype-cycle or they're not re-writing those things and are carrying on with their work.
[+] [-] JonChesterfield|3 years ago|reply
All the demos I've seen of Idris suggest the compile time cost is substantial. So my best guess at present is the languages take too long to compile but that doesn't seem like it should be a deal breaker.
[+] [-] oconnor663|3 years ago|reply
[+] [-] zozbot234|3 years ago|reply
[+] [-] jryb|3 years ago|reply
[+] [-] pjmlp|3 years ago|reply
Every new fad is followed by folks that want to monetize conferences, books, training, consulting gigs,...
Eventually everything that mattered is said and done, a née generation comes along, and a new cycle starts.
[+] [-] sebzim4500|3 years ago|reply
[+] [-] fithisux|3 years ago|reply
[+] [-] bradwood|3 years ago|reply
[+] [-] otikik|3 years ago|reply
If this was calling Rust from Lisp, on the other hand…
[+] [-] qbrass|3 years ago|reply
Calling a C stub written in Rust using Lisp's C FFI is just your average Tuesday in comparison.
[+] [-] JonChesterfield|3 years ago|reply
edit: and there are lots, already, where for each one it is difficult to tell where it lies on the spectrum from vapourware to production
[+] [-] cultofmetatron|3 years ago|reply