derdi

People keep saying this "everyone can switch" thing, but it's not my experience at $VeryBigCorp. We don't have an Anthropic contract at all. Is this different in other places? The bigger and more bureaucratic an org is, the less I would expect it to have contracts with all the providers. Curious about others' experiences.

But then what does it mean when the FT writes that that "revenue" number already accounts for the 15 billion losses? That the FT doesn't use these terms correctly either, and we can't really know what its reporting means?

You're right that the outcome may be similar, in that trivial contributions are discouraged. But the reasoning to getting there is completely different. Sqlite's copyright.html talks about copyright, not about maintainer overload.

An otherwise overloaded maintainer of another project may probably be willing to accept individual brilliant contributions from brilliant contributors. Sqlite will not, no matter how brilliant, if the contributor doesn't sign an affidavit. Independent of Sqlite maintainer load.

A known Sqlite contributor who has signed an affidavit, and has a history of good, accepted contributions, may also start spamming trivial contributions that may lead to maintainer overload, and nothing in copyright.html will prevent that.

Many people want "contributed to <well-known project>" on their CV.

The text you quoted is purely about copyright/licensing, not about the maintainers' sanity.

The more relevant quote is: "In order to keep SQLite completely free and unencumbered by copyright, the project does not accept patches from random people on the internet. There is a process to get a patch accepted, but that process is involved and for smaller changes is not normally worth the effort." Though this is still about copyright, not about being swamped with PRs.

This is from a vaguely interested outsider, I hope an expert chimes in.

My understanding is that in choreographic programming, the protocol/choreography is considered an explicit "thing". That explicit thing is explicitly defined in one place, as opposed to the implementation being divided up across multiple places, like the client, server, etc. This is the explicit opposite of "reason[ing] about each object/microservice in isolation", at least with regards to the protocol. Since the protocol is one "thing", there is no reason for abstraction: Abstraction is for when you combine multiple "things".

In the example, the client's network code may know about internals of the service's network code, but that's not a problem. This doesn't mean that the client's business logic knows about the service's business logic. It's also not a problem that the client knows that there is a separate login provider that could be communicated with. You may be thinking, "oh, if the client knows about the login provider, it might try to talk to it directly". But no, because the entire network code is generated based on the protocol specification, and the protocol specification doesn't include this.

You might take the generated network code and break it by hand. I guess the response to that is, "please don't".

Again, I hope someone can correct this or explain it better.

Got it, thank you! I had read your "remove any occurrence of the expression type in the tree-walking AST" as removing nodes from the AST, but in some sense it's about removing edges, as in, the references from one operation to others.

Fair! Though I still don't know what you mean by "removing" nodes from the tree-walking interpreter's AST. Assume we have an AST like:

    (Add (LoadConst 1) (LoadVar x))

The corresponding stack machine code might be:

    [PushConst 1, PushVar x, Add]

In what way was anything "removed" from the tree?

Hmm, what's a stack machine AST? I can't follow your description of the transform, what does "remove" mean here? I can remove all of the internal nodes of a tree, which leaves me with a soup of leaf nodes, but how is that an AST for a stack machine?

Given that GCC was first released in 1987, that would mean that tail call optimization, including of indirect calls, has been around for more than half of GCC's lifetime. So it's indeed fair for the parent article to say that "[GCC has] had tail-call optimizations for most of [its] existence".

I flagged this. I don't think we need to doxx people here, it's enough that the featured article does so.

"AI-generated copy that says a lot and commits to nothing." Haha.

Seriously, it's nice that Kimi did the investigation, and it's good that that's disclosed at the end (would be better at the top). But please, do a pass of human review for the most grating inconsistencies and style issues.

Haha, excellent downvote, thanks. I stand corrected, one other person mentioned the word "copyright" in the time between me searching the discussion for that term, and then writing and posting.

There is some copyright discussion on one of the other submissions on this topic.