HNHacker News
TopNewBestAskShowJobs

marcan_42

11,384 karma · joined December 5, 2017

submissionscomments
marcan_42··on I enforced the AGPL on my code (2020)
Are you arguing that creating a program that interacts with another program is "modifying it"? Because then essentially all software is a derivative work of everything else and the entire industry is one giant copyright violation.

Come on. You're grasping at straws here. That makes zero sense. It goes against everything we know about how software licensing works. It is extremely well established that interacting with software through stable, external interfaces does not constitute creating a derivative work of the software.

marcan_42··on I enforced the AGPL on my code (2020)
They could proxy access to an AGPLv3-licensed application, where such access does not convey copyrightable content. For example, consider a database server that puts up a banner with a link to the source when you open the connection. You could remove said banner with a proxy.

It actually doesn't have to be a second party in my opinion, I believe it'd be perfectly legitimate if it's the same party. I'm just using that as a more clear-cut example because otherwise things devolve into endless arguments about whether a judge would see it as good faith or not.

marcan_42··on Milky Way and Andromeda galaxies are already merging (2020)
The image is very nice, but the explanation of brightness is a bit confused:

> But, of course, the galaxy isn’t nearly this bright. You need a dark sky to see it, and, even then, it’s a barely visible fuzzy patch of light. In order to appear as bright as in the image above, the Andromeda galaxy would need to be closer. If it were close enough to look so bright, it would appear even bigger on our sky’s dome.

Things closer by do not appear brighter, they merely appear bigger. The Andromeda galaxy will never appear as bright as in that image, not matter how close it is. As things get closer they do, of course, cast more light on us, but that light also comes from a larger solid angle, which means when we look at them, the brightness (per area) remains constant. It's why your computer monitor doesn't look any dimmer as you walk away. It just gets smaller in your field of view.

This breaks down for pointlike objects, like single stars - anything small or far away enough to look like a point to our eye cannot get any smaller, so changes in distance are only apparent as changes in brightness. But as the image demonstrates, the Andromeda galaxy is much, much larger than a pointlike object to the naked eye, and so this does not apply (it doesn't matter that the individual light sources are pointlike stars here - for a galaxy they average out due to density, but even if they didn't, as individual points get brighter the space between them gets larger so it all still cancels out when we look at overall apparent brightness for the whole group).

marcan_42··on I enforced the AGPL on my code (2020)
> The simple solution is to make the program a quine - make it able to serve it's own source code. That way it will always be up to date!

Indeed! Unfortunately, the FSF isn't interested in educating users about this requirement and how to work with it (probably because it would make it plainly evident that the license imposes fundamental restrictions on how you can modify the software, making it non-free), and so almost no AGPL software out there actually does this :(.

I'd be a lot less uneasy about running Nextcloud and Grafana if they had this feature. At least it would make it a lot harder for me to accidentally violate the license by, say, misunderstanding whether any given file is technically source code (which triggers the AGPL) or configuration (which would not), or installing Gentoo packages that come with patches.

marcan_42··on I enforced the AGPL on my code (2020)
> Party 2 in this case appears to be in violation, serving a service without the offer.

If Party 2 has not made any changes to the source code, they have no obligation to make any offer under the license, since the requirement only applies to parties who modify the program. Party 1's obligations are not transferred to Party 2 when the program is. The license applies as written, there is no "carry-over" of state.

marcan_42··on I enforced the AGPL on my code (2020)
> should have modified it further to have the correct link, they are the ones that failed to comply with the copyright license terms for the version they run.

But by not modifying it in the first place, they avoid entering into any legal obligations to do so. See the problem?

> But the teacher copied a page of the book, gave it to his students for class, and then one of the students sold that page without permission from the copyright holder! Aha, the teacher has violated copyright". Which no court would ever hold to be true, even if a very literal reading of the law may be more murky.

Nope, the student is the one who violated copyright here, as copyright also controls the right to distribution, not just making copies. By making the sale, a copyright violation occurred. The teacher is likely safe under fair use, as you say.

If the teacher were to sell his original copy of the book, that would be legal under the first-sale doctrine: the copyright holder's interest in distribution rights for a particular copy is exhausted after the book was initially sold. But the interest in the right to make copies persists, and since the copy made for class was not sold by the original copyright holder, but rather only made and distributed under fair use, it is not bound by the first sale doctrine, and distribution rights are still controlled by the copyright owner (they re-appear when the copy is made). And hence, the student is in violation, as such a sale would not fall under fair use.

