Hacker News new | comments | ask | show | jobs | submit login
Apple is patenting Swift features (swift.org)
580 points by maxdesiatov 23 days ago | hide | past | web | favorite | 208 comments



Chris Lattner has commented on the OP:

-----

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.

-Chris

-----

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?


IP lawyer here. No, that is a correct interpretation.

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)


Is there a potential for a kind of legal armageddon one day if companies had a real incentive to fight each other over one of these massive Apache-2-based open source projects?

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.


The worst case scenario in any patent fight is you are forced to

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.


What you misread is that the patent is awarded to Apple, not Swift. Apple is not being released under Apache 2 license and Apple is not restricted to using the patent only for Swift. If they decide tomorrow to have another language that is not being released under Apache 2 license then there is nothing stopping them from using this feature as the patent is already theirs.

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.


Exactly! Apache 2 may protect users of Swift from suits for use of Swift itself, but it does not protect everyone else from suits for use of the concept elsewhere.


Including from suits from Apple itself for using concepts of Swift elsewhere in projects that were developed from scratch, not forked from Apple's projects, right?


Yes, that is my understanding.


> What you misread is that the patent is awarded to Apple, not Swift. Apple is not being released under Apache 2 license and Apple is not restricted to using the patent only for Swift. If they decide tomorrow to have another language that is not being released under Apache 2 license then there is nothing stopping them from using this feature as the patent is already theirs.

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.


The issue is you cannot make a language that uses the feature. It doesn't matter if you are user of Swift or not. The license only grants you the ability to use the patented feature as long as you are using it as part of the licensed software.


The license is irrelevant. Apple doesn't need a license because it owns the patent. Also, the license that Apple grants to others to use its invention doesn't take away any of its own rights to the patented invention.


patenting syntax might fall in the same box as patenting number sequences


> >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.

> 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.


Right, also it's for "any patent licenses granted to You under this License" - if Apple owns the patent, they have no need for Swift's license to grant them a patent license. They own it. (They are not being licensed the patents by the government, and they're certainly not being licensed them under the terms of Swift's license.)


OK, so it sounds like for Apache 2.0 to have any teeth, there have to be actual patents in play.

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.


The biggest question here is whether this means they lose the patents when they sue something that's not covered by Derivative Works as defined in Apache 2.0?

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.


Just to bring clarity on what has been patented on one of the patents:

    Monad Maybe where
        Nothing  >>= _ = Nothing
        (Just x) >>= f = f x
Those three lines, implementing the Maybe Monad/bind operation, are commonplace in all functional languages. (They just called it Optional instead of Maybe and "chaining" instead of "bind"/>>=)

