WmyEE0UsWAwC2i

That sounds like something taken from the book: Burn Math Class.

There is always f(b) > f(a) <=> f increases in [a, b] or f(b) /= f(a) <=> f changes in [a,b].

But how useful is that?

It seems the ML's cost-reward function maximises profit for the platform.

How does this correlates with weather?

Recommender Systems, trained to maximize revenue, are punishing kids for being curious.

I'm specially refering to YouTube here. Take for example the "cell biology" subject. In a few videos ahead you'll start getting non-scientific videos, as "recommendations".

Suffices to say that those videos speak about widely discredited life theories but with nicer stories.

These recommendations exploit the human brain in ways that even the creators can not comprehend.

We could, for example, use these technologies to teach children to solve equations. Use ML to find the optimal, user specific, series of teaching material that takes a child from zero to "can solve any equation involving +,-,* or /". But no, "we don't have the resources". Ah! want to go from cell biology to cute animations of pidgeons? Yes, we have de optimal path to get you there for free on YouTube.

Why would the data only be used for patology?

* Diet balancig? (Hey, eat more cucumbers)

* Calories? (IANAD)

* Also more serendipiteous opportunities we can't foresee now

Or:

(at the doctor's)

t = 0 - Doc - I would need a urine analysis

t = 60s - User - Here you are.

Cons:

* Huge privacy concerns (Hey, you are fired! btw, you also have cancer)

I believe YouTube's algorithm takes into account comments in shuch a way that some motivated group of activists could demonetize the videos of a channel by posting hate-speech.

I belive that abstraction can be a double edged sword.

Pro. you write less code Pro. Your code is easier to read for everyone familiar with the abstraction. Con. You need a math degree. Con. Harder to get contributors. etc...

Tangentially. The docs also say that:

"In practice, cofree comonads are quite useful for annotating syntax trees, or talking about streams."

Sometimes you can learn the abstraction and one of its particualr use cases. And apply it when you find it, without needing the degree.

Also to answer your question: "So I take it you believe that a degree in category theory is the bare minimum for people to expect to be able to understand other people's code?"

No, I don't believe so.

But the experiment of forming a team of people that knows all this to see how productive they are, would be nice to see.

It depends on the reader's amount of "vocabulary". Why write more complicated code if it is just Cofree? DRY.

OTOH, how many elements should the reader's vocabulary have to enable him to read other's people code?

You can think a monad defines a DSL. Let's take for example the Rand[0] monad:

    type Rand g = RandT g Identity

    newtype RandT g m a = ...

    -- with
    runRandT :: (Monad m, RandomGen g) => RandT g m a -> g -> m (a, g)
    newtype MyType = Rand StdGen

    -- now you can define
    intGreaterThan :: Integer -> MyType Integer
    intGreaterThan = ...

    randomName :: Integer -> MyType String
    randomName length = ...

    -- an finally convine the two above

    nRandomNames :: Integer -> Integer -> MyType [String]
    nRandomNames length n
       | n <=0 = return []
       | otherwise = do
           tailNames <- nRandomNames (n-1)
           headName <- randomName length
           return (headName:tailNames)

These functions of type `...->MyType a` can be viewed as a DSL where the Random generator state is abstracted away.

[0]hackage.haskell.org/package/MonadRandom-0.3/docs/Control-Monad-Random.html

Net neutrality should be on the constitution. Safe from lobbists and the politician in office.

I started using haskell before stack but after cabal sandboxes. Once I learned to use sandboxes cabal gave no problem.

I don't understand why it keeps receiving so much heat. What does stack do that cabal can't?

Thanks for the write up!

I didn't know i wanted this.

How do you scrap all that data?

Those are very good results (99%), I would like to see a calibration curve [0]

[0] http://scikit-learn.org/stable/modules/generated/sklearn.cal...

in your blog post about launch: This is essentially how this all works. It is not exactly magic, but not easy [ether] also [failsave] a few words ahead.

Nevetherless it was an interesting read.

You mention a "few weeks" of development and testing. How many few weeks?

I think the parent's argument could rewriten as:

The numbers induce a probability distribution in the adjacent tiles. But you also should take into account that the remaining mines are uniformily distributed.

In other words, consider the prior.

I couldn't write math neither in favor nor against this claim.

1. Maybe for uniformly distributed mines the numbers have all the information you need.

or

2. Maybe using the fact the the mines are uniformily distributed, in addition to the numbers, has impact on the probabilities distributions EDIT:

you play a 10x10 game with 20 mines.

your initial move in a non-border tile reveals a `1`.

you now know that around that `1` there is a 1/8=0.125 chance of hitting a mine.

ITOH there is a 19/91 = 0.20879 chance to find a mine in a tile not adjacent to the `1`

I imagine the conversation going on the lines of:

Facebook: In the week we exposed the user to the add, the user posted a picture of your product. We made that sell for you!

Advertiser: Say no more, take my money!

Facebook: (smiles smugly)

I think the rule template is:

What happens in %REMOTE_PLACE%, stays in %REMOTE_PLACE%.

What about the dynamics of a mixture of self-driving and humand driven cars?

I'll have to agree with that. But then I would also say that I had to make some assumptions, right? :)

I think GHCi is helpful in this situation, however. It clearly distinguishes between leaky and non-leaky code. This leak is a product of "just doing what the coder says" (go to "Data.Monoid.sum" and do what it says there with such and such...). I'm assuming that, for this code, GHCi is bug-free.

I think

    sum (replicate n 0)

is as dangerous as

    foldl (+) 0 (replicate n 0)

or

    foldr (+) 0 (replicate n 0)

. `sum (replicate n 0)` may be the right thing to do in some cases unknown to me.

There is `{-# LANGUAGE Strict #-}`, as you mention, and BangPatterns for strict arguments. But I would assume, those are used only by coders already familiar with haskell and its leaky pitfalls.

But if you try it on ghci you will see that it breaks. (ghc 8.0.1). So it dependes on how you "interpret" the code. `ghc -O` is sophisticated enough to make the right decisions when compiling your code. You probably don't want a space leak, so it doesn't generate one.

GHC will have more trouble making the right choice in more involved computations. It will revert to "just do what the coder says".

Consider this C code for example:

    unsigned int sum = 0;
    const unsigned int n = 1000;
    for(int i = 0; i<n; i++) {
        sum += 0;
    }

If you look at it, you can tell this is O(1) in space for any valid `n`. A spohisticated enough compiler may replace it by

    unsigned int sum = 0;

and be done with it. But even an unsophisticated(but correct) compiler will produce O(1) space wise code.

EDIT: format

EDIT: What I was trying to say in my original comment is that, in haskell, space leaks my appear even in the most innocent looking code. And that it may require a bit of experience to identify and avoid them.

Being lazy evaluated, Haskell, makes it hard to reason about performance in more than trivial code (as a rubik cube solver would be).

All those suspended computations may eat your RAM for no good reason at all. For example:

    sum (replicate n 0)

has a space leak O(n). While:

    foldl' (+) 0 (replicate n 0)

works fine O(1) space wise.

My point is that it is easy to eat all your RAM using haskell even in the simple `sum` case above. More so in more involved computations.

Of course, if you can compute your solution in constant space using C, you can also do it in haskell. But writing it in Haskell would require careful thought in how your code is evaluated.

EDIT: It is about trade offs.

If you want declarative and readabe code, with little memory layout noise (allocate memory, assign variables, etc...) then haskell is a reasonable choise. You can write fairly readable clode for complex algorithms. If you are an expert, you can also make it efficient on the first go (speed and space wise). If speed is of upmost importance, then you can write more compiler specific code but with a lot of added noise.

Or you can start with C, write less (than haskell) declarative code and less readable code. It would be harder to get right(the more complex the computation the harder to debug), but when you are done you probably have efficent code. If you have the experience, you may be able to make it fairly readable too.

d) revenue considerations, could be related to b). That would be something that could degrade de recomendations.