People love to throw around this idea that the law is all subjective and judges work off of common sense, but that's really not how it works. The law is incredibly detailed on these things and lawmakers aren't stupid. This is all written in the books. Yes, there is some leeway for good faith interpretations, but the legal system doesn't run on whatever the judge feels is right on any given day. This is all spelled out.

marcan_42··on I enforced the AGPL on my code (2020)
> But generally, the two party problem is solved by them needing to modify the source to remove the link to the source.

The idea is the second party does not modify the source, they merely prevent the link from reaching the end user. Since the second party isn't bound by that clause at all, there's no way this could constitute a violation per se.

marcan_42··on I enforced the AGPL on my code (2020)
Party 1 develops the software, and hosts it on an open endpoint that is not publicly advertised. Party 1 has met their obligations.

Party 2 hosts the software, and does so behind a wrapper that does not forward the source code offer (this doesn't mean a wrapper that does s/source code offer//; it could be a protocol converter, WAF, or any other number of things that could lose non-protocol-relevant data like a source code offer).

None of this demonstrates intent. In fact, I have ended up in the Party 2 scenario accidentally already (in my case I was both parties, but that was a a coincidence), as I ran an (accidentally) modified AGPL service behind another public server that used it as a backend. There was no source code offer at all to begin with, but even if there had been, the nature of the system involved would mean it would be pretty much impossible for that offer to percolate past the frontend and back to the external users, just the way the protocols involved worked, no explicit malice involved.

marcan_42··on I enforced the AGPL on my code (2020)
> You're so focused on the first sentence that you missed the one I've put in caps. Once you link to the program, you've created a modified work, which as it says plainly right there in section 9, you cannot do without accepting the license, which is a contract that tells you what you can and can't do with that modified work.

First, you're still refusing to read Clause 13 properly, because it clearly sets requirements for what your modified work needs to do, not what you need to do when using it.

Second, this still fails the two-party test, because obviously you could convey the modified version to another party and then they would not be bound by anything, and could evade any source code offer requirements in place.

I feel like we're going in circles here; I already made all of these points in my original analysis.

I also don't know why you're bringing up linking. Linking doesn't factor at all in any of the scenarios I'm talking about. I know how the (A)GPL works in that respect and am extremely familiar with this concept; you don't need to SHOUT IN ALL CAPS about this completely irrelevant point. The licenses are very clear in what constitutes linking, and merely running executable binaries and communicating with them does not, which is the situation we'd have with an offer-stripping reverse proxy. This is extremely well established in the free software ecosystem. You don't need to lecture me on how the GPL works; I am very familiar with it, agree with the consensus interpretations of GPLv2 and GPLv3 (and LGPL), and know all about the linking stuff. It is the AGPL I have a problem with, which does not change any of the requirements related to linking.

marcan_42··on I enforced the AGPL on my code (2020)
> The law would be more than happy to accept that there exists something that generates a link or git clone command to stand in as a distribution mechanism for the source archive which a competent practitioner could use to derive the program in question.

The requirement is for the source code for the corresponding version is what is advertised. The vast, vast majority of AGPLed apps do not have any automatic mechanism to match the currently running version to such offer; if there's an offer at all (which there often isn't, making all forks and branches violations unless they add it first), it's usually a hard-coded link, and then the onus is on the person making changes to first modify that link to point to their version.

Yes, there are technical ways in which you can make the AGPL work in a vaguely reasonable way, avoiding this problem by automating your way around it. And nobody implements them. If people understood these requirements and actually implemented those mechanisms, we wouldn't have this problem, and people would also be aware of just how special and non-free the AGPL is because it's imposing requirements on modification beyond what a free software license can.

I'm not saying it has to be a source code archive, but if it isn't a source code archive, then you'd better find a way for the app to magically know what git repo hosted elsewhere should be used as the source code offer link, and have it automatically update for any forks/branches and always stay up to date. Having an automatically generated local source code archive, or outright serving the source code of the currently live app (e.g. for interpreted languages) are the only sane ways I can think of of automating compliance with this AGPL requirement. Anything that points to another server or repo isn't going to stay up to date as people make changes, and then you're back to square one.

marcan_42··on I enforced the AGPL on my code (2020)
> The copyright holders of the code will not care if someone forks their code, updates it, doesn't update the link, contributes back, and has zero users.

You're correct, but the whole point of licenses is having them work as intended. We don't run the free software ecosystem on goodwill and "I don't care if you violate my license as long as I like what you're doing". Licenses exist for a reason.

> If there are 0 users of my modified version, I have offered a link to "all users".

My reading of that is akin to "all potential users", as implied by the requirement being on what the modified version does; the code itself can only affect potential users since it has no idea of what actual users may or may not eventually exist.

marcan_42··on I enforced the AGPL on my code (2020)
> Your two-party scenario displays intent to interfere with contractual rights.

Only if those two parties actually colluded with that intent, and you can prove it.

Personally, I don't want to be on the hook for proving this kind of nonsense in order to enforce my license. If I cared about SaaSification, I'd much rather use an outright EULA that forbids it and cut out all this nonsense of pretending you can solve the issue with a free software pure copyright license.

marcan_42··on I enforced the AGPL on my code (2020)
> It is a violation of copyright law to make a modified work without permission

Hence why I keep speaking of the time when you make changes to the code.

> and the permission here is a contract: the license.

Which in this case is a pure copyright license, and therefore has no impact on how you use the software, by design, because its requirements only apply to modification and distribution. Look up how the AGPL was created. This was a concern and precisely why they did the bizarre modification-time wording that I keep pointing out.

> What you are suggesting would then violate that contract by using that modified version in a way contrary to the license granted for its modification.

We have a word for licenses that impose usage restrictions. They're called EULAs. They violate Freedom Zero and are not free software licenses.

The AGPL is not an EULA, though it tries its hardest to look like one with that clause.

I honestly don't even care that much about people choosing to interpret the AGPL in this way; I actually used to think like you, until I re-read it enough times to really understand what's going on. You're arguing that the AGPLv3 is a nonfree EULA that actually works as anti-SaaS. I'm arguing that it's a nonfree non-EULA that doesn't work. In both cases, it definitely isn't a free software license that actually works as anti-SaaS.

marcan_42··on I enforced the AGPL on my code (2020)
> You setting up a reverse proxy doesn't mean that users suddenly aren't "interacting with" the program.

That doesn't matter, because again, what the clause actually says is:

> your modified version must prominently offer all users interacting with it remotely through a computer network

If the version, as modified, makes the offer, then you have met your obligations at the time of modification. The AGPL is out of the picture after the modifications are complete, as it is a copyright license, not a usage license. The clause triggers when you modify the software - adding the reverse proxy in front does not modify the software, and therefore the clause does not apply at that point.

If your argument is that you are still bound by that requirement after the modifications, then all AGPL software authors are in violation of the license, at all times, since it would imply that the AGPL requires everyone who makes a modification to AGPLed code magically ensure that it always offers its source code to users, in all execution environments, no matter what reverse proxies are in front, operated by anyone, which is, of course, impossible.

> Notice what it doesn't say. It doesn't say it has to be offered over the exact same protocol.

If your users interact with the software via a certain protocol, then the offer obviously has to be made over that protocol, because there is no other way to make the offer. If I run an AGPLed DAW and hand a MIDI keyboard to a friend to play on, they are now a network user of the software, and the only way for them to be offered the source code is over that protocol. Of course the actual source code exchange could happen over a different protocol, but the offer has to reach the user (and prominently, as the clause requires) and that's not going to happen if you make the offer over a protocol the user isn't even using!

marcan_42··on I enforced the AGPL on my code (2020)
> If you put a reverse proxy in between you (serving the code) and the user of the software with the intent of disrupting any serving of the code, you are not in fact making the code available. Hence, you can't claim to be meeting your obligations under the license.

As I explained, your obligations under the license are as to what modifications you make to the code, not how you run the code. This is both explicit (if confusing) in the wording of the clause, and implied in the AGPL being a pure copyright license, and has been confirmed to be the intent by people involved in authoring the AGPL.

You are misinterpreting the license because the FSF has endlessly marketed it as something other than what it is, and so everyone thinks it actually restricts usage (while simultaneously thinking it's a free software license, which is impossible if you know how free software is defined), and so everyone loves to make this "a judge would not let this kind of clever workaround fly" argument. Unfortunately for everyone, judges look at the text of the license, not the FSF's marketing, and the text of the license does not say what the FSF's marketing implies.

marcan_42··on I enforced the AGPL on my code (2020)
Indeed, which is why ad blockers are legal. And thus, it follows that my interpretation of the two-party scenario is also correct, because similarly to the user running an ad blocker, the person running a reverse proxy has nothing to do with the licensing requirements imposed on a different person who modified the code.
marcan_42··on I enforced the AGPL on my code (2020)
> You're committing the same fallacy as a lot of software people: thinking that the law is a rigid computer program. Contracts are not executed like computer programs.

"Contracts are not executed like computer programs" doesn't mean you get to interpret contracts however you want, ignoring what is actually written. When I was working at Google, I had an argument with Chris DiBona about open source contributions that ended up with him banning me from that process, and telling me to "go to employment legal". I instead went back to my employment contract, and found that the wording was subtly screwed up; they got the Boolean logic wrong when transcribing wording sourced from California law into an Irish contract, and ended up turning an OR into an AND. And that meant I could contribute to open source in my free time at home with no worry of Google owning my code, so I did, and I'm absolutely confident no Irish judge would say "oh, you see, your contract says one thing, but clearly what Google meant was what's written in California law and so you're in violation". What matters is what's written down, not whatever the person writing it thought they were writing. This wasn't a case of a typo or an obvious correctable mistake; this was a change in the way the requirements for a clause applied, clearly with a different meaning from the original text, with no room for error. Whether it was an intentional change or not is not my problem.

If you dig deep enough into the history of the AGPL, you will find that not only am I right in my interpretation of it as a copyright license that applies to modifications, but that this was all completely intentional and amounts to a clever hack to try to give EULA-like powers to a non-EULA license, because the FSF knew they couldn't pass off an outright EULA as a free software license. And, like most clever hacks, it doesn't work properly in all cases, and the workaround I described is completely legitimate. And it's still nonfree, because instead of violating Freedom Zero it violates Freedom 1 (but they got that one to pass by without most people noticing, it seems).

marcan_42··on I enforced the AGPL on my code (2020)
> The requirement is not just for modifying code strictly. It's for offering the resulting program to users.

This is the same misunderstanding everyone makes, and that the FSF wants everyone to make.

> your modified version must [...]

You are not required to offer anything to users. Your modified version is required to offer the resulting program to users. The requirement is confusingly worded, probably deliberately, but what it actually requires is for there to be a mandatory feature in your modified version such that it itself offers the resulting program to users. You are required at the time of modification to ensure that your modified version, at the time of execution, makes that offer (as part of its code).

Yes, this is hideously unclear, but that's what the text really says. The requirement is on you at the time of modification (also implied by this being a copyright license), and that requirement is for the modified version to work a certain way.

I can't find the link right now, but IIRC legal analysis including people involved in authoring the AGPL has confirmed that this indeed was the intent; they didn't want to put in a restriction on usage (because Freedom Zero), so instead they came up with this cute (and broken) hack that applies at modification time. Unfortunately, they conveniently forgot to mention this restriction violates Freedom 1 instead.

> If I fork an AGPL project to contribute to it, modify the code, but don't actually host the modified resulting binary anywhere, I see no issues here.

By modifying the code, you have invoked the clause of the license that you quoted. If your modifications do not include a functional change to the code, such that, if run, it offers the resulting program to its users, then you have violated the license.

> Similarly, if the project is well built, for example if the build process in the repo builds a binary that includes the output of "git archive" to serve, that link will always be up to date for any build, so you don't even have to update anything to start hosting a fork of it.

Correct. Almost no AGPL project does this. It is the only way to remain compliant with the license and still have a sane development process, but nobody gets that. Indeed, this is the only situation where using the AGPL does not impose an undue licensing burden on developers, and it sucks that, as part of trying to sell the AGPL as magic anti-SaaS pixie dust, the FSF has obfuscated this, and pretty much nobody is actually putting this feature into their AGPLed app build system, and thus causing everyone collaborating on those AGPLed apps to violate the license every time, because if this feature isn't in place already it becomes the burden of every single contributor.

> In your (linked) comment about the AGPL, you seem to be arguing that just forking and modifying the source code violates that specific clause.

It does, unless you first implement that `git archive` feature, and then make your desired changes. Which, as I said, nobody does.

> That is what you're arguing, right? Why would that kick in if you change the code but don't actually host the service in question where users can interact with it over the network?

Because, as I said, the clause is really all about what kinds of modifications you are allowed to make and what would happen if users interacted with it over a network - that doesn't have to actually happen.

marcan_42··on I enforced the AGPL on my code (2020)
The FSF has long since ceased to listen to anyone. Stallman hasn't changed his views one iota in the past 20 years, on any issue, even ones where he's obviously wrong. I've even emailed him personally; he stopped responding after the second email. That one's been a lost cause for a very long time. Many people have tried.
marcan_42··on I enforced the AGPL on my code (2020)
It would be a lot more helpful if you explained the reasoning behind your understanding, instead of just making an unsupported statement.
marcan_42··on I enforced the AGPL on my code (2020)
> Hmm I would be unsurprised a judge interprets the writing/configuring of a reverse proxy that modifies the HTML output or blocks access to some pages to be the same thing as editing the AGPL code yourself.

That would mean anyone using an ad blocker (or any other userscript) on AGPLed websites is in violation of the license too.

This is actually a very complex legal issue, because HTML can be copyrighted, and so making changes to it can be subject to the license. It's why I mentioned that web apps can conceivably benefit from the AGPL in a somewhat reasonable way if they self-serve their own source code, to sidestep the AGPL's anti-developer aspect.

But for something like MongoDB, where the protocol does not convey copyrightable portions of the software? Doesn't work. The AGPL is out of the picture by the time the bytes flow out of the server.

marcan_42··on I enforced the AGPL on my code (2020)
You're presupposing I oppose the principle of anti-SaaSification. I don't. I understand the problem and why some people care about it. You don't want big corporations to host and sell access to your code without contributing back. I get it.

What I oppose is what the FSF does, which is mislead people into thinking this is achievable within Free Software without making deep fundamental changes to what Free Software means. And I especially oppose the AGPL for its utter brokenness and unsuitability for almost any purpose.

> You can try and use terminology like “EULAs” to liken them to big corporations that restrict usage

That's correct terminology though. I'm not trying to use scary words to be scary. That's literally what EULAs do. If it sounds scary it's because it is a deep change to how a license behaves and people need to be aware of that.

If you want to release your software under an EULA that prohibits SaaSification, I have absolutely nothing against you - more power to you! It's your software. I have nothing against proprietary software either, I use it every day (though I prefer free software where possible, for a multitude of reasons).

Just don't try to hide the fact that that choice of license makes it non-free.

In fact, I'm a lot more reluctant to use AGPLed software than lots of proprietary software, because the AGPL is worse in that it pretends to be a free software license, giving you the code, and then sets up a landmine for anyone who actually makes a change to step on, and it has been marketed in a way that confuses everyone involved. As I mentioned in the reply to my analysis comment, I already accidentally violated the AGPL once because I ran a script that unknowingly patched some AGPL code without following the terms. If the code hadn't been there to begin with, or the AGPL had been correctly recognized as non-free and thus not amenable to such patching, that wouldn't have happened.

marcan_42··on I enforced the AGPL on my code (2020)
> I also do not understand why "you need to share the source when you expose" is apparently so much worse than "you need to share the source when you distribute".

Because distribution is an act controlled by copyright, while usage (which includes exposing) is not. That Free Software licenses are pure copyright licenses is a fundamental tenet of Free Software (which follows from Freedom Zero). We call licenses that restrict usage EULAs. You know, like the Windows license.

Thankfully, the AGPL isn't actually an EULA. In turn, it doesn't effectively accomplish its goal of avoiding SaaSification. Instead, it tries to work around this fundamental issue by imposing restrictions on how you can modify the code instead, therefore making it not Free Software, since such restrictions violate Freedom 1 of the Free Software Definition. Kind of like some of those weird nonfree "shared source" licenses.

marcan_42··on I enforced the AGPL on my code (2020)
> That's why the author used the AGPL, which requires you make source code available to users who interact with your service.

It doesn't, though. That's just the PR the FSF wants you to believe. What it actually does is require you to add a feature to the app to serve or link to its source code if you modify it. If you don't want to actually give your users the source, you can just stick a reverse proxy in front that removes the source code offer. The AGPL is powerless against that.

Conversely, it means every time someone forks an AGPL project on GitHub and pushes a commit, they are in violation of the license unless they first change or add the source code offer feature and point it at their repo. The AGPL is extremely difficult to comply with for normal Free Software developers, and doesn't actually protect your rights since it can be worked around. It's a horrible license and nobody should use it. I linked a deeper analysis of it in a top-level comment.

marcan_42··on I enforced the AGPL on my code (2020)
Only because the company in question didn't actually read the license. Read my analysis to see how broken it is.

This company likely violated the AGPL (as it is doubtful they followed the source offer requirement when modifying the code) - in the same way as 99% of third party AGPL project contributors violate the AGPL on a daily basis, every time they make a change on a GitHub fork. It's a horribly anti-developer license. But if this company had wanted to modify and host AGPL software legally, without providing source, there are workarounds they could've used, as I explained.

marcan_42··on I enforced the AGPL on my code (2020)
None. For better or worse, stopping people from using (which includes hosting for third parties) your code without publishing the modified source code is incompatible with the Free Software Definition.

Any discussion around what a license trying to solve that problem should look like needs to start by accepting that fact, and going from there. Either we change the Free Software Definition, or we accept that such licenses can't be Free Software licenses. There's no magical solution that satisfies both. You can't have your cake and eat it too.

marcan_42··on I enforced the AGPL on my code (2020)
Yet another example of someone who doesn't understand the AGPL and how it doesn't work to protect your (or anyone else's) rights. It really is an utterly broken, non-free license. I've written about this in the past (read the topmost two replies too):

https://news.ycombinator.com/item?id=30044019

In fact, the author of this article claims to quote the AGPLv3:

> If you run a modified program on a server and let other users communicate with it there, your server must also allow them to download the source code corresponding to the modified version running there

But that is absolutely not the text of the license. You can check for yourself. That's not how the paragraph is worded at all. If that were the text of the license, it'd be a non-free EULA, since that wording imposes a restriction on usage, violating Freedom Zero.

Instead, the AGPL is a non-free copyright license because it violates Freedom 1, by instead imposing restrictions on modification, as I described in the analysis I linked above.

I really wish the FSF would stop pushing this nonsensical license and misleading everyone into thinking it does things it doesn't. Their PR around it absolutely does not reflect the actual wording and consequences of the license. It's deceptive and harmful to the free software ecosystem.

marcan_42··on Moving the Linux Kernel to Modern C
It's obvious that the hack would work on a technical level, that's fundamental to the whole idea. The question is how complex the logistics of doing it in the real world would be; how you insert the tampered code, how you avoid anyone noticing, etc.

For example, I run Gentoo Linux, and haven't reinstalled my OS since 2004 or so. That means that, modulo a few binary packages, I have a direct source lineage to the state of Linux in 2004. If you want to pull off that attack against my system (and you didn't already back in 2004), you'd have to tamper with source archives. That would both imply changes that are easy to analyze (more than binary patches), and it would involve changing the archive hashes in the Portage tree. That tree is in Git, which means that it would create an immutable public record of what happened (Git is the original blockchain, remember), modulo forced pushes which people would, again, notice all over the place.

In practice, if you want to persistently backdoor a new system (supply chain attack), it's usually easier to do that in hardware or firmware than trying to do a RoTT attack on the distro and its compiler. In fact, it's users of binary distributions (or proprietary OSes) that should be more worried, as it is much easier to do a binary-based RoTT attack that self-updates to handle new versions consistently when all your users run the exact same binaries. Source code users should be more worried about compromise upstream than local persistence. And those attacks are a review / auditing issue, unrelated to RoTT.

In the end, if you are worried about being personally targeted, it's easy enough to make that impractical by re-bootstrapping your computing from an unpredictable source (e.g. walk into a random shop and buy a PC, walk into a net cafe and download your favorite distro and check the hashes there). And if you are worried about large-scale attacks, RoTT style ones aren't practical without someone somewhere noticing; you should be worried about traditional compromise instead.

marcan_42··on Moving the Linux Kernel to Modern C
Linux has a checkpatch.pl. If it doesn't already test for Unicode identifiers, it would be trivial to add that. This is a non-issue. You don't ban a new version of a language just because it allows some undesirable things; it's trivial to ban those things specifically, either with scripting or specific compiler option overrides.

Heck, Linux already uses GCC plug-ins to implement some fancier security stuff; it is silly to think they can't handle forbidding Unicode identifiers.

marcan_42··on Moving the Linux Kernel to Modern C
Linux already uses a lot of C99 features that were GNU extensions before C99, like designated initializers. So in practice, Linux is already C99, and hasn't been buildable on strict C89 compilers in a long time.
← PreviousPage 4 of 34Next →