Fully agreed, other than the fact that Rust is absolutely beating Haskell in being the usable-in-production choice (and Haskell is WAY ahead of any other ML languages). Rust has just enough ML type goodness to make a big improvement AND it has the affine types which are legitimately novel.
Haskell is still struggling with what exactly to do about Linear types (and get the whole ecosystem on board), and strictness. While lazy-by-default is really amazing for certain things, Rust's approach just wins out for production code, I think.
> In general the lack of quality is a side effect of the lack of liability in many software fields, not the programming language that gets used.
This is true, until you have languages with truly novel features, like an implementation of affine types, and strong compilers.
Even just the difference between errors-as-values versus exceptions is a huge difference in my book -- Rust code gives you a clear chance/requirement to handle every possible error.
Scala, Kotlin, F#, the ML inspired type system, with the plethora from Maven Central and NuGet universe packages, with IDEs from biggest IDE companies on the industry.
The biggest benefit over all these for me has been Rust is a more native and arguably easier to use across your stack, you can write a 1000 line lib in Rust with a C API and it will be almost no extra performance cost.
F# is even simpler but you have the entire C# and CLR complexity that you need to grok to read it.
Same with Scala, Kotlin and others... I find for people coming from not CLR or JVM or etc Rust has less to worry about.
I do agree all this also means a high intial learning curve but I just find myself liking the language more than others.
Honestly OCaml's ppx and multicore churn scared me away. And for performance focused stuff Rust is the best ML-curious language around, atleast for me and a lot of other people.
I personally like F# a lot too it might be the better language if only Microsoft invested in it more.
Kotlin and Scala on the other than are just imho too tightly coupled with JVM. I have seen AoT attempts for both but man are they not good enough.
Personally I just like the ethos of Rust more for some reason. The idea of safety through type system while ensuring we don't have any significant loss of performance is just awesome to me.
And I like to think a lot of people share that opinion.
I might be wrong, and so can a lot of other people but I just want to see the idea of Rust succeed.
To be clear I write a lot of Go and like Zig and Haskell as well but Rust just feels more practical. I am not sure what it is...
And I have checked I am not any less productive in Rust than in Go. Or anything else including C#
While I tinker and enjoy these languages themselves (Scala/F#), unless one doesn’t have the libraries and aren’t willing to write them, Cargo and rust-analyzer are just so good. That paired with the basic http-based work I do now, and the ability to use any IDE I want with minimal setup, I can pay the slight borrow checker tax for these ergonomics. Perhaps I’m a minority and just need to give Kotlin a chance.
Haskell is still struggling with what exactly to do about Linear types (and get the whole ecosystem on board), and strictness. While lazy-by-default is really amazing for certain things, Rust's approach just wins out for production code, I think.
> In general the lack of quality is a side effect of the lack of liability in many software fields, not the programming language that gets used.
This is true, until you have languages with truly novel features, like an implementation of affine types, and strong compilers.
Even just the difference between errors-as-values versus exceptions is a huge difference in my book -- Rust code gives you a clear chance/requirement to handle every possible error.