Hacker News new | past | comments | ask | show | jobs | submit login
Haskell Researchers Announce Discovery of Industry Programmer Who Gives a Shit (steve-yegge.blogspot.com)
429 points by pchristensen on Dec 1, 2010 | hide | past | web | favorite | 109 comments



140 points? Really?

I know it's fashionable in these parts to make fun of Haskell, but it's just not funny unless the writer knows something about the language. Would you upvote these articles?

* Why C++ is More Object-Oriented Than Smalltalk

* Stupid Ivory-Tower Academics Claim "Perl Is Too Slow for Weather Simulation"

* LISP: It Would Be a Lot More Useful Without All the Parentheses

It's especially galling considering pg's various articles on language expressiveness; remember this quote, folks?

"""As long as our hypothetical Blub programmer is looking down the power continuum, he knows he's looking down. Languages less powerful than Blub are obviously less powerful, because they're missing some feature he's used to. But when our hypothetical Blub programmer looks in the other direction, up the power continuum, he doesn't realize he's looking up. What he sees are merely weird languages. He probably considers them about equivalent in power to Blub, but with all this other hairy stuff thrown in as well. Blub is good enough for him, because he thinks in Blub."""

When somebody tosses around phrases like how to subvert Haskell's type system to accomplish basic shit you can do in other languages, it's a big red flag that they've never used Haskell, and possibly have never even seen Haskell code.


I think it's great that you've tried to provide a review criticizing this post. But please resist the urge to tell me what I ought to find funny, just as I have resisted the urge to tell you what you ought to find interesting.

Especially resist the urge to criticize others for liking things you find unworthy. Your comment's criticism of the OP is appreciated. Your comment's criticism of other members for voting for the post is, well, something else entirely.


Surely there are better places to post funny but thought-free links than Hacker News?


Have you ever tried to write satire? Done well, it's exceptionally difficult. The post may be many things but thought free is certainly not one of them.


Privately, I agree with you and I haven't upvoted it. After that, I suggest that our options are to (1) Flag it if it's really off topic, and/or (2) Criticize it, which I think you've done well. My only concern is whether we should (3) be galled or outraged that others have their own idea of what ought to be #1 on HN.

I like humour, and it seems like we share a personal preference for the kind that makes you laugh and then think hard when you realize that there's something incredibly insightful at the heart of the joke.

Alas, I'm not skilled enough to pull that off myself. All I can say about Haskell is to quote Alan Perlis: A language that does not change the way you think about programming is not worth learning. And given that, the sad observation that most "Industry Types" as stereotyped in the OP are not interested in changing the way they think about anything.

It's more than a Blub thing, it's a comfort zone thing.


I think comfort zone plays a part in IT developers seeming uninterested in "new" ideas. Closer to the heart of the problem IMO is that most business applications are just not very interesting. You can reduce them to: take input values from screen, run SQL query, and post query results back to the screen. Writing good SQL is the most challenging part.

In order for apps to be more interesting - making new ideas in IT appealing - businesses must be willing to re-examine their processes and change them with an eye towards better automation and some business intelligence. However, getting a single department in a business to change its processes is as monumental as changing global warming.

Of course, another issue altogether is COTS reducing the applications actually written in-house. Making intellectual investments in powerful programming languages is just not sound when a developer is simply writing "glue" code between vendor systems.

People do generally get jazzed up in IT departments when new technologies come around. Sure, there are technological curmudgeons, but very few. Enthusiasm gets dampened when it is clear that a good business case cannot be made for the new technology.