( https://docs.swift.org/swift-book/LanguageGuide/OptionalChai... )

EDIT:

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/


Your example can be implemented in many different ways. This patent claims one or more ways but not all of them.

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.


Rust does this as a core idiom. I don’t think this will work.

Edit wrt edit in parent: all three of these claims apply to Rust.


Or, you know, every typed functional language released in the last 30 years


I think they’re trying to patent the syntactic sugar that corresponds to the Maybe monad, not the concept of “bind” itself.

That said, I think there are other languages with very similar syntactic sugar (e.g. Rust), so this is still a very questionable claim.


I've seen patents that hinged on a single line of Javascript code because it was used in a context that has never been patented before and no prior art. Not only was it submitted, but it was accepted and is a patent now.


It really means very little that a patent was granted. They do not do an exhaustive search for prior art, or validation of relevance. Until it has been litigated no one really knows which patents can survive litigation.


But if you’re a company sued asking for less than what the cost of fighting would be, it’s in your interest to cut a deal.

In that case, whether the patent is valid or not doesn’t matter.


> But if you’re a company sued asking for less than what the cost of fighting would be, it’s in your interest to cut a deal.

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.”


Realistically, most small companies can't afford to fight a large one over a patent infringement claim, regardless of the merits of the case.

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?


> Realistically, most small companies can't afford to fight a large one over a patent infringement claim

Sure; the hypothetical was “if you're a company”, not “if you're a much smaller company”. Power assymetry definitely affects the options here.


I'm having a hard time getting a clear picture what this actually entails. I am in violation if I reimplement Swift without forking the project (i.e. a "clean room reimplementation")? If I'm designing my own language, am I no longer allowed to include optional chaining? If so, I'm pretty disappointed with this direction, since it runs counter to the entire point of accessible programming languages, including many of the ideas that Swift itself uses. Imagine if there were patents on C: software development would be far further behind than it is today, because nobody would be able to make a compiler for it or reuse its syntax or features in any new programming languages. I'm not seeing any benefits aside from a vague "it protects Swift users from patent trolls", but I'm not sure I understand how this argument works.


Exactly this, thank you for summarizing this so well! I've tried to clarify this exact point at Swift Forums, but I haven't seen even a clarifying answer from anyone in the core team on this point. Everyone says "it protects Swift", but looks like this protection comes at a cost of the overall ecosystem.


And this is one very real reason to avoid languages owned by huge companies like Google's Go and Apple's Swift. They can and will do evil things, instead of supporting them please consider supporting smaller languages which are often just as good or better as Swift/Go.


Such as? Many of the newer languages I’m seeing, notably Swift and Go, but also TypeScript, ReasonML, and Rust have their development backed by one corporation.


Such as Julia (https://julialang.org/), which is general-purpose and open-source.


> julialang.org > no mention of "license" > "Julia is a NumFocus project"

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.


This is definitely not true of ReasonML. ReasonML is just one part of a larger ecosystem that is pushed forward by a combination of academia and industry, and ReasonML is is very community focused/driven.


dom96 was probably thinking of Nim[0], as they're one of the developers in the project.

[0] https://nim-lang.org


Yes, as well as libraries, tools, applications that are not in the hands of one or few companies only.

Plenty of technologies get hyped up by companies and later on bent out of shape or dropped.


C++.


And also, "it protects Swift" in their context always means "it protects Apple's Swift" unfortunately


No, it definitely applies protections to the entire Apache licensed work. People can fork it and make changes, rename the project and they will retain their patent license as long as they abide by the terms of the license.


but what about reimplementing a compiler from scratch without reusing any of Apple's code? It wouldn't fall under a definition of Derivative Work under terms of Apache 2.0 then


If your going this way you must also take account for "reimplementation from scratch under restrictive licence”.

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!


Sorry, I'm not sure I understand this point. Why would I need a different license for this from scratch implementation? What if I want Apache 2.0 as well?

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?


> 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

Should? What rule, law, or moral code does it break to reimplement something?


If you start from a position of strong support for broad legal protection of "intellectual property", I can see that there would be an argument that a programming language as a whole could be locked up by a patent. As a possible analogy, (my understanding is that) Lego held a patent on the bricks at some point, and no clones could be produced because of that.

Like you, I would have a pretty hard time being convinced that this was actually a good idea, though.


The trick would therefore be to pull in a little bit of Apple's code so you can argue that it's a derivative work and therefore covered by the patent license grant ;)


I agree, that is the real issue. I was responding to the comment that the protections were only for "Apple's Swift".


These patents seem to be a countermeasure against patent trolls, since the code uses the Apache license. Quoting from link:

> 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.


Thats not the only thing, no? Doesn't it also prevent e.g. other people/company from including that feature in their own programming language that doesn't use Swift at all?


Yes. This, exactly.

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.


We can find out if apple is serious about keeping it open by asking them to turn over those patents to an entity like RPX


Patents _are_ supposed to cover inventions, not implementations.

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.)


Patents are about how you do something, not what you do.

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.


They didn't invent anything anymore than I invented the peanut butter sandwich i made yesterday


Can't you make a pretty similar argument about all types of patents?


A key difference is that software is already covered by copyright. Identical copies violate copyright for software. For a mechanical device, identical copies generally don't violate copyright (trademarks, text, etc aside).

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.


