skysight-inc/HackerNews huggingface dataset:
slaves were compensated with food, and were incentivized through application of force. inmates are under constant threat of violence and abuse, which is itself a force. escaping that force briefly to do hard labor is a sad tradeoff and it is a cynical and disgusting brand of exploitation.
Because the process is well designed. No single person or single party was left alone with ballots, marked or unmarked, at any point. Any counting machines get spot-checked. Any count discrepancies from voter rolls to ballots cast trigger manual counts. Packages of blank ballots are sealed. Voting machines are locked, so no one can easily get into them to add/remove/replace ballots without the key(s). Used ballots are sealed at the end of the election. Signed chains of custody for everything. Etc.
>And hey, if voters are dumb enough to fall for that, maybe we can get them excited for touchscreen machines!

People are partisan and will buy any story that explains why they lose. A non-trivial portion of Democrats think the Russian advertisements on Facebook changed the election to Trump's favor.
What if number types were Optionals after any operation that could result in any kind of unusual number (sqrt(-1), Infinity, NaN)? Or maybe after every operation, since any operation could overflow the type.

Do any languages do that? Seems more consistent (if way more hassle) than giving a mathematically false result out of pragmatism. At least in a strictly typed language.
New measurement of particle’s lifetime intrigues physicists by Ana Lopes
Now anyone can train Imagenet in 18 minutes
This triggered an immediate "that is wrong!" response from me, which I had to suppress to actually read the argument.

From this definition, I'd guess that pony isn't optimized for numerical code and floating point operations, because there it tends to make less sense.
We don't have any need here for a comment like this. Please say something meaningful instead, or nothing.

https://news.ycombinator.com/newsguidelines.html
"There are no school shootings here that I'm aware of " (Referring to brazil).

Here is an entire list:
https://en.wikipedia.org/wiki/List_of_massacres_in_Brazil
but this article is about learning, not the day-to-day development in OCaml. I agree it is good to learn how to structure, compile, and run code without a REPL. ie. learning how to import files and all that.
> What does it mean to take a factorial on the real numbers, or to add only on the even integers?

I don't think that's exactly the same problem.

It is perfectly valid to define an operation on a particular domain. Defining an add operation on even numbers is perfectly fine (If you had said odd, well...). Factorial on real numbers is more or less the Gamma function. The problem here is that the operation is defined on one domain...

> We can say that division’s domain is all the real numbers except zero.

...but then, for some reason, it is decided that will will be applied on a different domain. That is, that we're going to apply on all real numbers including zero. So now we need to modify the definition of the operation. And the thing is that, the new definition, created to accommodate the new domain, usually tends to produce friction precisely on the new elements added to the domain. We excluded zero initially because that way the operation was defined in a simpler way. Now, having to consider zero implies that our definition becomes more "complex".

Now, we can change the definition in different ways. Is any one of those objectively "better" or "worse" than the rest? Well, that's what the discussion is all about.
how do you forgot the bank robery?
Something that never seems to come up in discussions of violence rates in the Americas is our history of colonial domination. The fraction of people who survived the onslaught of Old-World diseases were not equipped to effectively resist the influx of predatory Europeans. That was and is a very violent process. It's not over.
You’re doing something different than real number arithmetic. Saying 1/0 = x, and then treating x like a real number is inconsistent. But just saying “we are going to augment the real numbers with an element x that is not a real number, and then define some properties of x and prove things about it” is not.
It helps that they used NaCl. When cryptographers looked at it, they found an issue: People can impersonate your friends if they get their hands on your private key.

This is pretty bad, but so is having had your private key compromised in the first place. It should be fixed next time they do a flag day.

Other than that, and the rekeying issue (keys are only renewed when the client is closed. They should be on a period of time, to make forward secrecy really effective), nothing else bad was found.

Notice that, for a couple years now, effort has gone into polishing (toktok) toxcore and documenting things, rather than else (eg: adding fancy features). That's a good thing.

