15,703 karma · joined January 5, 2016
https://xyrillian.de (podcasts and blog) https://github.com/majewsky Mastodon: https://digitalcourage.social/@xyrill
What I say is often colored by my work experience, but opinions are always my own and not those of my employer.
At least for those here under the jurisdiction of the US Copyright Office, the answer is rather clear. Copyright only applies to the part of a work that was contributed by a human.
See https://www.copyright.gov/ai/Copyright-and-Artificial-Intell...
For example, on page 3 there (PDF page 11): "In February 2022, the Copyright Office’s Review Board issued a final decision affirming the refusal to register a work claimed to be generated with no human involvement. [...] Since [a guidance on the matter] was issued, the Office has registered hundreds of works that incorporate AI-generated material, with the registration covering the human author’s contribution to the work."
(I'm not saying that to mean "therefore this is how it works everywhere". Indeed, I'm less familiar with my own country's jurisprudence here in Germany, but the US Copyright Office has been on my radar from reading tech news.)
I like "Copy-lot".
type AccountName string
except you write it like (abridged) type AccountName refined.Scalar[AccountName, string]
func (AccountName) IsValid(value string) bool {
return accountNameRegexp.MatchString(value)
}
and that enforces an invariant through the type system. In this case, any instance of type AccountName needs to hold a string conforming to a certain regular expression. (Another classical example would be "type DiceRoll int" that is restricted to values 1..6.)But then you run into the problem with the zero value, where the language allows you to say
var name AccountName // initialized to zero value, i.e. empty string
and now you have an illegal instance floating around (assuming for the sake of argument that the empty string is not a legal account name). You can only really guard against that at runtime, by panic()ing on access to a zero-valued AccountName. Arguably, this could be guarded against with test coverage, but the more insidious variant is type AccountInfo struct {
ID int64 `json:"id"`
Name AccountName `json:"name"`
}
When you json.Unmarshal() into that, and the payload does not contain any mention of the "name" field, then AccountName is zero-valued and does not have any chance of noticing. The only at least somewhat feasible solution that I could see was to have a library function that goes over freshly unmarshaled payloads and looks for any zero-valued instances of any refined.Scalar type. But that gets ugly real quick [1], and once again, it requires the developer to remember to do this.[1] https://github.com/majewsky/gg/blob/refinement-types-4/refin...
So yeah, I do agree that zero values are one of the language's biggest mistakes. But I also agree that this is easier to see with 20 years of hindsight and progress in what is considered mainstream for programming languages. Go was very much trying to be a "better C", and by that metric, consistent zero-valued initialization is better than having fresh variables be uninitialized.
I think my question at this point is what about this is specific to LLMs. Humans should not be forced to wade through reams of garbage output either.
https://www.aljazeera.com/features/2025/6/27/putin-confirms-...
Charging a tip for to-go items is preposterous. When dining in, I will indeed tip, usually by rounding up to the next 5 or 10 euro increment for a group meal, or to the next 1 or 2 euro increment for single meals (e.g. during lunch hours near the office). But this is only if the service is actually good. If a restaurant makes me wait more than 30 minutes for a quick lunch, they will be paid exactly the amount posted on the menu.
And why is that? Should they not be interested in sharing the numbers to shut up their critics, esp. now that AI detractors seem to be growing mindshare among investors?
Yes. You correctly stated the important point.
This misunderstands why systemd succeeded. It included several design decisions aimed at easing distribution maintainers' burdens, thus making adoption attractive to the same people that would approve this adoption.
If a systemd fork differentiates on not having attestation and getting rid of an unspecified set of "all the silly parts", how would they entice distro maintainers to adopt it? Elaborating what is meant by "silly parts" would be needed to answer that question.
For extra flavor, const $$ = (selector) => document.querySelectorAll(selector) on top.
Why do random HN commenters have to come up with a business model for free LLM usage? If LLMs are so great, they should not need to offer a free tier at all. Surely word of mouth would make people line up around the block to snatch one of those highly coveted subscriptions.
[1] Before you ask, I'm not reading the full diff on something like x/sys. Mostly on third-party dependencies where I find it harder to judge the reliability of the maintainers.
Oh hey, it's my favorite pet peeve. When flagging a potential conflict of interest, the word is "Disclosure". "Disclaimer" means "I'm just a random guy who cannot assume responsibility for what they're saying", like in IANAL.
Context: This news story https://news.ycombinator.com/item?id=44180533
[1] Source (2024): https://zbir.deutschebahn.com/2024/en/interim-group-manageme...