Patents protect how something is done. Copyrights protect what you make (e.g.,. expression of idea).


the “expression of idea” is precisely “how something is done” or am i missing something...

idea: superhuman who flys around saving people

expression: superman, 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

edit: spelling/formatting


>Can't you make a pretty similar argument about all types of patents?

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.


it wouldn't be quite the same because software does not have physical material properties. IMO this difference is crucial.


Patents were meant to protect the person who invented a particular physical object or physical process.

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".


So-called software patents are always drafted as machines that can perform the claimed actions. These machines are comprised of one or more hardware components, including some hardware components that can execute machine readable instructions.

(There really is no such thing as a software patent.)


In Europe we do manage to make that distinction, though it is nuanced, and it specifically excludes the "program on a media" or "program in the physical memory of a computer" methods of trying to make all software appear to be physically technological.


True, through many well-drafted US "software patents" can be successfully prosecuted in the EU without too much trouble.


To me software patents and patents for, for example, real world engines are the same. It's okay not to like patents, but separating software patents from the rest makes no sense.


Ah, but you are overlooking the key difference: you cannot commercialize an engine without building it. With software, commercialization costs "nothing" [1].

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.

[1]: 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).


I don't think that's really different between hardware and software. Even in software, the bigger company often has a decisive advantage in marketing. The history of computing is littered with the graves of small companies crushed by behemoths.

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.


> I don't think that's really different between hardware and software.

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?


”With software, commercialization costs "nothing””

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?


Did you read my footnote?

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.


--edit-- see below comments.. this may not be so simple.

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.


The patent hasn't been granted to the world via the Apache license. The Apache license only covers the code in the Swift language.

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.


Yes, but this is also the case for say features in Swift that IBM contributes to the code base.

It is a purposeful limitation of the Apache 2.0 license that the "patent pool" effect is limited to the project.


So, to make it clear - since that's a question that was unanswered in the linked discussion.

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?


Speaking as a PMC of Apache Flex, but not as a lawyer...

> 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.

https://www.farmanddairy.com/columns/the-story-behind-the-fa...


Apple could try, sure, and you wouldn't have something like the Apache 2 license to point to in order to attempt to resolve things quicker.

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)


I believe there is a flaw in the Apache License 2.0 here. If the patent grant only covers the code in question. If this is true, then it not only reinforces software patents, but reinforces implementations too.


My understanding is, that the point is to make sure the users of the code don't have to care about patents. It's a license for the code, not for the patents.


How about Apple switching to a different patent holder friendly license for a future version of Swift? Older versions would be safe, but they could ask money to use the new ones. And maybe they decide who to go after first.


This sounds like defensive patenting, which is what Microsoft used to do: patenting things to keep them out of the hands of the patent trolls, but not to restrict people from actually using the idea against them.

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.


It also prevents any fully independent implementation of a compatible Swift since it wouldn't be from the Apache-licensed source.


Someone could even implement the feature in a dynamic language like Python or Lisp for a particular application. Does that mean the application is infringing the patent because they didn't use Swift?


Many Lisps (like ANSI Common Lisps, and many of its predecessors) have optional chaining in their list processing; it has existed before Apple Inc.

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


no.


Patents are written to be as broad as possible. The most careful interpretation is that if anyone does option chaining anywhere, it is covered by the patent, and actionable by the patent holder.

Companies that are mere consumers of IT have been sued by patent trolls, and paid up.


Take a look at the claims. The patent does not claim option chaining. It claims a few ways to implement a system that may support option chaining.


If whatever language implementation you are using implements that, and infringes, then you infringe that by running programs in that language. All unlicensed users of anything emanating from the patent infringe on it.


Could you please elaborate on this? Is there any direct confirmation of this? There wasn't any single answer from anyone affiliated with the Swift core team on this specific point. Or from any lawyer for that matter.


Patent claims define the legal scope: if "using Swift" isn't in the claims then using another language, provided it fits the language of the claims, is also covered by the patent.


