Hacker News Reader

Comment by dmos62 | Hacker News Reader

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.

View on HN

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?

Only if those people compete with Apple's profits.

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

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.

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)

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.

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.

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

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

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.

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.

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

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.

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

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?

no.

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

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.

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

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

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.

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/

Groovy had null (optional) chaining

https://therealdanvega.com/blog/2013/08/20/groovys-null-safe...

and Kotlin https://kotlinlang.org/docs/reference/null-safety.html

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.

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.

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

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.

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.

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.

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

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

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)

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.

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

Indeed, that could do it I think.

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

Is there a way to waive that right?

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.

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.

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.

Reply on news.ycombinator.com