Adioso: have you talked to ITA Software (now part of Google) about licensing QPX? We solved the data issue, very painfully, over a 10-year period, by working directly with the airlines. (This was, in fact, one of my major contributions to the company as COO, and many people were involved.) Using QPX, you could implement exactly what you envision with stuff ITA already has running.

I'm a cofounder of ITA but am no longer affiliated with the company. But if you want to talk to people there, I can connect you. Just reply here with some way for me to contact you.

> Since the late 1990’s British farmers have been vaccinating hens against salmonella [...] Amazingly, this measure has virtually wiped out the health threat in Britain.

"Amazingly"? No not really! Vaccination stops disease. It's completely expected, not amazing at all.

edit: Likewise it's not "amazing" that cases of Diptheria, Measles, Polio, etc have been drastically reduced - by 100% in some cases - since widespread vaccination began in the USA (source: http://www.forbes.com/sites/matthewherper/2013/02/19/a-graph... )

I love the work that was put into this and there are some elements that I think are done extremely well and stand on their own...but after seeing a page where everything is flat, I've totally joined the non-flat side of the debate, due to the confusion/ambiguity of the interface...the buttons were especially jarring for me.

Actually, you're both right, you just had different experiences. With 2-6 hens, the flock is more centered around the human, allow themselves to be touched and hand fed, and exhibit recognizable personalities. With 10-20 hens, the flock is more "wild" and establish their own pecking order by being aggressive to each other (and grabbing all the food they can grab before the others). I had a flock of 12 and saw both kinds of behavior, though because we kept the roosters for a while, it tended towards the wild side.

Of course, chicken breeds, coop environment, and owner personality are huge factors in chicken behavior as well.

BTW, this is a great article in that it reveals a little about our industrial food chain. I suppose it's popular here on HN because it has a bit of the "How things work" vibe. There should be articles like this for every type of food sold in stores.

Good god this was funny, right down to the usernames.

But now its time to be very HN about it.

> Rats, top comments will be impossible to beat.

Actually I think I have a solution to this, though its just guesswork.

I'm not particularly well known here (or anywhere), but either people actually like the words I say, or I simply have yet to make a complete ass out of myself. (I think one of these is more plausible, but who is to say.)

My average karma on HN is 20.59, which seems to be a lot. Specifically, on the Leaderboard[1] that puts me in fourth place among the HN big names for average karma (though I have nowhere near the total karma to appear there).

I've noticed that when I reply to a post, even if there's already 30 comments, my post usually ends up at the top. And it stays there, even if no one replies, and even if I don't get many or any upvotes for it, for a few hours sometimes.

Alas I don't know for certain, but my guess is that if you have a high average karma then your posts are automatically weighted higher, so you can inject your opinion into almost any topic at any time. This affords me the luxury of being a contradictory whine even if I come late to the party!

Can anyone confirm or deny my suspicion here?

[1] http://news.ycombinator.com/leaders