ok, does it mean that if you implement only parts of the patent (say only a single feature) there's no infringement because then it doesn't "fit the language of the claims"?

Also, "using Swift" isn't in the claims ¯\_(ツ)_/¯


If you look at the main claims (any that don't add to a previous claim, ie don't include "the invention of claim X wherein ...") then you need to be doing something that matches all clauses in the claim to infringe.

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.]


Only if those people compete with Apple's profits.


To echo a comment in the linked thread: what does the Apache license say about other implementations? If I want to create my own implementation of the Swift compiler, or create another language with optional chaining, would this license protect me? Or does it only protect the use of this implementation?


Well, given that Rust and C# also have these features I think the likelihood that the patent is upheld is unlikely. I guess they could threaten you with it since lawyers are expensive, but it seems silly to me.




In Apache Groovy you need to write `a?.b?.c` for nullsafe chaining on both `b` and `c`. In the past, its project managers have discussed propagating nullsafety down the chain so you'd only need to write `a?.b.c` to make both `b` and `c` nullsafe, but they've never implemented it.

Not sure if that's in Rust, Kotlin, C#, or Ruby, or in Groovy's Antlr 4 parser.


FWIW Rust does not have optionals chaining, except in the monadic sense (in which case ML and Haskell have optionals chaining).

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".


Right, but isn't `?.` just syntactic sugar on `Option::and_then`? Is this a patent on a piece of syntactic sugar, or is it a patent on the idea of chaining optional values?


Ruby does seem to have the exact thing: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/


I'm also pretty sure I had it in C# before Swift was introduced.


one thing though, in swift you can actually mutate fields using optional chaining, e.g. person?.name = "Bob". you can't do that in c#. not sure about rust but in scala you would unwrap the optional with a foreach or something.


In Groovy you can mutate through optional (null-safe) chaining, eg:

    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


I knew I had seen this somewhere else. I don't understand why C# doesn't support this since most C# code is mutable anyway. I can see why it doesn't fit well with functional languages but C# usually espouses pragmatism over purity and having this would clean up a lot boilerplate null checking.


Yeah and using optionals in rust vs swift makes rust super annoying to use because of that.


Do Rust and C# implement these features the same exact way as Apple claims in this patent?

Patents protect how you something, not what you do.


Technically speaking, C# does not have optionals so I don't think it can be argued that C# violates the patent unless it's generalized to include null propagation which operates on reference types.


C# Nullable<T> is optional for all purposes (a struct with .Value and .HasValue), it's just restricted to value types.


right, c#'s nullable types are the ultimate in syntactic sugar in that you can just use them like regular value types in most places without realizing they are monads underneath.


I wouldn't say they have substantially more syntactic sugar than other languages with the same. If you need to use them in the context that is not optional, you need to use HasValue/Value, or casts, or (since recent versions) pattern matching to extract the value.

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.


The Apache license covers derived works.

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.


And what about languages like JavaScript and Kotlin which have already integrated the optional-chaining operator themselves?


This is interesting because it raises questions about what is a fork. Can I fork Swift and throw out everything except for the patented part and then merge it with my project?


Judges don't typically fall for stuff like that. Just because you created something by using the fork process, the end result after your giant purge isn't recognizable as a fork of Swift.


> These patents seem to be a countermeasure against patent trolls.

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...


Indeed. They sued Samsung for making a phone that was a rectangle with rounded corners as if every maker of watches, wallets, tables, beds, couches, previous cell phones, cafeteria trays, cars seats, coffee cups with handles, axe handles, power tools, sports rackets, three-ring binders, televisions, remote controls, radios, messenger bags, and briefcases didn't realize sharp pointy edges are uncomfortable.


That was a design patent, not a utility patent; the former are more like trademarks in purpose than they are like utility patents.


Indeed, but there's nothing distinct or original about the design elements. All sorts of products including electronics products already contained the obvious and practical elements.


