Lego's original moat was their patent. This expired in the 80s, and so their new moat became their manufacturing tolerances. None of their competitors could match the quality of their product. This lasted until about the 2010s when clone brands in China finally caught up, and coincidentally, Lego's own quality started slipping. Thus, they needed a new moat, and the choice was obvious: licensing.
You're very correct but I suppose I was really answering why compilers centralize around SSA. It's a bold choice to choose one data structure for everything, and that requires more motivation than, "it makes certain optimizations really easy". Because again, it makes other stuff harder.
>And going further with the sea-of-nodes representation just makes them all more powerful; I really do recommend reading Cliff Click's thesis.
We might have to agree to disagree on this one. I actually found sea of nodes to be a boneheaded idea. It makes one or two optimizations a little more elegant but everything else a huge pain in the ass. At least, that was my experience.
I like this article a lot but it doesn't answer the question of "Why SSA?".
Sure, a graph representation is nice, but that isn't a unique property of SSA. You can have graph IRs that aren't SSA at all.
And sure, SSA makes some optimizations easy, but it also makes other operations more difficult. When you consider that, plus the fact that going into and out of SSA is quite involved, it doesn't seem like SSA is worth the fuss.
So why SSA?
Well, it turns out compilers have sequencing issues. If you view compilation as a series of small code transformations, your representation goes from A -> B, then B -> C, then C -> D and so on. At least, that's how it works for non-optimizing compilers.
For optimizing compilers however, passes want to loop. Whenever an optimization is found, previous passes should be run again with new inputs... if possible. The easiest way to ensure this is to make all optimizations input and output the same representation. So A -> B is no good. We want A -> A: a singular representation.
So if we want a singular representation, let's pick a good one right? One that works reasonably well for most things. That's why SSA is useful: it's a decently good singular representation we can use for every pass.
The issue isn't an AI reading copyrighted code, the issue is an AI regurgitating the lines of copyrighted code verbatim. To be clear, humans aren't allowed to do this either.
And sure, nobody cares about your stupid binary tree, but do they care about GNU and the Linux kernel? Imagine someone trained an AI to specifically output Linux code, and used it to reproduce a working OS. Is that fair?