hyperpape

Whether or not you draw a distinction, it seems plausible that the world as a whole would draw a distinction between sharing encrypted messages with the NSA and deliberately injecting malware into widely distributed software. Corporations can look at the former and think it is unlikely to affect them.

So regardless of how bad its prior behavior is, it makes sense that Microsoft has more of a reason to try to keep software distributed through GitHub as secure as it reasonably can.

They're implementing a widely used compression standard created by a developer at a competing company.

Even if Google is the absolute most evil company in the world, they will still make many smaller decisions every year that are just reasonable engineering. If you forget that, you end up going down a conspiracy rabbit hole and losing any ability to understand the world.

Where are the measurements comparing throughput of tracing GCs and manual memory management? I'm aware of how incredibly hard this area is to measure, but it's a shame that the state of mainstream discussion is "most people just assume GC implies slow, but then again a handful of people say it's not."

What you wrote sounds superficially plausible, but you're overcorrecting.

It is true that the average age of first birth varies widely based on socioeconomic factors, but it's up for all groups. The average age to have a first child was 21 for a woman in the US in 1972. In 2018, it was 26. For women without a college education it was 23.8, but that's still higher than it was in 1972. https://www.nytimes.com/interactive/2018/08/04/upshot/up-bir....

The US is not the most extreme country in this regard either.

So yes, there will probably be fewer great-grandmothers in the future, though of course there still will be some.

I agree with your top level point, but I find your phrasing absurd.

The "humans who are exposing those vulnerabilities" are doing it to profit by committing extremely disruptive attacks on random businesses, hospitals, and important infrastructure.

I don't support literally getting them killed, but they're not innocent hackers driven by curiosity the way your comment makes it sound.

At the time, the only public results were demonstration games against a much weaker professional. The actual strength of the machine was only known privately within DeepMind.

What they did, lowering rates to fight a deflationary environment with low growth, is the exact same strategy that the US has used for many years (and Europe as well). The difference is that the situation was much more severe, which made them actually resort to negative rates.

Now that worldwide inflationary pressure is much higher, you're seeing rates rise everywhere. Of course, rates are different from country to country, but directionally, there's nothing novel about what's happening here.

You're saying you can't generalize, but on the contrary, there's a very obvious generalization here.

$180M is 10% of Uber’s global net income for 2023. Sure seems like a lot for one country.

Also, it looks like it wasn’t even for Australia as a whole, just one state?

Didn’t use an original Macintosh, but I used a Mac Plus. It was pretty typical to turn your computer off between uses. This optimization was very valuable.

The result seems to rely on stipulating the LLM must answer true or false to all its questions, and can't say "I don't know." So it's an interesting result, but it's not obvious that it tells us much about our actual problem, which is 100% about how to get a system that accurately understand the level of confidence it should have.

With a physical book, code requires extra pages, which drive up the cost, and make the book take up more space (though this can be a positive if your book might look too short otherwise). With a digital book, you can freely include as much code as you want.

Worth noting that by market cap, Twitter is 20-30x less valuable than Facebook.

2.9% would be excellent if sustained. It would correspond to keeping a significant majority of the employees you want to keep for more than 10 years. That's generally quite rare.

I'm less clear on how to assess the 6.8%. It seems somewhat significant, though if you're hiring many people, that's a period where you might expect churn, as some of them don't work out.

Of course, you can't extrapolate any of this, as 2023 was a year when employees would be very averse to moving, and it was also a year when many companies were coming off of previous hiring sprees. So expect the 2.9% to eventually increase.

I'm sure there are reasons the implementation might not be easy, but conceptually this seems fixable. You just need a lower bound of "how bad can this plan be?" and that doesn't require completing the query, just observing that it's been running for a long time and/or used unreasonable amounts of resources.

Also, is the problem with the 50 join query that the planner screws it up, or that it's fundamentally doing too much?

I believe insurers are required to spend 85% of premiums directly on medical care: https://news.ycombinator.com/item?id=37977842.