I'm always amused by these posts praising how everything just works on the Mac, and how it's so nice not having to worry about [annoying linux/windows stuff #351].

Am I really the only one blind to this effect ? I've used a mac. It's nice. But it "just works" only until you want to productively use Finder, or you want to connect to a Samba server, or you want to shuffle files with UTF-8 filenames around, or a dozen other things like that.

I suppose I'm just not the target market. But I would have expected someone like the author not to be in it either, so.. shrug

I have to be honest - I find the developer tools a pain: They aren't even close to replacing Firebug, yet they're more obtrusive. So I can't stop using Firebug, and I can't remove the unwanted built-in menu options.

So for me personally, what I'd really like to see is either one of:

- Match Firebug feature for feature

- Allow for the dev tools to be completely removed from the interface

Sorry, but it really does come down to those two: Whilst the Dev Tools can't replace Firebug, I won't use them. So either allow me to get rid of them, or allow me to switch 100% to them.

Sorry it's not more constructive, but I've no interest in having to juggle between two different debug tools because they both have awesome features. So I don't care what amazing new stuff you might be lining up, I won't use them until all of the functionality I use in Firebug is also available in FF's builtins.

Haskell is also very simple--not from an implementation standpoint but from a semantics standpoint. Having polymorphism with no sub-typing (and no casting) is conceptually simple and easy to work with. Parametric polymorphism (like Java's generics but simpler and less horrible) is actually an extremely simple concept. The difficulty comes from a) implementing it in a stupid way after the fact (cough Java) or b) having sub-typing. Neither is necessary!

In this day and age, semantics are far more important than implementation.

You can fit Haskell's evaluation rules and its typing rules on one page.

Haskell's syntax is also very simple and consistent. It has fewer constructs than most imperative languages--fewer constructs than anything short of Lisp. It just also happens to be much more flexible than other languages.

Moreover, much of Haskell's syntax is very transparent syntax sugar. You can easily desguar it in your head. It makes code nicer to read but does not add any real complexity because it trivially maps to a bunch of simple function calls.

Most of Haskell is a very transparent layer over a typed lambda calculus. Lambda calculus is basically one of the simplest possible constructs. Ignoring the type system for a moment, it has literally three concepts: functions, variables and application. We then throw in some very straight-forward extensions like numbers, add a bit of syntax sugar and a type system.

The type system is also surprisingly simple. It has to be, for the inference to work! It's also very consistent in the way that is almost unique to mathematics. Consistency is pretty important.

This is where I shall bring up the "Simple Made Easy"[1] talk. It comes up a lot in these discussions, for a reason: most people mix the two up. I don't agree with all the points in the talk, but the core message is completely correct and very valuable.

[1]: http://www.infoq.com/presentations/Simple-Made-Easy

Simplicity is valuable. And Haskell, for all its being hard to learn, is simple.

IO is a great example here. Monads are difficult to learn, granted. But they are not complex. Rather, they are abstract. In fact, monads are extremely simple; the actual difficulty is twofold: it's not immediately obvious why they matter and they're too abstract to permit any analogies. Ultimately, a monad in Haskell is just any type with three simple functions that behave consistently--it's just an interface.

Go is not particularly simple; rather, it's easy. It's familiar. The syntax is more arbitrary, but it is C-like. The built-in constructs like loops are more complex and arbitrary (Haskell, after all, has no built-in iteration at all), but hey, it's C-like. The exposed features? Again, fairly arbitrary.

That's how I would sum up Go's design: arbitrary. And mostly C-like. Where C itself is pretty arbitrary. Especially from a semantics standpoint.

Essentially, Go has whatever the designers felt like adding. Just look at all the different ways you can write a for-loop! Or the fact that you have a loop at all. Haskell, on the other hand, has a deep and elegant underlying theory which ensures that different parts of the language are all consistent.

Haskell is much less arbitrary. Most of the features naturally go together. Many are just generalizations or facets of the same concept. Even the complicated, advanced features like "type families" or "GASDTs" are just fairly natural extensions of Haskell's basic concepts. It's very much akin to mathematical ideas, which have an elegance and consistency eluding most other languages.

Here's a particular example of how the features fit together: algebraic data types. Haskell essentially has two fundamental ways to create data types: you can combine fields into a record (like a struct) or you can have a choice (a tagged or disjoint union). The really neat bit? These aren't arbitrary--they're actually deeply related. In fact, they're duals of each other. Having both makes the most sense.

It also gives you a much better way to signal errors. In Go, for whatever reason, errors are essentially built into the language as an implicit tuple. However, in practice, you either have a result or an error. If you have an error, the result is meaningless; if you have a result, you shouldn't have any error! So it makes much more sense to represent errors as a variant, a choice--a sum type. This lets Haskell avoid baking in error handling into the language, making it simpler.

Haskell is as mixed-paradigm as the languages you listed. Those languages are imperative with some weak support for functional programming. Haskell is functional with some weak support for imperative programming. It's the same idea, inverted. Except Haskell can also support things like non-deterministic and logic programming. It's just that, for some reason, when people say "mixed-paradigm" what they really mean is "imperative with some functional support" and never "functional with some imperative support".

Sure, Haskell's syntax for mutable structures is awkward. But have you seen C#'s or Python's or even Go's syntax for functional programming? Compared to Haskell, it's just as awkward! And Haskell's "syntax" for mutable constructs is just a library; it can be improved. It just turns out that imperative features aren't useful enough for experienced Haskellers to warrant the improved syntax. (Also GHC sucks at optimizing sufficiently complex imperative code, I gather.)

There's a nice example of what you can do on Lennart Augustss's blog[2]. He essentially embedded a very C-like language into Haskell without using macros. So it's certainly possible, just not worth it.

[2]: http://augustss.blogspot.com/2007/08/programming-in-c-ummm-h...

So yes, perhaps Haskell will never be popular. But that's a social issue. It is not an issue of the language's qualities.

And it shouldn't stop you from using Haskell. At your startupt. Hint, hint.

Obligatory Emacs version: https://github.com/syohex/emacs-git-gutter

I thought that the latest browser tests showed that FF used less ram than Chrome. http://lifehacker.com/5976082/browser-speed-tests-chrome-24-...

Unfortunately, reputations stick.

This is generally one of the first things that people who decide to keep hens learn, and is reprinted in nearly every homesteader/farmer magazine ever.

(that said, I'm surprised to find it on the front page of hacker news!)

Where I live in NH lots of small farms and people keep a few hens, and most of the smaller places will mention this to customers.

Eggs from these "home hens" definitely taste different, though I doubt it has to do with washing and much more to do with hen diet.

(And now it's mid noon here, time to go home and make eggs. Far more important than any local food movement, for me, is living within walking distance to work!)