nemetroid

> And should I stress again that there is absolutely zero positive tradeoffs?

Just because you don't value or acknowledge them doesn't mean they don't exist.

Just make sure that the pipeline is fast, or allow an override, and there is no issue.

> The crew on the ship were Russian nationals.

Citation needed. The sources I can find (e.g. [1]) claim that the vessel "is captained by a Chinese national and includes a Russian sailor". The first part can be verified by the strong accent of the radio operator [2].

1: https://archive.is/3weox

2: https://www.svt.se/nyheter/utrikes/kina-redo-att-samarbeta-o...

99.9% of the code I’ve written is proprietary.

For a five-second demo I agree. But for five hours of playtime, I think the original would result in serious visual fatigue.

All these things are possible to do, even though only developers need them. Why shouldn’t the same be true for useful profiling abilities? Because of the 1-2% penalty?

Do 50% of users need to be able to:

* modify system services?

* run a compiler?

* add custom package repositories?

* change the default shell?

I believe the answer to all of the above is "no".

The fastest code in the article has an average latency of 14 ms, benchmarking against localhost. On my computer, "ping localhost" has an average latency of 20 µs. I don't have a lot of experience writing network services, but those numbers sound CPU bound to me.

The problem is probably that the repo is not hosted in Europe.

What's wrong with grams as a measure of fluid volume? It's not a measure of volume, for starters.

Section 11.9.5.4 of the C++23 standard describes the observable behaviour.

If the US had the same IPv4 scarcity as the rest of the world (specifically, if major US ISPs were using CGNAT), the IPv6 transition would be happening much faster.

Sure, they often are less reliable, which is the R of the smurf and not the M.

Not all systems are web sites. Those issues are not inherent to the concept of end-to-end testing.

End-to-end tests verify high-level expectations based on the specification of the system. These high-level expectations generally stay stable over time (at least compared to the implementation details verified by lower-level tests), and therefore end-to-end tests should have the best maintainability score.

The author seems to reinforce the original point, that the async paradigm ends up working best in an all-or-nothing deal. Whether the difficulties in interfacing the paradigms should be attributed to the blocking part or the async part does not really matter for the practical result: if calling blocking code from async code is awkward and your project's main design is async, you're going to end up wanting to rewrite blocking code as async code.

I don't necessarily disagree, but the original comment didn't suggest that gambling and cannabis are equally harmful, or even that cannabis is harmful. The point was that policymaking seems to tend toward all-or-nothing (either fully prohibited, or anything goes), and the legalization of cannabis is a recent example of that. The goods or harms of cannabis are beside the point.

It’s just an example.

ICAO four-letter airport codes are hierarchical. The first one or two letters indicate the country, e.g.:

EDDF - Frankfurt (E: Northern Europe, D: Germany)

EKCH - Copenhagen (E: Northern Europe, K: Denmark)

VTBS - Bangkok (V: South/Southeast Asia, T: Thailand)

KJFK - New York JFK (K: USA)

Using ICAO codes, you can make sense of a written out route at a glance. Taking one of the examples from the link:

AUY TAH VLI BNE BKK CPH SFJ JAV JUV NAQ

becomes

NVVA NVVW NVVV YBBN VTBS EKCH BGSF BGJN BGUK BGQQ

I.e.: Vanuatu (a few jumps) -> Australia -> Thailand -> Denmark -> Greenland (a few jumps).

That’s one ugly Å, without any separation. The font looks nice in general though.

> To some extent emissions are not as bad as you'd think since they are being emitted over less time in the course of a shorter journey.

Emissions are usually compared in amounts per passenger-kilometer.

Posters on /r/boeing on Reddit seem unhappy.

https://old.reddit.com/r/boeing/

Black background, white foreground works fine on my iPhone 13 mini.

If the memory has been paged to disk, I guess so?

So what is the definition of "blocking" here? That it takes more than 1 µs?

That's just as terrible as making a flippant comment about the DEMOCRATIC People's Republic of Korea.

I don't know OP's reasons, but OWA's landing page says:

> We [...] have come together to advocate for the future of the open web by providing regulators, legislators and policy makers the intricate technical details that they need to understand the major anti-competitive issues in our industry and how to solve them.

Zero matches on the page for "Google" or "Chrome", whose monoculture is the greatest threat to the open web.

Most of these, maybe all, have a dual pull request antipattern.

> The Ransom Note

A developer submits a patch that's especially important to them. When you point out that additional changes are needed elsewhere to make the component stay logically consistent, you get told that those changes are unrelated to the problem being solved (their problem being solved).

> The Guessing Game

A developer submits a substantial patch. They contents of the patch indicates that the submitter has not understood the design of the code they're modifying. When the reviewer communicating this back to the submitter, the submitter expects the reviewer to drop what they're working on and instead work on designing the feature the submitter needs.

> The Priority Inversion

A large patch has been submitted with poor explanation of the underlying design. Properly reviewing if the patch makes sense takes time. The submitter (publicly) complains that they (verifyably) aren't getting responses to their code reviews and that this is holding back feature X.

> The Catch-22

There's a tradeoff to be made, and the decision made by the submitter is far off the mark.

---

The problem usually isn't picky reviewers or sloppy submitters, it's the lack of clear contribution guidelines.

Sure, and packaging the artifacts of the liburcu build is going to be trivial in any package management system. It makes very few assumptions about how it's going to be used. Using Folly requires you to ascribe to the Folly worldview of dependency management.

Abseil isn't too bad.

A pretty reasonable one, too. Getting liburcu to build is trivial.

So what's the enterprise-quality solution for querying the GPU for the information they need?

If I search Google for "nvidia-smi.exe", one of the top results is a Stack Overflow answer with 70 upvotes, describing exactly the approach taken by the linked code.

https://stackoverflow.com/a/57100016