(Not saying that's the right number, health care in the US is out of control).

I don't know of anything like a comprehensive estimate, but there are people working on documenting and quantifying these costs: https://springboardpolicy.medium.com/getting-to-know-the-tim....

You haven't given any mechanism that would make this happen. Specifically, some reason that the company would see contributing be beneficial to it. Of course, it benefits from the existence of open-source as a whole, but what material difference does its contribution make?

Take a small-medium sized business (say 5 - 50€ million annual revenue). Perhaps it can fund one library that is critical to it, but no contribution it makes will make a material difference to the trajectory of major products like Linux, or Python.

The old code was

    targetEndDate = new Date();
    targetEndDate.setFullYear(endDate.getFullYear());
    targetEndDate.setMonth(endDate.getMonth());
    targetEndDate.setDate(endDate.getDate());

Even if the endDate is valid, this can fail, because today is the 31st, which doesn't exist in endDate's month.

If you just did:

    targetEndDate = createDate(endDate.getFullYear(), endDate.getMonth(), endDate.getDate()); 
    // createDate is an intentional placeholder, I didn't want to double-check the actual syntax

you wouldn't pass through the transitional stage where you have the new month but today's day of the month, which is what causes the bug.

In this case, using mutation on the individual fields makes you have to transition through an invalid state to get back to a valid one, and the JS date object does something unexpected (though I think there's nothing good to do here, an exception is probably the best you could do). So mutation really is at issue here. In general, mutation creates room for these kind of counter-intuitive state transitions to arise.

Already, several comments saying how being a truck driver is a tough job (it is!) or "that's what they have to pay to get decent drivers". But whether the job is hard, isn't the question, and the second comment is sort of vaguely accurate, but just ignores the interesting part. From the article:

> One of the best jobs you can get in trucking is at Walmart. The uber-retailer says truck drivers can make up to $110,000 in their first year at the company. That’s twice the nationwide median pay of a truck driver

The interesting question is: why does Walmart pay so much more than is typical? Unfortunately, the article gives a pretty superficial analysis.

Edit: to forestall helpful comments, I am aware that businesses often make an effort to do things based on a kind of sophisticated analysis where they compare the upside of doing the thing ("benefits") to the downsides ("costs"), and then do the thing if the upsides seem to exceed the downsides.

The question is, why is it that this significantly above market rate is what Walmart thinks maximizes its benefits compared to costs?

I'm a little confused by your question. The discussion is about which button should be ok, and which should be cancel. The browser will not lay that out for you, you have to pick a layout.

There are some things where the browser will apply platform conventions, but nothing resembling the consistency you'd expect from (well-designed) native apps.

When you put it that way, it kind of undermines the snark towards web developers. Of course things are inconsistent, no one is in charge to say “this is the way the platform does it.”

There are lots of other design sins this doesn’t excuse (low contrast, for instance), but expecting conventions to be as consistent as on a desktop OS feels naive.

My understanding[0] is that building product was always categorizable as R&D (though it was up to the company to choose to categorize it that way). What was not R&D was operational expenses (production support, etc).

[0] This is based on working at a company that went through a brief period where we had to do extra tracking to be able to capitalize our time if it was possible, and then reading up on the matter to try and understand what the hell the purpose was. Possible I'm wrong about the matter--I've never been the one doing the finances.

I said it was subtle, not small. I agree it's a valuable distinction.

I agree that this is not a memory leak.

However, the semantic distinction between "this uses much more memory than expected" and "this is a memory leak" is a little subtle, and it seems pretty rude to call it clickbait.

Please go read Wikipedia: https://en.wikipedia.org/wiki/Memory_safety.

Agreed.

In the Haskell world, "space leak" is used to refer to a lazy computation that overallocates because of laziness (classic example being the difference between foldl and foldr or maybe that's foldl' and foldr'--I forget some details/cannot be bothered to think about folds right now).

I've personally stolen the terminology for a computation that temporarily holds on to a bunch of unneeded memory.

Which rural areas are you thinking of? Toulouse and Seville are really not that big (they’re both around the size of Oklahoma City when considering their metro areas). Hamburg is quite a bit bigger.

Every second you’re reading build XML or making decisions about it is time not accomplishing the core goal. I’ve created a lot of little libraries over the years, and every time, the worst part is the tedium of setting up the environment.

If you have XX years, you can update the expiration date when the author dies. If the author is still alive, expiration is safely decades in the future.

Of course, the real problem is that the system is not seriously designed with the idea that false positives are a problem.

https://github.com/openjdk/jdk/tree/master/src/jdk.compiler/...,

Wiki citation for good measures https://en.wikipedia.org/wiki/Javac.

Maybe you're thinking of Hotspot, which is written in C++.