Bond is not such a bad example, because he introduces himself as “Bond. James Bond”, not as “Bond. Bond James”. If he did introduce himself as such, then you’d be forgiven for thinking that his given name was “Bond”.

The problem is also not the short form of author names, which as you point out places the family name first, and which typically abbreviate the given names. The problem is that many sites will reverse that order when they render the full names. The solution is simply to allow the authors to specify how their full name should be rendered. This not a problem that is unique to scientific journals.

The full article is available here: https://archive.ph/1NGkF

See also https://shinesolutions.com/2018/01/08/falsehoods-programmers-believe-about-names-with-examples/

Looks like Bun 1.4 is out now: https://bun.com/blog/bun-v1.4

This breaks down when there are more than one SOURCE file, since each DESTINATION file depends on all source files. This means that $< will always be the first file in SOURCE. For example, if source contains the files 0001-01-01-some-file-name.md and 0002-02-02-some-file-name.md:

$ make -n
mkdir -p destination/0001/01/01/  
/bin/bash ./myscript.sh source/0001-01-01-some-file-name.md > destination/0001/01/01/some-file-name.md  
mkdir -p destination/0002/02/02/  
/bin/bash ./myscript.sh source/0001-01-01-some-file-name.md > destination/0002/02/02/some-file-name.md  

OP is probably better off using a scripting language to automate this kind of thing

EDIT: Fixed example filenames

But if you actually described this methodology in your PR, then it’d no doubt be closed immediately, based on the spirit of the rules rather than the exact letter of the rules.

Rules like these ultimately presuppose that the contributor is acting in good faith. Because otherwise the contributor could just lie about using an LLM. They don’t need to engage in rules-lawyering or jump through hoops to circumvent the rules

If you mean the “Sign in” button on the top right, then yeah, I’ve just been staunchly ignoring that. But it turns out that there’s also toggle to remove it, so now it’s gone!

It’s worth noting that there’s a single toggle that, to my knowledge, turns off all AI features in Zed. So if you do not object to the presence of this functionality, but simply do not want to use it, then you’re probably better off just sticking with upstream.

However, I’m not sure what you mean by “GitHub integration”, so that may not be covered. If you simply mean Copilot support, then that is also disabled by the aforementioned toggle

Obviously. It is, however, a good heuristic. The headlines that can be answered in the affirmative are very much in the minority

Betteridge’s law of headlines:

Any headline that ends in a question mark can be answered by the word no

You are not going to accomplish that using a random selection of textbooks. It doesn’t even look like there are that many textbooks in these piles. Realistically, you’d probably have better luck asking students taking intro-level courses to donate their old text books, or just pirating the textbooks you need

I’m guessing that the big books are old collections of scientific journals. Depending on the journal, you could have multiple of those tomes per year. These days scientists access journals digitally, so there’s little benefit to keeping the physical copies around in most cases

In practice, that would require buy-in from the apartment/house association board, since the average resident would be unlikely to care about whether or not the software was open source or owned by the association. Cost would likely be a more important metric for most members, and here a company that serviced multiple associations would likely have an edge, especially since they could also provide general support to the end-users.

If it did get approved by the associations members, then the board would then likely have to hire a third party do carry out the actual development. If you’re (very!) lucky, then one or more members might be willing to do it cheaper than a third party, but that would likely only last for however long they lived in one of the apartments or houses.

I would put this scenario down as possible in theory, but very unlikely to work out in practice. The vast majority of such associations would go with an existing (closed-source) SAS provider, since that would be a lot less work and since it would survive the constant turnover in such an association.

I honestly have an even harder time seeing how it would work out for OSS in general, since most software does not come with an existing organization, nor a community that is as directly invested as residents in an associations. For most projects, the work involved in setting up and managing such an association would greatly exceed the work involved in developing the software itself, which, similarly to the above, most of the users would not be able to contribute to

EDIT: A more plausible scenario for an house/apartment association, would be somebody setting up a company structured as a co-op and then recruiting multiple associations as co-owners/customers. Is that what you had in mind? Though that of course requires that somebody has both the funds and the interest to get it off the ground, which is unlikely to be an existing association

Both find and xargs are POSIX commands, so there’s something wrong with your OS if you are missing either, and find does not have an equivalent of -P. Granted, -P is an extension, but it is supported by GNU’s, OpenBSD’s, FreeBSD’s, and BusyBox’s xargs commands, and probably also by others, so it is reasonable to assume that it is available unless you are targeting some obscure OS

Here are a few random thoughts based on skimming the source:

• I’d advice againsts using -Weverything. Many of the warnings it enables are not very useful, and you are going to get a lot of them. And if you enable warnings, then fix them, or you’ll just miss it when your changes cause new warnings.
• A couple of your check functions may reach the end of the function without returning, if type is not on of the expected values. That is undefined behavior. One simple way to avoid this, is to move the common return out of the ifs.
• That const std::string type argument in the above functions should be enums, since you are just checking againts one of three fixed values ("name", "ext", and "date").
• Speaking of which, I can’t think of any situation where you’d want to have an const std::string argument. Either use a const reference (const std::string&) or a string_view (const std::string_view). The latter has the advantage that it doesn’t create a new std::string if you call the function with a C-string and it can be sliced cheaply.
• You have const std::string &df = df_str; in a couple of places, where df_str is a std::string passed by value. That is of course utterly pointless, and you should simply change df_str to be passed by const reference or as a string view.
• You define main with an int return type, but use std::exit to exit the function. Those std::exit calls could all be replaced with return, which does the same thing in main.
• Don’t do work before you need the results. For example, in check_type you perform two checks (saved as starts_with_dot and has_dash), that are not used if name == "name".
• Nobody who sees a function named check_exists would expect it to create a directory, so it should be renamed to something more descriptive. It is also redundant, since you already check that the directory exists in main.cpp via is_directory, but unlike that check check_exists doesn’t actually verify that the path is a directory.
• is_founded is Engrish

ls can be piped safely if you use --zero:

ls --zero *.txt | xargs --null -I {} mv {} /home/user/Documents

While the above is a pretty silly example, one reason why you might want to do this is that xargs has a -P/--max-procs argument, that runs N commands in parallel. So you could do something like the following to gzip four files in parallel:

ls --zero *.txt | xargs --null -n1 -P4 gzip

This is a bit simpler than using the equivalent

find . -maxdepth 1 -name '*.txt' -print0 | xargs --null -n1 -P4 gzip

Other git hosts are also getting scraped, and have had to implement counters because of it. For example, this is the kind of thing Codeberg shows crawlers. I’ve even seen people who self-host complaining about getting overloaded because of bots scraping their forge

For me, and a few other projects I checked, it only has non-GPL repos. But it also does not have everything that isn’t GPL, despite the repos being much older than the cut-off date. But it does have repos without a license, which they are simply not allowed to copy.

I wonder if those repos have been deduplicated, and one of the forks (on some other person’s account) is included instead. Unfortunately you can only search the first 5M records via the website, and I don’t have time to play around with the API at the moment, so I could neither confirm nor deny that possibility

If nobody owns the code, then then nobody can enforce the terms of the license it was released under, and free software under the FSF definition becomes impossible. All you have is public domain.

For example, a company could take the Linux kernel, modify it and distribute it with their gadgets. And they could simply not release the modifications they’ve made, as is required by the GNU Public License. But nobody would be able to do anything about it. Currently, copyright laws allow the people who wrote the Linux kernel to sue the company for breaking the license and violating the authors’ copyrights

Neither of those terms seem problematic to me; a plain reading would be “mostly” means more than half of the code, and “tolerated” would mean that the ban is not enforced on such projects. Of course, if you are already operating under the assumption that Codeberg is acting in bad faith, then it doesn’t matter what the terms of service says nor how they they might say that they interpret them.

It is, however, not surprising that their terms of service are subject to interpretation. That was already the case before they added these particular terms. For example, the Codeberg TOS already included a prohibition against “content that harms the reputation of Codeberg” before the recent changes. Codeberg simply added projects related to cryptocurrency as an example, when the ban was voted through. It is furthermore the case that most, if not all, terms of service are subject to interpretation. We are talking about documents describing human behavior, not machine code.

If this kind of thing is not acceptable to you, then your only real solution is to self-host

Banning “AI” is too broad and too shortsighted.

They haven’t done that. The actual terms are

You must not share projects that mostly consist of code written by “generative AI”-tools (including services such as Claude, OpenAI Codex). Such projects having an unclear copyright status (see requirements § 2 (1) 1 and § 2 (1) 3) and furthermore have little safeguards to ensure that they do not include harmful code (c.f. § 2 (1) 5).

See also their blog post, where they specifically mentions experiments as “tolerated”:

Side projects and experiments with little resource usage

https://mynoise.net/ is great if you want something non-verbal. I’m particularly fond of Dreaming Nautilus and Sleeping Dragon. They do have a paid tier with more soundscapes, but most of the time I just listen to stuff that’s in the free tier