Filing a patent on your art is a convenient way to put your prior art on the record against lawsuits by future patents.


I'm not too knowledgeable about patents, but maybe we need a "liberal" patent? Something that can't be used to sue other people, but protects you from being sued.


Just publish all your findings and establish prior art and you should be ok. Or is there more to it?


How can you guarantee that the person publishing their findings won't change their mind later and apply for a patent?


In the US they have one year to file. In UK, EU, and most other countries public disclosure bars them from filing a patent application.

But there is no way to really be sure. Because they may have filed something before or after (within the 1 year) public disclosure.


Is there a way to waive that right?


Indeed, that could do it I think.


That isn't exactly how defensive patents work. Part of the deal is to build up a portfolio you can counter sue with and then force a patent sharing agreement where the two parties agree not to sue either either for any patents.

Its just a mutually assured destruction arms race. The system is broken.


How would that work? If company A receives a "defensive" patent on a technology design, and company B decides to use that patented design without a license, seems like they'd be able to without any recourse. In which case, does the patent system even make sense anymore? I think that's the bigger question in the context of software.


That's the point. The idea of having a "defensive patent" is to avoid having trolls patenting the same thing and then going after small companies with no means to defend themselves in a patent suit. For instance: https://www.x-plane.com/2015/12/patent-troll-update/.

Anyone would be free to use the patent. But trolls can't sue with it.


The way the system is supposed to work is that simply publishing should be sufficient to prevent anyone else from registering future patents on anything that you've published. After all, publishing creates prior art which should invalidate any future patents covering your technology.


Defensive patents are for when IBM comes after you with a stack of patents demanding licensing fees amounting to 3% of your revenue.

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 feel like this is just a loose-loose situation that instead of encouraging and protecting small innovators from the power of established companies instead just locks them out. Patents are essentially MAD (except of course for the part where everyone dies if it goes wrong). Like nukes, these patents aren't actually useful. They are only necessary because everyone else has them and the people actually under threat are the less powerful people that don't. This is very different from say pharma patents, where companies seem to directly benefit from Patents in their intended way.

I wonder if it's time for a Patent Denuclearization... but I'm not exactly sure how that could look like.


theoretically publishing an explanation of the methods and not patenting it is sufficient


Not since the US changed to first-to-file. A patent can be issued to another party and you can be sued for using your own invention. If an examiner never finds your prior art you're still on the hook to deal with the expensive legal process of defense and invalidation.


Elsewhere prior use is an absolute defence against being sued for patent infringement; I've not seen USA caselaw on this specific issue but I can't see how it could be different.

Prior use in public would count as "prior art" and void a patent too.


I don't think first to file is relevant to prior art ( direct from attorneys for things I've tried to patent this year with medical devices)


Is it actually a legitimate concern that a patent troll would be able to sustain a claim to syntactic sugar around a specific monad? It seems far more likely that a non-patent trolling entity would implement a similar feature in some other language (along with the languages that already have similar features) than a patent troll would sue and claim patent rights to it.


sure it can. you make something patentable. say AR lenses. You write an iOS app in Swift. Apple copies your lenses. When you go try to sue them they point out lose the right to use Swift


Optional chaining? You mean Apple got a patent for flatMap?


Don't you just love the USPO? They are severely understaffed for the increasing rate of patents. Any other gov't agency would just form a backlog, but instead they just approve things with little examination.


I don't quite understand.

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?


IP lawyer here. You should ignore everything but the claims, and see what the claims say.

So stare at https://patents.google.com/patent/US9952841B2/en

and look only at the claims.

To me, that set of claims is ... worrying


It's really interesting. They're describing the entire apparatus that's been built up to switch from ObjC to Swift and allow them to coexist using multistage compilation, and the recompilation of IR code to target newer devices (or for a few other enumerated reasons).

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?


"Also, the new language provides two range operators, the half-closed (e.g., a . . . b) and closed (e.g., a . . . b) range operators, which are not found in the C language. " their examples for half-closed and closed are identical. I wonder how many such mistakes are in a patent filing in average and what the effect of such mistakes is.


