Disclaimer: I'm not an apple employee and not am not lawyer, this is just my understanding of the situation having spent lots of time talking to lawyers and other experts about this:
I agree with much of the sentiment that software patents are often silly and the system is broken in many ways. This patent is a reasonable example of that (patenting syntactic sugar for monads, really?). I have no idea if there is prior art, but I wouldn't be surprised. For sake of discussion, lets assume the patent is valid.
Even if I and others don't like it, the software patent system exists. As is pointed out upthread, one of the major reasons that Swift uses the Apache 2 license is to provide more certainty for the community w.r.t. licensing and patents. An additional bonus of the Apache 2 license is that the open source project as a whole benefits from companies having and contributing their patents under the terms of the license: to say more directly, it is good for the Swift project that Apple has this patent and has contributed it to the project.
The reason for this is the Apache patent revocation clause 1, the end of bullet 3:
>If You institute patent litigation against any entity (including a cross-claim or counterclaim
in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes
direct or contributory patent infringement, then any patent licenses granted to You under this
License for that Work shall terminate as of the date such litigation is filed.
This basically says that if someone sues someone else over Swift then they lose access to the patents contributed to the project, and are therefore subject to countersuits. This is a significant part of the protection that the Apache license provides (it is a big deterent to lawsuits in general) but it only has teeth if there are actually patents in play!
The LLVM.org community is actively working on a multi-year relicensing effort specifically to achieve these sorts of projects for LLVM as well.
Am I misreading this to mean that if Apple sues someone for infringement over the patents they have been granted, they immediately lose those patents?
The reason it doesn't matter is because of this:
"then any patent licenses granted to You under this License for that Work"
As the owner of the patents, Apple doesn't need this license to have rights to those patents. They have rights otherwise.
Now, it would terminate the rights they have to other people's patents under the license.
(IE if a contributor submitted something the contributor owned a patent to, apple would lose rights to that patent)
For example, with Swift, IBM is a major code contributor and runs significant portions of the project. IBM is one of the largest patent holders in the world. If Apple and IBM ever had a patent dispute involving swift, wouldn't that naturally lead to attorneys scrutinizing every other similarly licensed open source project to find an angle against each other or their partners? Wouldn't that then lead to other companies getting drawn into the dispute? And once the gates are opened, any long-simmering patent issues would be easy to add... affecting more projects and companies...
What would have happened if the Microsoft/Google/Android dispute involved Apache 2?
IANAL, but these boilerplate patent-agreements-in-open-source-licenses seem scarier than just leaving things ambiguous.
A) give some chunk of your profit to someone else while you
B) reallocate development resources to invent something new that lets you keep doing business without relying on the patent
In the end, B) is valuable and A) costs money and they probably cancel out, financially.
Also, has anybody noticed that every single language in existence borrows features from some other language FOR FREE? If all languages started patenting their features then we soon will be completely boggled with lawsuits or unable to invent new, better languages as they will not be able to use already established convenient features.
There are only this many simple convenient ways to denote programming language features. There is limited number of single character operators and ways you can organize them. Granting patents to single characters is just stupid.
This is wrong. The license says:
>3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted.
'Each Contributor heareby grants to you, ... licence ... to use ... the Work ....'
However, I am very much not a lawyer. Like Chris, I do talk to IP lawyers as part of my work.
> Am I misreading this to mean that if Apple sues someone for infringement over the patents they have been granted, they immediately lose those patents?
You in this case is likely a defined term with a narrow meaning and likely does not refer to Apple (which is probably referred to as We, Us, "the company", etc) in the document.
Since Apple has received the patents, not through the Apache 2.0 license, but from the USPTO, they would not lose access to those patents should they sue for infringement over them. IAMAL, but it seems like there still might be a case to be made for Apple's use of Swift to be covered through the Apache 2.0 license.
It seems like the most logical explanation of this whole thing is that Apple wants to ensure that all users of Swift are free from litigation. To do so, they used the Apache 2.0 license to cover the code. However, the license requires there to be patents that exist, so that enforcement clauses prevent trolls from being granted a patent and then going after users of Swift. So, Apple filed for some patents that cover aspects of Swift.
Looks like an implementation of a compiler not from Apple (that is, not a fork, or one that diverged too much from the original) or different languages that overlap with the patent would be infringing even if they used Apache 2.0 as well.
Monad Maybe where
Nothing >>= _ = Nothing
(Just x) >>= f = f x
( https://docs.swift.org/swift-book/LanguageGuide/OptionalChai... )
The second one linked is a package manager — https://patents.google.com/patent/US9329841B2/en?oq=9%2c329%...
The third one is "a programing language that combines elements from C and Objective-C", sounds like a broad claim on swift — https://patents.google.com/patent/US9329844B2/
1. A non-transitory computer-readable medium with instructions stored therein, the instructions, when executed by a processor, cause the processor to perform operations comprising:
receiving a first request to compile a first set of program instructions coded in a first high-level language, the first high-level language a C language based object-oriented programming language;
receiving a second request to compile a second set of program instructions related to the first set of program instructions, the second set of program instructions coded in a second high-level language including object-oriented elements and procedural elements, wherein the second set of program instructions includes a data type provided by the second high-level language to indicate absence of a value of any type;
compiling the first set of program instructions and the second set of program instructions using a modular compilation system including multiple front-end compilers, the first set of program instructions compiled into a first intermediate representation of the first set of program instructions and the second set of program instructions compiled into a second intermediate representation of the second set of program instructions;
linking the first and second intermediate representations; and
compiling the first and second intermediate representations using a back-end compiler that is specific to a target processor.
Edit wrt edit in parent: all three of these claims apply to Rust.
That said, I think there are other languages with very similar syntactic sugar (e.g. Rust), so this is still a very questionable claim.
In that case, whether the patent is valid or not doesn’t matter.
Or, it's in your interest to fight and make it as expensive as possible for the person making the claim to prosecute it, if you have a good case, because while it's an iterated game, not a single round, and you need to make sure the next however many potential trolls (whether the same with a new claim or a different one whose seen how you react) don't try to shake you down.
To quote Kipling: “But we've proved it again and again, / That if once you have paid him the Dane-geld / You never get rid of the Dane.”
It might be worth a couple of rounds of letters saying "we don't believe your claims to be valid", but if the aggressor continues into litigation, the legal fees can quickly become overwhelming. As in more than the defendant's business is worth.
Individuals writing open source software (such as compilers) have no chance, as most of them are not wealthy, and their personal assets are on the line.
If you're unluckly enough to be in the situation the parent describes, where an aggressor will keep coming for more if you capitulate on the first one, there's probably no way to win. Sometimes the rational action is a painful one: Completely shut down whatever it is you're doing, and find something else to do instead.
I'm familiar with projects that have shut down, some having been published and then (sadly) removed from public availability, over patent issues where it wasn't clear the aggressor's claims had merit, but they couldn't take the risk. Several in fields I wanted to work in.
The effect I see is development paused for a decade or two until it's safe to resume.
I suppose you might find a "no win, no fee" lawyer, but are those common in this situation?
Sure; the hypothetical was “if you're a company”, not “if you're a much smaller company”. Power assymetry definitely affects the options here.
it is a non-profit corporation, but still a corporation. Whose life depend on donations from the owners of the other languages you compared julia against.
Plenty of technologies get hyped up by companies and later on bent out of shape or dropped.
Apache license don’t say anything about clean room reimplementation under other licence because it’s a tricky subject beyond the scope of the license. I personally think that if someone reimplement Swift, name it Schwift, guarantee it’s 200% faster (for some reasons), and then sell commercial licence of that it should be sued (but with such business plan I believe he’ll go bankrupt first).
Apple logically won’t comment on what they will do in case of a "clean room" implementation because they have zero interest in anybody doing such a thing.
And actually nobody have any interest in such a monstrosity (except maybe for theological reasons?). The project is goddam Appache2, fork it if you want, but spending any second trying to reimplement years of works is a total waste of time. Want to start something from scratch? Fine but do something original. Want to improve swift ecosystem ? Fine but work on the main project or on a clean fork!
Also, I'm convinced that many many people do have interest in this. Many people were interested in GCC existing in parallel with whatever other compilers were available. Heck, Chris Lattner's Clang wouldn't exist if C and C++ were "protected with patents from patent trolls". Are you saying that all these alternative compilers were a total waste of time?
Should? What rule, law, or moral code does it break to reimplement something?
Like you, I would have a pretty hard time being convinced that this was actually a good idea, though.
> Apache license gives the right to use patents required to use the code (assuming the original author had those rights), and the code implementing optional chaining in the compiler is Apache licensed. So, the only thing Apple having a patent on optional chaining does is to stop frivolous suits from patent trolls. It can't be used for any kind of nefarious power play by Apple, which is what OP was worried about.
By patenting this language feature Apple has very clearly stated that they are "making a claim of ownership" as it were of this feature across all languages and non-derivative implementations.
...which is a perfect example of why software patents shouldn't exist in the first place. One could implement this feature in any number of novel, unique ways therefore the patent is nothing more than a claim on a broad concept rather than a specific implementation (which is what patents are supposed to cover).
The paradox of patents on software is this: If the patent covers what it's supposed to cover (a specific implementation) the patent will be useless because anyone could implement what amounts to the same thing using different methods, languages, whatever. If the patent covers a broad concept it will prevent anyone from using it or innovating in that entire domain until the patent expires. Completely defeating the purpose of having patents in the first place. It will also likely (after millions upon millions of dollars wasted in lawsuits) be ruled invalid as being overly broad.
Software patents are inherently a bad idea and should be done away with.
They're about innovating technological abilities, and disclosing them in exchange for limited monopoly; it's not about specific products or specific implementations.
If it were just about implementations then all patents could be easily circumvented and there would be no reward in exchange for the full disclosure of a new invention.
(Design patents do cover specific implementations at the morphological level.)
This patent is about how Apple's compiler implements some programing language features. It does not protect the programming language feature itself. Another compiler that employs a different 'how' can implement the same programming feature. So, if you don't want to infringe on this patent, you are forced to invent (or use) another way of doing the same thing.
Mechanical devices need patents for the design, as a competitor can easily re-implement an absolutely identical design. It's often clear by inspection how it's made. A different device that accomplishes the same task in a slightly different way doesn't infringe on the patent.
Software already has protection against identical copies through copyright. The key difference is that software patents go farther; they claim to cover the concept. Any implementation of the concept violates the patent. Re-implementing software to accomplish the same mathematical concept in a different way still violates the patent.
idea: superhuman who flys around saving people
alternative expression: ultraman
both protected respectively by copyright (imagery, stories, movies etc)... do they also need patents?
i think the answer here is “no” and it’s the same for software... but again, please correct if i’m missing something
Yes, yes you can.
While I'm sure that you can find examples of software patents that have patented a specific implementation of a given idea, you can also find mechanical patents that claim a broad concept. These patents exist for two main reasons: 1) They discourage competitors from attempting anything within the broad concept. Even if a judge would probably rule a patent unenforceable, the risk of litigation is enough to make legal departments recommend against doing things that are covered by the patent. 2) They give companies ammo when they do get to litigation. If Company A sues Company B for infringement on one of its patents, Company B can come back and countersue because it holds a large war chest of other broad patents. Even if most of them are unenforceable, each one poses its own risk that some part of it is held up and the infringing party is liable for damages. The quantity of patents involved (and the legal costs for litigating such a case) help push companies into a quicker out-of-court settlement.
The problem as I see it is not with software patents versus mechanical patents. It's with broad patents versus specific patents. There needs to be a mechanism for easily challenging the validity of a patent after it is issued.
Edit: For context, I'm a mechanical engineer who's worked on design & development of technical consumer products.
Patenting software amounts to patenting algorithms, which is basically patenting math. It's far broader in scope by its very nature. On top of that, it's not hard to get software patents on things that are obvious, often by simply patenting "$well_established_process, but in software".
(There really is no such thing as a software patent.)
A smaller company could come up with a unique engine design, but without patent protection, a bigger company could just drop by and take the design and build it themselves. In other words, the larger company would get R&D "for free". In the engineering world, only by "building" the design can you make money (in general).
So without patents, there would be no reason for smaller companies to exist, simply because such companies would have no counter-measure for their lack of financial resources.
: Nothing here means "no physical resources". The big costs would be labor and compute (depending on the idea). But I would argue that labor is a bigger cost for a company that would like to build an engine at scale (initial design, manufacturing, testing, supply chain, and so on).
So that might actually be an argument in favor of software patents, if they actually did protect the interests of small companies. Unfortunately it's almost impossible to implement a new idea in software without using a lot of other recent ideas at the same time, and if all the recent ideas are patented, no one will be able do anything that isn't 20 years out of date unless they have a defensive patent portfolio of their own.
Marketing budget is something inherent in small vs. big companies in all industries, so I do not agree that the fact that software and hardware share this makes them similar.
Your example does demonstrate a benefit of software patents in theory, but is this how they are typically used in practice?
So, I invent a method that dramatically improves search engines. How do I commercialize it for “nothing”, if I’m not one of the few companies with access to a huge data set, and cannot protect my invention with patents?
And yes, there are definitely exceptions, but my point is that the general case in software != the general case in engineering, which is why you cannot directly compare the effect the patent system has on the two fields.
No. The Apache License 2.0 does not work that way. You are allowed to copy and use everything in the Swift language to your own liking in a similar manner to the MIT and BSD permissive licenses. However if you then try and begin a lawsuit against Apple for anything in what you copied, your rights are terminated, therefore invalidating your suit. The Apache License also gives you access to the patents in the language. It's a bit of a hack like GPL is, except that you are allowed to do just about anything with the code except sue.
The license, at least the way I see it, is a signal that Apple isn't in the business of patenting language features. In fact, in a way, Apple is using their resources to gobble up space that patent trolls can never again exploit. Once a patented feature is released under Apache 2.0, I know of no way that it can be undone.
So if you implement the claims of the patent in something that isn't derived from the Swift code you are not covered under The Apache license.
It is a purposeful limitation of the Apache 2.0 license that the "patent pool" effect is limited to the project.
If someone makes a from-scratch implementation of Swift, or any other language with similar features, can Apple then sue them over these patents? Or does AL prevent this?
> If someone makes a from-scratch implementation of Swift, or any other language with similar features, can Apple then sue them over these patents?
Yes, Apple can sue you for making use of their patents w/o a formal license in place!
> Or does AL prevent this?
No! The Apache License protects users who use code from the project in question, but does not allow you to use those patents for other purposes.
To give a parallel example:
I license a photograph of two kids in overalls to put it on a poster and sell it.
That does not give me permission to use that image on playing cards, porcelain dolls, or other avenues.
Any number of people could try to sue you for any number of things. Thats unfortunately how lawsuits work.
You could also attempt to get another license from Apple for your work. They might not be willing to do this unless you somehow could guarantee all patent licensees for your version of Swift would be unmotivated (by some legal clause or agreement) to sue them as well.
I doubt Apple would go through the work of getting a patent for something that they already openly give out licenses for people to use (via Apache 2) unless it was meant purely for defensive purposes. So I'd be shocked if they went after a from-scratch Swift implementation except for trademark purposes (aka, you can't call name it Swift if it is a partial implementation)
This is not, by itself, a bad thing. In fact, it's good.
However, is there any way Apple could change their minds in the future and start wielding the patent against others? To me, that is the danger of granting patents even to people who appear to be acting as a good guy.
Companies that are mere consumers of IT have been sued by patent trolls, and paid up.
Also, "using Swift" isn't in the claims ¯\_(ツ)_/¯
When drafting the claims writer (patent attorney or agent usually) will add clauses to work around prior art. You can't just add unrelated features though, the features need to have synergy to represent a single invention.
[I've read a lot on USA patents but only worked directly with UK and EU patents.
This is not legal advice.]
Not sure if that's in Rust, Kotlin, C#, or Ruby, or in Groovy's Antlr 4 parser.
That is, in Rust you'd use Option::map or Option::and_then, there is no equivalent to the `?.` and `?` operators, the `?` operator (or `try!` macro) is a shortcut for an "unwrapping guard".
x = [ foo: [ bar: 1] ]
x.foo.bar // 1
x.boo?.bar // null because x.boo is null
x.boo?.bar = 1 // succeeds even though x.boo is null
x.boo // still null
Patents protect how you something, not what you do.
The only special sauce I can think of is that C# also implements null-lifting for most operators in the language, which is not necessarily a good thing because it treats null as "unknown" rather than "missing" - e.g. a + b works on int?, and will produce null if either a or b is null. With Boolean operators, it's even clearer - false & null is false, true | null is true, but true & null is null, and false | null is null. But quite often this is not what I actually want! If null really means that the value is missing, then a + b shouldn't even compile for optionals. But in practice, I'd say that vast majority of all uses of Nullable are to denote missing rather than indeterminate values.
So if you fork Swift, you’re covered. If you don’t form Swift, then you’re not covered.
Note that the Apache license is much stronger / better than the PATENTS.txt files accompanying projects like those from Microsoft / Facebook, because those usually don’t cover forks and are designed to protect the parent company.
Nope. Prior art is the only protection against patent trolls. Patents are no protection at all against trolls because patent trolls are unlikely to infringe any of your patents, due to their sole business being patent litigation.
There are two reasons for Apple to get these patents: defensive and offensive patent litigation against other companies in the industry. Apple has a history of using offensive patent litigation, going so far as using it as a weapon to keep industry wages low. https://www.cnet.com/news/steve-jobs-threatened-palm-with-pa...
But there is no way to really be sure. Because they may have filed something before or after (within the 1 year) public disclosure.
Its just a mutually assured destruction arms race. The system is broken.
Anyone would be free to use the patent. But trolls can't sue with it.
Then you whip out your defensive patents and demand that IBM licenses your IP for 3% of their revenue. (Win-win cross licensing ensues...)
Patent trolls are a different animal though. However, having some good patents may at least protect you from willful infringement (increased damages)
I wonder if it's time for a Patent Denuclearization... but I'm not exactly sure how that could look like.
Prior use in public would count as "prior art" and void a patent too.
The patent (9,952,841) seems to be about the language swift.
There is mention about language features describing the language, but I don't see a specific claim to any of them.
"optionals chaining" (the feature that everyone is alarmed about) is just one of the features listed. Other features mentioned include an "IDE" and "unicode" as well as support for "functions".
Am I missing something? Where is the claim on an specific language characteristic?
So stare at https://patents.google.com/patent/US9952841B2/en
and look only at the claims.
To me, that set of claims is ... worrying
As someone who's been working on the platform for several years before Swift was announced and got to watch it all unfold, it's pretty incredible to see it described so succinctly. And definitely worrying as to the future direction of the work I've done.
Could you help us know any similar software development ecosystems that have been similarly patented, or anything else that might indicate how it could play out?
* Projects in different languages (originally, C#, VB and curiously Eiffel) compile to the same p-code/IR and are dynamically linked into an application.
* A single project contains multiple languages (C#, ASPX, Razor) compile to the same p-code/IR and are statically linked into an application.
.Net may not be the first that did this intentionally, but it does cover all the scenarios.
It's not because there is magic here, it's because the set of rules, regulations, and interpretations to follow is voluminous.
The document you want is called the MPEP.
This covers the rules/regulations/interpretations/etc that they will expect you to know/follow, and examiners to know/follow. In that sense, it literally does cover everything you'd need to know to do this right, and how the examiner/etc will look at your patent application, etc. It's even understandable by normal human beings and goes to great lengths to explain its reasoning and the case law that supports their views.
However, it's also thousands of pages.
Now, it's definitely possible and in my experience, examiners are fairly nice to pro-se applicants and try to be helpful.
But this would really be a thing you'd want to have to spend a significant amount of time doing.
For the vast majority of people, it's much more effective to hire someone who will charge a fixed fee.
(for a single person filing a patent for the firs time, you'd qualify as a micro-entity, so most of your fees would be the lawyer/agent for sure)
But, if you decide to do it, that's the document you want.
(And just as a disclaimer: i don't make a living patenting stuff and think patents in general hurt a lot more than they help. So i'm really not the type to tell you to go spend money on a patent lawyer if i can avoid it)
edit: word order
This actually seems quite legitimate from a 'patentability' standpoint. The precise mix of features coupled with syntax would definitely be patentable under existing law.
This does make it risky to implement a competing compiler however.
Unless, of course, you can satisfy the terms of the license
and include the copyright/license and a list of changes (which is indeed a little strange if it's actually a fresh implementation). That said, if you're needing to provide the same license, then you might as well fork it and not worry about starting from scratch.
If the patents are to defend the language then they should have no issue donating them to a dedidicated org which gives transparent and iron clad guarantee that they can never be used aggressively. If not, I expect them to pop in the next Apple vs. X thermonuclear ligigation where any and every bit of IP gets used as a weapon.
If we can't fix software patents in the courts then it might come down to us the devs to reject any language or API that doesn't sign up to into the appropriate non-agression pact. We need something similar for API copyright too. We are on a bad path right now where the big orgs have every incentive to be less open and more litigious.
Edit: actually, see below.
(It protects how Apple implemented some features)
Apple is a Contributor. They have given a patent grant on their contributions. If they didn't contribute something to Swift and they sue Swift other contributors for making a patent violation or their non-contributions, then all patent grants for Apple disappear and other contributors can sue Apple for anything that Swift uses that was patented.
I don't see how options chaining is specifically reserved, it's a patent on the entirety of Swift by the looks of it.
Please keep it in mind next time you purchase a laptop, smartphone or tablet!
So they are patenting something for our protection?
It does open the door for gcc to inadvertently develop similar functionality and get sued. Not that there's, afaik, a cleanroom implementation of Swift.
I make a language with "Apple's" claimed invention. (EDITED)
Apple sues me.
The patent is about building a compiler out of 2 modular front-ends – each taking an input language (one being an OO language based on C), generating the appropriate IR, and handing the IR to a backend.
It goes on to specify that one of the integrated frontends does more compile-time safety checking, calling out bounds-checking and optionals, and the other doesn't (because it is specifically based on C).
yes, it chains:
(cadar nil) -> nil ;; the nil object doesn't have a "car"
(cadar '((b c))) -> c
(car (cdr (car '((b c))))) -> c
This freedom was introduced in InterLisp, quite a few years before Jobs and Wozniak got together in a garage to make the Apple I.
If you want prior art, there it is.
Another prior art, related to this, is the Null Object Design Pattern, which is very similar.
In Common Lisp, this pattern (like many others) disappears because `nil` is the element of a `null` class, to which we can specialize methods. So in other words, we can make
If we have a method called position that normally returns the position of an object, if we specialize the method to the null class we can make (position nil) do something.
In Java-like OOP languages we would have a specific NullWhatever class that implements the same Whatever abstract interface/base as an ActualWhatever. Thus we then have an optional Whatever because code that takes a Whatever can take a NullWhatever or an ActualWhatever.
Yet another prior art is the use of sentinel objects instead of null pointers: for instance doubly-linked lists that have a special node, not considered part of the list, that is the predecessor of the first, and successor of the last. Then the code operating on lists neither blows up with a null access, nor does it have to check for nulls. Statements like node->prev->next = node always work.
"The single event that had the most influence on the creation of the League [for Programming Freedom] was Apple's lawsuits against Microsoft about supposed copyrights violations of the look and feel of the Macintosh in the development of Windows."
The patent protects how a compiler implements some features in a multi-target environment. Nothing to do with optional chaining.
Who "learned that"? The public (devs, etc) already knew and wanted that.
Companies however, have been patenting their languages and techniques since OS/360 or earlier (IBM, Oracle, MS, Google, and so on). So it's not as if "Apple has gone insane" at all, all big players do it. And not because they want to sue either -- you also need them to not be sued yourself oftentimes... (if Apple doesn't patent e.g. their "Optionals chaining" technique mentioning, what's to stop e.g. Oracle doing it and suing them?)
Can you imagine every Swift app has to be deleted because of a competing patent claim?
Anyone remember LZW? https://en.wikipedia.org/wiki/Lempel–Ziv–Welch#Patents
Proof that they had it before it was patented.
I don't know of any instances of Amazon, Google or Facebook trying to patent programming languages. Microsoft definitely did try this.
Questions in that thread:
> 1. If a separate open-source programming language under Apache 2.0 license implements an optional chaining feature, would it be a violation of the patent then?
> 2. What if there's a separate implementation of a Swift compiler developed from scratch independently from Apple, does mean that it's not able to implement optional chaining without licensing the patent?
> 3. Here's the most interesting part: let's say there's a fork of a Swift compiler that significantly diverged and is developed independently from Apple. It seems to me that forks like these still don't violate the patent, otherwise any GitHub fork with unmerged PRs would be a violation. But let's say Google's fork no longer wishes to contribute its changes upstream, at what point does this separate development could trigger a patent violation? Does amount of divergence have any impact, let's say 90% of the codebase changes? Does the name of project matter, if someone names their fork as "Sparrow", not "Swift" is it considered a patent violation at this point if there's no license and royalties paid for optional chaining?
They have patented one or more ways to implement some programming language features.
Read the claims, that is what is protected. Do one step differently and you are golden.
This patent is a nothing burger.
Don't take it personally. Patent law is about the most complex area of law. Most tech press blows it too.
Maybe the rescue plan is to become a patent troll?