(I used "new" relative to an IT department's current environment and not in reference to age of the technology.)


This is humor understandable only by programmers, specifically, programmers who have some understanding of Haskell- I would hardly call that thought free humor.


I read your comments before reading the article, and fully expected to loathe the article. I found it well-written and amusing. I for one am pleased that it ranks highly on Hacker News.


Here's some content-rich Yegge for you: http://www.youtube.com/watch?v=BttI-y9VzXQ


Yeah, because lord knows how programmers hate to laugh.


See, other places, people would ignore the submission rather than focusing the conversation on the post. The effort required to rant about a humor piece on HN is considerably than the effort it takes to glance past the obvious satirically titled post.


please resist the urge to tell me what I ought to <verb>. Oh, wait . . .


This is the inherent irony of meta-commenting, and one of the reasons why many online communities try to either discourage or moderate it."Don't X!" "Don't tell me not to X!!" "Will you two stop talking about X!!!" And so forth.


Haskell is listed under Steve's "Favorite Languages", along with OCaml, Clojure, Common Lisp ans Scheme.

I don't think Steve is trying to make fun of Haskell so much as the idea of Haskell.


Actually I think he's making fun of the people who take Haskell really seriously.


I actually thought he was parodying the standard way to make fun of Haskell.


I think you nailed it :)


> 140 points? Really?

I think some of these votes are purely because the author is a very recognizable name who hasn't blogged in a while.

I for one broke out into a smile when I saw a new yegge blog post.


Absolutely. I'll blindly upvote any post by a respected name, simply because I'm always, always going to read their post. And I assume others are like me, and will want to be informed when a new "Yegge" comes out.


There's this thing called an RSS feed.


I don't believe this article was meant to make fun of Haskell, more to make fun of Haskell fans lack of a sense of humor. Don't take it too seriously.


I'm not taking it seriously, I'm just sort of baffled about it.

If this were an article talking about how FORTRAN is never used in industry because punch cards are too expensive, it would garner a few votes before being eventually buried. Perhaps one or two quick comments about how the author is uninformed.

Ditto somebody making fun of Erlang because nobody's written a web browser in it yet, or elaborating on why Python's poor industry adoption is because of mandatory whitespace.

There's a lot of material that could go into a satire on Haskell. For example, one could mention its extant-but-completely-useless shared library support. Or how quick midnight hacks end up becoming part of the language's standard definition. Or even the absolute absurdity of a package publishing system that mandates bumping your package version every time a dependency has a new release.

But he doesn't talk about any of that; anybody who's bothered to google for "haskell" has read his material on half a dozen blogs. "Monads are hard" is right up there with "why shouldn't I just make everything global?" in the list of topics useful for juicing pagerank, but nothing more.


> For example, one could mention its extant-but-completely-useless shared library support.

That wouldn't be funny. This article is funny because of the hyperbole of the usual criticisms (e.g. too academic). I think you have taken the post a bit too literally:

> "We crafted a fake satirical post lampooning Haskell as an unusable, overly complex turd -- a writing task that was emotionally difficult but conceptually trivial. Then we laced the post with deeper social subtext decrying the endemic superficiality and laziness of global industry programming culture, to make ourselves feel better. Finally, each of us upvoted the post, which was unexpectedly contentious because nobody could agree on what the reddit [OR hacker news] voting arrows actually mean."

His post is this fake satirical post, it's actually about "the endemic superficiality and laziness of global industry programming culture". So if you look a bit closer, you see he's making exactly your point: these criticisms are superficial.


Holy crap. He just tied the knot in prose form:

http://www.haskell.org/haskellwiki/Tying_the_Knot


Part of the article's popularity probably has to do with the popularity of Steve Yegge.


> Or even the absolute absurdity of a package publishing system that mandates bumping your package version every time a dependency has a new release.

Wait, what? Do you have a link for this? It sounds alarming, and I haven't heard of it.


Say you've got a package webbrowser, which depends on libhttp

The Haskell package versioning policy < http://www.haskell.org/haskellwiki/Package_versioning_policy > says that your package metadata should specify a minimum and maximum bound on which version of libhttp you support; this way, if a new version of libhttp is released that is backwards-incompatible, they can bump the version and every dependent package will still build correctly.