Tox might be understaffed and progressing slowly, but there's nothing fundamentally bad about it. They got a bunch of important things (really distributed, DHT, public keys as addresses, temporal keys for forward secrecy, always end to end encrypted) right. I'm not aware of any other project that got this much right, unfortunately.

If only if Tox got more attention, it'd gain developers, donations, and the possibility of getting a proper audit done.
Paywalls rarely use DNS hijacking because it risks putting a bad entry in the clients cache and breaking them. They just intercept http (and sometimes HTTPS) connections to inject a temporary HTTP redirect to an auth page.
If you have an Android phone, you can also go into the developer settings, turn on a colour blindness simulation, launch the camera, and then point it at anything (in the real world, or on a monitor) and see an idea of what it might be like to a colour blind person.
This article grinds my gears. He quotes a number of mathematicians that correctly state the undefined nature of 1/0. Then proceeds to interpret that this means that we can choose any specific value to represent as 1/0 that we want. NO. We have "NaN" for a reason and it is an important signal to the programmer that a mistake was made. The language that assigns it to 0 silently is bunk as is this article.
You know what would happen. Math is ubiquitous in lots of code, so syntactic shortcuts would be introduced. Thus, we wouldn't use `a >>= (\x -> 2x) >>= (\x -> x^2)`, but would soon introduce syntactic sugar. For example, we could re-define `[asterisk]` so that it had type `Maybe Number -> Maybe Number -> Maybe Number`. You'd need a `return` (or `Just`) at the beginning, but soon that would be elided too, so that numeric literals would be auto-promoted to `Maybe Number`s. Then the language would add silent mechanisms to allow `Maybe Number`s to be displayed easily. You should check if your `Maybe Number`s are `Just Number`s before letting them out to play, but, if the language doesn't force you, then you know you won't. And then we're right back in the current situation.
GSoC wrap-up – Splitting Servo's script crate
You could except you would get sued. The Kindle 2 was announced with a feature that would read the book to you and Amazon landed in court. https://sunsteinlaw.com/read-it-aloud-and-weep-controversy-s...
The function "division" is just like any other function. It takes two inputs, and gives an output.

The reason it's a useful function is it has some properties:

y=1/x is continuous except where x==0. That is, as you approach 0 from either side, it grows to either +- infinity. The developers of this language want to make this function ==0 when x is 0.

You can do that, sure, but it doesn't change the fact that when you go from +0.0000001 to -0.0000001, you now have 2 non-continuous jumps instead of just one.
It's common to think of an exception as the program stopping and never being started again. In that sense, the invariant is still maintained, because the program never sees it violated. This has non-trivial consequences - for example, Rust lets exceptions and endless loops produce any value at all, even though they obviously can't actually do that.
I am not seeing how a lender is better off lending money to people who cannot pay it back.
15 Tips to Speed Up Your Website – On-Page SEO
Diagram reminds me a bit of: https://www.reddit.com/r/Physics/comments/8l8c9a/brian_green...
From my experience, extrapolating retention like that isn't really particularly valuable. It's basically the same as making something up whole-cloth past a certain point--feels more like lying than projecting.

