layer8

The only implementation to ever support the C++98 “export template” feature, as far as I know. I wonder if that’s still in the open-sourced version.

> Gitea drops the historical 1. prefix from its version numbers, so this release is 28.0.0 rather than 1.28.0.

Do you expect competing AIs to give up on private ownership of the means of production and using them for profit?

Not the other commenter, but we won’t have robot plumbers in 10 years. Maybe in 50.

LLMs aren’t trained on movies, though.

Image/video models are, but those weren’t the topic.

The argument wasn’t about how much it’s worth, but about how much it cost to create. These are very different things.

The root comment was asking how it is a problem. If one considers it wrong, then it’s a problem regardless of whether Anthropic is complaining or not. Anthropic’s complaining or non-complaining should have no bearing on whether it’s considered a problem or not.

*complement

Commoditizing one’s compliments is a different strategy.

You can be grateful to individual things an enemy does.

Two wrongs don’t make a right. (If you consider them as wrongs.)

SOTA models cost hundreds of millions to train. Did creating the contents of the text corpus they were trained on really cost an equivalent of 20x as much (~10 billions)? I honestly don’t know, but I could imagine it having been significantly less.

This isn’t meant as a moral argument, just musing about the relative cost comparison.

I mean, the whole article is the author bemoaning that LLMs have usurped his writing style.

> Could unique Agents identity possible outside of them owners and if yes how?

This is unintelligible.

I have no pressure to use LLMs for agentic coding, so I haven’t tried that hard, to be honest. I use LLMs to generate initial code drafts and to perform logical refactors (those which classic mechanical refactoring tools are unsuitable for) that I then touch up or revise manually. Basically, areas where it actually saves time while still fully controlling the design of the code and reasoning through all aspects of the implementation. I don’t see how agentic coding can save time without giving up some level of diligence, coherence, and attention to detail, which I’m not willing to do.

FWIW, I’m in the same minority(?) as you. I suspect that others just have lower standards of rigor.

My point is that your argument regarding the average customer doesn’t seem to apply. But neither do I believe in a nefarious motive.

Looks like “ClawGPT” was already taken as a name.

(Indeed: https://clawgpt.com/)

The average consumer doesn’t have a $100+ ChatGPT Pro subscription though.

What’s an active blogpost? Do you mean an active blog?

> Take the QuickTime record button.

Arguably it’s visually centered, because the menu arrow on its right is changing the visual weight between left and right.

It may be a layout accident, but it might also be deliberate.

He might have started feeling that way only after trying the VR headset.

It’s not just a matter of there being different ways to do it, it’s also that none of the ways obey expected arithmetic laws like associativity. Adding four months and then subtracting four months can yield a different day than the starting point. Or adding three months and then one month can yield a different date than adding four months at once.

If you have a link that would be appreciated.

Regarding the last part, the strategy is to not have everything depend on everything, to instead modularize with succinct interfaces, so that you can reason locally. Of course beyond a certain project size, there is no single person who understands every part in detail. But for every part you can have someone who understands it, and can reason about it in terms of the interface contracts with the other parts. It’s also not essential that every detail is still understood at every point in time, as long as it’s sufficiently documented. What is essential is that for every part someone did reason through it with the necessary rigor at some point.

I’m not talking about formal verification, but about diligent informal or semi-formal reasoning through the code, so that you can rightfully claim that you understand the code and will be unlikely to be surprised by its behavior. Having learned formal verification does train that form of exhaustive reasoning about properties of the program. This practice also has you structure the code such (and select your dependencies such) that you can reason about all relevant properties. This is perfectly applicable to what you’d call CRUD and enterprise applications (that’s half the projects I earn my living with). Testing and fuzzing are complementary, but not a substitute by any stretch.

> I never understood the code. You think it works a certain way, until you find out that it doesn't. What LLMs make possible is for me to say: find out all the ways this thing works. Analyze the different ways we can run this software, build a fuzzer, build property tests, and run this software in every scenario possible. Log full traces. Log all the outputs. Now, analyze each scenario for bugs. You can't do that by hand.

Testing isn’t the same as understanding the code, or proving (even informally) that it is correct. Having the LLM do all these things above doesn’t lead you or the LLM to understand the code, to logically reason about its behavior over all possible states and inputs.

“Finding out that it doesn't” means that you didn’t properly reason through the code beforehand, checking all your assumptions against what the code and underlying systems are actually guaranteeing. This may be a matter of formal education (proving computer science theorems and algorithmic correctness in university), I don’t know.

It made sense when databases and programs were used almost exclusively locally. It still makes sense for local apps (e.g. local-first or local-only smartphone and desktop apps) who typically will automatically do the right thing that way based on the OS regional settings.

It only started causing widespread issues with the rise of cross-region internet SaaS. Database systems, language runtimes, and OS APIs are keeping the default behavior for backwards compatibility.

> Adding a month with + INTERVAL '1 months' is timezone-dependent. […]

Adding months isn’t well-defined anyway, even when using date, for days of month > 28. I think it’s a mistake that systems generically allow such a computation (as opposed to application code implementing domain-specific business rules).

Many people like email for a similar reason: Every message is an independent item that can be moved and copied at will, organized into folders, filtered and sorted, moved between accounts and email clients, attached to other messages, saved and loaded as files, and so on.

First of all, it usually doesn’t work, so “if it worked” remains kinda moot at present. Then I also prefer only typing a few keywords, rather than having to spell out in length what my goal is.