On a tangential note, ads. They sell those ads as "targeted" but when you play your "yoga" video... BAHM! a coca-cola add. So why build those "targeting" algorithms?

Does any one has a mirror?

Whit the zika outbreak I thought, what if we could some how harden(genetics) the mosquito inmune system to fight off zika? (or any other undesirable virus)

Then find a way to replace the native populations with the hardened ones. (For example some kind of selective trap)

Something similar to what is currently done with livestock, which is vaccinated against many posible human patogens.

I think, experimentation with mosquitoes could be more agressive that trying to find a way to cure a human. And you would not eliminate the population which could lead to problems down the road.

What I did was to feed them noise. I clicked the like buttom on popular things, followed popular people. It is kind of a chore, and it can prompt their anti-bot measures (like asking me if I'm interested in pig (the animal?)).

This, of course, has its drawbacks.

It's a linux install after the windows 10 fiasco. Probably my fault not to have the image viewer installed. And XFCE not to provide one, altough they are lightweiht so it makes sence.

Why did you assume the computer was old?

Edit: also mfw.jpg when HN answers are the same as 4chan

Hi, nice list. Have you used `is course X's textbook` feature?

Are you doing peer reviewed reproductible research, with both open source code and data and tyying to disprobe your hypothesis? </s>

Even researchers don't agree what are "acceptable" research findings [0].

I think that priming[1] would be an important factor to consider when doing "lot of" research. And, were someone going to dimiss it, they would need "extrordinary evidence" as the say goes.

Here is a testimonial of one of these "ideas" supporter:

   "The first principle is that you must not fool yourself – and you are the easiest person to fool." -- Attrib. Richard Feynman (|p| < 0.05)

The fact that "[you] can't see how it would influence [you] much" is one of the features of biases.

Regards

[0] https://en.wikipedia.org/wiki/P-value [1] https://en.wikipedia.org/wiki/Priming_%28psychology%29

What's wrong with silence?