Say the author of libhttp realizes he really needs to add another parameter to a function. That might break dependents, so it's backwards-incompatible. So he bumps the version from 2.3 to 2.4.

Like a good package author, your browser's dependencies look like this:

    name: webbrowser
    version: 1.0

    build-depends:
      libhttp >= 2.3 && < 2.4
Now you can be notified of the change via < http://packdeps.haskellers.com/ >, download his new package, test it, and verify it works. You didn't use that function, so the change doesn't apply to you. You can change your metadata to:

    build-depends:
      libhttp >= 2.3 && < 2.5
Except now there's a problem. Hackage doesn't support modifying already-uploaded packages; there's no way you can say "webbrowser-1.0 supports 2.3 and 2.4", because it already has a record for webbrowser-1.0. So you have to bump your version:

    version: 1.0.0.1
And re-upload.

And your choice is 1) do this for every package and every dependency, or 2) ignore the versioning policy, hope no dependency changes break your packages.

It sucks.

The general feeling I get from core Haskell developers is that they work in finance, medical, or other fields where every dependency has to undergo a four-month certification process before it can be used. So they don't care about this, because they just never see it.

But for somebody who just wants to publish his stuff online and let others use it, it's a goddamn nightmare.

The other day, the developer of the 'text' package bumped his version to 0.11. As far as I can tell, it doesn't actually have any significant changes. All he did was fix an obscure edge condition when a particular function is passed invalid input. Everything that could build against 0.10, will build against 0.11.

Since I followed the package versioning policy, most of my packages < http://packdeps.haskellers.com/feed/?needle=John+Millikin > are set to refuse his new version. It's not too bad now, but sooner or later a user will upgrade their 'text' and then try to install one of my packages and then they will email me asking me why I am so mean and restrictive.

Which means sometime in the next week or to, I need to sit down for a few hours and recompile all my stuff, then bump the versions, then commit and tag and sign and push and sdist and upload. And somewhere in that hour I'm going to be thinking about just removing the bounds check, and letting my users deal with whatever hell befalls them if in three years there is a real breaking change somewhere.


At our startup we actually use Haskell for all our backend code and we've had a lot of package dependency problems. This was all due to people ignoring the versioning policy.

A package that is a bit outdated is far less worse than a package that refuses to compile, because someone felt the need to ignore the versioning policy.


Couldn't the package system adopt a policy like 'foo>=1.2 means any version 1.x where x>=2, foo>=1.2.1 means any version 1.x.y where x>2 or x=2 and y>=1, foo>=0.3.5 means any version 0.3.x where x>=5', etc? This would, at least, mean that bugfix-only updates wouldn't require everyone to bump their packages...

Also, isn't Haskell very statically typed? To the point that you could just assume that, if a package is compatible with foo>=1.2 and compiles against some foo with a higher version number (and passes the test suite, if any), it's also compatible with this new foo? That's mostly how the rest of the world does it, and it works.


That is exactly how it works. The version has four components: A.B.C.D. The first two, A.B, are the major version, and have to be bumped on incompatible changes. The third is a minor version, and has to be bumped if you add to the API. The fourth is free for you to do with as you please.

You can then depend on A.B.* in your package, meaning you get all bugfixes, but no API changes that would break your code.

And statically typed doesn't mean new versions automatically work. If you specify >= 1.2 because you tested with 1.2, and version 1.3 comes out, which doesn't work, people trying to build your package will automatically pull in 1.3, and their build will fail. Specifying 1.2.* means their builds will continue to succeed.


Just pointing out: there was a breaking change from text 0.10.x -> 0.11; a few functions were renamed for consistency with the rest of the Haskell Platform, which it is now part of.


Haskell being functional, that design decision makes some sense ;)


> I'm not taking it seriously

Serious enough to claim you found it "galling" and to paste a quote from Paul Graham that virtually all of us have probably read (including the author of the original post).


