Ask HN:  Why Haskell? - <AUTHOR> I was hating on Haskell the other day.  A lot of HN'ers apparently love it, because my comment was downvoted.
One of the replies said:
"I've seen experienced programmers failing at learning Haskell...the initial learning curve is very steep, and they don't see the value on climbing that wall...with Haskell, all those seemingly complex concepts come with a big reward." [1] [2]
My question is:  I currently don't see the value proposition of learning Haskell.  What is this great enlightenment I'm supposed to receive from studying Haskell?  Can someone give me the TLDR version?
PS:  If you say "functional programming", please elaborate.  I know all about function pointers in C, and I've read the docs of Python's functools module [3].
[1] https://news.ycombinator.com/item?id=7478274
[2] I don't want this thread to degenerate into a favorite editor flamewar the way the other one did, so I'm leaving out the commenter's clearly preposterous claim that learning vim is worth your time.
[3] http://docs.python.org/3/library/functools.html <comment><USER2> Perhaps three things:

* Haskell is (very) strongly and statically typed and Python isn't. Haskell's type system can prove the correctness of many functions at compile time. In contrast, Python usually waits until runtime to throw exceptions, even for something obvious like a syntax error.

* Because the types are known, there's an incredibly powerful testing framework called QuickCheck that is capable of e.g. generating tens of thousands of valid inputs and seeing if it can automatically disprove your assertions about your code. Python's typing is insufficient for this.

* Qualitatively, writing Python feels like writing instructions for computing something, and writing Haskell feels like simply describing what something _is_ , and the system works out how to compute it for you. It often feels compelling and magical.

Lastly, some tone stuff: Function pointers have nothing to do with functional programming. And why hate on a language you haven't studied? And why does there _have_ to be a TLDR version of a mind-expanding experience like learning a new programming style? Why form a strong opinion about something you don't know in the first place, and why feel entitled to challenge someone to explain it all to you? It's pretty frustrating.

<comment><USER3> _> Because the types are known, there's an incredibly powerful testing framework called QuickCheck that is capable of e.g. generating tens of thousands of valid inputs and seeing if it can automatically disprove your assertions about your code. Python's typing is insufficient for this._

I think immutability also helps on this front.

<comment><USER4> Just being statically typed helps, there's nothing particularly special about Haskell that makes QuickCheck possible.

<comment><USER5> Have you read the source to Haskell's QuickCheck?

It can automatically derive automatic randomized generation of your data-types _FOR_ you. No other generative testing library (such as for Clojure or Erlang) can do this.

Further, the random data generation can be customized using the functional combinator API.

Haskell QuickCheck's source code is a compelling example of what can be done with static types and typeclasses in Haskell.

<comment><USER4> > It can automatically derive automatic randomized generation of your data- > types FOR you.

There's nothing about Haskell (or some extension to Haskell, I presume) that makes this possible that wouldn't make this possible in other languages like C#, Java, or, with a bit more verbosity, C++. If I'm wrong, please say what it is, I'd love to know.

<comment><USER5> You're wrong and you should look into how typeclasses, derivation, SYB, and GHC generics work.

That they _aren 't_ doing it is reason enough. Clojure and Erlang's QuickCheck libraries would derive Arbitrary if they could. :)

<comment><USER4> I already know how they work. Still waiting for an explanation of what they can do that you couldn't do in Java or C# or (with some verbosity) C++.

Edit: For example, to answer this question, you could define a type and explain how Haskell lets you automatically generate arbitrary instances of that type, where Java or C#, being as limited as you claim them to be, would be incapable of doing so. Edit: Also, Clojure and Erlang are irrelevant. My comment you originally replied to said that static typing was what makes QuickCheck possible.

<comment><USER6> Let's use circles and rectangels to motivate some analysis. In Haskell you might define:

      data Point = Point { x :: Float, y :: Float }
        deriving(Generic)
      data Shape =
        Circle { center :: Point, radius :: Float }
        | Rectangle { topLeft :: Point, bottomRight :: Point }
          deriving(Generic)

In C# you could similarly define

      class Point {
        public float _x, _y;
        public Point(float x, float y) {
          _x = x;
          _y = y;
        }
      }

      interface Shape {}
      class Circle {
        public Point _center;
        public float _radius;
        public Circle(Point center, float radius) {
          _center = center
          _radius = radius
        }
      }
      // etc, for Rectangle ...

Let's start from the C# end of things. Let's say we want to do some tests on random Shapes and that we want to get an instance of a random shape by calling Generate.random<Shape>(). There are a couple of different ways to do this. We could explicitly define a RandomShapeFactory and a RandomPointFactory and then wire those up into the Generate class. Maybe we could use reflection to dynamically generate instances of Points and Shapes from their definitions at runtime. It would probably end up looking like some combination of the two.

Haskell doesn't let you magically generate random instances of Shape. The cool thing it gives is the "deriving(Generic)" part. Effectively, this causes the compiler to generate a description of Point and the Shape-Circle-Rectangle set of types. In many ways, it's like C#'s reflection. The QuickCheck library uses this reflection-like definition to generate random instances.

The core functionality isn't very different, but Haskell's approach has a number of advantages. Most importantly, it's type-checked at compile-time. In the C# version, I could call Generate.random<Cat> and the code would blow up at run-time, whereas we would just get a compiler error in Haskell. The other major advantage in this case is the reduction of boiler-plate. There's no need to register factory instances inside of some singleton object at startup, the type system can infer which Generic components are needed where.

C# and Haskell are both turning complete, so you can do anything in either language. Haskell makes certain types of programming more enjoyable by reducing boiler-plate and preventing annoying runtime errors.

EDIT - code formatting

<comment><USER4> > There's no need to register factory instances inside of some singleton > object at startup, the type system can infer which Generic components are > needed where.

You would only need to do that if you wanted to define custom behavior, instead of automatically derived behavior, and registering a few delegates is the same amount of work as manually implementing an instance of Arbitrary and CoArbitrary.

<comment><USER6> Yep. The only really-real difference is compile time checking.

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER7> When haskell programmers say "functional" they mean "functions, like in math": yes, mathematics has higher-order functions (derivative, etc) but the main thing is a mathematical function doesn't fire missiles or mutate variables (what we call "side-effects"). Writing code that's like math is "declarative"; you describe _what things are_ not _what to do_.

Others have given lots of good views on the various upsides to using haskell, especially the ways in which the type system can catch bugs for you. But my favorite thing about the type system is it lets you create good abstractions. For example it's possible (and often quite easy) to create a library which _cannot be used incorrectly_. And because you finally have abstractions which are good (not brittle or leaky) you can build on them to create larger abstractions (by "abstraction" here, think: conceptual unit that is easy to reason about). And that's also one of the challenges with learning haskell: there's more to learn because we can create new abstractions that are worth learning.

I like talking about haskell, but certainly won't presume to tell you you should learn it. But if you want to learn and are put off by what you've seen of it on HN for whatever reason, I can tell you that the community is incredibly generous and full of very kind and smart folks (though some humility and an open mind, as always, will get you far). The community is why I actually have something of a career in software today.

</comment><comment><USER5> Edit:

Before Haskell, I used Common Lisp, Python, and Clojure. I was impatient, generally more interested in hacking than math, and was happy using untyped programming languages.

Haskell changes the equation, it (alone, for now) provides even better leverage and expressiveness than untyped languages like Clojure, Python, or Ruby. Further, it does so in a way that is more powerful and reliable because you have the leverage of the type system behind you.

Learning to think about code in terms of types is a transformative experience.

Types is where the future is headed.

I've been getting people started with Haskell for the last ~3-4 months. It's not that hard to learn at all if you use proper learning material and do the exercises.

Don't waste any time, just learn Haskell and find out for yourself.

My guide for learning Haskell:

