tntn

https://ajph.aphapublications.org/doi/pdf/10.2105/AJPH.2017....

> Conclusions. Male firearm use drives the increased rate of suicide in rural areas

> There is no requirement to post the article headline as-is on HN.

There is. From the guidelines:

> Otherwise [i.e. not excessive clickbait] please use the original title, unless it is misleading or linkbait; don't editorialize.

The comparison is between the last three years and 1915-1918, but the Spanish flu was just getting going in 1918.

EDIT: folks just arriving, the HN title has changed since I commented. It previously said "worst trend since Spanish flu," or something.

Rust people, is there a way to tell the compiler that each thread gets its own elements? Do you really have to either (unnecessarily) add a lock or reach for unsafe?

Page 15.

Now it is clearing pushing a driver-assist angle ("improves your stock ACC and LKAS," "copilot," "augment"). No mention of "self-driving," "autonomous," or the like.

Previously, it was clearly marketing a full-self-driving, no human involved system: "ghostriding for the masses," "software to make your car self driving."

I wrote a compiler from emoji-code to amd64 (mostly because I'm more interested in compilers than reversing). It runs quite fast - prints the whole domain in ~1 min. I'd highly recommend it to people who are into assembly, it was a fun exercise.

    >>> import autograd.numpy as np
    >>> from autograd import grad
    >>> def fn(x):
    ...   return np.power(np.power(x, 3), 1/3)
    ...
    >>> gradfn = grad(fn)
    >>> gradfn(0.0)
    /usr/local/lib/python3.6/dist-packages/autograd/numpy/numpy_vjps.py:59:RuntimeWarning: divide by zero encountered in double_scalars
    lambda ans, x, y : unbroadcast_f(x, lambda g: g * y * x ** anp.where(y, y - 1, 1.)),
    /usr/local/lib/python3.6/dist-packages/autograd/numpy/numpy_vjps.py:59: RuntimeWarning: invalid value encountered in double_scalars
     lambda ans, x, y : unbroadcast_f(x, lambda g: g * y * x ** anp.where(y, y - 1, 1.)),
    nan

    >>> import torch
    >>> x = torch.tensor(0.0, requires_grad=True)
    >>> y = ((x**3) ** (1/3))
    >>> y.backward()
    >>> x.grad
    tensor(nan)

Sure, we call that computer algebra. As soon as you start doing that, you aren't doing automatic differentiation, you are doing (at least in part) symbolic differentiation.

(I probably should not say this, but I will anyway: your comments regarding math and science always give me the distinct impression that you know the name of a lot of things without knowing much about the thing. You are frequently breathless about analog quantum computing, Lie algebras, Chu spaces, some universal concept of duality, but then you fail to respond with substantial arguments to people that try to temper the breathlessness. If you want to convince people of things, you should work on this.)

I will not be convinced that an implementation of map that gives different results when there are identity functions in the middle is doing the right thing.

FTFY.

I know exactly how map works: https://en.m.wikipedia.org/wiki/Map_(higher-order_function)

This is map:

> a higher-order function that applies a given function to each element of a functor, e.g. a list, returning a list of results in the same order.

Since that is not what Array.prototype.map does, it is not map, it is some similar thing that is misnamed as map. If I wanted the index and the array as arguments, I would ask for them.

Your knowledge is incomplete. T4 has been available in google cloud for many months.

2. The code you pull in will not get exploited when someone masquerades as the package owner. (How many widely publicized cases of this have there been by now, 5? 10?)

3. Presumably you read the code enough while copy-pasting to be sure it isn't mining Bitcoin or something.

See https://en.m.wikipedia.org/wiki/Emulex_hoax for an example of fabricated news causing massive changes to stock price.