They claim they want to use AI for "any lawful purpose". They didn't go further to say that they want to build either Skynet or engage in mass surveillance.

Anthropic wanted the DoW to specifically disclaim those things, and the DoW position is that it will not disclaim any specific mission set that it's legally allowed to engage in, whether that's Skynet, targeting, surveillance, or anything else. Not for Anthropic, not for any contractor.

But refusing to disclaim a mission isn't the same as saying you want to do, just like refusing to answer "when did you stop beating your wife?" doesn't mean you're beating your wife.

Is the DoW response to this tiff over the top? Sure, but it's also not 100% political either, I've run into many government bureaucrats who love bureaucratic knife fights like this.

Honestly that question has been open for as long as GovCloud has been around. I've used it myself as an exercise in pushing within the Navy to adopt public cloud where security requirements permit, rather than forcing everything onto GovCloud.

After all, if it's the same S3 either way then the real point of security isn't the Amazon datacenter employee changing out dead hard disks in a physical GovCloud datacenter, but the S3 service team developers who are frequently not even American citizens, but whose code may very well go on to touch the most sensitive data the nation generates.

The Federal government often imposes terms on its contractors that specify what sub-contractors are allowed to do, including "flow down" requirements that ensure these terms are themselves enforced recursively all the way down to leaf suppliers.

None of those amount to a ban, after all private companies are also able to do the same thing, and often do. E.g. when Apple requires its suppliers to pursue clean energy efforts as in https://www.apple.com/newsroom/2023/09/apple-advances-suppli...

Offloading the detail onto the team allows the org to scale higher by allowing the leader to bring more teams/problems into the mix. But it also introduces the complexity of keeping those teams in close enough alignment that the overall effect is still positive.

This is by no means guaranteed to be positive, and there's a lot of details to get right for leadership in making this work. But they are different details than what each individual team was bringing to leadership.

Abstractions are helpful, in business management as much as in systems architecture.

That's not to say Bifrost wouldn't have been better, but the choice to use LiteLLM was arrived at after a fair bit of internal discussion (most of which predated my addition to the team), and so far we've seen nothing from LiteLLM that has been contradictory to the pros/cons they thought would be the case when LiteLLM was adopted.

Or in other words, the org will be happy indeed when they have solved so many of the rest of the problems we've had in AI uptake that the difference in latency between one AI gateway or the other becomes a problem to be solved.

If even they had to add escape hatches despite the presences of powerful language primitives like types, traits, borrow-checking, maybe the people charged with making it all work with 80s compiler technology weren't the literal Antichrist for also having UB as Rust does.

For what it's worth, C and C++ are much different in terms of hazard, so when you bucket them together it makes me wonder how familiar you are with the actual risk of UB in practice.

Nowadays it generally stems from doing weird things.... but no one is making you do weird things, any more than people are making you use Rust's unsafe keyword.

Rust also has UB, btw, https://doc.rust-lang.org/reference/behavior-considered-unde..., so I don't know where it is that people have imagined this is something the C and C++ language designers went out of their way to foist upon you.

If you want to write code for a VAX, then you can use the K&R C compiler where it had defined outcomes for everything. If you want to write portable C code for modern CPUs then it's fair to ask what the C language standard is supposed to define for each of those CPUs and OSes and ABIs.

And a bunch of people were nice enough to do that for you and I, but because they are not deities, there are things that they had to leave out to make the language useful, so they did.

And nor is an LLM generating text just "copy/pasting a Wikipedia article", you'd think people on HN would be smarter than that at least.

If all Joe Smith is going to do is cat $(which claude) to his LinkedIn, then he'll deserve the poor results he gets from it, but we shouldn't mistakenly say that this will be because LLMs simply cannot write. It would be just as dumb for Joe Smith to do with with a professional human ghostwriter.

Of course, with real books we do have the problem of ghostwriting, where an author willingly writes for a book that will be published under someone else's authorship. That may be where things end up here, with requirements to acknowledge sources, whether ghostwritten for you or written by others.

Writing is a way humans communicate ideas. It's not the only way humans communicate ideas. And now, it's not only humans who communicate ideas, we just saw with the OpenAI HuggingFace hack how AI agents were able to communicate amongst themselves by using various hacked websites to opportunistically write notes for later agents to use.

All that "X is a thing only humans do" type of circular definitions will buy you, is to expand the definition of what humanity is. And I doubt that's really what you think.

But you can now have multiple zero-sized types as siblings in a struct or class that can be zero-sized, the restriction is that they do have to be different types.

C++ actually did end up evolving the ability to define a zero-sized class without a unique memory address, but mostly to allow optimizations like the empty base optimization to apply in other situations where it could make sense, especially with templated or constexpr code.

If you have a value of the type itself (not a pointer or reference), then polymorphism doesn't even enter the equation in C++, even if you initialize from a derived type.

E.g. in this code:

    Base b(m_catalog.makeDerived());
    b.call_virt_func();

Runtime polymorphism is therefore only a game for pointers or references; it is the process of resolving the indirection that even allows for polymorphism to become a thing in C++. But this means that the compiler cannot know the actual type at compile-time for a polymorphic type, unless it can perform devirtualization as an optimization pass.

So although C++ will certainly allow you to define a class method that returns a virtual type by value (and not by pointer or reference), even for complex types, it is almost certainly a bug to do this unless you know for sure what the type will be statically, at compile time. Because the object you create as the return value will be forced to be the return type declared at compile time, "forgetting" the fact that it was created from a type deeper in the inheritance chain. This is the 'slicing problem' that was mentioned in the earlier comment.

There's a reason companies talk about "customer acquistion cost", as you generally need to pay to market your products to potential customers of them.

So free marketing can be a real cost reduction. It may not be enough to be a benefit compared to the cost of piracy, but it's hardly a made-up defense.