I agree with you. Just posting to say that there is an HTTP server in Erlang that's supposed to be very good: Yaws.


That's a server, not a browser ;)

I was using FORTRAN, Erlang, and Python as examples of languages which are heavily used in industry, but have neither the crushing popularity of Java/C# or the pop-culture appreciation of Ruby or Javascript. It doesn't really matter how much Haskell or Erlang are used, or how many billions of dollars pass through their runtimes every day; for whatever reason, the Internet has decided they are not popular.


Quite obscure, but I was surprised to find that a 3D modelling program, Wings3D, that I've used on and off over the years, is written in Erlang.


While I don't use Haskell that often to solve problems, I have a lot of interest in the language. I've given talks on why Haskell is important to groups of very average, very 'real world' programmers and it is precisely because of that that I found this piece hilarious. This isn't mean spirited attack on the language, it's making fun of the condition of being a Haskell evangelist more than anything else.


When somebody tosses around phrases like how to subvert Haskell's type system to accomplish basic shit you can do in other languages, it's a big red flag that they've never used Haskell, and possibly have never even seen Haskell code.

IMO, it proves exactly the opposite; a person could never say it unless they at least tried to write some Haskell code.


Subverting the type system is roughly equivalent to embedding assembly in C; possibly useful for very special cases, but almost never done otherwise. It's certainly not required to do anything commonplace.


I disagree. For instance, debug printing is a very common pattern in many languages.


You don't need to subvert the type system to debug print; simply use 'print', 'printStrLn', or for something truly complex, WriterT. Debug.Trace is available as a last resort, but in roughly a year and a half of writing Haskell code, I can count how many times I've needed it on one hand.


You can't inject 'print' or 'printStrLn' into a random function, which is the point of debug printing. And using 'Debug.Trace' qualifies perfectly as subverting Haskell's type system.


I'm not arguing that 'trace' is subversive, rather, most of the time it's simply not necessary (or useful).

Haskell's not like other languages, where you have to build up massive unreadable piles of code to get anything done. It's easier to write properly, with small functions glued together; and when you've done that, debugging is a matter of either simply reading the code, or running it in GHCI (and then reading it). Import your function, pass it input, see what comes out; when it's wrong, you know what the problem is.

Debugging with prints is for stuff that isn't pure, behavior that is outside the Haskell runtime system and thus can't be reasoned about. Which means you're using IO, which means you can take advantage of 'print' or whatever.


I'm not arguing that there are no ways to debug Haskell programs. My point was that the OP's phrase indicates at least basic familiarity with Haskell and debug printing might be the thing he had in mind writing it.

Haskell's not like other languages, where you have to build up massive unreadable piles of code to get anything done.

That's fanboyism. I understand you feel offended by the OP's post, but it is not a good satire unless it offends somebody, and IMO, the article is excellent in summarizing attitudes of some members of the Haskell community. ;)


You absolutely can, if only you're willing to break the rules. :)

(Note that this does NOT break referential transparency as long as you're not dependent on the program's debug output for correctness of the rest of the program.)

    include System.IO.Unsafe (unsafePerformIO)
    include Control.DeepSeq (deepseq)
    
    (unsafePerformIO $ putStrLn "OES NOES") `deepseq` doStuff
VVV EDIT: blocking would also block doStuff owing to the deepseq, which means that your program might take longer to complete but will either return a consistent result or none at all. Similarly, if it causes an exception, at least it won't have failed silently. Moreover, none of these complaints are any worse than those you'd find in another language and both cases are esily detected (i.e., you immediately know when referential transparency is broken), so it's still fundamentally safe as a debugging aid.

Let me state that another way: if there is no evidence that putStrLn fails, the result of the above is identical to the result of "doStuff" alone.

