[Tehnix]

> As someone who really likes Haskell, I've found the response to the talk from Haskellers, like in that thread, really disappointing. The common refrains indicating that Rich doesn't understand Haskell, types, etc. are patronizing and likely incorrect. (I realize he's trying to hit a few targets, from C++ to Java to Haskell in one go, so it's not always clear which he's complaining about.)

I can see why you would feel that, if you hadn't seen Hickey's talk, being having seen it he was honestly quite patronising himself towards static typing, so no wonder he would risk getting some of the same tone back. That said, I don't think it is far off to say he doesn't understand Haskell, either that or he deliberately ignores the solutions that Haskell offer to the problems he's complaining about. Also, one commenter from the thread mentioned,

    I do know from interviews that he's done (MS Channel9, i think it was) that he has at least a passing familiarity with Haskell as of 5-10 years ago, but that's a completely different beast to what exists now

Including he himself mainly focusing on having been a C++ programmer.

> underestimate how little reach the type system has in an open system where data's flying around arbitrary services

There are certainly times when dynamic programming is nice and all, but I feel your statement is quite disproven with e.g. something like Haxl and Facebooks spam filter, which is an incredibly large scale open system, unless we have some different definition of that.

Finally, I agree Haskell and the like are not panaceas, but when a person goes out with incorrect/invalid points talking down about the effectiveness of a system, when in fact the users of it would agree it is highly effective, I feel like it does no benefit to the community to simply let it stand just because the person speaking is someone kinda famous.

[carljv]

> I feel like it does no benefit to the community to simply let it stand just because the person speaking is someone kinda famous.

That's not really what's happening. As I explained in my comment, I've found the technical rebuttals by Haskellers to be lacking.

Yes, of course Haskell can be and has been used to make large, high quality systems. I can say the same for C++. That doesn't mean there aren't costs associated with those languages, and good reasons why someone might want to make different decisions about how to design a language. This is literally what the talk was about: why Clojure was designed the way it was. Not why Haskell is a bad language (it's a great language), but why Clojure was designed differently. Pretending like the type system has no costs and only benefits is not serving the Haskell community well.

> I can see why you would feel that, if you hadn't seen Hickey's talk

Not sure what this comment is. I've clearly seen the talk. This pattern of assuming someone who disagrees with you must have less information is off-putting.

What I'm taking away from Haskeller rebuttals is: Haskell has solutions to all your problems, if only you're smarter than Rich Hickey. This is not, to me, a compelling sales pitch.

[tome]

> What I'm taking away from Haskeller rebuttals is: Haskell has solutions to all your problems, if only you're smarter than Rich Hickey. This is not, to me, a compelling sales pitch.

As one of the Haskell rebutters, let me give my point of view.

Firstly, "Haskell has solutions to all your problems" is a perfectly good overstatement of the case. No need to bring Rich Hickey's intelligence into it.

Secondly, Haskell gets you at least quite far towards Hickey's goals. Haskell does have solutions, or at least partial solutions, to all of the problems Hickey raises. Where the Haskell support is particularly weak, for example with row types, we've admitted that. Yet neither he nor his proponents here have shown any understanding of the Haskell (partial) solutions. If he or they had said "I know about all this great stuff, parametric polymorphism, generics, Dynamic, -fdefertypeerrors, ... but it still doesn't get you close to Clojure because of <specific reasons>" then he would be presenting a useful argument. As it is all we can do is disabuse Clojurists of their basic misunderstandings of how Haskell works.

Am I being hypocritical? After all, I do not know the intricacies of Clojure. But I'm not the one up on stage being filmed making claims about a language I don't seem to be familiar with.

[carljv]

I get why the tone of the talk is ruffling feathers. If I were a serious Haskeller, I think I'd be a little miffed too. But I think it misses the forest for the trees, and I think, as I commented before, it's hard to understand the context of his issues without understanding his interest in systems. So I get why a lot of rebuttals have been focused on his somewhat glib representation of certain features, but it's still a little frustrating, because I don't think it's a particularly interesting debate.

I also don't think he referred to Haskell specifically at any point, and really just spoke about algebraic type systems generally. It wasn't in the scope of the talk, and I don't think it'd be a very interesting talk, to compare Clojure and Haskell features. I bet he thinks Haskell is a great language. Clojure takes a lot of inspiration from Haskell: default immutability, core seq functions that look like Data.List; STM, etc. There probably wouldn't be Clojure without Haskell. His whole point is that types, like any other design feature, come with costs. They can be quite heavy and constraining compared to their benefits in certain contexts, and that may not be worth it.

That being said, I don't think it's a compelling rebuttal to say: "If you use Dynamic and fdefertypeerror, Haskell addresses his issues." You'd be run out of town writing Haskell code like that.

Re. parametric polymorphism, he explicitly talks about parametricity, and his take seems to be that he doesn't find parametric types that useful for conveying information or guaranteeing interesting things (to him) about your program. I think he's exaggerating, but I get that it's a response to a lot of breathless advocacy about how informative type signatures are.

Again, regarding his tone in the talk, I get it. But I think this should provide Haskellers a good opportunity to examine how casually dismissive they are of other languages, especially dynamic ones. IME, statically typed FP proponents are much more dismissive of dynamic languages than dynamic language proponents are of types. It's often "Your language is unsound garbage for lazy programmers" vs. "Sometimes the type system becomes an overly-complex constraint on my problem."

As someone who does like types, I'm nonetheless glad that there are folks designing sound dynamic languages and arguing for their usefulness.

[danwilsonthomas]

Part of the reason why I personally was so upset by the talk was that it felt as if there was no room for discussion or debate on the points raised. In addition there was what felt like a lot of sniping towards features of statically typed languages that felt designed just to get a reaction from the crowd. The fact that there was an entire slide designated to tearing down a series of videos by SPJ felt not only irrelevant, but also disrespectful. There seemed to be a lack of willingness to meet halfway and concede there was anything useful from the other side.

Perhaps most frustratingly, I know that RH is capable of much better, much more informative presentations. There might have been something worthwhile in here, but the tone, style, and majority of the content didn't make it worth digging out in my opinion.

Regarding Haskellers' attitudes, I'll add that I haven't seen anything like what you describe at least on the Haskell subreddit. It could be happening in other forums but by and large it's been a welcoming community even to those that come in skeptical.

[carljv]

It's a keynote talk, not a panel discussion. Most keynotes are expressions of strong opinions.

> The fact that there was an entire slide designated to tearing down a series of videos by SPJ felt not only irrelevant, but also disrespectful.

From the transcript:

"Simon Peyton Jones, in an excellent series of talks, listed these advantages of types." ... "And I really disagree just a lot of this. It's not been my experience."

How is that tearing down or disrespectful? I get there were a lot of glib bits in the talk, but as you point out, he's talked about these issues with more nuance at other times. It's a shame that hyper-focus on a couple of thrown off jabs at the costs associated with types is distracting folks from the very useful larger point he's discussion about levels of problems in programming, contexts of programs, and how languages that impose strong opinions about how to aggregate information can be counterproductive.

I think the Haskell community is, overall, very good and welcoming, but smugness does creep in a lot, IME. But if you want to talk about meeting halfway, I find that it's much less common to see static FP folks concede any benefits of dynamic languages (besides that they're "easier" in a kind of condescending way).

[tome]

> but it's still a little frustrating, because I don't think it's a particularly interesting debate

I agree this level of debate is not very interesting. Hickey did not give concrete examples. He caricatured a strawman Haskell rather than presenting Haskell as it is, that is as a language with at least partial, if not complete, answers to most of his complaints.

I've asked here about a very specific example that could enlighten the debate and I hope I'll get an answer:

https://news.ycombinator.com/item?id=15599451

> I also don't think he referred to Haskell specifically at any point

Ctrl-F "Haskell" finds three places he explicitly mentioned Haskell (and as it happens in all three places he was promoting misconceptions about Haskell). He also quoted Simon Peyton Jones. This talk contained a significant anti-Haskell component and it's clear he doesn't understand Haskell.

> I bet he thinks Haskell is a great language

I don't, given what he said about it. He talks dismissively that you have to "prove" things to the compiler, that pattern matching is a terrible idea, that some programmers think 'that "correct" just means, I don't know, "make the type checker happy"'. I don't think he likes Haskell at all. But that's fine, because he doesn't understand Haskell at all either.

> That being said, I don't think it's a compelling rebuttal to say: "If you use Dynamic and fdefertypeerror, Haskell addresses his issues." You'd be run out of town writing Haskell code like that.

Firstly, I didn't claim that Dynamic and -fdefertypeerrors address his issues. I said that unless he mentions them explicitly he's not demonstrating sufficient familiarity with Haskell's dynamic capabilities to be critiquing them.

Secondly, maybe you'd be run out of town for writing Haskell code like that, maybe not. If that level of dynamism genuinely adds business value as Clojure proponents are claiming in this discussion then why on earth wouldn't you write code like that?

> But I think this should provide Haskellers a good opportunity to examine how casually dismissive they are of other languages, especially dynamic ones. IME, statically typed FP proponents are much more dismissive of dynamic languages than dynamic language proponents are of types. It's often "Your language is unsound garbage for lazy programmers" vs. "Sometimes the type system becomes an overly-complex constraint on my problem."

That's an entire other discussion. Maybe Haskellers need to "examine how casually dismissive they are of other languages". Everyone and every community should be self-reflective. But I hardly think self-reflectivity is inspired by people promoting misconceptions about you. If anything it would be a Haskell apologia that promotes misconceptions about Clojure that should inspire the Haskell community to self-reflect.

> As someone who does like types, I'm nonetheless glad that there are folks designing sound dynamic languages and arguing for their usefulness.

Likewise. I just don't want them to spread disinformation and I'm not surprised when that disinformation is challenged.

Personally I've got a lot out of this discussion. I agree wholeheartedly with Hickey's criticism of "place oriented programming" and I'm a proponent of adding row types to Haskell. I've also opened my mind to reconsidering the benefits of programming with `Dict String Variant` or `Map String Dynamic`. I've worked in a place that used that style and I don't think it worked well! But I will turn it over in my mind a few more times.

[carljv]

Like I said, I get why the talk is ruffling feathers, and I think it's fair to feel he's being glib or exaggerating; he is. I've also seen Rich and others discuss these point with more nuance and detail elsewhere so I think I'm willing to interpret them in that more nuanced context.

Re. the Haskell mentions, they all relatively offhand and are usually combined w/ mention of another language, like C++ or Java. (I think this also doesn't help outside understanding since he's trying to talk about disparate static type systems in one fell swoop.)

Re. Rich's feelings about Haskell, there are not only the obvious language influences I cited, but also this very explicit response in the Clojure mailing list (https://groups.google.com/forum/#!msg/clojure/DUKeo7sT4qA/TU...)

"There is no purpose to a message like this.

Everyone, please refrain from language wars. Haskell is a tremendously ambitious and inspiring language, for which I have the highest respect. There is zero point in bashing it (or its users) in this forum.

Thanks, Rich"

Again, I see a lot of what looks like "bashing" to you as a response to an over-fetishization of "correctness," and over-hyping of types. I mean, how many times do you think Rich has heard someone complain that Clojure doesn't have types?

It's also nuts to keep saying things like "he doesn't understand Haskell at all."

Re. dynamism in Haskell, I still don't see this as a compelling point. Those things are unidiomatic and not really comfortable to use in Haskell. I mean, you can put type annotations all over your Clojure code, use typed Clojure, and spec and schema the crap out of your program and get all kinds of safety guarantees. I wouldn't make that an argument that Clojure can solve all your type safety concerns. It's just not a comfortable way to write the language. You can write functional code w/ immutable values in C++ and Java, but nobody does it, because the language makes it hard.

I raise the point about dynlang dismissiveness from Haskellers because I think in large part, the tone of the talk is response to a long history of Clojure being criticized and dismissed for being dynamic. I've used both Haskell and Clojure a lot, been in both communities, and really don't think this talk was the opening salvo of glib dismissals.

I think we both agree the sniping about pattern matching, etc. is not really that interesting, and my sense from the talk is that this is really a very secondary issue. (Indeed I think he makes the point that many features are good if you can get them a la carte, but having the language impose them on all your data can be costly.) It would be great to see Haskellers and Clojurians discussing bigger picture problems that go beyond language features, because the two communities share a lot of values.

[Tehnix]

I just wanted to say that your tone and approach in this whole discussion has been utmost pleasant, especially considering these topics are usually some that get quite a lot of people up their seats :) Props for that!

[tome]

That message to the Clojure mailing list is very reassuring, thanks.

> It would be great to see Haskellers and Clojurians discussing bigger picture problems that go beyond language features, because the two communities share a lot of values.

Yes it would be great. The Haskell and Clojure paradigms share too much and their communities are too small to have infights. We've got the whole mutable, OO, world to oppose, for example!