IANAL, but those claims seem to describe .Net (multiple languages targeting a common IR?), so there's prior art.


p-code?


The key "innovation" that Apple seems to be claiming is that multiple languages are intended to be compiled down to a single p-code (in this case, LLVM). .Net does this in two ways:

* 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.


Could you recomend me a book or course on how to file an utility patent? I took a mooc explaining the overall process but it lacks details.


You really really really don't want to do this if you can avoid it.

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. https://www.uspto.gov/web/offices/pac/mpep/index.html

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)


Filing your own patent pro se is one of the best ways to both waste your money and lose your rights.

edit: word order


This is how I interpreted it. It doesn't seem to patent a feature in as much as Swift itself.

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.


Remember that each claim stands by itself, unless it explicitly evokes another claim.


> 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.


Can we setup the equivalent of https://www.openinventionnetwork.com/ for programming language design?

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.


Apache License 2.0 is as good as donating it. Just now, nobody can sue anyone else for that design feature.

Edit: actually, see below.


IANAL, but as far as I understand Apache 2.0, it grants patent license only in cases which were used in the original code, not universally.


You know what. I looked again at the license. I think this is the first time I've noticed a flaw in the Apache 2.0 license. I think you are right. Derived works is described as: "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof."


This feature wasn’t even invented in Swift, the fact that a patent was granted on it shows the sorry state of technical policy making


I think American patents changed some time in the past decade to match how they’re done in the rest of the world; The first person to patent the thing gets the rights completely regardless of the time or person the implementation is associated with.


Prior art still invalidates patents AFAIK. Unless there's some recent Fed Circuit decision that changes that.


But only in the first year after first publication. So if the feature was available elsewhere for long enough, no patent for anybody.


Good thing this patent does not protect any programming language features.

(It protects how Apple implemented some features)


Out of curiosity, which language would you say first implemented optionals?


This is a specialisation of algebraic datatypes, it has to go at least as far back as SML.


I don't know which specific language, but there been around since at least 80s I would guess.


This is why the D programming language is Boost licensed. Many other languages are adopting D features we could have patented, but did not and will not.


It looks like there is an unintended consequence of the Apache License 2.0 of allowing a company to patent some functionality, and the only way to acquire that patent is to keep your implementation as a close fork of the original derived work. The question is, whether or not the patent grant for just using swift (downloading and running it), can cover other development work that is not associated with swift. If not then Apache License 2.0 actually seems to paradoxically reinforce the situation it is trying to avoid by tying implementation and copyright directly to patents, thereby boosting patents as a way to squash other open source projects. Any comment by an Apache person would be greatly appreciated.


>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. 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.

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.

IANAL.


Patent text: https://patents.google.com/patent/US9952841/en

I don't see how options chaining is specifically reserved, it's a patent on the entirety of Swift by the looks of it.


Yes... I really don't understand what all the FUD is about. I don't think most people here have read the actual text. Otherwise we'd have people complaining that Apple is trying to patent things like two stage compilation.


https://patents.justia.com/patent/9952841 This is the actual patent. I'm having a very difficult time understand what their actual claims are -- can someone explain it?


Read the claims section. That is what this patent protects.


As if Apple isn't a big enough threat to tech by designing their software to be incompatible with everyone else's hardware, now they want to spam technology patents on a PROGRAMMING LANGUAGE. This is a horrible idea and only serves to stifle innovation.

Please keep it in mind next time you purchase a laptop, smartphone or tablet!


Let's see if I have this right: Apple is patenting concepts in Swift then licensing it under Apache 2 in order to protect users of the language from patent trolls.

So they are patenting something for our protection?


Apache will only protect the particular implementation, viz. LLVM.

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.


Yes, lets hope they don't alter the terms of the deal (again) at a further date.


Monads and do notation as prior art. Boring


