I guess I don't know what "national champion" means. Do they receive different legal treatment from other similar companies? If so, that would be a worrying signal. A common feature of fascism being present doesn't mean you've definitely got fascism, but it does raise a pretty big red flag.
>Do they receive different legal treatment from other similar companies? If so, that would be a worrying signal. A common feature of fascism being present doesn't mean you've definitely got fascism, but it does raise a pretty big red flag.
They definitely get assistance from the government. Where that crosses into "different legal treatment" is up to you, though personally I think the distinction (if any) isn't really worth much. The original claim was "Most favored companies", not "are totally exempt from the law". In the case of openai, it's not really clear whether any laws have been broken, because despite all the cries over "they hacked people!", the question of intent would make any prosecution tricky. Not to mention there's similar cries about AI companies in general violating copyright laws, so if the implication is that openai gets to break laws scott free but anthropic doesn't, that really falls flat.
The crux of the issue isn’t hacking - all the big US labs have hacked someone now (https://www.felonybench.com/)and none have faced charges. It also isn’t copyright violations, they all seem equally guilty and equally uncharged.
The issue is openai and anthropic both make similar products in similar ways and yet only one has been designated a “supply chain risk” for entirely opaque reasons that based on timing are probably just “they didn’t kowtow correctly”.
The gov putting their finger on the scales for the company that showed the most deference to them is not a good sign for democracy.
I don't get the analogy. Brakes that are good enough for a Honda Civic driven at regular speeds are not good enough for a fire truck or a race car, but there are in fact standards that are "good enough" for all of those.
I was unpleasantly surprised that those default mounts weren't just included in the base toml config like the ones from the home dir. What's the purpose of having two different kinds of "defaults"?
I've never understood this. There is no "gun show loophole" anymore, if there ever was. Some states have two different standards required things like background checks and identification for gun sales between private party sales and dealer sales. If a dealer goes to a gun show, they have to background check their buyers just like anywhere else. Similarly, if a private party (in a state where they're not required to background check) sells a gun on Craigslist, they're equally unrequired to background check.
Many states, including most of the "anti-gun" states, have moved to requiring background checks from all sellers, including person-to-person transfers and even gifts from family.
The "gun show loophole" is massively overblown. There's nothing special about gun shows in it.
That counts as many states, and most of the "anti-gun" states, which is what the parent actually said.
Personally, I think people should be as free as possible to sell goods privately without the government getting involved. It's not a loophole, it's how things should work.
If you think any of these laws prevent felons and other prohibited persons from getting guns, you must be remarkably unfamiliar with felons, and their willingness to commit felonies. Most felons I know through friends/family have a gun (often stored somewhere plausibly deniable), and it's not a particular secret.
These laws primarily harm law-abiding citizens — who were never the problem in the first place — far more than they restrict prohibited persons from acquiring guns.
The same thing will occur with restrictions on open models, but arguably the results are far more harmful — limiting the technological and economic capacity of the people and countries we have to worry about the least, leaving the playing field open for those we have to worry about the most.
Fun fact - habitual drug users are no longer blanket prohibited from possessing firearms in the US, at least according to UNITED STATES v. HEMANI, decided by the Supreme Court this summer.
Of course it's not quite that simple. Among other things, the form to buy a firearm still asks if you are a user of controlled substances, and lying on the form is presumably still a felony.
The opinion is still a fascinating read and IMO a huge step forward.
That's a tautology though. You're defining a set of people by their illegal behaviour and then saying "all of these people have a demonstrated comfort with a capacity for ignoring the law". Well, yes, obviously.
My point earlier was that people don't neatly sort themselves into "law-abiding citizens" and "felons" until after they've committed a crime. A law-abiding citizen can turn into a felon at any moment.
And, of course, this is in the context of the gun control debate, where you can't issue guns to only law-abiding citizens because you have no clue which of those law-abiding citizens are going to commit a felony and magically become a felon
Of course "a felon has previously committed a felony" is tautological. But "a person who has committed a felony is substantially more likely to commit serious crimes in the future" isn't.
It's a well-established empirical claim, and that's why they're prohibited persons.
As for magically predicting whether someone will become a prohibited person: we can’t, and even if we could, that would mean preemptively restricting a constitutional right.
Right, so your future felon is a law-abiding citizen now.
> These laws primarily harm law-abiding citizens — who were never the problem in the first place — far more than they restrict prohibited persons from acquiring guns.
When you sell a gun to a law-abiding person, you have no idea if that person is going to become a felon or not. There is no hard line between the two, any law-abiding person can become a felon at any point.
This is why the rest of the world restricts people from owning guns.
Graphene has been my daily driver for the past year or so. The only thing I miss is the ability to do contactless payments. Otherwise, it's been awesome. I don't run any games nor do I care about any of the AI features. YMMV.
Those people will never be able to use Graphene or any other privacy-preserving smartphone. They'll be stuck with Apple or approved Android. At least that's how it looks today.
Or they can get a Garmin watch with contactless payment, or do what I do - stick a credit card in their phone case.
Funnily enough, I feel the exact opposite! The limitations of terminal make them portable while still being more than powerful enough. But then I've used vim as my editor for going on 15 years now so I'm biased.
I do used vim for many years too , but when developing web apps , Terminal become a limitation , things cannot be preview outright in the interface is a big downer.
Huge plus for GUI base dapplicaitons : you can view total and complete render of HTML , PNG , SVG , PDF right in the IDE/Harness tools. That is no where terminal app can do with good performance .
I'd be interested to hear other strategies in this space. I've done the naive thing of allowing retries everywhere, and gotten into retry storms. When I was next presented with the problem, I tried the other naive thing of only allowing retries from the very top level service, which led me to redoing absolutely tons of work for each failure. What's a nice middle path that doesn't add too much complexity?
There's a good amount of literature about this (check the other comments), but you can vastly simplify this into two things you need to do:
1. Your service that retries should have some retry budget. This is a good place to be "smart", because you can reason entirely locally instead of turning it into a distributed systems problem. The best library I've seen for this was doing Exponential Moving Average of requests per second sent down that pipe (not counting retries) and only allowing 20% more requests per second as retries, total. Each individual request could be retried 3 times. This was critical as it bounds the additional load from retries.
2. Whenever a service retries but has to give up, the error it sends to its callers should never be retried. There has to be some agreement that that HTTP code will never be retried. This prevents the multiplicative factor of retry on top of retry, which is why those storms can generate so much load.
Everything else is nice-to-have, but those two alone should bound the total requests you get in a retry storm.
> 2. Whenever a service retries but has to give up, the error it sends to its callers should never be retried. There has to be some agreement that that HTTP code will never be retried. This prevents the multiplicative factor of retry on top of retry, which is why those storms can generate so much load.
This can't really be tolerated in practice, though, because it means that one bad component somewhere in your stack, one that is able to accept and respond to requests but for whatever reason isn't able to make requests to its backends, poisons the whole stack. You can't take one backend's word for it that the failure is not localized and therefore retryable.
> 2. Whenever a service retries but has to give up, the error it sends to its callers should never be retried. There has to be some agreement that that HTTP code will never be retried. This prevents the multiplicative factor of retry on top of retry, which is why those storms can generate so much load.
Ooh, I like the idea of propagating "no retries" hints in the responses back upstream. Have you seen it implemented in the wild, or in public discussions about the practice?
In gRPC, the statuses it returns in trailers can include arbitrary details, and Google has a well-known proto for common ones in `google/rpc/error_details.proto`. One such detail is RetryInfo [1].
When we implement retries where I work, the general rule is that if a request is suitable for retry, it should include the RetryInfo in the error status and use it as the base delay for the exponential backoff. The absence of that detail means don’t retry, and we have a client interceptor that parses the response status and retries according to that logic.
I get a feeling of dejavu for this one. Most of my experience has been in Java and in most places I worked in the past we had this hierarchy of exception classification which gets reflected into the http status codes as well. On high level the HTTP status codes in case of errors are already classified as re-tryable or not, the convention varies globally but can be adopted in a standard manner within a company.
The reason why I brought up the exception propagation is cause within a large enough service with multiple layers of depth the exception hierarchy provides with similar context.
The hard part is not implementing something like this, its about maintaining it consistently across every new change. With small product teams this architecture concept/convention/constraint can easily get lost/forgotten and what you are left with is a theoretical system which does not works as desired when the storm comes
So many variables, but the simple thing is to set things up like normal rate limiting (which you would want to do anyways). The one generating the errors passes back a retry time. You can add jitter here, tell low priority requests to wait longer, etc.
BTW: do keep track of priority. It’s like having a database that gets flooded with connections and won’t allow new ones in—but will for admin users (btw, it did not used to be that way in the early days of MySQL).
At $previousJob we implemented circuit breakers: centralize all requests to the foreign service (every call to service theta went through the service theta client which had some shared state so everything so we could keep track of requests) and then monitor, when error % got above a certain limit start to dump requests to a text file for sending in the future instead of now. And the centralized caller will send one message every time gap (we started at 30s) and as long as that errors out we keep writing.
We did that because otherwise we would get 2x30 second timeouts to a dead service on every user interaction and it made for a terrible user experience. Keeping track and handling it smartly made the average user experience a lot better.
One good option that is not (yet?) mentioned here is a deadline for retries. You can cap the request duration by, say, 500ms and pass the remaining time budget to downstream services.
This can be done via an HTTP header and enforced by the middleware.
Just limiting your retry budget to 1% of normal rates using a client-local token bucket with no distributed coordination will eliminate the possibility of long-lived retry storms.
This is trading a good developer experience for a bad user experience. There are situations where it makes sense to force manual retry, but there's no reason to apply one universal rule to all possible situations. Lack of considering nuance for your situation is just intellectual laziness.
My point was that just throwing exponential backoffs at the retry problem is not a magic solution
I don't follow how being cautious about avoiding multiplicative layers of backoffs is trading a good developer experience for a bad user experience. The described situation is an awful user experience. Simply adding a retry and calling it a day sounds like the easy developer experience at the expense of the user experience
> The described situation is an awful user experience
Sure, the worst case scenario is. 99.9999% of the time, a transient error will actually just work on the first or second auto-retry and save your users the effort of paying attention and manually retrying things. This is especially prudent for background tasks where the failure may not be noticed right away; coming back to something fire-and-forget 30m later to see it never tried to finish is not a good user experience.
> My point was that just throwing exponential backoffs at the retry problem is not a magic solution
Nobody said it was. In fact, I suggested the exact opposite - a proper solution takes dev effort. Adhering to an iron rule of "just make them manually retry" is throwing your hands up and not even trying to solve the problem because laziness is convenient.
I responded to a post that merely linked to the Wikipedia article for exponential backoff (in response to "I'd be interested to hear other strategies in [protecting against retry storms]")
The submitted article is precisely about the degenerate case and the difficult work of dealing with it
> This approach works for transient or low-rate failures. However, during moderate or severe degradation, it becomes counterproductive. Aggressively retrying against an already struggling service increases load, accelerates failure, and amplifies retry traffic across upstream dependencies. What begins as a localized outage can quickly escalate into a stack-wide incident—ultimately degrading, or in the worst case, completely breaking, the end user experience.
Yes, and then responds to that degenerate case by suggesting that you never automatically retry. It's like saying "you should never drive a car/take a flight/ride public transportation because it's gone wrong so many times". Things go wrong. You should absolutely consider the impact and what will happen when they go wrong, but the end takeaway to just never engage with them because they can go wrong is, frankly speaking, lazy and bad advice.
A universal health care mandate were both radical and divisive, and the popular nickname for the ACA today is "Obamacare".
I happen to think the policy was a good idea, and voting to keep it in play was the best vote of John McCain's career ... but it was definitely both radical and divisive.
Now, much of the "mandate" has been stripped away, health care remains a mess, and access is far from affordable, but you can't really blame that one on Obama.
> A universal health care mandate were both radical and divisive
It seems quite ironic, given the frequent complaints about the inability of Congress to either govern effectively or fix health insurance (for many and various definitions of "fix"), that the ACA was so divisive. At least it got passed! Yet given the opportunity twice (2017-2019, 2025-2027), a politically viable alternative hasn't been offered up by opponents of the ACA, let alone being able to fully repeal it.
Lol cool so health care is your definition of "radical" and "decisive". Hint: it's neither of these things and the only reason it was considered as such was because Obama was black (see tan suit). Seems like we need a few more years of woke cause you still can't see the obvious
I'm shocked that more people don't know about this. It seems insane that the "land of the free" (yeah I know, not really, but that's the pitch anyway) would have such an obviously command-economy policy through the heart of the cold war.
reply