derdi
derdi on Hacker News
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.
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.
Nobody mentioned copyrights or stealing in this thread.
Nice, but what is the motivation for this? That the syntax is perceived to be nicer than SMT-LIB format? Or that Lean can get involved? Differential testing? Just for fun?
The Turing test has been passed. The Turing test had already been passed in 2002. The Turing test isn't about some machine fooling all humans all the time. It's about fooling some humans some of the time. That's an extremely low bar. It has been cleared. Let's put this to rest.
What should one check for?
Not sure what this is a parody of, but it's hilarious, thank you. Keep it up!
The "blocking" happens on the side of the AI users. You like using AI. You are aware of this policy.
Will you submit an AI-generated pull request to OpenJDK? No? Voilà, you have successfully self-enforced the OpenJDK policy.
Or do you go to the trouble of finding an interesting issue to work on, get your agent to code it up, manually polish it to make it less AI-looking in case there are doubts, and then submit it? Yes? No. Why would you? To prove some kind of point, to yourself, that you can never disclose publicly? Most people have better things to do. Voilà, the policy is, again, self-enforced. Enjoy your day at the beach instead of trying to trick a project that is politely asking you not to trick it!
Why would they? The only thing the readme says about RESEARCH.md is "if you want to contribute to the language please read RESEARCH.md". The OP doesn't want to contribute, they want to see an example of choreographic programming. This shouldn't be hard. What is hard is guessing which of the random markdown documents to click to find an example.
You're presumably using an LLM to drive the compiler, and your LLM should be just as capable of reading the compiler's error message and fixing the problem. So why double the work?
It's not, and the article's attempt at putting lipstick on this pig is nonsensical:
> StringView has no operator bool, so a successful match reads as !scanner.accept('=').isEmpty(). Noisier than returning a bool, but the matched text comes back with the answer instead of requiring a second call to go get it.
Clearly there is a second call, it's the call to isEmpty. Plus, the actual text is lost in this particual example (though we know what it was).
An actual ergonomic way of using this would set things up so that the INI parser's inner code could be written something like this:
bool success =
(name = trim(acceptUntil('='))) &&
accept('=') &&
accept(Space) &&
(property = acceptAll());
Got it, fair enough, thanks!
Cute game! Very CPU-hungry (in Firefox on Linux), maybe you can get it a bit more optimized. There are some annoying AI-isms ("the X is the goal not the Y"-- just tell me the X please).
Is there a way to build anything on the ground floor, or is it just a big empty lobby? Feels like wasting a lot of space.
> Before, coding is only 14% therefore, small slice.
But also, no, because they write:
> “coding” (not including bug fixing, testing, etc.)
What if bug fixing includes "coding", or "writing code", or however one would want to define that? Especially in the enterprise setting they evoke, a lot of work will not be "coding" in the sense of churning out new features, but "coding" in the sense of fixing bugs. I know a lot of my "coding" is in this category. But we're not given a number for it. I suspect the slice would be bigger if they included this type of "coding".
What kind of robots are we talking about? What will robots do for me five years from today?
There was this submission two months ago:
https://news.ycombinator.com/item?id=48365904 . Basically they have a TUI frontend for the same thing. And the blog post says: "Bonsai_term would feel familiar to anyone who’d ever done web development here, and it had the huge advantage of being especially amenable to AI assistance. It was actually somewhat of a mystery to us how good the models were at writing Bonsai_term code, given how relatively obscure it is [...]"
How about hosting a read-only demo instance somewhere, so people can explore what this actually looks and feels like? Could be slop-filled, or even be your actual project's data (which I assume might be public enough, given that you are planning to release an open source version).