I wish you the best of luck at defending against Apple's lawyers backed by a patent system that no longer promotes the progress of science or useful arts.


something something, i wish apple lawyers going after projects sponsored by microsoft. :)


Yep, also C# has the same damn thing specialized to optional chaining for the same exact reason. The Prior Art is Strong in This One.


Thank you, I was wondering if they had patented a half-assed version of monads.


option chaining definitely is that. seen in both swift and rust. and I guess in some styles of javascript too afaik


They haven't patented monads or any programming feature.


I'm not using Swift, so I don't get rights conferred by the Apache license.

I make a language with "Apple's" claimed invention. (EDITED)

Apple sues me.


No. Did you look at the patent? "Optional chaining" is not one of the patent's claims.

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).


No, I went by the posted link. It does't alter my point.


I'm left dreaming of a future when we have to pirate programming languages.


Lisps that return nil for (car nil) are implementing "optional chaining".

yes, it chains:

   (cadar nil) -> nil ;; the nil object doesn't have a "car"

   (cadar '((b c))) -> c

   ;; i.e.
   (car (cdr (car '((b c))))) -> c
This is exactly like, in Swift-like syntax, doing '((b c)).car?.cdr?.car? where the ? indicates "don't blow up if it's nil", except the "don't blow up" is built into car and cdr.

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."

https://en.wikipedia.org/wiki/League_for_Programming_Freedom


You are talking about language features.

The patent protects how a compiler implements some features in a multi-target environment. Nothing to do with optional chaining.


We're building tanks but we promiiiiise we'll only ever use them for defense!


OMG, the U.S. patent system is so crazy and people are so scared of being sued for any dumb reason. Why don't you change it? I am glad that I live in the E.U., where the situation is saner.


Patents are so literally rent-seeking that I cannot fathom why people support them.


Does this have any implications for Google's effort to integrate Swift into Fuchsia?


So they're claiming (values) and &optional but in C?


One strategy behind patenting open sourced inventions is to protect the users of the open source product.


Could you please provide an example? From what specifically have any patents protected users of an open source product? I know plenty of examples when patents were used to harm the users, the most notorious one being Oracle and Java. But I don't remember a single case where users of an open source product were protected from anything with a patent owned by a big for-profit company, would be happy to know a concrete example that shows that this protection outweighs the risk of a company harming open source users.


>This is very disturbing. It's like Apple has gone insane. Computer languages are not supposed to be owned by any company. We learned this mistake with Java and APIs. Computer languages are supposed to be a part of the Commons, owned by everyone for the benefit of humanity, not the benefit of a greedy corporation.

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?)


> 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


> what's to stop e.g. Oracle doing it and suing them?

Proof that they had it before it was patented.


You are correct here, but the question is, is there a flaw in the Apache License then? Should it also include the patent grant for non-derived works, as long as someone adheres to the license?


> all big players do it

I don't know of any instances of Amazon, Google or Facebook trying to patent programming languages. Microsoft definitely did try this.


Classic Apple hoarding software patents. Even if they don't use them, this looks like a threat move. Patenting programming language features is just sick.

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 not patented any programming language features.

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.


That doens't make it any less sick really (as applies to all software patents). But it's especially sick in the context of programming languages.


It is clear that you, like many commenters in this thread, have very little, if any, understanding of US patent law.

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.


Patent law that allows software patents is already seriously messed up and urgently needs fixing. When it allows patenting programming languages, it's outright sick.


Software based inventions aren't special, they are just new to the game.


They are special enough to cause serious harm to progress if patented. This was demonstrated many times. Since the whole point of patents is to promote progress, software patents should not exist.


From what we see, software patents have caused more harm than good, but would be great if there were enough concrete public examples listed somewhere that prove otherwise.


The future of Apple seems uncertain. Some says it is the beginning of the end.

https://www.forbes.com/sites/stephenmcbride1/2019/01/21/the-...

Maybe the rescue plan is to become a patent troll?




Applications are open for YC Summer 2019

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: