> The flip side, of course, is that you can have "picked the wrong license" if your intent was to force someone to do something.

Yes, for this purpose, copyleft is an example which forces everyone to keep the software and its derivative works free, and from history we know it's very effective. Nevertheless, I have some doubts on whether a copyleft-style acknowledgement license will effectively work in a similar way as we described due to some practical problems below.

First, it has no power on independent implementations. In the academia, if J. Random Hacker developed a new algorithm that solved an important problem and published under a free license, sequentially, all the relevant papers that come after that will acknowledge that "In 2020, J. R. Hacker, et al. developed the first....", even if what the paper shows in an independent research not directly related to the original. However, such acknowledgement can never be enforced using a license. This is not just a hypothetical scenario, earlier in this year, the first controversy on using FOSS without acknowledgement was the AppGet incident [0], which has received strong attention to the community. If my observation is correct, it's how the current discussion began. However, in this case, Microsoft didn't reuse any the original code from AppGet - WinGet was an independent implementation by Microsoft in another programming language and has no similarity to AppGet at the source code level. However, the accusation was that "WinGet works pretty much identical to the way AppGet works", in other words, it only served as an inspiration for Microsoft on its high-level architecture. In the academia, we certainly expect such inspiration to be acknowledged, on the other hand, an "attribution" license will have zero legal effect - If the proposed license cannot even address the prime controversy that triggered the entire discussion, what's the point?

Second, if acknowledgement is forced by a license, the license must be careful not to overspecify the acknowledgement requirement. A historical example of overspecification is the original 4-clause BSD license, which includes an advertising clause, "all advertising materials mentioning features or use of this software must display the following acknowledgement: This product includes software developed by the <organization>." It requires all promotional materials of a product to include an acknowledgement if a piece of 4-clause BSD software is included. Such a requirement is inherently problematic to integrators, distributions, and packagers, which are an important part of the community. For a distribution, it must acknowledge 1,000+ projects (even in a one-page poster) to comply with the license [1]. Thus, the copyleft-style acknowledgement license must include some forms of "escape" conditions to allow one to skip acknowledgement.

Examples: you can skip the acknowledgement if...

1. If you are shipping more than 10 programs simultaneously.

Failure mode: This requirement is too simple. A bad company will simply ship a bunch of packages to get a free pass. Thus, the conditions should be more robust if your intention is to force bad actors to behave in certain ways ("someone goes up against a company that seems to have lost its way morally").

2. If it's used in an unmodified form (LGPL-like).

Failure mode: If the original project has been forked by the community, the exception becomes useless again, and everyone has to spam acknowledgements everywhere. Thus, conditions of higher complexity should be used.

As you see, in order to avoid inadequacy of the license, and to prevent bad actors to abuse the escape clauses, I'm afraid that it's possible that these conditions can quickly become extremely convoluted and difficult to follow. Perhaps someone can come up with an elegant solution, but I'll remain skeptical until the solution is demonstrated.

Third, this hypothetical copyleft-style acknowledgement license would be incompatible with most existing copyleft licenses, namely GPL (unlike most pessimistic licenses, which are GPL-compatible), making it impractical in the larger established community. Traditional copyleft licenses, such as GPL-2 or GPL-3, explicitly forbids relicensing to prevent a bad actor from nullifying its the copyleft nature by additional restrictions. Since no additional licensing terms shall be added, any code under the acknowledgement license can never be used in a GPL'd project, nor can it use any GPL code. Even worse, multi-licensing, the traditional solution to this cooperation problem cannot be used - In the existing community, if cooperation between GPL and BSD developers are needed, the code can be explicitly dual-licensed or even triple-licensed to avoid compatibility problems, for example, Linux kernel has dual-licensed GPL/BSD code, and Firefox is available under three licenses. However, if multi-licensing is applied to a copyleft-style acknowledgement license, the license becomes useless and pointless to enforce, since a bad actor will simply select an alternative license.

In conclusion, I'm not sure whether a copyleft-style acknowledgement license is a good idea.

[0] https://news.ycombinator.com/item?id=23331287

[1] Worse, it won't be a problem initially, but only after most people had noticed this trend: they would want their acknowledgements too, and everyone would start adding advertising clauses, in the end - everyone spams all posters with credit and nobody gains any notability, it's kind of a tragedy of the commons. The only way to stop this problem is explicitly discouraging everyone from using this license, which is what has happened to the original BSD license.