Calling Purgatory from Heaven: Binding to Rust in Haskell

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.

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.

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?

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.

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.

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.

Calling a C stub written in Rust using Lisp's C FFI is just your average Tuesday in comparison.

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