[https://gist.github.com/bitemyapp/8739525](https://gist.github.com/bitemyapp/8739525)

<comment><USER4> Have you ever used any other statically typed languages? How much of Haskell's benefit do you think it provides that simply having static typing doesn't provide?

<comment><USER8> \- Haskell types often guide development: the error message ("type mismatch: expected blabla") gives you strong hints about what sort of error you've made. The magnitude of this one is hard to convey by merely writing/reading about it though.

\- Easy wrapping to create new types: Ever switched the arguments of `mv` in your terminal (strings)? Read the User ID as an account balance (ints)? You can distinguish these statically, and it's easy to do so. (You can of course write a wrapper class in C++ around Int as well a la "class OtherInt { int value; int get(); set(int i) }", but how often do you do that?

\- No IO in a type? It cannot do IO. Has "Monad" in the type? It can do Monadic stuff, but no operations specific to any Monad instance (such as Maybe, IO, ...).

\- Types are forced documentation. Don't get me wrong, no documentation is as awful in Haskell as it is anywhere else. However, even without any ordinary comment, a type can give away a lot of what a function does; maybe even more importantly, it tells you what it cannot do. If you see something of type `(a -> b) -> (a -> a)`, you know that the first argument cannot possibly be used - it has to be a dummy parameter.

<comment><USER9> How do you do documentation in Haskell? For Python and Clojure, there's docstrings. For Java there's Javadoc. For Haskell, there doesn't seem to be any well-established documentation practices.

This is of course not counting the occasional comment explaining why/how you're doing something convoluted.

<comment><USER8> > For Haskell, there doesn't seem to be any well-established documentation > practices.

Oh yes but there is! It's called Haddock. It's widely (and probably exclusively) used. The entirety of the documetation you can find on Hackage [1] (example: [2]) is generated using it. The user guide can be found here [3].

[1]: [http://hackage.haskell.org/](http://hackage.haskell.org/) [2]: [http://hackage.haskell.org/package/pipes-4.1.0/docs/Pipes- Pr...](http://hackage.haskell.org/package/pipes-4.1.0/docs/Pipes-Prelude.html) [3]: [http://www.haskell.org/haddock/doc/html/](http://www.haskell.org/haddock/doc/html/)

</comment></comment></comment></comment></comment><comment><USER10> One aspect that doesn't get mentioned much is recruiting from both sides.

As an engineer, if you land a job coding haskell you're pretty much guaranteed to be an environment thats extremely engineering-centric, has minimal technical debt, and is staffed by lots of smart people. usedox.com, alpha heavy, jane street (ocaml but close enough), silk, tsuru, fobo are all exemplary examples of this. anyone of them is an amazing environment and you'll learn a ton. (the first one is my own company, so consider that one with a grain of salt)

As an employer of engineers, if you put out a call for haskellers, you'll get a far smaller applicant pool than say ruby, python, java, or c#. But the signal to noise ratio is incomparably higher. Very few mediocre engineers will claim haskell as a skill.

<comment><USER11> Hi. At your company and other Haskell teams that say they hire elite engineers, is an engineer's compensation higher than comparable non-FP shops?

Please forgive the bluntness; as a guy who is about halfway down "the road to Haskell", it seems like none of the shops that say they value FP are willing to pay more for it. For me, it's been easier to extract money from a javashop that's starved for talent and just figure out a way to install FP there. DK effect might also be clouding my self valuation.

<comment><USER10> DK effect?

I can only speak to my current company (dox) and Jane Street, where I worked a long time ago.

At JSC, comp was above market and everyone was quite happy but they've quadrupled in size since my time so YMMV.

As Dox, we are currently bootstrapping off of a small round and everyone is working well below market in terms of cash but with commensurately higher equity. we will be raising a round later this spring and intend to roughly match or exceed comparable shops when that round closes. we've been completely transparent about that to the entire team as they've all taken pay cuts to work with us a this early stage, something we respect and are extremely appreciative of.

If immediate salary is a principle concern, probably best to look at JSC, Stan Chart, or Barcap rather than a place like us or one of the other startups.

<comment><USER12> _" DK effect?"_

[http://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect](http://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect)

</comment></comment></comment></comment><comment><USER13> A while back I was learning Haskell. I had a problem I wanted to poke at a bit, so I thought I'd give it a try. So I made various types in Haskell's nifty type system, which is NOT hard or tricky. I made some functions to work with the types. Easy. I worked all this stuff up and tried to compile, and being that I wrote a fair amount of code of course there were a couple of typos, etc. But then there was another part that wouldn't compile because I'd made an error, and the type system called me out on it. It's like getting the benefit of _unit analysis_ (or _dimensional analysis_ ) from the compiler.

That's one thing to like. A lot. There are other things. Polymorphism/overloading through type classes is so easy and clean it's hard not to love. The list goes on and on.

For my part, I got hung up a bit on using monads. This was a few years ago, so maybe there are better articles/explanations now, but at the time there were a zillion monad tutorials, all of them written by people who almost but not quite "got it". I need to try Haskell again.

<comment><USER8> The _Monad tutorial fallacy_ is an in-joke in the Haskell community nowadays, born out of what you observed: when people feel like they understand monads, they are so happy about it that they write a bad tutorial about it.

My advice: Monad is a typeclass, and typeclasses unify things that act alike. Learn Monad instances (List, Maybe, State, ...) separately without worrying about how they are "monadic". After some time you will develop an intuition for what do, <-, return, >>= etc. have in common. And that's what Monad is.

</comment></comment><comment><USER12> _" [2] I don't want this thread to degenerate into a favorite editor flamewar the way the other one did, so I'm leaving out the commenter's clearly preposterous claim that learning vim is worth your time."_

Asserting that a "claim that learning vim is worth your time" is "clearly preposterous" is not exactly the straight and true path through the valley of flamewars.

</comment><comment><USER14> Short version: Most, if not all programming bugs are due to your code receiving something it did not expect. Haskell's type system helps eliminate this problem by forcing your code to declare exactly what it expects, and to handle all cases of said expectations.

In other words, it's doesn't let you skip out by not thinking about the entirety of your code. It's the same line of benefits that TDD gives you, but TDD is, IMO, a stepping stone towards the pure, functional programming that Haskell provides.

Note that I am by no means a Haskell programmer. To me, Haskell is the "last level" in learning development. I hope to one day reach such a level.

<comment><USER4> > Short version: Most, if not all programming bugs are due to your code > receiving something it did not expect. Haskell's type system helps eliminate > this problem by forcing your code to declare exactly what it expects, and to > handle all cases of said expectations.

No it doesn't (force). It's about as good as C++ on this front, with better error messages. What it does do is make it a lot easier to program in a style that handles all cases, but without forcing you to do so. You can pattern match on something instead of making a visitor. But you can still call head or tail.

<comment><USER5> Your comment misrepresents the reality for Haskell programmers.

<comment><USER4> If you wanted a useful reply you could explain how. The grandparent has things backwards -- it's possible for functions to force restrictions on their _callers_ (by forcing them to pass a pure function as a parameter). The caller can't _force_ the callee to consider all cases of its input.

</comment></comment></comment></comment><comment><USER12> Haskell's biggest win is the power of its type system, including its ways of getting types places other languages simply can't.

In C and Python, "a statement" is a different kind of thing than "an expression". Statements don't "have types" \- the expression that makes it up may, but the value winds up discarded and the type doesn't matter (except maybe to produce a "unhandled value" warning, if you've set things up for that).

In Haskell, statements are just another kind of expression, and the types of those expressions determine how they get chained together. This means I can leverage the type system to help me avoid new kinds of errors - want to be sure you don't try to do I/O in an STM transaction? Or access that variable from the wrong thread? Or... In Haskell, that's straightforward. In C, that's not something you can express and you have to check it all by hand.

</comment><comment><USER15> Here's a handful of things I really appreciate about Haskell, although some of this apply to other ML family languages as well:

1.) Algebraic Data Types let you enforce a huge amount of correctness in your programs simply by how you define your types.

For example, say you have a data type that represents a player's state in a game. If the player is alive, he has a "HP" and "inventory" record. If the player is dead, he should just be dead—HP and inventory may or may not be set to 0 and None, respectively. In C or OOP languages, you just get a player object/struct and you have to enforce this state logic manually, and you can easily write a function that puts the player in an inconsistent state (player.alive = False, but player.HP = 15). In Haskell, you can define the player such that code that produces this kind of inconsistent state will not compile.

Of course, you should still write tests in Haskell, but it's amazing to me that the type system can catch the vast majority of programming errors before your program even compiles. It takes longer to get something up and running, but you make up for this up front cost with long term gains in maintainability.

2.) Functional purity enforces two very useful properties:

a.) Data is never mutated by accident. This ensures you never have to look beyond the scope of the function you're working on (or closing over, in some cases) to know what's going on. You can then compose these functions to create more complex programs.

b.) When you do need mutability and side effects to happen, Haskell forces you to be very explicit about this and enforces a strict separation between "pure" and "effectual" code. This seems arbitrary until you realize that almost all of your errors not caught by the compiler happen because of IO. Whereas you have complete control over the pure part of your program, IO is nondeterministic and full of exceptions and edge cases. Separating this part of your code makes it far easier to reason about what's happening, adding to maintainability.

As a side note on the last point: people make the argument that this separation makes Haskell impossible to do printf debugging. Not true—the standard library provides ways of circumventing the type system specifically for this reason.

3.) "Monads" and other fancy sounding abstractions can be hard, but with practice they become as intuitive as inheritance in OOP. The real barrier to entry is the awful, awful documentation everywhere. I make no apologies for that: it's just really shitty and the community needs to do a hundred times better.

<comment><USER4> > In C or OOP languages, you just get a player object/struct and you have to > enforce this state logic manually, and you can easily write a function that > puts the player in an inconsistent state (player.alive = False, but > player.HP = 15).

False. In OOP you can do this using the visitor pattern. The difference is that Haskell makes this real convenient, with its algebraic types feature baked into the language, while OOP makes it very cumbersome.

> As a side note on the last point: people make the argument that this > separation makes Haskell impossible to do printf debugging. Not true—the > standard library provides ways of circumventing the type system specifically > for this reason.

It's still far more annoying when the language is lazily evaluated and has Haskell syntax.

<comment><USER15> > False. In OOP you can do this using the visitor pattern. The difference is > that Haskell makes this real convenient, with its algebraic types feature > baked into the language, while OOP makes it very cumbersome.

I don't think we're on the same page here. I meant to say that Haskell protects against inconsistent states: you literally cannot create a dead player with HP and Inventory records. I don't have a strong grasp on the visitor pattern, but I'm not sure how it can be used to accomplish compile time guarantees that the properties of an object will always be correct.

> It's still far more annoying when the language is lazily evaluated and has > Haskell syntax.

Python:

      def f(x,y):
          print x, y
          return x + y

Haskell:

      f x y = traceShow (x, y) (x + y)

Laziness is a separate issue altogether. Debugging lazy behavior is difficult in any language, and you would have similar problems in Python if you were testing deeply nested generators.

That said, laziness should not be an issue if you are simply testing that functions are correct, since most functions are pure and you will almost never use lazy IO.

If you need to debug evaluation order or a memory leak, that's much harder, and admitted one of Haskell's biggest weaknesses. My answer here is that you should almost always prefer strict data structures and functions unless you really need laziness. That's not a cure all, but it is a good policy when programming in Haskell.

<comment><USER4> > don't think we're on the same page here. I meant to say that Haskell > protects against inconsistent states: you literally cannot create a dead > player with HP and Inventory records. I don't have a strong grasp on the > visitor pattern, but I'm not sure how it can be used to accomplish compile > time guarantees that the properties of an object will always be correct.

An example of the visitor pattern:

        class LivePlayer;
        class DeadPlayer;

        class PlayerVisitor {
        public:
          virtual void VisitLive(LivePlayer *p) = 0;
          virtual void VisitDead(DeadPlayer *p) = 0;
        };

        class Player {
        public:
          virtual void Visit(PlayerVisitor *v) = 0;
          virtual ~Player() { }
        };

        class LivePlayer : public Player {
        public:
          void Visit(PlayerVisitor *v) { v->VisitLive(this); }
          LivePlayer(int hp, std::vector<InventoryItem> inventory)
            : hp_(hp), inventory_(inventory) { }
          int hp() const { return hp_; }
          const std::vector<InventoryItem> &inventory() const { return inventory_; }
        private:
          int hp_;
          std::vector<InventoryItem> inventory_;
        };

        class DeadPlayer : public Player {
        public:
          void Visit(PlayerVisitor *v) { v->VisitDead(this); }
          DeadPlayer() { }
        };

This is equivalent to the Haskell code

        data Player = LivePlayer Int (Vector InventoryItem) | DeadPlayer

including the fact that in this example the objects are immutable.