(Anyhow, upvoted your comment because your statement is certainly correct, even if I claim it doesn't invalidate my initial claims about debugging :) )


Even assuming independence from the debug output, `putStrLn` may fail or block, which breaks referential transparency.


Haskell researcher Javier Escuella remains hopeful that one day they may be able to double or even triple the number of industry programmers who give a shit about Haskell.

Wow, even Javier wouldn't have guessed the number would double so soon!


I think you're taking the article way too literally, especially considering who the author is (almost all of Yegge's rants are sarcastic or contain large amounts of sarcasm.) The dig isn't on Haskell, it's more on "industry" if anything.

I read it as more a satirical lamentation regarding the relatively low adoption of Haskell outside of academic-leaning circles. I, for one, upvoted the article and think that the upvotes are justified. I felt that the article held literary value and espoused an interesting and humorous (if a bit brash) take on this situation.

If you google around, it would seem that most professional Haskell programmers are PhD holders, and I think the point he is trying to convey is that this is a somewhat unfortunate situation given the power and potential of the language.


There have been "alternate syntax for Lisp" articles on the front page of HN, at least...


A few years ago (when Steve was still @ amazon), ocaml was one of his favorite language, and AFAIK, ocaml and haskell are the two most proeminent languages with a powerful type system. I think it is fair to say he has at least some vague idea of what he is talking about, even though it seems that in the recent years he was more enclined to go the dynamic typing route (again, only judging from his blog)


Your response is predictable and completely devoid of new ideas in addition to not being funny. I don't think it was even worth 4 but you've got over 30. Whatever. That's the way the system works.

The three sample article titles you offer are not even analogous to the original post. Yegge's title is a humorous re-working of the phrase "nobody gives a shit about Haskell," the subject of the article. Your suggestions are analogous to half-assed critiques of the language itself.

And again, they weren't funny. For example, instead of "LISP: It Would Be a Lot More Useful Without All the Parentheses" try something like:

    * Scheme is an exotic sports car. Fast. Manual transmission. No radio.

    * Emacs Lisp is a 1984 Subaru GL 4WD: "the car that's always in front of you."

    * Common Lisp is Howl's Moving Castle.
http://steve-yegge.blogspot.com/2008/11/ejacs-javascript-int...


My response was not supposed to be funny; it's a critique of an uninformed article.

None of your title suggestions match mine, because yours are true. Scheme is simple and no-frills; elisp is outdated and utilitarian. Common Lisp is...well, it's not Japanese, so he's lost me there.

But implying that Haskell is unsuited or unused for industrial purposes is absurd; most major Haskell libraries are written for companies, the main compilers are developed by companies, most papers are about solving some particular industrial problem, etc. Yegge's article might as well be about how nobody uses Erlang or Forth, it would make equally little sense.

Hell, the industry Yegge specifically calls out (finance) is known to use Haskell more than usual; Barclays, Deutsche Bank, Bank of America, and Credit Suisse especially. Barclays even released a paper detailing their experiences!


When somebody tosses around phrases like how to subvert Haskell's type system to accomplish basic shit you can do in other languages, it's a big red flag that they've never used Haskell, and possibly have never even seen Haskell code.

Well, actually, unless you've tried using Haskell you probably don't realize the it has a type system completely different from 'other languages'.

About Blub: That's a stick you can use to beat anybody who criticizes any other language. Oh, you don't think Brainfuck has anything to offer? Hah! Go read pg's essay on blub!


Well, actually, unless you've tried using Haskell you probably don't realize the it has a type system completely different from 'other languages'.

Really? Before I started using it, the only things I knew about Haskell were 1) it has a weird type system 2) it uses something called 'monads' and 3) doing IO is really really hard.

#3 turned out to be false, #2 was true but not as scary as the hype, and #1 was true.

It's not surprising that non-users know about the "odd" type system; types are one of the few ways arbitrary languages can be compared, so I know the type systems of many languages I've never so much as written Hello World in.

About Blub: That's a stick you can use to beat anybody who criticizes any other language.

Not so; one can use it to criticize anybody who claims a language is bad because it is more expressive than usual.