(I also read the OP's story as the investor asking to see actual numbers, and not projections--if someone asked to see those kinds of numbers my first thought would be that they were asking for historical data)
So according to you, 0*0 = 0, thus 0/0 = 0?
I love how people without an actual mathematical background make these sort of arguments - not because they're wrong but because it helps me check when I make those assumptions myself.

Multiplying by the square root of 2 is also a fun one since you need limits to show people that real numbers only make sense with the least upper bound theorem and limits and things they expect to work "intuitively" (like division or multiplication) only have approximate meaning when they use the common operations.
Hrm ... argumentation by reference to authority (various Ph.D. people) is a sure way to lose a scientific argument.

But that isn't my only qualm.

In the construction of the fields, there is a simple definition of the division function. It is intrinsically the solution of a = r * b, where r is the unknown. If a is nonzero, and b is zero, then r, the ratio, is said not to exist. Put another way, there is no real value of r that can be chosen that satisfies r * 0 = a. See [1] for example, as 0 is not an invertible element of the field over the reals.

So ... I can't say I agree with their choice of 1/0 == 0. They may be free to choose any value they wish, but then from an aesthetic viewpoint, do they really want to surprise the user?

[1] https://en.wikipedia.org/wiki/Multiplicative_group
What proportion of the time will a programmer intend and expect 1/0 = 0?

What proportion of the time will a divide-by-zero operation be a symptom of a bug, where evaluating 1/0 as any valid number will make it harder to identify that bug?

There might be a mathematical justification for 1/0 = 0, but the computer science justification seems tenuous at best. The overwhelming majority of the time, I want divide-by-zero to throw an exception or evaluate to NaN. I'd far rather deal with the edge case of intentionally dividing by zero, rather than the not-at-all-uncommon case of unintentionally dividing by zero and getting unexpected behaviour as a result.
This comment has put me firmly in the anti-Voter-ID column. I've always been on the fence regarding Voter ID.

One one hand, I can see the effect that it would have on the makeup of the voters: older, richer, more established.

On the other hand, I couldn't shake the idea that voting is too sacred to not enforce some level of identity verification.

You just swept away my "on the other hand". Thanks.
> if you divide by 0, from some standpoints, you do have nothing, because you broke it up into 0 pieces, and 0 pieces is 0.

This explains exactly why we shouldn't divide by 0. The pieces after breakage should, if one is so inclined, be able to be re-assembled into the whole; but, once you break something into 0 pieces, it is gone. Thus at best `0/0` could be defined … but the problem there is not that there's no answer but that every answer is equally good.
"Expecting the contractor to act in a way you personally expect a good contractor would act isn't a reliable way to identify good contractors."

That seems like saying "expect the unexpected". It may sound clever, but I don't see how you can decide to expect something other than what you expect.
How does that really work?

Because at the end of the day, to build your program, you need to have code in a source file of disk
Code in the REPL is not persistent

So unless the language come with some sort of repl server, which persist code on a server, and the program instantiate themselves from the server (something i have never seen and i doubt that this is what you meant)

I am guessing you actually mean, that development was REPL supported, and that you used the repl to test your code, and help you design your code

And I see no problem in that, but still you need a solid traditional cycle around that to actually build, deploy and distribute your code ... right
When setting out to add a new axiom to a heavily studied area of mathematics, perhaps one should at least formulate an argument that isn't shown to be incomplete with the most basic wikipedia search.

https://en.wikipedia.org/wiki/Division_by_zero
I.e. a short-circuit means current = 0 because it trips a fuse?
Is Brazil basically a failed state?
> without multiplication and division being entirely symmetrical (as they already are not)

What do you mean?
That’s only part of it, the long startup time is still there, even with cloud formation support. You can easily hack it all together with serverless framework now, and I’m really loving it for learning things but that startup time is going to be a problem for anything customer facing.
> So at least that's something

It's also nothing. :-)
I'm enjoying the weekend vue articles that have appeared lately.
It’s voluntary...they receive training, see family, get time knocked off, serve the community/others.

Dare I say it actually sounds like a rehabilitation program.

Of course it’s very easy to criticize on a forum behind a screen. So tell us how you have personally helped a prisoner combat the extreme power imbalance you observe beyond criticizing existing programs.
I'm not seeing how the tweet is mocking the Pony developers. It seems to mirror the tone and the content of of the documentation in the screenshot. It looks like an absurdist spin on the ivory tower vs industry meme, and it doesn't make anyone the butt of the joke.
Wait, if 1 / 0 = infinity, then infinity * 0 = 1

This seems just as bizarre, since zero times anything shouldn't become 1, no matter how big or how many times you do it.
And as it follows, if you divide by 0.00000000001, you can fit a whole lot of pieces in your original value... so what should dividing by 0 (which is even smaller than 0.000000001) naturally do? 0, or +infinity?
But none of that is related to my key point: multiplication by unitary values is significantly different depending on which axis the unit comes from (real vs imaginary), hence my usage of 'asymmetric'.

In the last part of my first comment I point out the benefit (that I perceive) arising from the asymmetry. I also still wonder if a symmetric version (like I describe in the first comment) would be possible.

Splitting the geometric behavior into rotation, reflection, and scaling is interesting—so thanks for the description—I just don't see how it relates to my comment.
Received an email from a VC at 3:30am that expressed interest in investing.

Sent over deck and demo.

Turns out he just couldn't sleep and wanted reading material "to pass the time."
So do nearly all developed countries
He's the CEO of a major company, he presumably can't let his personal views lead him to not be part of iOS. But his board/investors can probably be reasonably sold on the idea of saving the 30% margin Google takes... and also aligns well with his ideals.
I used to think the same way: let's throw an exception on divide by zero, and forget NaN like a bad dream! But then someone explained to me that it's common to feed a billion numbers into a long calculation, then look at the results in the morning and find them okay, apart from a few NaNs. If each NaN led to an exception, you'd come back in the morning and find that your program has stopped halfway through. So there's a certain pragmatism to having numeric code silently continue by default.
Facebook has for years been a tool in the deadly migrant trafficking trade
According to the standard definition of division, 1/0 does not equal infinity. It doesn't equal anything. It is undefined.
I just checked the rent prices of your "oakwood" in NYC. 8000$ a 1br in manhattan all sold out. I can imagine so many foreigner lucky to rent at such cheap price.
Now you're changing the argument...

What are the caveats with the dialer?

To ask someone to list some examples to make the general, obvious point is a bit derailing.

How is it "derailing" to ask you to give specifics and then systematically get them torn down?
> So it is _not_ a theorem that a * (b / 0) = b * (a / 0)

As the article explains, the whole issue about dividing by 0 is the lack of multiplicative inverse. If you define division for 0 as something other than multiplication by the multiplicative inverse, there is no longer an issue doing the division. Hope that helps.
Maybe that's because you're part of a privileged group that doesn't experience discrimination and targeted hate every day? For you, the idea of a segment of society being out to get you is a delusion. For millions of others, it's a concrete reality. If you're in a minority group in the US, you know exactly who "they" are in the parent's sentence.
Twitch is Closing its Communities
Extrapolate.

What value does 1/x approach?

What about 2/x?

And then, what about ∞/x? What value would we expect that to approach? ∞(±∞)
I would wager some HN karma that people that are libertarian (classical liberal) likely see no major issue with this practice.
You know.. dividing is like breaking something up [..]

No. What it is 'like' is totally irrelevant and actively harmful to consider if you want to be able to get anything serious done with your programming language. This is not a place to start philosophizing. For consistent arithmetic it is important to know which axioms are fulfilled. Division needs to be a mathematically clearly defined operation.
Perhaps I don't understand something? (I've only done a very small amount of Rust.)