Instead of using a case expression to pattern match over the player, you'd have to construct a PlayerVisitor and implement the visit methods on that type.

Things can be made a bit less cumbersome than that, for example in a language with lambdas, you can just have the Visit method take a lambda for each subclass, and each subclass's implementation calls one. That makes it arguably equally convenient to use the types (with some extra parentheses), but it's still much more annoying to define the types that way in the first place.

<comment><USER16> I think even the visitor pattern isn't required here, all you need is subclassing. Although this clutters things up more by having abstract methods in the base class, technically that's all you need.

<comment><USER4> Sure.

</comment></comment></comment></comment></comment></comment><comment><USER17> I've spent the last two months wishing I'd written the project I'm working on now in Haskell instead of C++ - the main reason? Lazy evaluation.

I'm working on developing a new algorithm, which is most easily defined as a set of constant functions over my data structure (a DAG with about a dozen node types). There's a fair number of places where I want shortcuts to not calculate things if they're not needed, and with Haskell's lazy evaluation I'd be able to just let the compiler handle most of those (the pattern matching constructs would make my functions-by-cases cleaner to define too).

I'm doing some funny stuff with memo tables indexed by object pointers that would be trickier to do in Haskell, but I think there's likely a library I could leverage.

</comment><comment><USER11> Functional programming is where you end up if you ask the question, "how can I write better software more quickly with fewer bugs". I know of no shortcut to grokking why FP makes this possible other than just learning how to do it.

<comment><USER18> Cribbing someone else's answer to my similar question (a couple months ago):

