someone13

Out of curiosity, do you have any theories of why it works so well at such aggressive quantization levels?

For one, Tailscale is a Canadian company :)

What hardware do you use, out of curiosity?

I just want to say how cool it is to see you doing a non-trivial review of someone else’s thing here

Why does a CoC have anything do do with a maintainer stepping down due to a technical disagreement?

And the way you word it makes it seem like you think CoCs are bad or “forced”; I don’t particularly want to engage there, but I’d encourage you to reflect on why you think that.

Appears to be a follow-up to https://news.ycombinator.com/item?id=42750420

That share link 404s for me, FWIW. I’d be interested in seeing it!

It’d also be neat if there was a way to sort by the passmark CPU benchmark score:

https://www.cpubenchmark.net/

As someone that has lived in several countries, and currently in Canada, I will respectfully have to disagree both about your opinion of the CBC and beliefs about government intervention. Some parts of Canadian local/provincial/federal government seem deeply dysfunctional, but some are extremely helpful and better than I’ve seen elsewhere.

Tell that to companies doing extremely large-scale machine learning. Or any cloud infrastructure provider. Or CDNs. Or literally any video production company that owns a render farm. Or any company doing large-scale media transcoding/streaming.

Maybe "don't have thousands of servers" is just a bad take :)

This is part of what makes this class of bug so bad; it's not something you can "fix" at the IDP without doing exactly this. The issue occurs when a Service Provider (SP) is misconfigured, and in many cases the IDP doesn't actually get any sort of feedback that would let them detect the issue.

See Lemon, which generates re-entrant and threadsafe parsers and is used in SQLite: https://www.hwaci.com/sw/lemon/

Shout-out for "AutoSpotting", which transparently re-launches a regular On-Demand ASG as spot instances, and will fall back to regular instances: https://github.com/AutoSpotting/AutoSpotting/

Combined with the fact that you can have an ASG with multiple instance types: https://aws.amazon.com/blogs/aws/new-ec2-auto-scaling-groups...

Means that you can be reasonably certain you'll never run out of capacity unless AWS runs out of every single instance type you have requested, terminates your Spot instances, and you can't launch any more On-Demand ones.

(and even so, set a minimum percentage of On-Demand in AutoSpotting to ensure you maintain at least some capacity)

Out of curiosity, how is this implemented?

I really like chi[0] - I think it strikes the right balance of being small and understandable, but also solving common problems (e.g. nested routes, URL parameters, etc.). It also uses standard Go conventions, so it's very interoperable and would be easy to migrate away from, if necessary.

[0]: https://github.com/go-chi/chi

Mind providing more details on your setup here? I tried throwing together an overlay network using OSPF, but never really got it off the ground. I'd love to hear what you've got here!

Screenshot, in case the page goes down (as of 0609 UTC): https://i.imgur.com/5pv7QFz.png

Your sign up JS is broken - I just tried to enter my email and got a "TypeError: undefined has no properties". Looks like a cool project, though - I've wanted something like that for a while :-)

(oh, and I'm using FF 55 on Linux)

I wasn't able to find anything about a fridge, but some searching found a Sears catalog from 1959:

http://www.aei.org/publication/appliance-shopping-1959-vs-20...

From that page, it looks like the price of the washer, adjusted for inflation to 2016, is $1756.12. A comparable washer today, from Sears, appears to be somewhere in the $400 - $600 range, or about 30% as much as it used to cost.

Data for today's washers: http://www.sears.com/appliances-washers-top-load-washers/b-1...

I mean this in the nicest way possible, so please don't take this as anything personally directed at you, but: any employee of Uber that feels strongly about this should find another company to work at. If you're working in tech, in the current employment market in the Bay Area, finding another job is not hard. Not easy, both in the sense that leaving a job can be scary, and that interviews can be draining - but doable.

There are other companies out there that solve interesting, challenging problems and don't have this toxic culture. There are other companies with talented people. And if enough of your coworkers disagree with Uber's culture, policies, etc., then the talented, moral people that you work with at Uber may even come with you.

The only way Uber will ever pay attention is if it affects their bottom line. Employees leaving, or people turning down offers is, person-for-person, one of the most impactful ways to do this.

Looks like the original article may be from here? http://www.cbc.ca/news/canada/toronto/anton-pilipa-found-1.3...

CBC date is: Feb 07, 2017 15:31 ET

Daily Mail: Feb 08, 2017 16:38 ET

Okay, this is a really cool post, but I have a small bit of criticism - the code samples are really hard to read. I'd recommend, at minimum, adding a bit more whitespace so you don't end up with lines like this:

    if(e[i].events&(EPOLLRDHUP|EPOLLHUP))close(e[i].data.fd);

Despite that minor criticism - pretty cool stuff!

Serious question (I haven't used a merchant credit card account): do regular accounts come with any fraud protection? The reason I ask is, I was sent a link to this a while ago, which seems to say that Stripe does do fraud protection:

https://stripe.com/docs/fraud

To elaborate a bit on the sibling comment here, Rust makes things a bit more explicit than Go does. A Go interface type is actually a pointer (of sorts), since you don't generally want to store things of different types and sizes in a single array. For example, if you have:

    type StructOne struct {
        field uint32
    }
    
    type StructTwo struct {
        field uint64
    }

It's pretty clear that these structures are of different size. Now, if both of these structures implement the "Foo" interface, we can't simply make an array like []Foo, since we'd have no practical method to index into the array. Go solves this by making []Foo actually be an array of pointers.

However, Rust's philosophy is, AFAIK, "be explicit about the cost you pay". So, if you want to make an "array of things that implement Foo", you need to explicitly put the "things" behind a pointer, or a Box<>. So, you get:

    struct MyStruct {
        arr: Vec<Box<Foo>>,
    }

Which makes it explicit that you're storing a "list of pointers to things that implement Foo". Of course, the nice part is that you can use generic syntax to make an array that doesn't use pointers, like so:

    struct MyStruct2<T: Foo> {
        arr: Vec<T>,
    }

In the above, you can only store items of a single type in the `arr` field, and the generics constrain that to be only types `T` that implement Foo. The upside is, however, that you don't have any pointer indirection (and the compiler monomorphizes - i.e. generates new code for each generic implementation), so your code is probably faster / easier for LLVM to optimize.

This appears to be https://github.com/daviferreira/medium-editor

Which service do you subscribe to, if you don't mind my asking?

Some back-of-the-envelope calculations suggest that first number is in the right ballpark. From [0], the lift generated by helium vs Earth air at STP is approx. 1.03 g/L. This suggests a lift of approx. 590,000 short tons on Earth:

http://www.wolframalpha.com/input/?i=%28%28%28%284%2F3%29+*+...

Then, if we assume that the gravity on Venus is 90% of Earth standard, you get about 656,000 short tons of lift. Note that this doesn't take into account the different air density on Venus.

No idea about the "doubling" bit, though :-P

[0]: http://www.chem.hawaii.edu/uham/lift.html

One option would be to allocate objects out of an arena[0] and then destroy the entire thing at once when you're finished with the contained objects.

[0] http://doc.rust-lang.org/arena/index.html

FWIW, you can implement the 'Drop' trait to provide a custom destructor, and then use, e.g. 'volatile_set_memory'[0] to zero out the memory of the object. This isn't subject to the same problems as C, AFAIK.

[0] http://doc.rust-lang.org/std/intrinsics/fn.volatile_set_memo...

Also note that the installation section is a bit out of date: they have Windows x64 binary installers now:

http://www.rust-lang.org/install.html