What exactly does this do? Let you write Java-style code in Rust? Why would I use this? (Is it because writing code like this is easier than straight rust?)
Actually, that's the entire point of 0/0. It's indeterminate, meaning it can only take on a fixed value in the context of an operation to approach it (usually a limit).
> In Julia I follow the following steps: … does it fit with AST?

I'm fairly certain the steps you've listed can be accomplished through AST manipulations, and would go something like

def manip_ast(fn):
import ast, inspect
fn_ast = ast.parse(inspect.getsource(fn))
new_fn_ast = …
return compile(new_fn_ast, …)

def rewrite(fn):
fn = manip_ast(fn)
fn = numba.jit(fn)

@rewrite
def func(*args):
…

there's nothing in the language that prevents this from working with the autograd package, except no one's taken the time to implement it (https://github.com/HIPS/autograd/issues/47). That said, for many tasks with wide vector data, a DL framework is going to do ok, e.g. PyTorch.

> Julia compiler / LLVM then generates code that reads and writes to memory exactly once (unlike e.g. what you would get with several separate operations on numpy arrays)

Numba's gufuncs address exactly this + broadcasting over arbitrary input shapes. I've used this extensively. That said, I don't find fusing broadcasting is always a win, especially when arrays exceed cache size. Numba's CUDA support will also fuse jit functions into a single kernel, or generate device functions.

Sometimes you want manual control over kernel fusion, and I've found the Loopy (https://documen.tician.de/loopy/) to be fairly flexible in this regard, but it's a completely different approach compared to Numba/Julia.

I'd be interested in a side by side comparison as well, and I was thinking that the main difficulty would be that I couldn't write good Julia code, but maybe we can pair up, if that'd be interesting, to address several common topics that come up (fusion, broadcasting, generics but specialization, etc).
Watch NASA’s Parker Solar Probe Launch
untapt | Back End Engineer | on-site | Full-time | https://www.untapt.com | $100K – $140K + equity.

untapt uses AI to help software engineers find great jobs. You’ll work alongside a team of passionate developers who are working to flip hiring on its head.

Our technology challenges are vast: on the surface, we're iterating upon a two-sided web application that is unlike anything engineers and hiring managers have ever seen. We're building a sophisticated, analytics-driven matching engine that uses structured and unstructured data to predict highly symbiotic working relationships. We use Angular, Flask, MongoDB, Redis, Kubernetes, and a healthy dose of Secret Sauce™ to make it all happen.

Together, we'll change how developers find work – forever.

Here’s how we’d ask you to apply: sign up at https://www.untapt.com/r/hn. You should match with our position and be able to show your interest using the platform. We look forward to seeing your profile and connecting directly with you.
Was curious, googling came up with this resolution: http://www.ncai.org/resources/resolutions/supporting-the-hav...

Curious how tarsnap relates to this?
> correctly state the undefined nature of 1/0

Erm, when we say it's "undefined" we mean it literally -- standard mathematical systems of arithmetic do not define a value for that division.

If you make another system of arithmetic you can define it how you want and be consistent with "regular maths" for the operations in which things are defined. It's an extension.

> We have "NaN" for a reason

Funnily enough, IEEE754 defines 1/0 as positive infinity, not Nan. But none of these things are "the truth" in any reasonable sense of the word, just "useful systems".

Defining it as 0 at least means floating point numbers are (presumably) closed under arithmetic operations, which could be handy.
The Art of Not Dying: the First Emperor’s Pursuit of Immortality
Yes, that's correct. The fact that 1/0 shouldn't be defined as infinity isn't an argument that it should be defined as 0.
Typically, divide by zero throws for integers because they can’t express NaN, which can instead be returned for floating point. In any case, integers can’t express special values, so you get exceptions instead. And this is actually defined at the processor level (for x86 among others), the trap is free (well, a sunk cost), why not take it?

Zero is not a very good NaN.
Are these just the names of the hexagrams in the I Ching?
> But is Pony doing something unsound? Absolutely not. It is totally fine to define 1/0 = 0. Nothing breaks

a=x/N

b=y/N

If a==b, then x==y

No longer true, with this change. Essentially a variety of mathematical properties of numbers in the Real space don't hold when you allow division by 0.
While I fully agree, I'd like to point out that reducing specifically to 0/0 = 0 is more generally useful (ie. maintains intuition) than x/0 = 0, which breaks intuition.

Given a/b = c, your intuition of finding c is to get a number such that c×b = a.

c×0 = 0 has an infinite number of solutions, 0 being a particularly practical one.

c×0 = 1 (and more generally a≠0) has no solution, especially in the reduced explanation of multiplication as taking integer multiples of a value.

(Also note that having 0/0 = 0 maintains symmetry and continuity of the function y = 0/x.)
> the "right" move for Google would be to fork AOSP, make new Android versions as closed as iOS

I wonder whether Google's new operating system 'Fuschia' serves this purpose...
In my piece of Floriduh a non-expert franks the signature on the envelope. It's still more secure than voting in person as state law prohibits inspection of paper ballots in a recount; The only regular ballots recounted are the machine-generated totals.