Pure FP means _no_ side effects. Side effects cause your state space to explode. (That is, no side effects means that the results of this function depend on its inputs only. Side effects means that the results of this function depend on its inputs, member variables of the object, file variables, global variables, the state of various things in the OS, user input read during the function, data read from the network, and maybe a few other things. It's _much_ harder to understand such a function, get it working correctly, debug it, and prove that it correctly handles all corner cases.)

The size of the program state space is your enemy, not your friend. Control it or die. FP dramatically helps you control it.

</comment></comment><comment><USER19> I've always disliked the notion that Lisp or Haskell are only worth learning because of some revelation they give you which makes you more productive when you inevitably return to a mainstream language. Yes, there are some good insights that both languages give you, but the real argument for using them is that you can be more productive _in those languages_ , and that it is reasonable to use them in a production environment for that reason. I don't think the "return to mainstream languages" is inevitable at all, and I am very happily using Haskell in production at my current job.

With that out of the way, what are the benefits? There are quite a few. The following is not a complete list, but I'll try to hit the main points.

First, type safety. This is the primary argument for Haskell over something like Common Lisp or Clojure, and it is hands-down the strongest reason I choose to use Haskell. I used to hate static typing, because I thought static typing meant writing a bunch of boilerplate that didn't really get you anything and frequently got in your way. In Haskell this is not at all the case. As it turns out, type systems have improved dramatically over the past decades. In Haskell we have inference, so no boilerplate, and we have incredibly powerful facilities for polymorphism, so the type system provides real benefits. Being able to derive instances of type classes actually drastically _decreases_ the amount of necessary boilerplate, even compared to dynamic languages. There's a common saying in the Haskell community that if it compiles, it probably does what you want it to. This has been my experience, and it is incredibly pleasant.

Second, rigorous isolation of side effects. Countless programmers have independently realized how good this is over the course of their careers. Haskell enforces it. Knowing that a given pure function can't possibly break something in another distant part of the application is wonderful, and completely prevents entire classes of bugs.

Third, the community. Haskell's community is often made fun of as being overly academic or too distant from the realities of programming, but in my experience the community's love of abstract mathematics is a massive benefit. One easy example is Edward Kmett's lens library. It is unabashedly abstract in its origins, and parts of it are still a little over my head. Despite that, it is perfectly usable without knowing the math behind it, and it is actually _extremely useful_ in day-to-day programming. Things like functors, monoids, and monads are often poked fun at, but they are just way too useful for me to care. In this sense, the community is a huge asset, because people keep churning out these useful tools that you just won't see in other languages.

Fourth, conciseness really is power. I often find myself writing one liners that would require a dozen or more lines in the other languages I've worked in. This frees me up to focus on the business logic, which is what actually matters.

Parallelism is also a huge selling point, but I'll let someone else cover that because I don't have a ton of on-the-ground experience with it.

Honestly, when I have to sum up in one sentence why I love using Haskell, it's because it makes my job easier. At the end of the day, it's really that simple.

<comment><USER20> > As it turns out, type systems have improved dramatically over the past > decades.

These kinds of typesystems were available in ML since 1973. SO they are available to us for 41 years.

<comment><USER21> I'm general, yes. The particulars have been refined.

</comment></comment></comment><comment><USER22> > _If you say "functional programming", please elaborate. I know all about > function pointers in C, and I've read the docs of Python's functools module_

That's maybe 1% of functional programming, if that. And from how you write about it, it seems like you haven't even tried to dabble with that (I mean, merely "read the docs of the functools module"?).

But, if I may, I think the issue here is not about Haskell. Judging from the Haskell query, and what you write about learning Vim, I think you have a general aversion to anything that doesn't have an instant payoff and/or isn't trivial.

Of course you can go on not knowing Haskell or Vim and 100 other things. Many do, and don't lose much, because there are other things.

But if you go on avoiding anything that needs hard work and only offers a future pay-off, that is, anything with a learning curve, it will certainly hold you back. That is, if your ambition is to be a very good programmer (which might not be).

If, on the other hand, you just want to have fun, and are content with easier stuff, there's really no reason to learn Haskell or anything hard for that matter.

<comment><AUTHOR> > That's maybe 1% of functional programming, if that.

I was asking where I can find the other 99%.

> And from how you write about it, it seems like you haven't even tried to > dabble with that

Yes, I have. I use functools.partial all the time, and I've written programs that use function pointers in C before. I'm just trying to figure out whether "functional programming" means "passing functions around functions as objects and the sorts of hacks you can do with args/kwargs in Python," or if there's something more than that. For all the replies I've gotten in this thread, the best answer I've gotten is "it's all of the above plus immutable state."

<comment><USER22> > _Yes, I have. I use functools.partial all the time_

Well, "I read the docs" doesn't convey that. And "partial" is just, well, a very small part of it.

> _and I 've written programs that use function pointers in C before. I'm just > trying to figure out whether "functional programming" means "passing > functions around functions as objects and the sorts of hacks you can do with > args/kwargs in Python," or if there's something more than that. For all the > replies I've gotten in this thread, the best answer I've gotten is "it's all > of the above plus immutable state."_

Only very superficially. Passing function pointers in C is just dipping your toes in functional programming -- if that. Let's say that those are the tip of the iceberg -- and that the whole idea lies in the interplay of functional concepts (much further than what people usually do in C, unless they implement their own ad-hoc Lisp in it).

It seems like what you picked as "the best answer" from this thread is the one that reinforced a preconceived opinion, without having to actually try programming in a functional language.

How about this reply you got above: "Lastly, some tone stuff: Function pointers have nothing to do with functional programming." \-- and others like it.

</comment></comment></comment><comment><USER23> _Stateless programming_ is what the craze is all about. A lot of programmers grew up on C-style "x = 3;" kind of programming, so to write 500 good lines of code without an assignment operator can be a bit like walking down the street on your fingertips.

There is _nothing special_ about Haskell. Every single one of its qualities have been / will be reimplemented in other languages. Do not stare at the tree that is Haskell: talk about the forest that is PL research / features.

For example, Shen is a great mindbender close in "power" to Haskell. It's a Lisp, it has an [inferential] static type checker, and only 2 functions in Klambda aren't referentially transparent.

Personally I dislike Haskell's syntax and think Worse is Better, anyways. ;)

</comment><comment><USER24> How do you know why Haskell is superior to whatever you're using? Haskellers will tell you.

It should be permitted not to think Haskell is the best thing ever, but in practice downvoting is heavily used for certain disagreements of opinion and this is one of them.

</comment><comment><USER3> I think if the curve is too steep probably you are trying to learn too much at a time. Focusing on small and well defined problems will help you out at least initially. For instance I used Project Euler[1] to study some of the basics, because the tasks there are well constrained and you cannot do too much architecturally. You will learn the mechanics of writing small functions, defining types, and then you can move onto something bigger, where high level concepts are involved.

[1] [https://projecteuler.net/](https://projecteuler.net/)

<comment><USER8> I don't think ProjectEuler is very helpful for learning a language. The first ten problems or so might be useful to learn the basic syntax, but after that it's really just about number theory, or optimizing brute force.

If you're looking for Haskell beginner exercises, I recommend

a) implementing functions from Prelude, Data.List, Data.Tree yourself

b) doing the exercises given in RWH (even if you don't actually read the book - just do those you understand).

RWH: [http://book.realworldhaskell.org/read/](http://book.realworldhaskell.org/read/)

<comment><USER16> exercism.io isn't bad either

</comment></comment></comment><comment><USER25> One of the biggest perks of Haskell is that it has a very good static typing system.

I wrote a blogpost awhile ago on the benefits of such a typing system, it's kinda long but you might find it interesting:

[http://bsamuels.net/blog/2013/11/20/StaticTyping.html](http://bsamuels.net/blog/2013/11/20/StaticTyping.html)

</comment><comment><USER26> Haskell encourages you to think upfront about the shape of your data, because you have to design the types upfront and your constraints are checked at compile time. You can build a level of reliability and quality into your software that's hard to achieve (not impossible, but rare without great programmers) with a dynamically typed language.

There's a certain imprecision that you see with mediocre programmers. They don't know how things work, and get used to fooling around with a certain squishiness that's tolerated on large object-oriented projects as long as there's one good programmer ("architect") in the batch to clean up messes. That's good enough to get by in the business world, but not if you really want to understand what you're doing and call yourself a true programmer.

Haskell forces you to build from the ground up, and a nice consequence of this is that, for any type, you can inspect its pieces and get down to the bottom. Functions will have easy-to-find type signatures and, sometimes, you can get a good sense of what the function does from its signature.

In fact, in Haskell, the type system can be used to make assertions about functions like "this function doesn't have any side effects" and it's trivial to do so.

In the long term, Haskell's heavy use of immutable data structures confers some major performance advantages as well.

Is it the right language for every purpose? No, but it's very good for many, and it's a source of great ideas that have percolated into other languages, like Clojure and Rust. Additionally, it will force you to think rigorously about your data and what is happening to it.

<comment><USER16> I like the balanced tone you employ here. Not a fanatic but reasonable about the analysis.

</comment></comment><comment><USER27> Short Answer: The Actor Model

<comment><USER8> Haskell is not about the actor model. It is possible to use it this way, but not what the language is about, or why you should learn it in particular.</comment></comment>


Apple Earnings: A Big Beat as iPad, iPhone Sales Soar - MarketBeat - WSJ - <AUTHOR> http://blogs.wsj.com/marketbeat/2011/07/19/apple-earnings-a-big-beat/?mod=e2tw <comment><USER2> I'm surprised that they sold half as many iPads as iPhones. I've read several predictions that the tablet thing would turn out to be a fad but it seems to have legs.

<comment><USER3> I think (and have thought since the iPad launch) that the tablet market will be bigger than PCs. They will take over roughly 90% of the laptop market (leaving behind the graphic designers and vintage geeks), and also add a whole class of users who don't currently have a computer of any kind, at least doubling the size of the "big screen computer" market.

It's a fascinating example of displacement at work. Apple was never going to get the PC world to start buying Mac laptops. So they're just going to displace that entire market with a new product category. Classic strategy from the _Innovator's Dilemma_ playbook.

<comment><USER4> Average people have an incredible mental block against switching from PCs to Macs. I'm speculating here, but it seems to me like what market share they've acquired for the Mac in the last decade has come largely at the margins - geeks, artists, students, etc. For the average person, their computer is still a scary, complex, bewildering machine somewhat akin to an automobile that can only be comprehended by experts. They would no sooner switch to a Mac than trade in their Camry for a Lotus.

The iPad is a psychic do-over. By creating a new category firmly embedded in consumer electronics rather than computing they can displace the computer _mindset_ as well as the PC as a physical product.

</comment></comment></comment><comment><USER5> Now with $76bn cash/cash-like to hand. It'd be fun to see some big acquisitions but I wouldn't bet on it.. Perhaps a few million into the MacRuby project? ;-)

<comment><USER6> There's really nothing they could conceivably do with that much cash. I don't understand why shareholders don't demand some dividends.

<comment><USER7> There's plenty they could conceivably do with their cash.

See here: [http://www.quora.com/What-would-make-sense-for-Apple-to- use-...](http://www.quora.com/What-would-make-sense-for-Apple-to-use- its-51-billion-in-cash-for-a-strategic-acquisition/answers/612608)

</comment></comment></comment><comment><USER8> And the stock is down (ever so slightly) in after-hours trading (as of 4:58 EST).

<comment><USER9> Not sure if you are trolling, but here is the after-hours price right from NASDAQ, up quite a bit after hours from close:

[http://www.nasdaq.com/aspxcontent/ExtendedTradingTrades.aspx...](http://www.nasdaq.com/aspxcontent/ExtendedTradingTrades.aspx?selected=AAPL&mkttype=after)

<comment><USER8> If you look at page 311 of that: [http://www.nasdaq.com/aspxcontent/ExtendedTradingTrades.aspx...](http://www.nasdaq.com/aspxcontent/ExtendedTradingTrades.aspx?&pageno=311&selected=AAPL&mkttype=after)

You can see one quote of $376.0167, below the closing price of $ 376.85. I just happened to look at bad data.</comment></comment></comment>


Wallace Wang: Computer book authors, denial, delusion, and desperation - <AUTHOR> http://www.topbananas.com/denial-delusion-and-desperation/ <comment><AUTHOR> Stumbled onto this article while browsing the website referenced in the "About the Author" section of the book "Swift OS X Programming for Absolute Beginners".</comment>


Ask HN: Any thoughts about the so called third-runtime? - <AUTHOR> Lately I hear a lot about the so called third-runtime existing of things like Google speaker, Amazon Alexa and Facebook Messenger.<p>Will there actually be a 'takeover' and a battle around different systems like happened in mobile? <comment><USER2> Yes</comment>


Ask HN: How do you manage your finances? - <AUTHOR>

As a youngish guy with no significant assets financial management or planning has never been something I've invested in mentally. Increasingly though lack of visibility around where my money is coming from and going is becoming pretty frustrating.
What strategies have smart people adopted to accomplish some of the following:

    * Monitor, graph and predict money I/O.
    * Identify major cost areas.
    * Track and improve credit ratings.
    * Quantify potential for lending.
 I bank with HSBC in the UK, but I have no problem changing that. Having just had to resort to Javascript[0] to get a CSV output of my previous transactions this seems appealing. Is anyone doing modern UX design in online banking? Or are their other services out there to fill the gap?
[0] https://gist.github.com/cantlin/5798166 <comment><USER3> RBS in the UK provide an industry-standard XML dump for each of your accounts. There are several online service that will take that file and categorise your transactions and forecast your cashflow for you. [https://www.mint.com](https://www.mint.com) is one such example.

I evaluated several a while back, but found them all to be lacking, especially with respect to accurate cashflow[1] and budgeting[2]. I also wasn't very keen for a company to have access to my financial data. I now have a homemade app that uses the XML file to get the info I want out of the transactions and display it how I want.

[1] Cashflow was generally not fine-grained enough for me, my account would show as being fine over the month but there would in reality be days where it would be overdrawn.

[2] Budgeting was very naive. Budget £200 for groceries, it would budget you £200/days_in_month every day. Not very useful if you do a weekly shop.

</comment><comment><USER4> Keep a budget. For 2 or 3 months be fanatical about writing down everything you buy and then analyze it. Ask yourself, 'what could I have saved on?' for example, made lunch more often, buy 1-2 cd not 10, etc. etc. Then set a budget from what you learned and monitor that.

Raise your credit score most effectively by buying something like a car or home and paying it off RELIGOUSLY. Try VERY hard to not be late. Set up direct payments thru your bank, etc.

Get One credit card (not just a debit card for your checking act.) and NEVER be late with that either. By one thing a month to keep it active and pay it off right away.

Shop around for stuff you want. Look all around compare and don't make those impulse buys.

As much as I hate the credit spiral we all are in, you have to game it to your advantage.

</comment><comment><USER5> In addition to oaxacamatt's excellent advice, you can use Excel or create a Google spreadsheet to track your expenses over the course of a month, or even a week; make budget categories, write everything down, and then start by using a week's or month's (or whatever period's) worth of data to formulate a target budget.

Then create a budget-vs-actuals version of your spreadsheet. When you have a periods worth of data, see if you need to adjust your budget (hopefully downwards, but you don't want to be shooting for some unrealistic numbers, so do adjust categories upwards if you need to do so to be realistic), and then continue to compare periods of actuals-vs-budget.

I also find it motivating to keep a list of "Yay!" and "Boo!" items, completely informally/separately from my spreadsheet. It's just a thing where I can write down things like, "Yay! Brought my own coffee to work instead of buying out" or other such little victories. The Yays can be more motivating to me than the Boos, but it might help to track both to see where you think you're breaking your own budget.

And this can all be adapted very easily to a work budget, startup or even an established business.

</comment><comment><USER6> Gnucash is a delightful piece of software, comparable to Intuit's Quicken ... but, naturally, Gnucash is free.

Keeping an eye on your budget and watching the graphs is _indispensable_ in terms of helping you manage your money. After all, you can't make tweaks if you don't know what's going on. Obviously you want to live below your means if you want to be successful, and you want to trim categories that seem to be out of control ... but this can only happen if you are proactively aware of where your money is going.

I've heard it explained this way: "managed money goes farther". If you make a budget (a plan, really) for your money, you're telling it where to go. If not, it'll easily disappear through behaviors you're not aware of.

Many people have said that when they finally started budgeting and making a plan for their money, it felt as though they got a raise. Of course, no new money came in _because of_ the budgeting, but the act of making and following a written plan led to far less waste, achieving the same effect.

</comment><comment><USER7> I was asking myself the same questions and ended up just writing an app - <USER2> first one - that simulates your future financial I/O based on earnings and spending etc. It's free:

[https://play.google.com/store/apps/details?id=com.codelemma....](https://play.google.com/store/apps/details?id=com.codelemma.finances)

What the app does is it takes your income, expenses, savings and debts, and generates tables and graphs showing future monthly cash-flow, savings, net worth. Each element may be independently configured with rates, amounts, durations etc.

It's my first app so I'd be very happy to hear feedback on usability, usefulness, etc. Thank you.

</comment><comment><USER8> Mint is awesome and I really like my bank Simple ([https://Simple.com](https://Simple.com)). It makes it easy to set goals and monitor your money. If anyone wants an invite you can email me I have 9 at the time of writing this.

<comment><AUTHOR> Sadly neither Mint nor Simple are available in the UK.

</comment></comment><comment><USER9> I used to use a lot of budgeting tools like Microsoft Money. At the end of the day I realized that they were all a waste of time. No amount of new bank accounts helps you make more money.

Everybody has the same common goal of making more money. The only way to do this is to earn more and/or spend less.

No amount of time spent budgeting, forecasting or plotting graphs helped me earn more money. Maybe it would help you keep an eye on your spending. If you are good at that, then there is no need. Spend your time setting up a startup instead.

</comment><comment><USER10> How about Money Lover App ([https://play.google.com/store/apps/details?id=com.bookmark.m...](https://play.google.com/store/apps/details?id=com.bookmark.money&hl=en))? I have used it for a long time. It was good, but keeping spending info was actually a challenge.

</comment><comment><USER11> Service to fill the gap in online banking - Mint.com</comment>


Spirit obit - <AUTHOR> http://www.nasa.gov/mission_pages/mer/news/mer20110525.html

<comment><USER2> It may be wise to change the title to use the full word "obituary," instead of something that might be read as "orbit."

<comment><USER3> I ran into the same confusion when trying to parse the title.

</comment></comment><comment><USER4> I'll admit I'm struggling not to anthropomorphize Spirit too much here. Maybe it's the face-like features of the mast mounted pan-cam. Maybe it's that XKCD strip from awhile back...

Or maybe it's the compelling story of excellent engineering that created something able to keep expanding our knowledge of the Universe so much beyond what was planned.

Either way, I can't help but feel a twinge of sadness, even as I say congratulations to everyone who worked so hard to make it the succes it was.

<comment><USER5> I too feel a little sad on this one, but I did like the extend version of the comic posted in the forum [http://forums.xkcd.com/viewtopic.php?f=7&t=55907&sta...](http://forums.xkcd.com/viewtopic.php?f=7&t=55907&start=280#p1997605)

</comment></comment><comment><USER6> The mars rover project is a source of inspiration for hackers everywhere. JPL should be applauded for the successful design and deployment of a "product" in some of the harshest imaginable conditions and then have it exceed expectations more than 10 times over. A testament to what can be accomplished with a billion dollars.

</comment><comment><USER7> From the images in the video, the blogging from last year and the fate of previous missions, it seems likely that a major factor in the shutdown was dust on the solar panels[1] which combined with low-light winter conditions to compromise the health of the electronics when they could no longer be heated. Future rovers may be able to self-clean the panels[1], giving a much longer theoretical lifespan (at least for this component).

[1] <http://en.wikipedia.org/wiki/Cleaning_event>

[2] [http://www.technologyreview.com/printer_friendly_article.asp...](http://www.technologyreview.com/printer_friendly_article.aspx?id=26116)</comment>


Show HN: Learning keyboard touch typing with instant feedbacks - <AUTHOR> http://hotcoldtyping.com <comment><USER2> This looks great. I wish it supported alternate layouts like COLEMAK.

<comment><AUTHOR> Thanks. It is coming shortly.</comment></comment>


A History of Tug-of-War Fatalities - <AUTHOR> http://priceonomics.com/a-history-of-tug-of-war-fatalities/ <comment><USER2> I saw a tug-of-war disaster happen once. I was working at a summer camp, and we had a giant tug-of-war with around 50 kids / side at the end of every two week session. I was refereeing and the rope snapped right in front of me. Sounded like a gunshot.

There was one serious injury: the first kid on the left side had his arm broken -- it was bent to a 45 degree angle, but luckily didn't break the skin. Nothing else, though, which was extremely lucky. Someone could easily have lost an eye. Heck, I could have seeing as I was standing right where it snapped.

I remember that the kid was from Mexico and didn't speak English at all. I think he was eight or nine. He was freaking out, and I figured out that he was asking if they would have to remove his arm. His older brother was refusing to translate anything for me, so I had to reassure him in my non-existent Spanish. (I'm Canadian so we learn French, not Spanish)

That was over 20 years ago, but that post sure brought back the memories.

<comment><USER3> Why would the older brother refuse to translate ?

<comment><USER2> I really can't remember, but we were all in shock at the time. My vague recollection is that he was trying to protect his brother. People react strangely in situations like that.

</comment></comment></comment><comment><USER4> My favourite weird old Olympic event was the plunge for distance.

[http://en.wikipedia.org/wiki/Plunge_for_distance](http://en.wikipedia.org/wiki/Plunge_for_distance)

</comment><comment><USER5> A 13,000 pound rated rope for a world record where some subset of 2300 people were pulling on it means there was only enough room for each person to generate between 5 and 25 (500 people) pounds each before the rope would snap. I would expect a heavy weight construction company to be able to handle basic math.

<comment><USER6> If 500 people pull on a rope with 25 pounds of force each, the tension is 6,250 pounds, not 13,000. Your math would be correct if one end of the rope were anchored.

(Or put another way: if two people pull on a rope with 50 pounds of force, the tension is 50 pounds, not 100.)

<comment><USER7> Wouldn't two people pulling in opposite directions generate more tension than one person pulling a rope with the end anchored? (Assuming all people are equal)

<comment><USER6> The anchor pulls on the rope too, that's what you have to remember. You can swap one person out for an anchor and the rope wouldn't "feel" any different, still 50 pounds of tension.

Or put it this way: when there's 50 pounds of tension, that means that there's fifty pounds of force at one end and fifty pounds of force at the other end. It doesn't matter whether that force comes from an anchor or from someone pulling. Or you could have a pulley with a fifty-pound weight at each end. Or a rope tied to the ceiling with fifty pounds at the other end.

(The simplification here is that the rope mass is negligible. In reality, the tension will vary across the rope's length.)

</comment></comment></comment></comment><comment><USER8> > Our intention isn't to sensationalize these mishaps

Fail. It's put me off Tug-of-War. And lets be realistic, it was the intention.

But an enjoyable article none the less.

<comment><USER9> Tug-of-war is fun, I used to be the 'anchor' for my form high school team. However it's one of the few games where you're potentially pitting the total exertable force of a group (in our case 8 adolescents) against the minimum resistance of your opponent.

Our instance: we were the best team all through highschool because we were well coordinated. One of our last games we faced a decently weighted team, but their anchor was neither strong nor heavy. Flag dropped, we heaved and charged back. Their anchor had wrapped the rope around him and twisted it (basically knotting himself in. We caught them off guard and dragged him between his team mates. He was really cut up from being dragged between people's legs (and everyone wears cleats).

It's fun, but it really punishes anyone who's stupid. Our teacher used to walk around and whack anyone who wrapped their hands in the rope due to people getting broken hands.

It's the exact same as the idiot who goes on field when people are throwing javelins, discus and shot put.

<comment><USER10> Another example of exertable group force would be a Rugby Union scrum where at the top levels they generate around 16.5kN of force(1). The ARU coaching manuals recommend only selecting players with short, thick necks for the front row and drilling players how to react instantly when there is a "mayday" call.

(1) [http://opus.bath.ac.uk/32592/](http://opus.bath.ac.uk/32592/)

</comment></comment></comment><comment><USER11> Worth the read if only because the photo of Harvard's 1888 tug of war team.

</comment><comment><USER12> I remember when the Taiwan accident happened because my local paper decided to publish a picture of some guy's severed arm lying on the ground.

Not exactly what I wanted to see first in the morning over my cornflakes...

</comment><comment><USER13> I did not expect that article to be nearly as long nor as interesting.

</comment><comment><USER14> I expected an article commenting on fatalities on some tug-of-war metaphor — for instance, a power-struggle between two countries. I was surprised (and possibly delighted) to find that this article was actually about tug-of-war.

<comment><USER15> Please let us know when you have determined your level of delight.

</comment></comment><comment><USER16> Surely these are all casualties, as not all resulted in fatalities.

In fact, the only fatalities listed in this article were 2 boys in Frankfurt Germany.

</comment><comment><USER17> I've seen something similar: in middle school a classmate tied the rope around themselves to anchor the back of the line. He was pretty badly injured when the other team pulled him over and dragged him across the field, pulling the loop tight. I never thought about a rope snapping, though.

</comment><comment><USER18> The subject matter was interesting, but because of my squeamishness I couldn't bring myself to read the actual description of the injuries or fatalities. I'm one of those types of people that can't stand seeing broken bones or reading about them, horrifies me

</comment><comment><USER19> Good words of warning. The pun at the end seemed a bit much to me though.

</comment><comment><USER20> Imagine if political disputes were settled this way instead of real war

<comment><USER21> Or with a nice game of Quake.

<comment><USER22> There's no chance of officials dying or suffering grievous injury that way. Unless they start throwing keyboards.

</comment></comment></comment><comment><USER23> I've always felt Priceonomics is gaming HN. How does this post have 28 upvotes and no comments (other than mine)?

And what does tug of war fatalities have to do with Hacker News? Why not a story about people dying from vending machines falling over on them? (7 on average per year)

<comment><USER24> If they're gaming HN, they're fooling both the software and me, and I've spent a ton of time working on this.

Please don't dilute the threads with meta complaints. Instead, do as the guidelines ask and email us at firstname.lastname@example.com; or flag the post; or both.

<comment><USER23> OK, I'll drop it.</comment></comment></comment>


"Eeny, meeny, miny, mo" and the ambiguous history of counting-out rhymes - <AUTHOR> http://www.theparisreview.org/blog/2015/04/16/losing-count/

<comment><USER2> It's a garbled version of a latin exorcism: "Inimicus animo"

[http://www.phrases.org.uk/bulletin_board/18/messages/777.htm...](http://www.phrases.org.uk/bulletin_board/18/messages/777.html)

</comment><comment><USER3> It's for counting!? I always had this idea it was like a pseudo-random way of picking one option out of several, like in my part of México we (used-to) use (not-really Spanish) "de tín marín de do-pingüé, cúcara mácara tîtiri füé, yo no fuí, fué te-té, pégale, pégale que ese mero fué". Which reminds me of another one I learnt from a book as a child but have never heard it from anyone else out in the open: "pin-pin, zarambolín, el ratón comer comer, el ratón comer comer, ¿cuánto das por el ratón? cien tostones y un doblón, arre mula carretera pin-pin estás afuera!".

<comment><USER4> It is used for "randomly" picking at option. I remember when I was young realizing I could compute the remainder and "cheat" when using this.

Not sure why they call it a "counting-out" rhyme, though I guess I can't think of a better thing to call it.

Side note, the way I learned it, the last line was always "out goes Y-O-U". Much better than simply repeating the first line over :)

<comment><USER5> This is how I learned it growing up (southwestern US in the mid 1990s):

Eeny, Meeny, Miny, Mo

Catch a tiger by the toe

If he hollers, make him pay

Fifty dollars every day

My mother told me to pick the very best one

and you are [not] it

</comment></comment></comment><comment><USER6> I love this idea that the essence of these poems are in the rhythm, vocalizations, and play and not in the specific words themselves.

When I was small, my parents would tell me a toe-counting rhyme, which I knew as "icky-pee, penny lou". I wanted to learn what the "real" words were and found this page [1]. In the comments there are dozens of variations on this same poem and none use the same phrasing we did.

Oral traditions seem to have a way of distilling information to essences over time vs. bit-wise copies.

[1]: [http://www.mamalisa.com/blog/the-origins-of-some- scandinavia...](http://www.mamalisa.com/blog/the-origins-of-some-scandinavian- toe-naming-rhymes/)

</comment><comment><USER7> I came across this a while back also when watching videos about the Lake District/Valley of Stone area in England. The video and accent helps alot to understand the method: [https://www.youtube.com/watch?v=uZTEvdf3KP4](https://www.youtube.com/watch?v=uZTEvdf3KP4)

</comment><comment><USER8> We also used "Engine, engine number nine/Rolling down Chicago line" (etc.) long ago. And about 20 years ago, I heard children using it who appeared to be the US-born children of fairly recent immigrants.

<comment><USER9> The usual rhyme at the small village school in England I attended in 1993ish was "Ip dip, dog shit, fucking bastard, dirty git, you are not it!"

But the better ones had a variable, and I could reliably make myself "out" if I had the chance to select it. This was sometimes considered unfair.

"There's a party on the hill, can you come? Bring your own bread and butter and a bun. Who is your best friend?" "David" "D-A-V-I-D" (final letter means out!).

"Ippy-dippy-dation, my operation, how many buses in a London station?" "Twelve." "1 2 3 4 ...12, O-U-T spells out!"

</comment></comment><comment><USER10> I'd be curious as to the timing of the 'Tiger' iteration, and its spread. Certainly growing up where I did (Northern NSW, Australia) in the late '80s, we used the original wording.

No doubt some of that was a lack of cultural awareness - it was a fairly white part of the world, especially in private education. I'm a mongrel breed, which basically just means I always look like I have a nice tan but nothing more, and even I got called a 'nigger' once playing football because I was the darkest person that kid had ever seen.

</comment><comment><USER11> Scotland (late 80s/early 90s): (adults present) Ibble ubble black bubble ibble ubble out (no adults) It dit dog shit you are not it

Don't really hear it any more though - kids today with their "hash" tags and their clever telephones are really missing out, I think.

<comment><USER10> We use to run (Northern NSW, Australia), as an eeny meeny variant, 'Ip dip dog shit / You stood in it / What colour was it?' where 'it' would then name a colour, which would then be spelled out in a counting round (R-E-D) - and then 'D' would be 'It'.

If you were called upon first and knew enough colours of differing lengths, and I did, then you could ensure any specific person would become 'It' at the end of the round.

</comment></comment><comment><USER12> A list of several dozen posted recently to twitter:

[https://storify.com/mooseallain/picking- rhymes](https://storify.com/mooseallain/picking-rhymes)

</comment><comment><USER13> A more thorough history of the subject rhyme:

[http://en.wikipedia.org/wiki/Eeny,_meeny,_miny,_moe](http://en.wikipedia.org/wiki/Eeny,_meeny,_miny,_moe)

<comment><USER14> Used to be Paris Review articles were more than weak summaries of Wikipedia pages...

</comment></comment><comment><USER15> ink-a-bink-a bottle of ink, the cork fell out and you stink

Eeny, meeny, miny, mo catch a tiger by the toe if he hollers, let him go eeny, meeny, miny, mo</comment>


12gm Micro Tug Robots Pull 21Kg Weights - <AUTHOR> http://techcrunch.com/2015/04/30/micro-tug-robots-can-pull-objects-2000-times-their-own-weight/

<comment><USER2> SI unit symbol for gram is "g", not "gm". For kilogram it's "kg", not "Kg".</comment>


Ask HN: Founders who raised money, what do you wish you had spent it on? - <AUTHOR> I am talking about a seed/initial round.
What were the biggest mistakes in terms of how you used the money?
What actually paid off?
How do you think about it now? <comment><USER2> Make something people want. That's it.

If you spend money on anything else, you're wasting your money.

</comment><comment><USER3> Seed/ Initial round- make sure you are getting money from the investors who believe in your business idea, else its becomes an distraction

Your focus should be having 1) product ready for market 2) market startegy 3) Sales/ Sales - Get the customer pipeline ready. This is market validation and revenue -

</comment><comment><USER4> Not for every instance, but at least once, I wish I had given the money right back.

</comment><comment><USER5> Don't hire without product-market fit, make sure to have enough runway to find it.</comment>


Install PAC-MAN on Sequoia voting machine w/o breaking tamper-evident seals - <AUTHOR> http://www.cse.umich.edu/~jhalderm/pacman/

<comment><USER2> It is one of the curious facts of modern culture that the people who love technology the most also seem to be the most opposed to electronic voting.

I think it's because the people who most understand how computers work also understand that no data can be considered trustworthy if somebody else has been in possession of the hardware. Yet governments continue to trust the impossible promises of the people who make voting machines that their machines are secure, despite a continuous stream of demonstrations to the contrary, both intentional and accidental.

<comment><USER3> I don't know that we're opposed to it in theory, it's just that every single implementation thus far has been terrifically bad. Making the code open source would go a long way, I think, as would establishing open working groups to establish security standards. I may be an optimist, but I do believe that theoretically (at least information-theoretically[1]), it can be done well.

[1] [http://scholar.google.com/scholar?q=Information- theoreticall...](http://scholar.google.com/scholar?q=Information- theoretically+secure+voting&hl=en&as_sdt=0&as_vis=1&oi=scholart)

<comment><USER4> It's also fairly easy for us techies to grasp the hacking of computer systems. But we often forget how insecure and error prone paper systems can also be:

<http://www.youtube.com/watch?v=sJfj9ySYg0Q>

Massive voter fraud could be happening every election - it's pretty easy to vote fraudulently and there is almost no way to find out after the fact (I've done it unintentionally). For whatever reason, we are insanely afraid of hackers pushing an election over the edge, and yet we don't even ask for photo ID at the voting booth.

<comment><USER5> We're more concerned about electronic voting because it lowers the effort and manpower needed to defraud _immensely_.

<comment><USER6> And more likely, in a close election the election can be stolen by a minimal change, which will probably go undetected.

</comment></comment></comment></comment></comment><comment><USER6> "We received the machine with the original tamper-evident seals intact. The software can be replaced without breaking any of these seals, simply by removing screws and opening the case."

Ouch.

Incompetence doesn't even begin to describe it. Or is this by design?

<comment><USER7> "What's inside the AVC Edge? It has a 486 SLE processor and 32 MB of RAM—similar specs to a 20-year-old PC. The election software is stored on an internal CompactFlash memory card. Modifying it is as simple as removing the card and inserting it into a PC."

Seems to be a history of dubious competence for this machine and company:

[http://docs.google.com/viewer?a=v&q=cache:vVOdcOpBZ_EJ:w...](http://docs.google.com/viewer?a=v&q=cache:vVOdcOpBZ_EJ:w2.eff.org/Activism/E-voting/20040818_sequoia_avc_edge_v0.8.pdf+sequoia+avc+edge&hl=en&gl=us&pid=bl&srcid=ADGEESjhaOTNsoZUzCrBrCwzpVGX2LU5gtwvjm1wWeCnLdAgglQ8UhhRlyTAQHBGuvk39zoOQzDx1oShg6biPbFhYSSg5Q-O9kyEdIrvsrNw7yKORyq1eez_0rINvKuvvJHsIPK3wmYY&sig=AHIEtbSRJi1WRVDG0rlwkgZx2BFX_DfRFA)

<http://sourcewatch.org/index.php?title=Sequoia_AVC_Edge>

<comment><USER6> I'm not too shocked by the use of the processor, that may very well have something to do with reliability. You'd be surprised how demanding industry is in this respect, and it's not rare at all to find what you'd class as 'ancient' hardware when it comes to doing jobs where you have to make the results reliable. Not saying that was the case here, but it could be, also I'm imagining these boards might be run from a battery backed-up power supply so they may want to have them consume as little power as possible (that's a guess though, but I can imagine that if your election is in an area where there is a power failure you don't want to lose the results).

Compare for instance with avionics and stuff on space flights. If crashing is not an option the rules about hardware change dramatically. It's a pity the article does not say whether the ram was ECC ram or not, that would be a hint that this is not just a way to be 'cheap'.

</comment></comment></comment><comment><USER8> I suspect the only way to get the public's attention on voting machine security would be for a group (Anonymous?) to hack a major election in favor of a joke write-in candidate (Mickey Mouse, "None of the Above", Bill Murray).

<comment><USER9> Definitely 'None of the Above' - I ran for student union president on a None of the Above ticket.

The irony was lost (magnified?) when I drew top of the ballot paper, but ultimately my preferences (was a preferential style not first-past-the-post ballot) tipped the victorious president over in a cliffhanger election.

</comment></comment><comment><USER10> The Open Voting Consortium is working on an open-source solution that uses everyday PCs and printers instead of these ridiculously expensive voting machines. Their solution[1] is actually paper-based, allowing for increased accountability and transparency. The source is available here[2] although the project hasn't seen activity in quite some time, so I am not sure of the status of the code base.

[1]: <http://www.openvotingconsortium.org/our_solution> [2]: <http://sourceforge.net/projects/evm2003/>

</comment><comment><USER11> Now make it so you have to eat the ghost labeled as the candidate you want to vote for, and it records the vote.

I might actually go to the polls.

<comment><USER12> Alternatively, a 1 minute quiz on the constitution and/or your countries system of governance. Get all the answers right and you can vote!

<comment><USER13> Half a century ago, literacy tests and trick questions were widely used to keep blacks from voting. That's why it's illegal to do so now.

<comment><USER14> Nowadays, the US repeals voting rights from those who have committed a felony, have a similar name to someone who's committed a felony, or live in the same neighborhood as people who conflict felonies. And who "just happen" to be black.

Civilization has advanced - this is no longer widely accepted - but that doesn't mean it doesn't happen in, say, Florida.

<comment><USER15> > have a similar name to someone who's committed a felony

Really? How is that justified?

<comment><USER14> To the best of my knowledge, not at all.

See e.g. <http://en.wikipedia.org/wiki/Florida_Central_Voter_File> for details.

</comment></comment></comment></comment></comment></comment><comment><USER16> Support verified voting if you are concerned about electronic voting: <http://verifiedvoting.org/>

</comment><comment><USER17> I can't imagine the horror of battling lobby groups and corporate interests to fix this on a federal scale.

</comment><comment><USER18> well, it works perfectly if what you want is steal an election...</comment>


Steven Sinofsky on iPads replacing laptops and transitions in computing - <AUTHOR> https://twitter.com/stevesi/status/1059663467676762112 <comment><USER2> I worry that people don't remember "The Coming War on General Purpose Computing" [1]...

When my tablet has a full IDE which lets me compile a new app and install it on the tablet, and share it to my friend's tablet, they will be "professional". When my tablet allows me to plug in any accessory I want without it having to be blessed by the tablet manufacturer, maybe it will be able to replace a "real" computer. (Although on this front USB-C gives me a little bit of hope, maybe..)

Those replies about how people are just grumpy that the times are changing are completely missing the point. We need to figure out how to re-focus the conversation and make people think about about the walled garden seriously.

[1] [https://boingboing.net/2012/01/10/lockdown.html](https://boingboing.net/2012/01/10/lockdown.html)

</comment><comment><USER3> I don't see it that black and white.

The big difference between iPad and PC is the input. It's no surprise that consumers are less power users of input methods than people working on their machines.

Power users always use less intuitive, but more efficient input. The mouse accelerates my cursor, it moves farther then the mouse travels and has great accuracy. On the iPad I'd have to stir my arm around all day and selecting within text with your finger in the way was never fun either (though the latter can be fixed easily). I could only imagine in "air mouse", like a touchpad on your desk with mouse-like tapping and scrolling per finger.

Typing is where I see input methods might evolve. A touch-typists will remain more efficient, especially coding for a long time. Physical feedback on screen-keyboards would have to improve to the level of physical keyboards to fix that. Good speech to text (or mumble to text¹) might overtake the keyboard for prose but not for code unless the synax of programming languages adapts.

After that I see eye-tracking and direct brain interfaces, but those wouldn't be iPad exclusive either.

¹ [https://www.youtube.com/watch?v=RuUSc53Xpeg](https://www.youtube.com/watch?v=RuUSc53Xpeg)

</comment><comment><USER4> If you sit on a couch or in another chill place, browsing the web with a good trackpad on a laptop in your lap is so much better than by touch on an iPad display. My impression is that the people hailing iPads that much are actually mouse and not trackpad users.

The iPad just requires more physical interaction to accomplish the same things.

The only device(s) that would be able to beat the laptop experience (imo) are comfortable (24/7 wearable) AR glasses + screenless laptop body as a keyboard. This would maintain the laptop/trackpad benefits while improving ergonimics (screen height) and also enable desktop like workflows, meaning thatcreatives don't have to switch between desktop and mobile desktop UX.

</comment><comment><USER5> I worked on Windows 7 and 8 on the Core UX team when he took over and turned the Windows desktop into a touch friendly interface. The guy is a true believer and maybe he is right, but I certainly don't feel like my iPad gets much use anymore. Most headlines I hear seem to be about declining sales and I can't help but recall the overwhelmingly negative feedback from users about the Windows 8 changes.

I always felt like Apple did it right - take the phone and move towards the desktop. Otherwise you are just creating a system that is as bad at the new computing scenarios as it has now become for the old ones.

<comment><USER6> I think MS did it right with 8.1, just hide tablet UI on a desktop. On a separate note, how do you feel about the regressions in Tablet Mode UI/UX in Windows 10? Seems like MS threw out even the stuff that worked.</comment></comment>


Slack down? - <AUTHOR> https://www.slack.com <comment><USER2> I've been sitting here refreshing HN to see if anyone else was going to report it. I haven't been able to connect to our company's instance for close to ten minutes now. Either via the Mac client or through the web client.

Edit: [https://status.slack.com/2018-08/389f96c3886d7d56](https://status.slack.com/2018-08/389f96c3886d7d56)

</comment><comment><USER3> Even if your uptime is 99.99% people sure do feel it when you go down when you're as mission critical as Slack.

[https://get.slack.help/hc/en- us/articles/204113126-Service-L...](https://get.slack.help/hc/en- us/articles/204113126-Service-Level-Agreements-SLA-)

</comment><comment><USER4> "Folks are having troubles connecting to their workspaces. We're looking into the cause and will have updates shortly.

10:30 AM PDT"

[https://status.slack.com/2018-08/389f96c3886d7d56](https://status.slack.com/2018-08/389f96c3886d7d56)

</comment><comment><USER5> It appears that if you already have an existing session open, then all is well.

But, if you try to login again, it will fail (e.g. after I restarted my linux workstation, Slack no longer connects).

</comment><comment><USER6> Confirmed on their status page now: [https://status.slack.com/](https://status.slack.com/)</comment>


Enterprise sales lessons: how I almost closed Google, Intuit and Oracle - <AUTHOR> http://blog.close.io/enterprise-sales-lessons-how-i-almost-closed-google-intuit-oracle-

<comment><USER2> These b2b posts are really helpful, thanks!</comment>


Countly | Mobile Application Analytics - <AUTHOR> http://count.ly/ <comment><USER2> Awesome demo! However, I seem to have trouble finding the "docs" section for developers.

I see:

* <http://support.count.ly/kb/sdk-installation> (but there is nothing about how to call init(), etc).

* [http://support.count.ly/kb/web-installation/installing-count...](http://support.count.ly/kb/web-installation/installing-countly-server-v12051-to-ubuntu) (but nothing about the requirements in the event I'm not on Ubuntu and have to install from source/other packages)

Having these two things are paramount to the usage of your software.

Thanks!

<comment><USER3> We have shortage of documentation for now thats for sure. We will be providing more documents about installation on different platforms in the coming days. If you have any problems or questions we will be more than happy to help if you open up a discussion from <http://support.count.ly>

</comment></comment><comment><USER4> This is really cool! Have you thought about the possibility of contacting the gamers via SMS or USSD (for polls and feedback). When you see that they haven't used a game for a while?...etc...? Give our Rest api beta a try!

<comment><USER5> Yes, polls, surveys and feedbacks are in the roadmap. We are not a lot interested in SMS/USSD since it's really under control of operators, but would like to invest more in exchanging data using 3G/4G networks.

It's really a good idea to trigger rules when an app is not used after a certain period of time. Will think on it :)

<comment><USER4> (thumbsup!) :)

<comment><USER3> It would be interesting to play with your API since Countly team is composed of all telco professionals :)

</comment></comment></comment></comment><comment><USER6> It's cool, I'm interested in trying it out.

Rethink the use of Lobster as your logo/text font a bunch of different companies Including Codecademy and HireAry use it. So it's Generic at best.

<comment><USER3> Thanks for pointing that out. I'm pretty sure our co-founder/designer Osman knows about this but anyways being unique is always better :)</comment></comment>


Why font rendering sucks in electron based editors? - <AUTHOR> Font always appears fuzzy or blurry. It doesn't happen in Sublime Text. Is there any solution to this problem? <comment><USER2> I ran into this issue when I installed Atom two years back. Today I installed VSCode and run into the exact same issue again. I tried a bunch of stuff to fix it; none of it worked. It was a pain two years back and it's a pain today. Except for the ugly fonts the Editor seems nice. Maybe I'll give it another try in 2019...

</comment><comment><USER3> Several solutions/workarounds, explanations, and links to lower-level bugs are here [https://github.com/Microsoft/vscode/issues/35675](https://github.com/Microsoft/vscode/issues/35675)

I would explain more if I knew - but I haven't read it. I just found the solution and applied it.</comment>


Google Doc template for 10/20/30 rule pitches from Guy Kawasaki - <AUTHOR> http://twitter.com/guykawasaki/statuses/861397541 <comment><USER2> I want to make a reinventing the wheel regarding anyone who makes a template for a Google Docs Presentation, but I just did.</comment>


Strange Brews: The Genes of Craft Beer - <AUTHOR> http://www.nytimes.com/2014/05/27/science/craft-beer-at-the-genetic-level.html

<comment><USER2> _The beers' colors are as varied as their flavors, ranging from cloudy gold to clear amber. Yet with the single exception of the yeasts used to ferment them, Mr. Prahl explains, they are all the exact same brew._

It's really interesting how much yeast influences (through fermentation) a beer. You can even combine yeasts to give a beer an even more complex characteristics (as discussed in the book, "Yeast: The Practical Guide to Beer Fermentation"[1], written by Chris White of White Labs).

1\. [http://www.brewerspublications.com/books/yeast-the- practical...](http://www.brewerspublications.com/books/yeast-the-practical- guide-to-beer-fermentation/)</comment>


Fund Prosemirror if only because you have faith in humanity - <AUTHOR> https://www.indiegogo.com/projects/prosemirror/x/11917587#/story <comment><AUTHOR> Fund Prosemirror if you have ever been frustrated by a WYSIWYG editor. Not because Prosemirror will be frustration free but because more effort in this area is necessary to get there. -> insert link to any Contenteditable WYSIWYG editor

Fund Prosemirror because you think collaborative rich text editing should not be a technology reserved only for web giants to have and acquire. Firebase/Firepad(acquired), Hackpad(acquired), Appjet/Etherpad(acquired), Wikidocs(acquired)...

Fund Prosemirror because Marijn Haverbeke has a good track record with Code Mirror. [https://codemirror.net/](https://codemirror.net/)

Fund it because open source shouldn't only be about free as in beer. [http://coderanger.net/funding-foss/](http://coderanger.net/funding-foss/)

Fund it because it is an impressive piece of work in its own right and current state. [http://prosemirror.net/demo_collab.html#edit- Example](http://prosemirror.net/demo_collab.html#edit-Example)

Fund it because in Marijn's altruistic intentions -- its already on github [https://github.com/ProseMirror/prosemirror](https://github.com/ProseMirror/prosemirror) to look at, he's asking for only a very small amount of compensation for a ton of work, and he's written incredible blog posts educating everyone. [http://marijnhaverbeke.nl/blog/collaborative- editing.html](http://marijnhaverbeke.nl/blog/collaborative-editing.html)

Fund it if only because you have faith in humanity.</comment>


No New Accounts Today - <AUTHOR> Traffic is unprecedentedly high today, presumably because Reddit is blacked out.  I don't want to repay them for their impressive stand by stealing their users, so I've temporarily turned off the ability to create new accounts. <comment><USER2> I am surprised you would think of it as 'stealing' users. More likely you are trying to avoid too many of a certain type of user that is only on HN because reddit is down.

<comment><USER3> I imagine that too many new users on one day is a troublesome idea regardless of what site they're from or why they arrive here.

It's as simple as noting that new users are new and still learning from everyone else around them. When everybody is new, it's hard to get a feel for the current culture and style.

I imagine that it would probably work on a permanent basis to gate new accounts to a certain fixed value per day or proportion of new to old accounts, e.g. .1% per day or whatever.

Personally, I came here from Reddit 1,791 days ago, so I will be the first to say that I hope we don't have an "anti-Redditor refugee" policy, whether express or implied. Far better to demonstrate through action and voting what we value as a culture and welcome as many people to the site as we can handle without diluting our ability to teach by example.

<comment><USER4> The idea of the percentage based gate was implemented on Slashdot to guard moderator privilege and it worked well.

</comment></comment></comment><comment><USER5> pg, could you post the HN traffic stats for today as a post-mortem style post?

<comment><AUTHOR> We got just under 1.6 million page views, whereas on an ordinary weekday we'd get just under 1.3 million.

<comment><USER6> What is the daily variance like?

</comment></comment></comment><comment><USER7> I wonder if there's a startup opportunity in helping online communities avoid the Eternal September effect. Some would claim reddit has solved the problem (subreddits) but others would disagree, citing front-page quality decline. So it seems to be an unsolved, universal problem right now.

Hm.

<comment><USER8> I wanted to look up Eternal September - but hit the Wikipedia anti-SOPA page for about the 8th time today. If nothing else, I bet a lot of people have learned how much they depend on Wikipedia today.

<comment><USER9> I use Wikipedia as basically an extension of my brain. I'm in a history program at university, and so many of the names and dates that are essential to it I don't actually know. I realized this when I was writing something last night. I was writing about the English Civil War, and the Restoration, and I wanted to comment on the relationship between Charles I and Charles II, and I went to Wikipedia...and it was down!I had to go to my shelf and get a book. Who does that?

<comment><USER10> "I use Wikipedia as basically an extension of my brain."

<http://en.wikipedia.org/wiki/Exocortex>

[http://www.antipope.org/charlie/blog- static/fiction/accelera...](http://www.antipope.org/charlie/blog- static/fiction/accelerando/accelerando-intro.html)

</comment></comment></comment></comment><comment><USER11> This seems fair, but I'd bet Eternal September was on the minds of the people who decided this.

</comment><comment><USER12> I would have thought that while the effect was due to Reddit (and others) being down, it was more a case of existing users refreshing for fresh content, rather than potential new users coming to register.

Is there really that much crossover? I need to spend some time seeking HN- esque subreddits perhaps.

<comment><USER13> I agree. I'd be interested to see both:

1) The increase in uniques (pageviews don't really count)

2) How many of those uniques are _new_. That is, what percentage of those IPs visiting today have not visited in the past month.

</comment></comment><comment><USER14> Are there ways to measure how much of the traffic is actually due to reddit being out. I bet there are other reasons for the growth in traffic, like the fact that HN has been making a great job at covering SOPA/PIPA for the past few weeks, I wouldn't be surprised if part of the increase is due to natural SEO. I'm sure one could find other reasons too.

I'm not doubting pg's claim. I'm simply interested and curious: What are the tools available for the analyst/engineer/community manager to analyze the increase?

</comment><comment><USER15> This is why Google is not blacked out completely, to avoid something similar with Bing.

<comment><USER16> Doubtful that's their only reason. Google going down would be akin to github going down: more harm than good, and the message would get lost in the chaos.

</comment></comment><comment><USER17> It's an excellent policy. If these new folks are actually interested in hn, they'll come back tomorrow.

</comment><comment><USER18> I would suggest pg to write a special "from reddit to HN" guide. That would help and we can link that to people who seem to be new here (if they havent already seen it ofcourse)

<comment><USER19> <http://ycombinator.com/newsguidelines.html>

</comment></comment><comment><USER20> I wouldn't call it stealing users. I mean if you knew the people from reddit and they asked you and you agreed then that's one thing. But in a true situation of a site being taken down this is exactly what happens. People go elsewhere. What would happen if reddit was taken down for real? Would you do the same thing and for how long?

What you are saying in a way is that a company or organization's competitor (if you want to call it that) can do something by free choice and decision, then you have to do something as well or you may be viewed as doing the wrong thing and viewed as doing something not politically correct.

</comment><comment><USER21> PG, once again a stand up guy. Cheers!

</comment><comment><USER22> Thank you. I don't mind rage comics and kittens but if I wanted to read about those, well, YC wouldn't be my normal watercooler. I spend time here because I want to talk about hacking apps, hacking life and the different start-up business cycles and modalities. That's why YC is my day-to-day watercooler.

</comment><comment><USER20> It actually looks like somebody hacked "ugh" account. Seems a little out of character.

<http://news.ycombinator.com/threads?id=ugh>

Edit:

And this one as well:

<http://news.ycombinator.com/threads?id=suyash>

</comment><comment><USER23> It certain is not stealing IMHO.

There are plenty of places to visit, dzone is another good site and maybe techmeme but neither of those have even a black bar on their site in solidarity.

HN does feel a tad sluggish though so maybe lack of new accounts helps prevent a total crash.

<comment><USER24> Not stealing, but it is profiting from goodwill. Attention is the currency of the web, and while you can't stop people looking for alternatives, you can be respectful about not profiting from it.

</comment></comment><comment><USER25> I find it funny that people of reddit try and keep the "youtube" community out, and hackernews wants to keep reddit out... Who wants to keep HN out??

</comment><comment><USER26> Bravo! Despite the folks saying, "It's not stealing," I think there is good reason to make a principled stand. Reddit is not a competitor.

</comment><comment><USER27> I don't see it as stealing. reddit is a great community, but completely different from HN.

</comment><comment><USER28> Yeah, we wouldn't want any memes popping up on HN now would we?

</comment><comment><USER29> pg, I'm curious why you haven't blacked out Hacker News today. Would love to know your thought process.

<comment><USER30> I expect it's something along the lines of "Everyone on HN is already aware about SOPA/PIPA, so what would be the point?"

<comment><USER31> The same could be said of Reddit, but it is a symbolic gesture and really encourages you to call up your representative.

<comment><USER30> I haven't seen anything about SOPA/PIPA on Reddit, apart from the warning that they were going to be down protesting against it. It's just not come up on the subreddits I read. I imagine it hasn't shown up on most non-politics non- internet subreddits.

</comment></comment></comment></comment><comment><USER32> luckily I registered an account 2 days ago.

</comment><comment><USER33> I even went to Digg ! See what SOPA does !!

</comment><comment><USER34> Regardless of the reason, I think this is the right thing to do.

</comment><comment><USER35> you must be dumb!

</comment><comment><USER36> This happens six hours after reddit blacked out. I'd guess the most eager redditors ended up here already, for better or worse.

<comment><USER37> Let's make it retroactive.

<comment><USER38> I agree, removing all accounts younger than 371 days should help.

</comment></comment></comment><comment><USER39> Classy move, :thumbsup:

</comment><comment><USER40> Do you own shares in Reddit? Then I get it, as HN has no direct revenues. Else, what's the point?

</comment><comment><USER41> Horrible stance.

<comment><USER30> Why?

</comment></comment><comment><USER42> No, no. Reddit users won't enjoy here. This site is for us, the enlightened ones. I am also on Reddit, but that's when I am not in a learning mood. You cannot steal Reddit users, coz most of them will come here looking for cats, and having found none will rather go to Digg. So your worries are baseless.

</comment><comment><USER43> FFFFFFFUUUUUUUUUUUU-

Edit: I'm happy to inform the HN community that your defense mechanisms at all superficial signs of redditry are in order and working. (One negative karma point per minute is damn impressive.) Whether those defense mechanisms also work against more subtle (and much more dangerous) redditry is, however, very much up in the air.</comment>


Ask HN: Alternatives to S3 Buckets? - <AUTHOR> Especially for smaller/personal projects. I know Google has an equivalent product, but I'm just trying to get the lay of the land. The bucket equivalent of DigitalOcean's hosting would also be interesting to know about (or does DigitalOcean themselves have a bucket product?). <comment><USER2> Yes, DigitalOcean offers S3-compatible storage: [https://www.digitalocean.com/products/spaces/](https://www.digitalocean.com/products/spaces/). However, they use a different pricing model than Amazon S3: they charge $5/month for 250GiB (additional storage is $0.02/GiB) + outbound data transfer for the first 1024GiB is free, then $0.01/GiB.

</comment><comment><USER3> [https://wasabi.com/s3-compatible-cloud- storage/](https://wasabi.com/s3-compatible-cloud-storage/)

BUT their "free egress" is not really free egress, since:

[https://wasabi.com/cloud-storage-pricing/pricing- faqs/](https://wasabi.com/cloud-storage-pricing/pricing-faqs/) "If your storage use case exceeds the guidelines of our free egress policy on a regular basis, we will contact you to change your pricing plan to one that involves paid egress or we may limit your egress."

</comment><comment><USER4> Minio is a self hostable object storage project [https://github.com/minio/minio](https://github.com/minio/minio)

</comment><comment><USER5> There's backblaze's B2 offering. cheap af, and s3 compatible.

</comment><comment><USER6> Vultr Object Storage (S3 compatible): [https://www.vultr.com/products/object- storage/](https://www.vultr.com/products/object-storage/)

Backblaze B2 Cloud Storage (S3 compatible): [https://www.backblaze.com/b2/cloud- storage.html](https://www.backblaze.com/b2/cloud-storage.html)

</comment><comment><USER7> Not sure about your use case but if it's simple enough consider not using an object storage service and just serve the files from the filesystem.

</comment><comment><USER8> Is there a reason you don't want to use S3? It's hard to recommend a product without understanding your goals here.

<comment><AUTHOR> I don't love the idea of giving Amazon money. And while I haven't done much research, I would imagine there might be an offering that does a better job catering to small projects, since S3 is very much built for "full-sized" use cases. Could be wrong about that. But mainly I'm just curious to know what the players are in the space.

<comment><USER9> The cost of S3 for any small to medium sized project is so minuscule you're not really giving amazon much money. Especially if you compare it to using EC2 or another VPS provider like digital ocean

</comment></comment></comment><comment><USER10> +1 for backblaze B2.</comment>


Respond to recruiters with a form letter - <AUTHOR> http://coderwall.com/p/ywoa5q

<comment><USER2> I disagree with being so blatantly dismissive. If I get spammed with an email, LinkedIn message, or phone call that is _totally out of my realm_ (like when someone requested I interview for a Senior Java Architect position at age 23 having never worked on an enterprise Java application before), _then_ I ignore it.

However, if something seems decently interesting and they don't seem like total sleazeballs, I'll talk to the recruiter, even if I'm not open at this time. A good reputation and a few good names to call can go a long way when you need them.</comment>