How Kids See the World Depends a Lot on Genetics - <AUTHOR> https://directorsblog.nih.gov/2017/07/25/how-kids-see-the-world-depends-a-lot-on-genetics/ <comment><USER2> Cool study, but it is my understanding that twin studies have a tendency to erroneously assume genetic causation since they fail to control for conditions the twins share in prenatal environments, which can (and do) affect behavior.

Some context: [http://www.robertsapolskyrocks.com/behavioral- genetics.html](http://www.robertsapolskyrocks.com/behavioral-genetics.html)

<comment><USER3> They controlled for that by having about as many fraternal twins in this study, though.

It's particularly surprising to me that they got very similar results with regards to discrepancy between fraternal and identical twins when testing again at a later age.

<comment><USER4> I don't get how that could be a control against assuming genetic causation. Fraternal twins still have similar genetics, right?

<comment><USER5> Fraternal twins and identical twins both have the same environment growing up, they experience the same hormones at the same time during gestation, they live in the same city, sleep in the same bed. They eat the same foods at the same times of day and in the same amounts, excepting personal preference. However, fraternal twins share 50% of their genes (on average) and identical twins share near 100%.

<comment><USER6> could it be be that such studies underestimate these effects because of this obvious assumption that fraternal twins share 50% of their genes - IMHO they share _more_ than that because for all genes that "matter" their _parents_ genes would be quite correlated.

Contrary to the popular saying, like attracts like. Parents are exceedingly likely to share visible traits and also mental traits - so the correlation between siblings wouldn't be halfway between random member of population and an identical twin, but much closer to the identical twin.

<comment><USER5> "Like attracts like" is an interesting assumption, there is some evidence that people are attracted to others that have genetic differences rather than similarities. A common misconception, for example, is that the genetic differences between ethnic groups are larger than genetic differences within an ethnic group, in fact, the reverse is true, if we speak of averages. (Think of two overlapping bell curves with means that are very close to each other, if you want to visualize what I'm trying to say.) Or in more concrete terms, if you select a random person with European ancestors and a random person with African ancestors, the expected genetic similarity is quite close to the expected genetic similarity of two random persons with the same ancestry.

Furthermore it's not actually that critical whether fraternal twins share 50% or 75% or 90%, the important part is that identical twins share nearly 100%, and the number for fraternal twins is significantly less, so if you see differences for fraternal twins that you don't see for identical twins, you can make a strong case that genetic differences explain the observation.

And finally, the idea that fraternal twins share ~50% of their genes is a bit of a simplification. On average, two randomly selected humans will have genetic similarity of 99.5% or so. So that "50%" quote is just a ballpark figure scaled to the relative genetic diversity of the human population to begin with.

Or it depends on how you measure "genetic similarity" anyway.

</comment></comment></comment></comment></comment></comment><comment><USER7> This makes me wonder how much differences in eye contact between cultures (in terms of etiquette) is due to prevailing genetic influences.

Like if most of the people in a group are wired to make less eye contact, maybe that's how the social norms get developed.

</comment><comment><USER8> Really neat article. I'd probably change the title to "How Kids Scan..." I was expecting something more about the inner model folks build for what makes up the world.

It would be interesting to me if this was somehow a physical characteristic of the eye. I'd also be interested to know if there are somehow more "optimal" methods of scanning than others.

Tangentially, I do worry about the emphasis on eye contact in children. It is almost like we punish kids for not wanting to look at us. It certainly seems to help know they are listening, but it is worrying to have tension just because someone doesn't want to make eye contact.

<comment><USER9> High School teacher here. I generally try not to take offense when I am talking to a student and they don't make much eye contact. Some of my coworkers take great offense when students don't make eye contact but I think it's just something that teenagers don't do (with adults/uthoroty figures). Also, some of my students are giving you the most attention when they are NOT looking at you.

Doesn't help that student desks are too damn short so talking to a sitting student forces you to loom over them like some cartoonesque evil authority figure. No one likes making eye contact in that kind of situation.

</comment></comment><comment><USER10> It's almost like feature detection, image segmentation, object detection, scene labeling, and tracking are pre-wired at some level... that would make learning a lot faster!

</comment><comment><USER11> Earlier eye tracking results by the Marcus Autism Center's Ami Klin and Warren Jones is described a 2011 TED talk: [https://www.ted.com/talks/ami_klin_a_new_way_to_diagnose_aut...](https://www.ted.com/talks/ami_klin_a_new_way_to_diagnose_autism)

</comment><comment><USER12> It's not clear from the summary or a very quick glance at the articles whether the researchers controlled for sex differences or impact on parent attitudes towards fraternal twins. It is sensible to assume that one sex will imitate dad while the other will imitate mom, or that one toddler receives more attention than another from either parent. Might anyone familiar with the topic have some insights on this?</comment>


Building our own tracking engine with MongoDB - <AUTHOR> http://engineering.thumbtack.com/2011/05/03/building-our-own-tracking-engine-with-mongodb/

<comment><USER2> OK, all jokes about "web scale" aside, why is MongoDB necessary for a measly average 2.4 TPS?

<comment><USER3> We're storing complex, loosely-structured data, which perfectly fits MongoDB's schemaless document model. The fact that it will easily scale up with us is just icing on the cake.

<comment><USER2> Thanks for the quick reply.

Did you look into the schemata of other tracking tools for inspiration, or was this an _ab initio_ analysis?

<comment><USER3> We came up with our model of tracking independently, but I found out later that Mixpanel has an eerily similar tracking API (see <http://mixpanel.com/api/docs/tour>). I think it's a fairly natural design, though, and wasn't surprised to see that someone else had thought of it.

Mixpanel does deal with funnels differently, however. With their API, you explicitly define events as being some numbered step in a funnel; in ours, the events are agnostic about what funnels they participate in, and we piece them together in a post-processing step.</comment></comment></comment></comment>


Functors, applicatives, and monads in pictures - <AUTHOR> http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html <comment><USER2> I think that many monad tutorials, including this one, fall into the same trap. They explain monads without giving any motivation, or when they do, it seems like monads only exist to get around problems caused by being pure.

When you program in normal languages, you have the ability to perform effects all of the time. You can always read/write to/from files, you can always raise exceptions or otherwise change the control flow. There's nothing you can't do.

Haskell is different. In Haskell, by default, you don't have any effects at your disposal at all. You can create values from other values, that's it. When you want to program with effects, you use a monad. The type of monad that you use decides the effects that you are allowed. For example, the maybe monad instance gives you the "fail without an error effect". The either monad gives you the "fail with an error effect". The list monad instance gives you the non-determinism effect. etc. You might expect me to say that IO gives you the "interact with the outside world effect", but that's not really true, forget what you know about IO for the moment.

The continuation monad instance is a bit special. In a sense, it is the most general of the monad types, because every monad instance can be seen as a specialization of it. The continuation monad allows every kind of effect. At this point, you might be thinking, "but how can this be, it doesn't allow IO".

To reconcile these facts. I present the coroutine monad. It has an effect, yield, that gives a value to the caller and waits for the caller to respond with a value so that it can continue. Here are some types:

        runCoroutine :: Coroutine i o x -> Either (o, i -> Coroutine i o x) x
        yield :: o -> Coroutine i o i

So running a coroutine either produces a value of o and function to resume the coroutine or it completes with a value of x. IO is very similar to the coroutine monad. When a Haskell program gets to a function that talks to the outside world it yields control to the runtime environment, the runtime environment does the actual IO and passes the result back so that the program can continue.

This is why Haskell is pure despite having effects. Haskell programs don't do IO, they yield control to the runtime environment whenever IO needs to be done.

So why are monads useful? They allow you to restrict the effects that are possible in different parts of your programs. This aids in reasoning about your programs, because you don't have to think about whole classes of behaviour, but they're less useful in other languages where you already have effects everywhere.

<comment><USER3> I don't know how else to put it, but at least half of what you have written above is completely wrong.

> but they're less useful in other languages where you already have effects > everywhere.

Scala has side effects everywhere, yet the Monad is extensively used in Scala programs. Monads have nothing to do with "effects".

Monads are not used to decide the kind of "effects" you are allowed. By calling every Monad a kind of "effect", you are just begging the question. Monads are merely objects that follow 3 monad laws, no more no less.

> This is why Haskell is pure despite having effects. Haskell programs don't > do IO, they yield control to the runtime environment whenever IO needs to be > done.

How is this different from a C program? Haskell is pure in the presence of IO, because the type system tracks IO calls and forces any function that even indirectly refers to a quantity obtained via IO to modify its type signature to reflect the IO action. This can be done with/without Monads. Haskell IO is a Monad, because it pretty much analogous to the State Monad and Haskell has special Monad syntax that lets you pass the World State implicitly and write imperative code in an imperative style.

<comment><USER2> > at least half of what you have written above is completely wrong.

That's quite an assertion.

> Scala has side effects everywhere, yet the Monad is extensively used in > Scala programs. Monads have nothing to do with "effects".

I didn't say monads weren't used outside of Haskell, I say that they are less useful. I haven't programmed in Scala before, I assume monads are used for their notation. They aren't required.

> Monads are not used to decide the kind of "effects" you are allowed. By > calling every Monad a kind of "effect", you are just begging the question. > Monads are merely objects that follow 3 monad laws, no more no less.

I don't know if you're familiar with group theory, but in group theory, every finite group is a specialization of the group of permutations. Groups are defined abstractly by the operations that they allow in the same way that monads are, but this definition for finite groups is as general as saying that every group is a subgroup of the group of permutations.

It's the same for monads, they are defined abstractly, but the abstract definition is equivalent to saying monads are all of the things that you can create by a specific kind of specialization of the continuation monad.

Continuations are an effect. Specializations of continuations are also effects. Monads define effects. What's really interesting is thinking about monads in terms of the Curry-Howard Isomorphism, on one end of the scale, the identity monad, you have constructive logic and at the other end, continuations, you have classical logic, what's in the middle? Does the list monad instance have an interesting associated logic?

Which question am I begging?

> How is this different from a C program?

It's just a different way of looking at programs. The distinction is never drawn for C programs.

> Haskell is pure in the presence of IO, because the type system tracks IO > calls and forces any function that even indirectly refers to a quantity > obtained via IO to modify its type signature to reflect the IO action.

This is quite a shallow way of looking at it.

> This can be done with/without Monads.

Sure, you could use continuations or uniqueness types.

> Haskell IO is a Monad, because it pretty much analogous to the State Monad

AFAIK, that's not defined in the Haskell standard, but that is the way that GHC does it.

> Haskell has special Monad syntax that lets you pass the World State > implicitly and write imperative code in an imperative style.

No, it's not syntax that's letting you pass the world state implicitly. In GHC:

        IO x = State RealWorld x = (RealWorld -> (RealWorld, x))

You can't get at this function and RealWorld doesn't have any constructors, so you can't call an IO operation or do other weird things. Anyway, it doesn't really matter how IO is actually defined. What matters is it's interface.

<comment><USER3> Reading your response, I think I need to read more on the topic. I haven't read Moggi's paper and I need to look up on the continuation Monad. You are probably correct and I am probably wrong. However, I will let my original post remain as a matter of historical record :-)

</comment></comment></comment></comment><comment><USER4> This has one of the usual dangers of trying to do a visualization of a monad, which is that it strongly implies that there is a one-to-one relationship between what you put in and what comes out, which is basically saying that the bind function of the monadic interface implementation will only call the function it receives once. This is not true; it may be called zero times (Nothing, empty list), once (Just something, a list of one element), or many times (once for each element in the list for the list monad, for instance), which is a critical element to understanding the monad interface. So, you know, be aware of that I guess.

<comment><USER5> /r/haskell has already discussed this at length: [http://www.reddit.com/r/haskell/comments/1co0s5/functors_app...](http://www.reddit.com/r/haskell/comments/1co0s5/functors_applicatives_and_monads_in_pictures/)

And I've given Maybe's Monad instance definition as well as explained it in pictures. If there's something missing please let me know specifically.

</comment></comment><comment><USER6> Yikes. That might as well be titled "Why functional languages will never catch on." It took something dead simple (a function that adds 3), and made it insanely complicated. Why would anyone _choose_ to deal with that?

<comment><USER7> They chose a deliberately over-simplified example in order to demonstrate the core concepts; I don't begrudge them that (nobody needs a program that prints out "Hello World!").

The audience level of this piece is confusing -- it _looks_ like a friendly, cartoony introduction for a general audience, but it actually assumes you already know Haskell.

Basically, you and I are not the intended audience.

<comment><USER6> I know a bit about Haskell and have played with it. I guess it just seems like functional languages are for those who want to solve super complicated mental exercises when doing tasks that would otherwise be easy using a traditional language.

There are very few things in the world of CS/programming where I can't follow along and grok what's going on, especially when laid out in a tutorial form like this. The fact that I was totally lost when reading this is not a good sign when you're trying to get people to adopt your school of thought.

<comment><USER8> >There are very few things in the world of CS/programming where I can't follow along and grok what's going on, especially when laid out in a tutorial form like this.

That's probably because most of the tutorials you've followed have adopted an imperative style of programming. It is easy for you to follow along because it really isn't all that different from what you are accustomed to. Functional programming really is a different beast entirely. It's often said (though I remain skeptical) that it's actually easier to learn functional programming as a non-programmer than to _un-learn_ your imperative programming tendencies.

>The fact that I was totally lost when reading this is not a good sign when you're trying to get people to adopt your school of thought.

I don't think that's a fair assessment. You could say the same thing about starting from functional programming and switching to imperative; some people actually do this! They find the idea of mutating a variable to be completely counter-intuitive!

<comment><USER6> I would love to meet this mythical being who understands functional programming but has no clue how to write an imperative program.

<comment><USER9> While going through a Math undergrad program in the mid-90s, I noticed that some number of my fellow students had a distaste for programming.

As someone who'd done reasonably well with both and had thought of them as heavily overlapping areas, I thought this was interesting, so I tried to poke at this a bit.

One of the concepts I got back from a talented classmate was basically a complaint about mutable variables -- that in an algebraic description of relationships for a given system what we call "variables" are less variable and more "unknowns" which represent _fixed_ if unidentified quantities. Others similarly noted there was something absurd about writing out equations like "x = x + 2".

<comment><USER10> I can see why they think that, but the important thing is that "x = x + 2" is not an equation. It's just an arguably poorly chosen operator (Pascal gets this right and uses ":=" for assignment).

The trick is to stop reading that line (in your head) as "x _is equal to_ x plus two", but instead "x _is assigned the value of_ x plus two".

<comment><USER9> > It's just an arguably poorly chosen operator (Pascal gets this right and > uses ":=" for assignment).

That's one potential takeaway, but when I turned over the complaint in my mind, this was arguably another way of complaining about mutability.

Also, given the timing, it's pretty likely that one of the languages they'd learned was Pascal: that was the language of the first few CS classes at my school in the 90s, it was also the language of any high school curriculum that led to the AP exam, and Borland's Pascal products were still pretty popular PC dev environments.

They could've also been unlucky and received their first exposure by choosing to do a numerical analysis class in Fortran or C, of course. :/

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER7> I reluctantly confess that, knowing nothing about Haskell, I was lost by the 4th diagram. Presumably if you know Haskell, the line "data Maybe a = Nothing | Just a" makes sense, but I can't parse it.

<comment><USER11> I don't know Haskell, but it seems pretty clear: "something called a Maybe named 'a'; is equal to Nothing, or just 'a' itself" (hmm, I'm not sure that's a whole lot clearer :-/ )

<comment><USER12> The variable 'a' there is a placeholder for a type.

e.g. loosely translating the idea of Maybe to C++ syntax (perhaps more familiar?) might give something resembling:

        Maybe<int> x = Just<int>(30);
        Maybe<int> y = Nothing<int>();

x and y are values of type Maybe<int>. I.e. we've plugged in the type int for the type variable a.

Given an arbitrary value of type Maybe<int> you have two cases to consider - either it is a "Nothing" which contains no further data, or it is a "Just<int>" which contains an int value.

You can think of the type Maybe<int> as being a "nullable int" type or perhaps a special collection of ints that can only contain 0 or 1 int value.

(beware: my knowledge of both haskell & c++ is not fantastic)

</comment></comment></comment><comment><USER13>
       > (+) <$> (Just 5)
       Just (+5)
       > Just (+5) <$> (Just 4)
       ERROR ??? WHAT DOES THIS EVEN MEAN WHY IS THE FUNCTION
         WRAPPED IN A JUST

A functor takes a function, and applies it to the inside of a context, but all of a sudden now a functor can't take a function and apply it to the inside of a context.

No, that will never make sense. Sorry. Haskell is hard.

edit: oh, it's in a just value, I didn't notice that the first time I read it, for... some reason.

<comment><USER14> "Just (+5)" is not a function. This would have worked with:

(+5) <$> (Just 4)

<comment><USER15> Or Just (+5) <*> Just 4 as it turns out.

</comment></comment></comment><comment><USER16> "Bill O'Reilly being totally ignorant about the Maybe functor" and the corresponding pic was (for me) LOL funny ;-)

My intro to functional programming has been via Scala; not quite Haskell, but makes use of some of the same functional idioms, so a good place to get your feet wet in FP if you're tied to the JVM (yes, yes, there's also Clojure, prefer Scala's type system and easily grok-able syntax).

</comment><comment><USER17> Still have not encountered a good explanation of monads although there seems to be a new try on Hacker News every couple of weeks. Wonder if/when it will reach mainstream and become part of the common vocabulary of programming. Wonder if a limited syntax would help.

Maybe a better example than the common 'or nothing' would help in this case.

<comment><USER18> I just worked my way through learning-myself-a-haskell yesterday, so this is timely. And I agree with your criticism. The `Maybe` example is simple, and helps with drawings, but it really lacks motivation. I understand all the words, and all the definitions, but it doesn't really explain what problem we've solved.

The payoff of the article is, I think, supposed to be:

getLine >>= readFile >>= putStrLn

Which looks great. But what I'd like to see is a longer explanation of why this is better than the alternatives (like simple function composition).

<comment><USER19> I think the biggest problem with monad tutorials is that it seems that everyone finally "gets" monads in a different way so the monad tutorials that get written lack motivation. For example, I finally "got" monads when I was working with a promise library in Javascript...

That said, one thing I noticed is that there are two main "types" of monad tutorials. The first one is the the one taken by the OP and I call it the "category theory" approach. It tends to show what sorts of things you can do with monads and how they work mathematically but they kind of lack an explanation for why you should bother with monads in the first place.

The other approach for monads is the "monads as an useful interface" approach. One paper I would highly recommend in this category is the "awkward squad" paper by Simon Peyton Jones:

[https://research.microsoft.com/en- us/um/people/simonpj/Paper...](https://research.microsoft.com/en- us/um/people/simonpj/Papers/marktoberdorf/)

Its an introduction to monads that helped me a lot and it also explains quite a bit about the history of monads.

Which lets me come back to your main point:

> why this is better than the alternatives (like simple function composition)

Because simple function composition doesn't work! While nowadays people like to point out that Haskell is a pure functional language, noone would have bothered with making a pure language (back then) if all you gained was all this headache with monads. The reason Haskell was pure in the first place was because its original goal was to be a lazily-evaluated language and that lazyness kind of forces you into pureness. You might think the order of evaluation of function arguments in C being unspecified is bad, but Haskell would be even worse since the order of evaluation for _everything_ is unspecified and some things might not even end up being evaluated at all!

They ended up trying all sorts of approaches for adding effectful computation to Haskell and the most successful one was the monad one (the SPJ paper goes over this a bit). If you pay attention, the monad interface forces computations to be single threaded (you can't "branch out" monadic effects) and doesn't let you generally start or end an effectful computation wherever you want, meaning that whoever defined the monad you are using can control how effects are started or terminated via what functions they expose in the public interface (Maybe exposes the constructors directly so you can pattern match on them but IO makes it so `main` the only place you can start an IO computation)

Finally, this gets us back to notational problems. While monads make things really neat in the type level and as a platform for effects, it can end up really noisy in practice:

        getNumber >>= (\a -> getNumber >>= (\b -> f a b)))

So for monads we have "do" notation that lets you write things in a neater way:

        a <- getNumber
        b <- getNumber
        f a b

This is really helpful and 99% of the time, do notation is precisely why people bother making things into monads instead of defining their own versions of (>>=), like they do in Javascript with promises. However, writing all those intermediate variables can be annoying and doesn't feel "composeable". The Functor and Applicative type classes provide methods to do that:

        f <$> getNumber <*> getNumber

Monads are always particular cases of these type classes and you can show this mathematically but its a bit complicated in practice because people added monads to Haskell before they discovered these otehr type classes were useful...

To wrap things up I would like to point out that most of the time monads and functors are an "advanced" technique that lets you take programs that you could already write before but write them in a neater way, with do notation, fmap, <$>, etc. (While its true that you can write generic programs that abstract over the monad interface, you only end up doing that if you are writing a control flow library or something even more advanced like a parser combinator). To give examples of what I am talking about, if you have functions that return null on error you can already get by with adding an if statements after every call (like you have to do in C) but monads let you omit the boilerplate if statements. A more advanced example I like is coroutines/generators (things that "yield"). You can write this sort of program in a normal language by manually inverting your control flow, storing state explicitly in stacks or other data structures. A continuation monad lets you write the code in a more natural way (and as a library, without needing to extend the base language with suport for a yield statement!)I think the biggest problem with monad tutorials is that it seems that everyone finally "gets" monads in a different way so the monad tutorials that get written lack motivation. For example, I finally "got" monads when I was working with a promise library in Javascript...

That said, one thing I noticed is that there are two main "types" of monad tutorials. The first one is the the one taken by the OP and I call it the "category theory" approach. It tends to show what sorts of things you can do with monads and how they work mathematically but they kind of lack an explanation for why you should bother with monads in the first place.

The other approach for monads is the "monads as an useful interface" approach. One paper I would highly recommend in this category is the "awkward squad" paper by Simon Peyton Jones:

[https://research.microsoft.com/en- us/um/people/simonpj/Paper...](https://research.microsoft.com/en- us/um/people/simonpj/Papers/marktoberdorf/)

Its an introduction to monads that helped me a lot and it also explains quite a bit about the history of monads.

Which lets me come back to your main point:

> why this is better than the alternatives (like simple function composition)

Because simple function composition doesn't work! While nowadays people like to point out that Haskell is a pure functional language, noone would have bothered with making a pure language (back then) if all you gained was all this headache with monads. The reason Haskell was pure in the first place was because its original goal was to be a lazily-evaluated language and that lazyness kind of forces you into pureness. You might think the order of evaluation of function arguments in C being unspecified is bad, but Haskell would be even worse since the order of evaluation for _everything_ is unspecified and some things might not even end up being evaluated at all!

They ended up trying all sorts of approaches for adding effectful computation to Haskell and the most successful one was the monad one (the SPJ paper goes over this a bit). If you pay attention, the monad interface forces computations to be single threaded (you can't "branch out" monadic effects) and doesn't let you generally start or end an effectful computation wherever you want, meaning that whoever defined the monad you are using can control how effects are started or terminated via what functions they expose in the public interface (Maybe exposes the constructors directly so you can pattern match on them but IO makes it so `main` the only place you can start an IO computation)

Finally, this gets us back to notational problems. While monads make things really neat in the type level and as a platform for effects, it can end up really noisy in practice:

        getNumber >>= (\a -> getNumber >>= (\b -> f a b)))

So for monads we have "do" notation that lets you write things in a neater way:

        a <- getNumber
        b <- getNumber
        f a b

This is really helpful and 99% of the time, do notation is precisely why people bother making things into monads instead of defining their own versions of (>>=), like they do in Javascript with promises. However, writing all those intermediate variables can be annoying and doesn't feel "composeable". The Functor and Applicative type classes provide methods to do that:

        f <$> getNumber <*> getNumber

Monads are always particular cases of these type classes and you can show this mathematically but its a bit complicated in practice because people added monads to Haskell before they discovered these otehr type classes were useful...

To wrap things up I would like to point out that most of the time monads and functors are an "advanced" technique that lets you take programs that you could already write before but write them in a neater way, with do notation, fmap, <$>, etc. (While its true that you can write generic programs that abstract over the monad interface, you only end up doing that if you are writing a control flow library or something even more advanced like a parser combinator). To give examples of what I am talking about, if you have functions that return null on error you can already get by with adding an if statements after every call (like you have to do in C) but monads let you omit the boilerplate if statements. A more advanced example I like is coroutines/generators (things that "yield"). You can write this sort of program in a normal language by manually inverting your control flow, storing state explicitly in stacks or other data structures. A continuation monad lets you write the code in a more natural way (and as a library, without needing to extend the base language with suport for a yield statement!)

</comment></comment></comment><comment><USER20> That last picture was problematic in that it showcased three different conventions for application:

      fx
      f <*> x
      x >>= f

The first of these (see also the Monads section) was the author's fault (should have used f <$> x), but the last conjures memories of PHP. Something to expand on? I would have also preferred more reminders that the box is the Functor/Applicative/Monad, not the function or the infix operator.

[1] <http://adit.io/imgs/functors/recap.png>

<comment><USER5> Whoops! I'll get this fixed shortly.

> the last conjures memories of PHP

As a non-PHP programmer I'm not sure what you mean.

<comment><USER20> A common complaint of PHP is that ordering of the arguments is inconsistent. So too here.

</comment></comment></comment><comment><USER21> One thing that bothers me, but I found no explanation why - is there a way to turn 'Just a' to 'a'? >>= seems like it does that but I only see it working with function that returns a Monad.

EDIT: I may have skimmed a bit.

<comment><USER2> Just think about it. Let's call such a function fromJust:

        fromJust :: Maybe a -> a
        fromJust (Just x) = x
        fromJust Nothing = ??? -- What can we put here?

Haskell doesn't have a null value that we could use here. There is such a function defined in the standard library, but it is partial. It uses error in the Nothing case.

edit: In many cases there is a clear value that should be used in the Nothing case, suppose you have a Maybe Int which is the number of times a specific event happened in the last second. Clearly 0 is a good default and you can write a function (Maybe Int -> Int). There's a function I tend to use for such cases: (maybe :: b -> (a -> b) -> Maybe a -> b). In this case:

        maybe 0 id :: Maybe Int -> Int

</comment></comment><comment><USER22> Have we got a new _why?

<comment><USER23> If so, let's hope it's more content and less drama... and please, let's concentrate on the content and not some odd analogy that will only take away from said content.

<comment><USER22> Mine was a compliment, not only an analogy.

The tech field needs people that are both confident with words, fun and have a deep understanding of the inner details of things.

_why was such a writer, let's hope Adit (correct?) is another.

Regarding form vs. content, I think that the HN community enjoy discussing form as much as content. Most of the people here are interested in design or typography, things that more close to form than to content.

<comment><USER23> I agree that the tech community could benefit from more well-versed people with insight into our tools and paradigms... however, I don't agree that _why is such a person.

He openly claims to be a poor programmer, and as an artist... well, my contention is that he appeals to a very limited audience. That's not a criticism, simply a suggestion that while he may be valuable in an artistic sense to some people, he's not contributing to the "tech community" in a meaningful way. By which I simply mean that he should not be a yardstick by which we measure anyone.

Let him be himself. Let the rest of us be ourselves. Let that be good enough.

<comment><USER24> > Let him be himself. Let the rest of us be ourselves. Let that be good > enough.

_why even said this himself:

> caller asks, "should i use hpricot or nokogiri?" if you're NOT me: use > nokogiri. and if you're me: well cut it out, stop being me.

<comment><USER23> Hard time arguing with that. :)

</comment></comment></comment></comment></comment></comment><comment> alok-g Posted earlier here: <https://news.ycombinator.com/item?id=5575334>

</comment><comment><USER25> If you learn Haskell without getting into these stuff directly it's soo much easier. It will obvious and not cryptic like if you tackle this without any basic understanding of Haskell.

This guide is for understanding the theory behind monads, the use should not be something difficult to get if you have used the IO monad before.

</comment><comment><USER26> I for one thought this was a fantastic article, and quite well-written.

<comment><USER5> Thank you!

</comment></comment><comment><USER27> good tutorial.

</comment><comment><USER28> The pictures look cute and friendly, but to me it read like a series of non- sequiturs or deus ex machinas. I don't know Haskell.</comment>


StartCom Launches StartEncrypt, Let's Encrypt Alternative - <AUTHOR> https://www.startssl.com/NewsDetails?date=20160606 <comment><USER2> The HN title makes a promise ("Let's Encrypt Alternative") that StartCom didn't make and can't deliver. dang -- can the HN title be changed back to the original title?

This is software to automate the creation and installation of StartCom certs; it doesn't include the "it's all free and validation is automated" part that Let's Encrypt brings to the table. The pricing model is just StartCom's normal pricing; StartCom has always used the model of charging for validation and then offering "all you can eat" certificates.

<comment><USER3> LOL. You should read their marketing email.

Dear StartCom customers,

This electronic mail message was created by StartCom's Administration Personnel:

StartCom, a leading global Certificate Authority (CA) and provider of trusted identity and authentication services, announces a new service – StartEncrypt today, an automatic SSL certificate issuance and installation software for your web server.

StartEncrypt is based the StartAPI system to let you get SSL certificate and install the SSL certificate in your web server for free and automatically, no any coding, just one click to install it in your server.

Compare with Let's Encrypt, StartEncrypt support Windows and Linux server for most popular web server software, and have many incomparable advantages as:

(1) Not just get the SSL certificate automatically, but install it automatically;

(2) Not just Encrypted, but also identity validated to display EV Green Bar and OV organization name in the certificate;

(3) Not just 90 days period certificate, but up to 39 months, more than 1180 days;

(4) Not just low assurance DV SSL certificate, but also high assurance OV SSL certificate and green bar EV SSL certificate;

(5) Not just for one domain, but up to 120 domains with wildcard support;

(6) All OV SSL certificate and EV SSL certificate are free, just make sure your StartSSL account is verified as Class 3 or Class 4 identity.

StartEncrypt together with StartSSL to let your website start to https without any pain, to let your website keep green bar that give more confident to your online customer and bring to online revenue to you. Let's start to encrypt now.

Please do not reply to this email. This is an unmonitored email address, and replies to this email cannot be responded to or read. If you have any question or comments, just click Here (([https://startssl.com/reply](https://startssl.com/reply)) to send your question to us, thanks.

Best Regards StartCom™ Certification Authority

</comment></comment><comment><USER4> I wouldn't say it's an alternative to Let's Encrypt... it's better automation tooling for using StartCom as a CA. Kind of misleading. Prior to Let's Encrypt, I used StartCom's free certs, which was always a nice option.

While I appreciate their efforts, it would be nice to see the CAs offer a consistent API for usage/automation... it's really something that should be a bit more commoditized than it currently is.

</comment><comment><USER5> I was pretty excited at the idea of "free" EV certs, but after reading into it a bit (conveniently the last bullet point after clicking through)

"For OV SSL and EV SSL, just charge the validation cost annually, certificate is FREE!"

<comment><USER6> You're never going to get "free" EV Certs. The validation and paperwork hassle is too much.

I mean, theoretically "it's possible" but someone would have to be pumping a LOT of money into that org

</comment></comment><comment><USER7> Reading through the claimed advantages compared to Lets Encrypt:

\- Install it automatically. Well yes, certbot will install the certificate for you, it's dishonest to claim otherwise.

\- Not just for one domain. I happen to have one LE cert with three domains on it.

\- Wildcard support. One genuine claim.

\- Two different advantages that both mean "we also offer OV and EV certs". OV certs in particular are a marketing exercise and nothing more - do you really believe any end user anywhere opens up a certificate, hits "details" and scrolls to the right part where they can check if an organisation is listed, and THEN considers what they find when trusting the site?

</comment><comment><USER8> Feels like a rip off (in name), but the features and difference in limitations vs let's encrypt are interesting!

I say, let the competition in! Probably only (mostly) good things will result.

<comment><USER9> It's a free product. It would be better to spend dev time improving LetsEncrypt, rather than start another one from scratch.

<comment><USER10> Well, not necessarily. Let's Encrypt gave us the ACME protocol. Would be nice if we started seeing competing implementations of that.

<comment><USER11> Competing implementations of which part? There's already a number of clients out there.

<comment><USER12> I think he's talking about the server.

The only two servers I'm aware of is the LE server and the LE staging server which both run the same software.

It would be really cool to get another CA giving out certs using the protocol.

<comment><USER11> Oh, absolutely. Enabling other CAs to use the ACME protocol* for certificate provisioning was an explicit goal during its development. As such, it's incredibly disappointing that Startcom decided to build their own incompatible solution here.

*: Yes, that's really what it's called. Stands for "Automatic Certificate Management Environment".

</comment></comment></comment></comment></comment></comment><comment><USER13> Any competition to Let's Encrypt is good. The more SSL deployed the better.</comment>


US Gov't to close 1,200 Data Centers - <AUTHOR> http://www.datacenterknowledge.com/archives/2012/01/04/feds-now-plan-to-close-1200-data-centers/

<comment> daniel-cussen 1,200 _government-run_ data centers.</comment>


Ask HN: Sweet.io An open micro-blogging platform driven by its users - <AUTHOR> http://signup.sweet.io

<comment><USER2> _We do not care about your email address and we will not share it with anyone._

Except with <http://launchrock.com> ?

<comment><AUTHOR> What is the problem with launchrock?

<comment><USER2> I have no problems with LaunchRock. But your text implies that you not sharing an entered e-mail address with anyone although you are sharing it with LaunchRock.

<comment><AUTHOR> Do you have info that LR using emails for their own ?

<comment><USER3> Jameson from LaunchRock. We don't email our customers' users.

</comment></comment></comment></comment></comment><comment><USER4> Show HN a product, not a meaningless LaunchRock page.

<comment><AUTHOR> I changed into ask hn. How is this?

</comment></comment><comment><USER5> LaunchRock page.

<comment><AUTHOR> Is there a problem having a launchrock page? Do you thinl that i misuse something?

<comment><USER6> No, but from the submission title people expect a product, not a landing page.

<comment><AUTHOR> I'm sorry. Changed the title to ask hn. More logical?

<comment><USER6> Ask HN is usually for specific questions. Your best bet is to build the site, and _then_ do a "Show HN" post. Good luck!

<comment><AUTHOR> Thanks for the help Paul</comment></comment></comment></comment></comment></comment>


Scaling with Kindle Fire - <AUTHOR> http://googleappengine.blogspot.com/2011/11/scaling-with-kindle-fire.html

<comment><USER2> Today I learned: Pulse was apparently installed on my Kindle Fire for the past 2 weeks. Pulse is some kind of news app that I've never heard of or used before.

Things I Already Knew: I can't find out what Pulse is because my Kindle Fire doesn't support a proxy.

<comment><USER3> What you might not care to know: Next to gmail, pulse is probably my most used app on my android phone. This is largely because much of my infotainment reading is done on the subway with no connectivity. Pulse caches news stories from various sources to your device so you can read offline.

<comment><USER2> Sounds cool. I'll have to check it out when I get somewhere the kindle can actually connect to the internet. Pre-bundled apps have a hard time... I automatically assume if it's installed from the vendor that it is corporate sponsored spam so it's as good as invisible to me since I've trained myself to completely and compulsively ignore the icons. (I can't even remember having seen Pulse on my Fire lol)

</comment></comment></comment><comment><USER4> It's highly unlikely to happen, but I'd love to get an idea of how much it costs to run a big service like Pulse on App Engine. A monthly estimation would be great. Anyone mind sharing?</comment>


Accenture to Acquire Symbian Professional Services Operations from Nokia - <AUTHOR> http://newsroom.accenture.com/article_display.cfm?article_id=4853

<comment><USER2> I wish all the best to those employees. Sadly, I haven't come across any professional services employee of Accenture who speaks positively of their employer or their job.</comment>


Paste: Making slides simple - <AUTHOR> https://fiftythree.com/paste <comment><USER2> Do these hip young companies realize how much historians are gonna be pissed at them?

"Paste"

"53" or is it "fifthythree"?

What happened to being unique?

Or even searchable FFS!

</comment><comment><USER3> To me, this is a super niche product. As expected (from fiftythree), the apps are beautiful. However I found the lack of editing features to be "limiting" as opposed to "simple". The collaboration aspect is interesting but definitely not at $8/month per user. It might be a _nice to have_ but existing productivity suites (from bigger players) have significant overlap of features.

This is coming from someone who uses the "Paper" app (also by fiftythree) religiously on my iPad Pro.

<comment><USER4> Super niche? PowerPoint slides are the format of choice for communication and thinking in the corporate world. If Paste could take even 1-2% of that market they would have it made.

<comment><USER5> Everybody thinks they can get 1% !

<comment><USER6> Ha yeah. If it was easy to get 1%, then a hundred more people will enter the market after you and take 1% each and leave you with nothing :)

</comment></comment></comment></comment><comment><USER7> This looks a lot like the new pinkish Dropbox re brand. So much that I was sure it's a new Dropbox product. They also have a product called "Paper" which confused me even more

<comment><USER8> To be far to FiftyThree, between the 2 of them (and only the 2 of them), FiftyThree used it first [https://news.ycombinator.com/item?id=7171724](https://news.ycombinator.com/item?id=7171724)</comment></comment>


Video Games Satisfy Basic Human Needs - <AUTHOR> http://nautil.us/blog/how-video-games-satisfy-basic-human-needs <comment><USER2> Wow, the original "4 types of players" paper is really, really good and also very detailed. Makes some interesting observations about the dynamics of those types of players in a shared game world.

[http://mud.co.uk/richard/hcds.htm](http://mud.co.uk/richard/hcds.htm)

Personally, I seem to be closest to the explorer type. I always liked single player games more, and I prefer well-written lore, depth and new things to discover over the mechanics or social aspect.

<comment><USER3> I didn't think I would, but I seem by those archetypes to land under "Achievers", this despite me never 100%:ing a game (the rare exception being Binding of Isaac, love the item synergy sandbox/breaking of that game), and hating achievements, never looking for collectables, etc.

I do however always accumulate/optimize for maximum ammo/currency/gear/weapons/items, to the point where I believe I completed >80% of Half-Life with the crowbar, to conserve ammo.

I also like you love singleplayer games and a well-written story, but I on the other hand hate open world games (because they're never open nor "worldy" enough), and equally hate too linear games (looking at CoD past 3 and the like).

I grew up loving games like Quake (for the multiplayer/mechanics/general tech side of it), The Longest Journey for the story, Half-Life for both aspects, and a bunch of games struggling with either storytelling/mechanics or other but loveable for their attempt at trying something more than they could achieve (examples being Outcast, Citizen Kabuto, Oni, Advent Rising, Too Human).

When thinking of what the last bigger/sorta AAA games I enjoyed playing was I think it's Half-Life 2 (kind of obvious), but also FarCry (1), Crysis (1, but also Warhead), Just Cause 2.

All of them had a story, most of them were open world and allowed you to approach a problem with undesigned solutions, which is what I really love.

I've bought GTA 4, 5, Far Cry 3, 4, Just Cause 3, and many many others, played them for less than a handful hours, and given up because it just feels like I have to churn this mill just to advance a movie, at which point I may as well watch a movie, or watch someone else play the game (which I now completely understand as a concept).

"Open world" games I've played in recent years - after the original concept of open world once went linear for consoles, and then consoles catching up enough to enable open world games again - don't seem to be so much about designing a world with some rules and a number of tools, but simply providing more than 1 or 2 designed solutions to a problem, which feels completely hollow to me.

I have no doubt that this is why MineCraft (which I haven't played much for lack of story/"game", although having plenty of sandbox/open world) and that genre has sprouted up to much success.

Sorry for hijacking. I don't know how this turned into a longwinded games rant, but it raised questions since I identified with you, while still feeling characterized under "achiever".

<comment><USER4> You should really try Rimworld. I am just like you. I usually downloaded (stopped bying them for this reason but I still had hope for one that would justify the money...) one of those AAA games, played it on a weekend and deleted them afterwards. Battlefield was perfect since they had an open Beta. Guess there is a reason why you have to pay for Betas today and Demos are pretty much dead.

Rimworld is now the only game I have and it is the first time I didn't regret a single cent I spend for it. Even when it's 30$.

Rimworld is a Base Building game. Handling may be compared to Prison Architect but with seemingly never ending depth (Prison Architect didn't work for me too...). The learning curve is part of the game and even now with the extended tutorial, you'll find new ways to optimize and new possibilities. The Modding community is very active too.

[https://rimworldgame.com/](https://rimworldgame.com/)

Also the reddit community is also pretty active: [https://www.reddit.com/r/RimWorld](https://www.reddit.com/r/RimWorld)

<comment><USER5> I must say I was a very avid gamer 5-10 years ago. I enjoyed the likes of World of Warcraft, Starcraft (1 and 2), Battlefield (all of them), and many more. Nowadays, I find it very hard to get myself to sit down and play for more than a couple hours at a time. This all changed with Rimworld, holy cow. Rimworld was a dwarf fortress I could pick up without the ridiculous learning curve. It's a game I can sit and enjoy in my free time without feeling "the grind". The base building genre is one that has barely been touched over the years, with Dwarf Fortress being the "founding father". I must say a truly unique game. The lead developer is always active on reddit and takes direct feedback from his player base. This a game I can easily see my self playing for the next decade.

<comment><USER4> Me too. The best thing about it is: even if for whatever reason (Tynan seems like a dev from a different planet) the game would go in the wrong direction, we still have all the previous versions. For all major platforms. This is value you get for your money!

</comment></comment></comment></comment></comment><comment><USER6> Sadly video games seem to be the only source of agency for a great number of people. Our lives seem to be more and more constrained without any authentic choice available to us and in response we retreat to artificial environments.

<comment><USER7> This. This whole article made me realize many things about why some of my friends made the choice to sit home, play games, and live on welfare benefits, instead of pursuing education and career. I guess this "strategy" allows them to reach all the human needs with minimal effort. Why would they do anything else, if that makes them happy? Even if it only makes them just enough happy to keep on going, its still an easier choice for them than a traditiotal career. The effort one needs to put on satisfying the needs through working are on a totally different scale. Very interesting.

<comment><USER8> What country and how? I'm just asking for a friend...

<comment><USER7> Finland. You can get a cheap flat from the municipality(at least in the city of Espoo), then rent assistance from the state, and then you visit the welfare office (Kela) sometimes and tell that you are out of money, and they'll give you some. Id guess you have like 300e to spend per month for food, and you live in the outskirts of the city in a 20square meter flat, but hey, at least you can play your games as much as you want. Not the life id want, but some of my old friends with whom I still occasionally play games online have chosen that path. I've read that the number of young adults (mainly males) who are living outside the normal society is already as high as 30,000 in Finland, but I don't know for fact if they are all as extreme as some of the people I know.

<comment><USER9> Sound like 30,000 ticking time bombs...eventually they'll want more out of life.

</comment></comment></comment></comment></comment><comment><USER10> Video games are like the dreams we have at night. We can explore worlds that are completely foreign to us, but in facing the unknown we face ourselves.

<comment><USER11> That's a good analogy. Also you can be the person you always wanted to be, or you can be the person you see yourself as, which may not be the person that you are in real life.

</comment></comment><comment><USER12> _> "Basically," he said, "if you're a jerk in real life, you're going to be a jerk in any kind of social setting, and if you're not, you're not."_

That somehow undermines the point of roleplaying. Would he also suggest, that actors who play questionable or evil characters are supposed to be evil in real life? That's like some extreme form of Stanislavski's system in reverse.

 _> They found that video games that allowed players to play out their "ideal selves" (embodying roles that allow them to be, for example, braver, fairer, more generous, or more glorious) were not only the most intrinsically rewarding, but also had the greatest influence on our emotions._

And that's also considered the worst form of roleplaying. A classical Mary Sue is based on reflecting too much of your own image into the character while at the same time idealizing it.

So it's surely not the only reason to play games. Some actually like more elaborate roleplaying than creating Mary Sues.

<comment><USER13> > "Basically," he said, "if you're a jerk in real life, you're going to be a > jerk in any kind of social setting, and if you're not, you're not."

I have anecdotal evidence that this isn't the case.

I can be an extreme jerk in games: textually abusive, team-killing just for fun, etc.

But I can also be super nice: lead clans, go out of my way to be helpful to everyone, etc.

Not sure what triggers my behavior one way or the other. Perhaps it has to do with consistent worlds (MMO) vs team deathmatch (FPS). Once it's manifested itself for a particular game, it stays that way.

In real life I'm a pretty nice guy. But I still go home at night and kill people while simultaneously insulting them.

<comment><USER14> So you somehow think that it's okay to be abusive online, but that you're perfectly squeaky clean face-to-face?

I have my doubts. I'm sure you come off as a lot nicer, but I suspect you're doing subtle things constantly that you might not even be aware of, or that you write off as normal and therefore perfectly fine.

My ethics and morals don't stop at my router. I don't attack people online any more than I attack them in person. People's feeling matter, no matter the medium.

<comment><USER13> > I'm sure you come off as a lot nicer, but I suspect you're doing subtle > things constantly that you might not even be aware of, or that you write off > as normal and therefore perfectly fine.

Maybe, but I doubt it. I'm sure I'm not the world's nicest person or anything, but unless everyone is lying to me: I have a fun personality and people prefer to be around me than not.

If your ethics and morals don't allow you to let the other player feel bad, how do you even play games? Usually the point of games is to win, or to at least out-achieve others. How do you spare their feelings while you shoot someone in the face in an FPS?

<comment><USER15> It's called good sportsmanship and (some) online games are the only place you can get away without practicing it. Anywhere else (board games, pick up sports games, etc) it's required regardless of whether you win or lose or you'll be ostracized.

<comment><USER13> Video games aren't the only place that you can get away without practicing it.

Places I've seen bad sportsmanship do fine (or prosper):

\- All major sports (NFL, NBA, college, etc.)

\- Business: Steve Jobs, (everywhere else)

\- Presidential Elections

People in these cases (and more I'm not thinking of) generally don't care about how much of a jerk you are and some even respect you more for it.

<comment><USER12> Which doesn't make it any better or justify in any way. I have no respect for jerks in any of these fields.

</comment></comment></comment></comment></comment></comment></comment><comment><USER16> You can't expect every avenue to be chased down on a short form article (why does it have to be short, lack of disk space?) but WRT killer, achiever, explorer, social, some of the most powerful or memorable moments in games is a mix of them.

There's a GTA series game, I think GTA:SA but maybe wrong, where there are hidden things all over the map, and you have to do crazy non-game plot urban exploring like jump your motorcycle across a river to the roof of a building where you jump a ramp to the next building and hidden up some stairs behind an AC unit there's a treasure chest or whatever. And of course there's about 100 in this game all over the entire map. So it appeals to both the achiever who's gotta get that last one and the explorer who ends up pretty much walking every sq foot of the game and every obscure corner. Pretty cool. And yes I did get addicted and eventually found all 100 and got some kind of reward. This was 10, maybe 15 years ago, and the memory of the details of even which GTA game is weak, but the memory of the experience and how much I enjoyed it is very strong. Other GTA games didn't appeal to me as much because they didn't have a reason (meaningless counters) to explore the map.

Likewise there's some achiever / explorer in games like nethack.

A game like Minecraft (modded, anyway) hits all four categories to some extent or another, and is quite popular.

</comment><comment><USER17> In games that allow "bad behavior", I almost always play the bad guy...but I feel really guilty about it. Then I have to play through again and do everything the "right" way. I wonder what that says about me?

<comment><USER2> In any game that allows both good and bad behaviour, I always intuitively play the good person. I sometimes _try_ to be bad, but feel so guilty about it (and afraid of dampening my conscience) that I can't enjoy it.

Yes, I've been meaning to replay the whole Mass Effect series as a Renegade character, but I can't get myself to actually do it.

<comment><USER18> Bad guy is always more fun, Tie Fighter is better than X-wing, but being annoying griefer guy is not.

Except in WWII games. During the early days of WWIIonline there were a few people who took playing german units a little too seriously and were quietly asked, told, to stop. I was a member of a german squad that rarely participated in mass offensives specifically to avoid confrontations with die- hard "recreationists".

<comment><USER19> I've usually found the opposite to be true. But perhaps because I like more of a challenge. In most cases I've seen, playing as the 'bad guy' was easier, because you could basically do whatever you want with minimal consequences. Completing objectives as the bad guy was simple. In contrast, being the 'good guy' often involved playing with your hands tied by certain restrictions, which often forces you to think more about how to complete your objectives without breaking the rules. I even tend to impose rules not explicitly indicated by the game, just because it seems like it would fit the character's ethos and makes for more of a challenging play.

<comment><USER2> Example: Mirror's Edge. You could get your way out of most (all?) situations without killing anyone. It was pretty challenging but also rewarding. I tried to play this style, managed to get to ~2/3 of the game before my (then pretty weak) computer gave out. Had only to restart a part of a level once, because I accidentally kicked a policeman off the building.

<comment><USER17> The original Deus Ex game was similar. I remember getting about 2/3 of the way through without killing anyone. I remember being backed into a corner and finally making a kill, then "screw it, I'm killing everyone". That was an awesome game though, so many different ways to accomplish the mission. At one point you become locked into a single path though, which always bothered me - IE, you can't choose to continue helping the bad guys at a certain point, you always end up fighting against them.

</comment></comment></comment></comment></comment></comment><comment><USER20> Fun in challenges should certainly be added.

I guess you could bend finishing a super mario level in to "achievements" but it's really more about the challenge.

Games could even be random generated without any level progression, it's just that random generated levels are not as good in creating interesting and non- repetitive challenges.

<comment><USER21> > it's just that random generated levels are not as good in creating > interesting and non-repetitive challenges.

i see this sentiment and similar echoed a lot and the issue i take with it is that there are degrees to everything. Just like there are good and bad hand designed games, there is the same spectrum of procedural games

there are many games that do this extremely well but they are mostly not very well known indie efforts. Off the top of my head:

* Dungeon of the Endless

* Invisible Inc

* Downwell

* Rogue Legacy

* Spelunky

* Teleglitch

<comment><USER22> Completely disagree. In fact I hate Rogue Legacy and all 'rogue types' because they think randomness = interesting.

<comment><USER23> Anecdotally, I really enjoyed Rogue Legacy and objectively, it was an extremely successful game that has a high rating both from professional reviewers and community reviews [[https://www.google.com/search?q=Rogue+legacy&oq=Rogue+legacy](https://www.google.com/search?q=Rogue+legacy&oq=Rogue+legacy)]. Unless you were there or know people who were, saying something like, "because they think..." will not go far at ycombinator (from what I've seen).

<comment><USER22> I don't write my comments to appease people here, if they don't like them then so be it, that isn't a goal of mine.

Rogue-like games plague the Steam store [1], though there will always be games like Legacy that rise to the top of their category. You could say Candy Crush is an objectively successful game too, but I see it as a micro transaction laden piece of trash.

[1] [http://store.steampowered.com/search/?term=rogue&tags=1716](http://store.steampowered.com/search/?term=rogue&tags=1716)

<comment><USER21> The reasonable statement to make from all this is simply that you don't like rogue-lite or rogue-like games.

The claims you made beyond that are invalid

</comment></comment></comment></comment></comment></comment><comment><USER24> Was there any study on video games and subjective well-being (i.e. does video games bring more happiness)? I'd be interested in that.

<comment><USER18> I read something by nasa many years ago. They were looking at games to keep people sane in confined spaces. There was also mention of people stuck in hospital beds using games.

Google around and you should find papers on vr games reducing requests for painkillers in children's hospitals.

<comment><USER25> Former co-workers doing exactly that: [https://artsandsciences.osu.edu/news/arts-and-sciences- stude...](https://artsandsciences.osu.edu/news/arts-and-sciences-students- partner-nationwide-children-s-hospital-create-virtual-reality)

<comment><USER18> I do laugh when these researchers creat thier own games. There are already people spending millions to keep kids distracted via games. Give them an x-box.

</comment></comment></comment></comment><comment><USER26> I was under the impression that this kind of psychology (your subconscious thoughts drive who you are and you're mostly a passenger) was on its way out, academically speaking.

I got this from Invisibilia's "The Secret History of Thoughts", their first podcast from January 8th of last year.

[http://www.npr.org/podcasts/510307/invisibilia](http://www.npr.org/podcasts/510307/invisibilia)

<comment><USER2> I understand that here it's not about subconscious thoughts, but about personality in general - that your personality determines the way you approach a game, how you play, and how much enjoyment you get out of it.

<comment><USER26> Yeah, you should listen to the Invisibilia podcast episode, the way they talk about it, this is the Freudian way of analyzing behavior, and it's not very popular anymore.

</comment></comment></comment><comment><USER27> He missed my archetype. Not sure what it would be called, but the only thing that would keep me interested in a game is finding ways to combine items, events, effects, etc to create situations where I'd be able to do things the designers never thought about, and that most considered impossible.

In other words, my goal was to defeat the gods. And it's very much the way I live my life in general.

<comment><USER28> Sounds like you're a Johnny.

[http://magic.wizards.com/en/articles/archive/making- magic/ti...](http://magic.wizards.com/en/articles/archive/making-magic/timmy- johnny-and-spike-2013-12-03)

<comment><USER29> I'm also a Johnny. I'd say a more general term is "builder". Players who like making new things in games are builders. Sandbox construction games like Minecraft, Kerbal Space Program, Space Engineers, etc, tend to suit us.

Builders probably best fit under Explorer in the Bartle Taxonomy, with some Achiever elements.

</comment></comment></comment><comment><USER30> I'd recommend anyone interested in more of this area check out Designing Virtual Worlds by the Richard Bartle mentioned in the article. It goes into a lot of detail on persona and self and issues that came up in the early days of online gaming. Many great stories and things to make you think. Great read even if you're not planning on making a game.

</comment><comment><USER31> > he identified four primary types of video game player (the Killers, > Achievers, Explorers, and Socializers).

Isn't this completely tautological? What else can you do in a game, and wouldn't you assume that some people would like some of these aspects more or less than others? And while he seems to have found that individual preferences tend to carry across games, is there any reason to assume that they stay consistent over time (either over the time spent playing a single game or over a lifetime across games?)

</comment><comment><USER32> I'm surprised there's no mention of Westworld in this article...or what our world might look like if we carried video games through to such a realistic implementation.

</comment><comment><USER33> This is really reminiscent of Caillois's game theory. These 4 kind of gamers have strong mappings to the 4 types of games as well. There is a sort of 16 types of gaming if you look at it this way (probably less because of all the overlap), all ranging on some level of free play and strict rules.

</comment><comment><USER34> Basic human needs? Food? Water? Shelter?

If video games satisfy me like even a _run_ would, I wouldn't run. If I play a video game for more than 10 minutes, I feel like I'm wasting my life.

Go outside, do something actually incredible. Meet people. Make mistakes.

Stop living in someone else's imagined world. Learn fully how to be your own human self.

Videogames couldn't be more apt for the analogy of shadows on the wall. There's real problems in the world that need to be solved? Checking out and staring at pretty patterns of light is a total cop out.

<comment><USER35> Running is bad for your knees. You should learn to do better and more substantive things with your life. Eat a vegetable. Watch a pigeon. Cure world hunger.

<comment><USER36> False. Running is not bad for your knees.

[http://onlinelibrary.wiley.com/doi/10.1002/acr.22939/abstrac...](http://onlinelibrary.wiley.com/doi/10.1002/acr.22939/abstract)</comment></comment></comment>


Engineering NullAway, Uber's Open Source Tool for Detecting NPEs on Android - <AUTHOR> https://eng.uber.com/nullaway/ <comment><USER2> I'm one of the authors of NullAway. Happy to answer any questions!

<comment><USER3> A code example contains:

      if (x.f != null) {
        System.out.println(x.f.toString());
      }

Apparently NullAway infers that x.f cannot be null inside the branch, so calling x.f.toString() is safe. However, strictly speaking, since field f is not final, it is possible that a different thread would modify it between the test and the call, resulting in a NullPointerException. Have you decided to just ignore such effects of multi-threading?

<comment><USER2> Hi, good point! Yes, we are deliberately ignoring multithreading, among many other things. We were aiming to catch the NPEs we see most often in practice while keeping the type system relatively simple. Based on our data from the field, I think NPEs due to multithreading and code like the example are fairly rare.</comment></comment></comment>


Is Freemium the Emperor's New Clothes? - <AUTHOR> http://blog.kachingle.com/2012/08/is-freemium-the-emperors-new-clothes/

<comment><USER2> I'm glad you note Evernote as an exception. That's a great example of an app that's:

1) Ridiculously Useful

2) No Comparable Competition

3) Has A Tie-In Factor That Makes Any Power User EVENTUALLY Pay (and be more than happy to).

</comment><comment><USER3> We use the freemium model with our time tracking/pm/billing app Paymo succesfully. I don't think the model is finished, it really has great potential BUT it's not a magical formula that works everywhere.

The way we do it with Paymo is that we offer basic functionality for free to people who can't afford the software at that point in time. (eg: someone who just starting freelancing). In time some of these users convert to paying customers.

The major problem developers face at the moment is the huge availability of "free" - some users just assume that they are entitled to free software no matter what. You really need to provide real value and have your users perceive this value in order to make money.

At the moment we have a bubble forming with huge amounts of cash poured into businesses that will never ever earn any real cash and i think it will pop pretty soon. This creates a lot of problems both short and long term which we'll have to deal with.

<comment><USER4> "You really need to provide real value and have your users perceive this value in order to make money."

This will always be true, no matter the business model involved.

<comment><USER5> I'd say that there are quite a few business models where you don't need to provide real value, or even have the people you are getting money off to perceive any real value and still make money. And some of these business models are even legal.

</comment></comment></comment><comment><USER6> You attribute the WSJ writup to Sarah Silverman heh.

<comment><USER7> Oops. Good catch. Sarah Needleman. Fixed in the post. -- Cynthia

</comment></comment><comment><USER8> The console and pc video game industry makes plenty of money just by charging for their software. I think App developers need to stop this race to the bottom thats killing everyone. I guess its fueled by this idea that on the internet the number of users is paramount to everything. Which I think is a silicon valley culture thing that seems like its going to cause or has caused a bubble.

<comment><USER9> I'm not necessarily disagreeing with you, but you mention the gaming industry; I thought I'd point out the biggest new development there is giving away the games for free and charging for items, aka. F2P (Valve/TF2 is one example. They increased their revenue 12x[1]).

Is this just not another form of freemium?

[1]<https://www.google.com.au/search?q=tf2+f2p+revenue>

<comment><USER10> Valve is not a good example for anything. They do things other companies can't, or won't, and at any rate, don't. They are the exception that proves the rule, in most things. In the TF2 case, they went to that model as an experiment, after TF2 had already been paid software for a long time and had made a lot of money for Valve. So, you don't see much of the annoying 'monetization' bullshit that you see with other titles, because there wasn't any pressure to put it in. Instead, they sold things that people wanted _without impacting core gameplay_ which is something that no other freemium developer seems able to pull off.

I haven't encountered other examples of freemium games of that type, that weren't utter garbage.

<comment><USER11> Check out the new Tribes: <http://en.wikipedia.org/wiki/Tribes:_Ascend>

<comment><USER12> Hi Rez are selling power. The expensive paid guns are a definite upgrade rather than a side grade on TF2. And their player base is dying compared to TF2 [http://steamgraph.net/index.php?action=graph&appid=17080...](http://steamgraph.net/index.php?action=graph&appid=17080q440&from=0)

</comment></comment></comment></comment></comment><comment><USER13> There also exist exceptions where there are competitors: Sharehosters

</comment><comment><USER5> Somehow people seem to have forgot along the way that value != money. I am a huge fan of people doing things just because they are useful without worrying about how they are going to try and monetise them, but just because something is useful and used by masses of people doesn't mean that the network of people that use it is easily monetisable, especially after the fact.

It seems that people just looked at the number of users and assumed that because a company can get millions of users, that the people working there must be bright enough to work out how to get loads of money out of them eventually, while forgetting that you don't need to be that smart to get millions of users when you are providing a useful service for free.</comment>


Growth Step #1: Pick a Goal - <AUTHOR> http://blog.yesgraph.com/growth-step-1-pick-goal/ <comment><USER2> This is my post. If you want a preview of the rest, watch this talk I gave at Airbnb [http://j.mp/1ALSWXn](http://j.mp/1ALSWXn)</comment>


Huawei Should IPO in America - <AUTHOR> https://interconnected.blog/why-huawei-should-ipo-in-america/ <comment><USER2> Haven't finished reading it yet (couple more paragraphs) but one of the most important lines in this entire article is this: "Nobody knows exactly who or what owns Huawei."

Really bizarre company the way it's structured and run. Owned by employees, run by employees, and it's private as well.

<comment><USER3> "Huawei is owned by our employees through an Employee Stock Ownership Program (ESOP) that has been in place since the beginning. No one can own a share without working at Huawei, and as of 2018 there were 96,768 shareholding employees. Our founder, Ren Zhengfei, owns a 1.14% stake in the company."

SOURCE: [https://www.huawei.com/en/facts/question-answer/who-owns- hua...](https://www.huawei.com/en/facts/question-answer/who-owns-huawei)</comment></comment>


HP bets it all on The Machine (memristors + silicon photonics) - <AUTHOR> http://www.extremetech.com/extreme/184165-hp-bets-it-all-on-the-machine-a-new-computer-architecture-based-on-memristors-and-silicon-photonics

<comment><USER2> The key quote:

"In the words of HP Labs, The Machine will be a complete replacement for current computer system architectures. There will be a new operating system, a new type of memory (memristors), and super-fast buses/peripheral interconnects (photonics). Speaking to Bloomberg, HP says it will commercialize The Machine within a few years, "or fall on its face trying."

Helion cloud play[1], and now The Machine? This article almost made me believe this ExtremeTech lifted an Onion piece by mistake.

[1] [http://bits.blogs.nytimes.com/2014/05/07/h-p- makes-1-billion...](http://bits.blogs.nytimes.com/2014/05/07/h-p- makes-1-billion-bet-on-open-cloud/)</comment>


Try Idris - <AUTHOR> http://www.tryidris.org/console <comment><AUTHOR> For those curious what Idris is, from [http://www.idris- lang.org/](http://www.idris-lang.org/) : "Idris is a general purpose pure functional programming language with dependent types. Dependent types allow types to be predicated on values, meaning that some aspects of a program's behaviour can be specified precisely in the type."

Here's a couple of talks about Idris:

Edwin Brady at London Haskell: [https://www.youtube.com/watch?v=vkIlW797JN8](https://www.youtube.com/watch?v=vkIlW797JN8)

David Christiansen at Haskell DC: [http://bmsherman.github.io/idris- drc-3-26-14/](http://bmsherman.github.io/idris-drc-3-26-14/)

And there's a tutorial and other docs available here: [http://www.idris- lang.org/documentation/](http://www.idris-lang.org/documentation/)

<comment><USER3> Just to note, Edwin was the original author of Idris, so I'd definitely recommend watching his talk.

Edit:

Given that my comment seems fairly high at the moment, I'll post a link to his PhD thesis, which seems to be the genesis of Idris for anyone interested: [http://eb.host.cs.st-andrews.ac.uk/writings/thesis.pdf](http://eb.host.cs.st- andrews.ac.uk/writings/thesis.pdf)

</comment></comment><comment><USER4> Hey everyone, I'm the creator!

Sorry for the problems - I was hotlinking to the awesome [http://rawgit.com/](http://rawgit.com/) website during development and forgot to remove it before posting it on Twitter.

The website should be fixed in just a few seconds. Thanks for trying it out!

</comment><comment><USER5> I'm glad to see dependent types move a bit closer to practical programming. I read (well, skimmed) the tutorial and learned a little of what it's all about. Being able to pass around assertions as first-class objects seems pretty interesting.

However, I'm still confused about what's happening at compile time versus runtime. Apparently some functions can be used in proofs (and are therefore evaluated at compile time), while some proofs must be evaluated at runtime?

The notation isn't very helpful here. Since types are no longer strictly compile time and values are no longer strictly runtime, it seems like we need some other way to easily distinguish compile time and runtime.

<comment><USER6> See this page ([https://github.com/idris-lang/Idris-dev/wiki/Erasure-by- usag...](https://github.com/idris-lang/Idris-dev/wiki/Erasure-by-usage- analysis)) for info on erasure. Unused proof values or indices in data types used for static checking are erased at compile time via usage analysis (if you don't use it in the RHS of a function definition, it gets erased).

If you want to ensure that the indices of your data type or arguments to your function are erased, you can use the new dot notation. E.g., if you give a function called "half" the following type

      half : (n : Nat) -> .(pf : Even n) -> Nat

then the compiler will complain if the proof argument is actually used.

</comment></comment><comment><USER7> Here's what I saw: [http://i.imgur.com/4yNB6t4.png](http://i.imgur.com/4yNB6t4.png)

        > This page abuses rawgit.com. You should complain to its
        > owner.

<comment><USER8> They can use cdn.rawgit.com instead, which is ok to use in production according to [http://rawgit.com/#cdn](http://rawgit.com/#cdn)

</comment></comment><comment><USER9> _> You can use the REPL above to play_

I don't see anything like that on my screen (OS X, Firefox latest). It's basically just three lines of code without any interaction.

<comment><USER10> The beginning of the HTML (including the head with the script links) is [sometimes] missing from the page sent by the server.

</comment></comment><comment><USER11> I discovered Idris when I was playing around with Agda last summer. It's cool to see a systems programming language with dependent types.

<comment><USER12> > It's cool to see a systems programming language with dependent types.

What do you mean by 'systems programming language'?

<comment><USER13> The tutorial says "The goal of the IDRIS project is to build a dependently typed language suitable for verifiable systems programming. To this end, IDRIS is a compiled language which aims to generate efficient executable code. It also has a lightweight foreign function interface which allows easy interaction with external C libraries."

I generally think of systems programming as drivers, kernels, embedded stuff, and performance-sensitive applications like game engines. Not sure how far in this direction IDRIS is going though. It feels a lot like the same niche as OCaml, with dependent types.

<comment><USER14> I tend not to use the phrase "systems programming" any more. "General purpose" is probably better (or my current favourite "Pac-man complete"). I should probably edit the tutorial to that effect. We've done simple network protocols and packet formats (I had a student working on DNS for example) but not driver or kernel level things.

That said, some people are experimenting with lower level things (thinking about making a minimal run time system with no garbage collection for example). It's not a primary goal, but it'll be interesting to see what comes of it.

<comment><USER15> > I should probably edit the tutorial to that effect.

Yes please do. Idris is a lovely language for bringing dependent types closer to the realm of production code, but giving people false hopes is a little cruel :)

<comment><USER16> Take a look at ATS then! My understanding from playing around with it is it is trying to be C with dependent types.

<comment><USER17> ATS looks fascinating in concept, but what code examples I've seen, the syntax is terrible and it's ridiculously verbose. I'm sure you could write absolutely bulletproof code in it, but the productivity hit would render it almost unusable for large-scale projects. I might be off here, of course... but one of the lovely things about Haskell is that despite its reputation as a difficult language, once certain key concepts are tackled, it's relatively easy to program rapidly and create real world products (with a considerably higher assurance of correctness than most languages provide). ATS seems complex to a level that nearly guarantees its usage won't extend much beyond academia.

<comment><USER18> If you use the non-dependently typed parts of ATS it is no more verbose than most ML variants. If you use it without the GC then verbosity increased because you need to add calls to free memory. If you add proofs or dependent types then declaring those adds more. I've used it in moderately sized production programs and it's similar to using OCaml or other ML in terms of productivity. Once you're familiar with the language of course.

If I paraphrase what you said about Haskell it's true for ATS too:

        "but one of the lovely things about ATS is that despite its reputation as a difficult language, once certain key concepts are tackled, it's relatively easy to program rapidly and create real world products (with a considerably higher assurance of correctness than most languages provide)."

The key, like any language, is learning the concepts. I think people assume ATS is more difficult than it is is because much of the documentation and examples for it use a verbose style and heavy proofs. A post I wrote a while back attempts to gently introduce ATS dependent types and you can see that the non-dependently typed examples are very similar to any other ML language:

[http://bluishcoder.co.nz/2010/09/01/dependent-types-in- ats.h...](http://bluishcoder.co.nz/2010/09/01/dependent-types-in-ats.html)

<comment><USER15> > If you use it without the GC then verbosity increased because you need to > add calls to free memory

The issue is that is the default mode I would like to work in. Rust is designed to make that the natural mode of working, rather than the exception. Fast, deterministic operations should be easier and more succinct than the managed alternatives – in the context of a systems language that is.

> people assume ATS is more difficult than it is is because much of the > documentation and examples for it use a verbose style and heavy proofs.

Then they need better docs. And a better website! And better marketing!

<comment><USER18> It's interesting looking at the different design decisions of languages. One persons pro is another's con.

ATS2 has no GC as the default mode of working too. The only reason it is more verbose is because you need the call to free. ATS strives to be explicit in what it does so it's easier to read the code and know what is happening.

Languages with destructors or implicit function calls seem to lean towards the C++ downside of "What does this code really do" when looking at it. I dislike hidden code where there is no easily identifiable call to tell you something is happening.

It's not all roses and unicorns with ATS either of course. What I really want is the next generation of dependently typed system languages which has learnt from the current ones.

<comment><USER15> > you need the call to free

So how does ATS enforce memory safety? With Rust you have a bunch of library types that you can reuse that abstract away from the memory management for you. The types make sure you don't screw up. Unfortunately you can't prove things about the `unsafe` blocks, and have to rely on careful auditing, but that only needs to be done once, and then you have a nice, reusable abstraction. Bookkeeping sucks.

> What I really want is the next generation of dependently typed system > languages which has learnt from the current ones.

Agreed. At the moment Rust suits me the best, but I definitely don't think it is the end of the road.

<comment><USER18> > So how does ATS enforce memory safety?

Linear types. Much like unique pointers in Rust, the type system tells you when you fail to consume a linear type. A 'free' call would do this. Same with closing files, etc - you use linear types to track that the resource is consumed.

<comment><USER15> Ah neat. Does it have regions?

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER19> Functional languages interest me, but are not very approachable. I mean I looked at the examples[1] page for Idris and came away completely confused, why he hell does this sequence of characters "data Nat = Z | S Nat" define a natural number? Or "data Maybe a = Nothing | Just a" somehow defines an option type.

It would be good to have an introduction for people not too familiar with functional languages.

1\. [http://www.idris-lang.org/example/](http://www.idris-lang.org/example/)

<comment><USER20> Right, I'm a big fan of functional programming, but I never got warm with functional languages. One big reason is the syntax. I'd love to be able to specify (in pseudo C(++):

        typedef positive_int: int {
            ensure {this > 0}
        }
        typedef ambulance: vehicle {
            ensure {this.has_siren && this.has_bed && this.color == "red"}
        }

and so on.

(aside: The other main problem I have with functional languages is the following, I'm not sure what to call it but it bites me every time: You finally find out how to do what you want in an elegant functional way, you code it up and you're happy. Then, you want to make a small modification, but it turns out that it's impossible with the current code, and you have to rewrite everything with much less abstraction. I can't remember a great example from the top of my head, but a simple one is, you'd like to add a progress bar to a computation. It's trivial in imperative languages, but much harder in functional style.)

<comment><USER21> Prof. Van Roy gives a good example of this in the Edx course "Paradigms of Computer Programming" He uses the simple example of trying to introduce code to a pure functional program that will record the number of times a particular function is called. To do this you need to modify the signature of every function on the call stack. No doubt there's some other way to do this and it probably involves a monad but he was dealing with a simple pure functional language in the example. His point was that in this sense the pure system is not modular.

<comment><USER22> That's exactly the point of monads - <USER2> [http://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/ba...](http://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/baastad.pdf). Such a system is still pure, btw.

</comment></comment></comment></comment><comment><USER23> > Failed to load resource: the server responded with a status of 503 (Service > Temporarily Unavailable) [http://rawgit.com/chrisdone/jquery- > console/master/jquery.con...](http://rawgit.com/chrisdone/jquery- > console/master/jquery.console.js)

this causes the console not to load. It would be better to host the js yourself, probably.

</comment><comment><USER16> Sadly the console seems to be missing and the compiler doesn't emit errors.

The second is more sad since so much of the dynamics of programming Idris comes from the trying to get its statics to compile. In particular, you will spend an inordinate amount of time staring down collections of type holes trying to solve the puzzle they present.

None of that gets reflected in the compiled Javascript.

</comment><comment><USER24> "This website abuses rawgit.com. You should complain to its owner."

<comment><USER25> Yeah, saw this alert after switching between 'Console' and 'Compile'.

</comment></comment><comment><USER26> This is one REPL, and compiler, that does not work and doesn't react to user interaction. That doesn't exactly inspire confidence.</comment>


Terry Childs case puts all admins in danger - <AUTHOR> http://weblog.infoworld.com/venezia/archives/021060.html

<comment><USER2> The more I read about this case, the more it seems like a witchhunt.

<comment><USER3> Yes, and it seems to have gotten to the point where the prosecutor has made it a point of pride to carry on the case.</comment></comment>


Getting Vertical -- What NVIDIA's Acquisition of Icera Means - <AUTHOR> http://jonpeddie.com/blogs/comments/getting-vertical-what-nvidias-acquisition-of-icera-means/

<comment><USER2> The correct spelling is "Icera", although the article might have you believe it's spelt "Icrea" at some points.</comment>


Chromium - Google's Chrome source code - <AUTHOR> http://code.google.com/chromium/

<comment><USER2> _You can find the application at [Debug/Release]/TestShell, depending on the selected configuration. Currently, the prerequisites don't fully build so you won't find an executable._

:( what a tease

</comment><comment><USER3> Too fast!</comment>


Depressed? Genetics affect how drugs work - <AUTHOR> http://www.seattletimes.com/life/wellness/depressed-genetics-affect-how-drugs-work/ <comment><USER2> Is there any evidence that anti-depressants in general work better than placebo? This seems to be up for debate.

Are there any studies that have actually linked genetic testing to increased positive outcomes for antidepressents?</comment>


Show HN: Remindr.co – SMS and Email Meeting Reminder SaaS for Small Businesses - <AUTHOR> https://remindr.co/?referrer=hn_1 <comment><AUTHOR> A small project that I built in my free time. It is currently free and available in closed beta. It's B2B and meant to be the cheap, easy to use option for small businesses like restaurants, nail salons, personal trainers, barbers, real estate agents, independent car mechanics, tech sales scheduling customer calls, ect. Anyone that books client/customer appointments and wants to avoid no-shows. It also comes with text message appointment confirmation.

Please give me feedback on all the things!</comment>