For example, there are languages with more expressive type systems than even Haskell; if a programmer used to such language called Haskell inexpressive, it wouldn't make any sense to argue against them with Blub (regardless of whether he's correct).


> completely different from 'other languages'.

It's not too different from OCaml or Clean. (Though, I do miss type classes in them.)


Also, Standard ML. I learned Standard ML and created a couple toy systems in it before becoming utterly frustrated with the insane state of the "standard" library[1] and fleeing to Haskell. I briefly considered OCaml, but of the MLish languages it seemed to me that OCaml had the ugliest syntax, so I chose Haskell instead. Dumb reason to choose a language, probably, but I absolutely adore Haskell.

...and I have spent an entire weekend trying to figure out how to describe within Haskell's type system something that is trivial in scheme[2] !

[1] In particular, there's a lot that's not in the SML spec that most people want in a stdlib, and every compiler's implementation is quite different. This means once you decide to use SML/NJ, if someone else has written a library you need, but for MLton, you're just up the creek. Perhaps this also happens with resp. GHC and Hugs, but I haven't found it to be nearly as much of a problem.

[2] If you care: can I create a function that takes as its arguments another function and a list, and applies the elements of the list as arguments to the function? E.g., listApply (+) [1,2] should return 3. In scheme, assuming that you already have curried functions, this is trivial. In Haskell, it's exceedingly difficult. Consider: the approach in scheme, iterative partial applications, absolutely won't work in Haskell, since the types won't match: (+) has type (Num t) => t -> t -> t, but (+1) is (Num t) => t -> t.

It turns out it's possible either with explicit isorecursive types (and some lifting functions) or using Template Haskell. For posterity, I posted both solutions on this old StackOverflow question I found when looking at how others had handled the same problem (viz., they hadn't, generally):

http://stackoverflow.com/questions/3775446/passing-list-elem...


I also love Haskell's syntax. It's very tasteful in most choices. Although my opinion of Python has gone down over the last few years, I still like its syntax, too. Especially the significant indentation, but I believe that Haskell has the slightly better mechanism, by defining indentation as a syntax sugar that you can avoid, if you want to.

OCaml's standard library is also quite dismal. At the recent meeting of the OCaml consortium in Paris we suggested creating a new extended standard library. (We will reuse Core and Batteries et al, of course.)

A co-worker and I are in the procss of writing a regular expression module that doesn't suck. It will be threadsafe and use poor OCaml---the module from the standard library calls C-code to run a backtracking bytecode interpreter with lots of mutable state.


Would you rather read another rallying cry about WikiLeaks?


Actually, I probably would upvote those.

I don't see the target of this post being Haskell itself. I see it as being the Haskell community. I see the thesis as being that Haskell has an undeservedly bad reputation and that its community doesn't really do anything to help by being elitist and disconnected from industry.


Actually, I saw their concern for industry being the target of the humor. Haskell is what it is; for the Haskell community to worry about industrial relevance is a funny, un-self-aware and touchingly pathetic "me too" reflex, like Bill Gates worrying about his pick-up skills or Bill Clinton wondering if his wife trusts him around other women.

