[michaelochurch]

I've seen startups killed by New Guy CTO Who Really Likes Java.

It's rarely a tool that kills a company, though. It's an attitude. It's not the tool's fault. If you use some Java (perhaps you need to be on the JVM, because you're doing Android development or because an external client wants Jars) but allow the better engineers to work in Clojure or Scala, you'll be fine. If you hire the New Guy CTO Who Really Likes Java and people are punished for using high-productivity languages, then you're fucked. (<whine>"How are we going to hire Clojure engineers?"</whine> "Train internal talent up to it, dumbass.") But you'd probably be fucked if you had that same guy and he was fixated on a different platform or language. It isn't Java's fault.

It's similar to the debate about Agile/Scrotum, in which defenders of these methodologies blame imperfect people for the messes that these processes often create. The Agile Manifesto is pretty reasonable, all considered. But the sorts of people who will impose Agile from the top down, as a justification for aggressive micromanagement and age discrimination (cf. the terminal juniority of a culture where even senior engineers submit to time tracking)... are also the sorts of people who will destroy your company if they ever get to make decisions that actually affect other people.

As for Haskell... I've never met anyone who regretted using it. Of about 20 cases where people put it into production, I've never heard of anyone regretting it. (I have heard regret stories about Scala, especially regarding the build chain circa 2011-13, though it may have improved.) There is one case where that company moved to F#, but it wasn't Haskell's fault so much as a standardization around the Microsoft stack.

[marktangotango]

>> Train internal talent up to it, dumbass.

Train an X programmer on Y, and you'll most likely get Y written as X for quiet some time, until they gain experience, if ever.

The disconnect I've always had with using Haskell for anything is; you never get a result until the entire computation is complete. Oh but monads they say. Well, monads seem an aweful lot like procedural code (to me, the uninitated, unpracticed) so what's the point again? That's not meant as a criticism of Haskell, but just one persons thought process on the issue. I'd use SML if I could.

[michaelochurch]

Train an X programmer on Y, and you'll most likely get Y written as X for quiet some time, until they gain experience, if ever.

Most companies are run by short-sighted mediocrities who don't look more than 3 months into the future. I think longer term. In the long term, the transition is worth it. The benefits of moving from Java to Haskell or Clojure, say, are worth a few months of struggling and first-time code. If you have half-decent programmers and a culture that allows people to take time to learn how to do things right, that pays itself off within the year.

The disconnect I've always had with using Haskell for anything is; you never get a result until the entire computation is complete.

That's not really true. If you need strictness, you can force evaluation and you don't need to use monads. I'm writing a Haskell class and I cover `seq` before I tackle monads in all their glory (i.e. beyond "here's how you do some basic I/O").

Oh but monads they say. Well, monads seem an aweful lot like procedural code (to me, the uninitated, unpracticed) so what's the point again? That's not meant as a criticism of Haskell, but just one persons thought process on the issue.

That's a fair point. Yeah, do-notation is a way to write imperative-looking code in a functional way. The truth is that for small programs, imperative code is often much more readable. That's how recipes are written, for example. Five lines of imperative code never killed anyone. It's when a function gets to 4,000 lines (often with multiple authors) that imperative programming completely shits the bed.

Monads, in short, are... a way to abstract around the concept of computational context so we can define what "stateful effects" are. `IO` has access to anything the machine can do. `ST` is single-threaded but stateful. `STM` can update some state (`TVars`) but has to follow the transactional rules. `State s` is a pure monad that looks stateful because it uses explicit state. Then we get to the monad transformer stacks, which are... potentially very complicated. (Phil Freeman's work with row types and the `Eff` monad in PureScript may replace the MT stacks one day.)

The point, in short is: imperative code is not evil, we're not trying to do away with it. We want to segregate it into functions that are preferably easy to read so we can reason about what stateful effects do happen. In Haskell, the monad system allows us to enforce this at the type level. You can look at the type signature and get an upper bound (unless "cheat functions" like `unsafePerformIO` are used; and they generally shouldn't be) on the space of stateful effects that can occur.

[zak_mc_kracken]

> I've seen startups killed by New Guy CTO Who Really Likes Java.

Of course, that's simple statistics. Java is the dominant language out there so it's going to be the most used language by startups that fail. That's a pretty silly argument.

And it works both ways: most of the startups that succeeded are based on Java (and other dominant languages). Hardly any of those based their product on Haskell. And again, I'm sure you can find a handful of those, but we're talking about statistical anomalies here.