I was mostly thinking of Dlang or Swift, but even those are actually not quite the same due to the lack of runtime. I think Go doesn't qualify as a "systems lan

I was mostly thinking of Dlang or Swift, but even those are actually not quite the same due to the lack of runtime. I think Go doesn't qualify as a "systems language" due to the inclusion of the runtime -- do people call Java/JVM languages "systems languages"? The term "systems language" is almost certainly not precise enough. What I mean to convey was a language that you could write performance critical low level code in. In my mind though, Rust satisfies both that definition and the vaguer "backend service" (i.e. the thing spinning behind some interface doing the hard work in your architecture) -- it works very well from very low level all the way up to application programming. If we're taking the second definition (vague backend-service-y) then Rust has lots more good competition -- if you can afford a runtime then the right language can give you some pretty good safety for less than the cost of learning Rust's borrow checker. BTW I hear you on the haskell docs, how to start with Haskell is one of the hardest things. I personally took this path: - http://learnyouahaskell.com http://learnyouahaskell.com (a fun read, introduction to basics, good prose) - Writing some euler solutions (quickly stopping, they become just a mathematics fest after a while) - http://book.realworldhaskell.org/ http://book.realworldhaskell.org/ (excellent examples for real-world code) - http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html http://adit.io/posts/2013-04-17-functors,_applicatives,_and_... (when you feel like you really want to understand the big M) - Writing the backend for a project in haskell - Watching lots and lots of talks and attempting to read papers to just headbutt certain concepts over and over till I could somewhat begin to understand them. I've found the secret is just to let the stuff go over your head at least 2-3 times until you start finding it useful. But I want to stress that you don't have to write 5th order polymorphic dependently-typed whatever to get lots of value from haskell, here is some low hanging fruit: - Haskell has the type system you thought/wish Java/C# had (i.e. `type AorB = A | B`, `newtype PositiveNumber = N { _posNum :: Int } -- guaranteed through constructor to be >= 0`). The ease with which you can have types express intent is mentally revolutionary. - Behavior and object structure are separate, like Go's structs + interfaces or Rust's structs + Traits, and constraints (dependencies from one typeclass to another) are really easy to use -- ex. `class Thing a => BigThing a where { ... }` expresses the dependency that for a to be a `BigThing` it needs to first fulfill the requirements of being a `Thing` -- this is how you can force the existence of certain functionality on with polymorphism. Once you get used to this everything else (well, subtyping at the very least) will look primitive. - Concurrent programming is amazing, both due to STM and the very good threading model (lightweight routines multiplexed to system threads) - I will say that I think there's lots of low hanging fruit out there though -- Haskell has the type system you thought Java/C# would have. They really have "class" systems rather than type systems.