(Sorry if that sounds overly political. I'm not a Bill Clinton hater or even disliker, but it's a perfect example and I just can't resist.)


The BillG pick up reference is probably a bit obtuse to anyone who hasn't read Accidental Empires... :)


I've been to some events of the Haskell community and hang out on the Haskll cafe mailing list. They don't seem elitist to me, and are quite fond of connections to industry. Where do you get those notions?


I don't get those notions. My point is that it seems to be that Steve got those notions.


Thanks for the clarification. I hadn't taken the indirect citation into account.


This is HN, we love Steve Yegge.


Articles fake, jmillikins comment only has 24 points right now, not 38.


"Avoid success at all costs."

I mentioned this at a talk I gave about Haskell a few years back and it’s become quite widely quoted. When a language becomes too well known, or too widely used and too successful suddenly you can’t change anything anymore. You get caught and spend ages talking about things that have nothing to do with the research side of things. Success is great, but it comes at a price. -- Simon Peyton Jones


"We crafted a fake satirical post lampooning Haskell as an unusable, overly complex turd -- a writing task that was emotionally difficult but conceptually trivial." - This is pure gold.


On the "truth is stranger than fiction" front, I got a good chuckle from the monads-in-Perl link http://www.perlmonks.org/?node_id=620692:

"Anyway, I think it would be worth doing, if it could be expressed readably, but I was not able to figure out a way to do that."

There is some deep irony in monads in Perl not being readable enough for Perl.


Actually, the "modern Perl" people are promoting a Perl style where your program contains more letters than special characters. They seem quite influential.


The only thing I liked about the article was the implied possibility of that sentence being self-referential.


If you don't find this funny, then you really need to examine your sense of humour, because this is not about making fun of haskell. It's barely about haskell at all. It is fantastically well constructed exercise in comic writing.

Stop thinking about the programming language wars for one minute and reread the text again, and look at the multileveled semantic games the author is playing. I thought most here were good at that?

Doug Hofstadter would be proud.


I chuckled, and I'm happy Steve Yegge might blog some more, but this feels a bit like shooting fish in a barrel.


As a "sort of" haskell programmer recently I admit I found it quite funny.


If only because you could fit all of the Haskell programmers into a barrel of standard size? I think that's the point of the article, actually.


More because it's easy to poke fun at Haskell in this way, even the Haskell people know they come off as obtuse and academic. AFAIK there's been much soul-searching in their community about how to get past that.

While Steve Yegge is a good satirist, I see this post as an extended version of this joke from the "Mostly Wrong History of Programming Languages":

Haskell gets some resistance due to the complexity of using monads to control side effects. Wadler tries to appease critics by explaining that "a monad is a monoid in the category of endofunctors, what's the problem?"


I love that joke, because I barely understand it, but minimal understanding just makes it funnier.


If Douglas Adams were to write about programming this is how he would do it.

That's a compliment.


Or the Onion. Not as much of a compliment...


I agree that this seems to be exactly in the style of an Onion article; however, I think The Onion has put out some hilarious stuff. For example:

http://www.theonion.com/articles/fuck-everything-were-doing-...


"I believe the root cause of the popularity problem is Haskell's lack of reasonable support for mutually recursive generic container types." -- Super funny!


"If we can create a monadic composition-functor wrapper that is perceived as sufficiently sexy by hardened industry veterans, then I think we will see an uptick in giving a shit, possibly as much as a full extra person."


She explained the trap they set for Briars: "We crafted a fake satirical post lampooning Haskell as an unusable, overly complex turd -- a writing task that was emotionally difficult but conceptually trivial. Then we laced the post with deeper social subtext decrying the endemic superficiality and laziness of global industry programming culture, to make ourselves feel better. Finally, each of us upvoted the post, which was unexpectedly contentious because nobody could agree on what the [HN] voting arrows actually mean."

Apparently their approach was more successful than they thought.


GHC Haskell actually supports mutually recursive generic container types, but you must enable type class system extensions which make type checking undecidable.


This successfully trolled me, because I think Haskell is really good stuff made by really smart and cool people. Surely there was a better target for satire.

I'm an industry programmer (in C). I also have a bunch of packages on Hackage.


Are you sure it's not making fun of the people who don't use Haskell?


Will there every be a satirical Steve Yegge post on HN that spawns any discussion other than quotes from the article itself?


That's what makes Yegge posts so long, I think: he thinks of everything people could say in response to his original "core" post, and then includes it in the post itself.


"Finding a person who gives a shit about Haskell is an inherently NP-complete computer science problem. It's similar in scope and complexity to the problem of trying to find a tenured academic who didn't have the bulk of his or her work done by uncredited graduate students."


Surely you could implement this search in at least O(n) time?


That's assuming that you can verify whether or not any given person gives a shit about Haskell in O(1) time.


At least is easy. At most is hard.


"At least, if not better." The context disambiguates the direction of magnitude.


Facebook uses haskell.

https://www.facebook.com/careers/puzzles.php (They only accept answers in languages they actually use.)


This was actually a personally test disguised as a blog post. See how you scored:

If you didn't understand it: You're not a hacker and never will be; go get your MBA.

If it upset you: You are a hacker without a sense of humor. You belong in a room without other people. Fed Ex will deliver your circuit boards tomorrow.

If you laughed once: You are an aspiring junior programmer. Keep on working hard and best wishes to you.

If you laughed more than once: You are a seasoned hacker. Nice to see you here.

If you sprayed Mountain Dew on your keyboard: You have that rare combination of understanding both bits and people. You must do great work.

If you are cutting and pasting these gems for your bulletin board: You and I must be kindred spirits. Email me. Let's do a start-up together.


If you write a post attempting to categorize everyone's sociability and competence based on how close their reactions are to yours: You are edw519


Loved the article, but someone please explain "faster than a teabagger with a grade-school arithmetic book". I'm pretty sure I got all the others.


In most of California and other hip areas of the country it is considered the height of wit to refer to people who support the tea party movement by puerile grade school insults ("teabaggers" - implying that they have something to do with scrotums). It is also assumed that anyone who deviates from the prevailing left-wing fashion must be unintelligent.

It is very rare that a supporter of the tea parties actually read any of these descriptions, since fashionable leftists primarily use such insults to signal to each other how enlightened they are. Referring to supporters of the tea party as "tea baggers" gets you +1 left-wing cred points.

Unfortunately, I live in California and frequent hacker news, so I'm the rare person who is insulted on quite a regular basis by my peers who assume I will think more highly of them for peppering such insults throughout non-political conversations (Hey, a satirical article on Haskell! Oh look, another person calling me an idiot for giving a shit about the size of the federal budget and wanting to do something about it before we go bankrupt.)


...their Giving a Shit gene shuts down faster than a teabagger with a grade-school arithmetic book.

http://en.wikipedia.org/wiki/Tea_Party_movement#Use_of_term_...

The implication is that TEA party constituents have no interest in actually understanding the grade-school math necessary to understand a budget.


Thank you very much (Canuck here so I don't usually get the political references).


There is a political movement in the USA called the Tea Party that included some demonstrations a couple years ago where they waved tea bags and called themselves teabaggers as a nickname.

Of course, teabagging has a risqué sexual connotation so the movement's opponents latched onto the nickname as the proponents dropped it.

The Tea Partiers are known for budget illiteracy, often suggesting impossible or mathematically absurd ideas to arrange government spending. At the lowest levels they suggest that cutting foreign aid and sex education will balance the federal budget. At the highest levels, they praise "courageous" budget plans like Paul Ryan's hand-waving and prayer plan to balance the budget by cutting taxes on the wealthiest and hoping that growth trickles down to all of us and health care costs magically stop rising. In between are the signs waving "keep the government's filthy hands off my medicare," the epitome of Tea Party campaigning this year.

So the story suggests that Tea Partiers have an aversion to basic arithmetic.


Honestly I think this is my personal funniest post of 2010. And no, it's not making fun of Haskell.


my new favorite Yegge post. very funny. and so true. :)


Sniff sniff. Whats that smell? O right, Onion worthy.


<Insert Dons and the usual angry Haskell fanboy diatribes here> </satire>


Diatribes?


Stop pretending Dons. It is quite amusing that you are voted up 5 times for such a content-less comment yet you and your associates are powerless to downvote the article.


I'll have my associates look into this matter.


there is no cabal




Registration is open for Startup School 2019. Classes start July 22nd.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: