Hacker News Reader

Comment by SwellJoe | Hacker News Reader

It's always surprising how little people understand the licenses they publish their code under. BSD does not make something public domain, but it does allow derivative works and inclusion in completely unrelated projects, without permission of the author. Rewriting it, from scratch, in another language generally completely bypasses even the requirement to reproduce the copyright notice (unless there are data structures being copied over, or similar, that copyright would apply to).

Algorithms are sometimes subject to patents, though I believe they shouldn't be, and if the author wanted this sort of control over the algorithm a patent is the path he should have taken, but as far as I can tell the author has not patented this particular algorithm (and I doubt it is novel, as it sounds similar to quite a few pre-existing tools in related fields).

This is just a sort of weird conversation. Why Open Source something if you don't want people to use it in interesting ways?

View on HN

Apparently, he didn't directly open source it. He approved its inclusion in the Open Refine package. It's pretty obvious that he didn't understand the consequences of releasing his code in a project licensed by BSD. I can understand his frustration, probably because he was told that his conditions were covered under the BSD license. Given that he sells the same code as a commercial product, this was obviously not his intention.

However, he failed to grasp some basic IP concepts, especially wrt US law. Algorithms are not copyrightable, and most are not patentable (especially after Alice v CLS) under US law. However, there is solid precedent for similar systems being eligible for patent protection (soundex, other patents that cite his systems as source material, etc). It does not appear that he applied for this protection at this time.

Moreover, under the modification clause of the 3 clause BSD license he used in his source file, there is a significant amount of commentary suggesting such a rewrite would be permissible under the terms of that license. However, re-licensing it under MIT would on the surface not be permitted.

EDIT: he may have applied for a patent. This could preclude the project from including his system. However, I'm not a patent lawyer, so I don't know how well this would hold up in international implementations (github being a US entity makes this point relatively moot).

http://www.google.com/patents/US20090043584

The BSD license does not contain any patent grants, so he can still assert the right over the use of his patent in pretty much anything - the BSD licensed code can still only be used with his permission, since you need both the copyright license and patent license to use it.

When patents are involved, it makes more sense to us a license like the GPL3 or Apache2.0, which also grant licenses for any patents which are covered by the code.

Some interpret BSD to have an implied patent grant, but the law on the subject is sparse and mostly untested. The license do say that: "Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met", but if that will be enough is up the court, and to my knowledge they have not been asked yet.

Patents are territorial.

Unless he applies (has applied at this point) in a particular country, or has a Patent Cooperation Treaty application filed in some country and is pursuing it in a particular country, he is completely out of luck by publishing his algorithm. (And as another commentor mentioned, post-Alice, it's pretty unlikely that a patent applicant will succeed with software patent applications absent some pretty close coupling to something specific about the computer hardware.)

It's amazing to me that so many software developers have no basic grasp of IP--the thing they work so hard to produce. It's not like it's all that difficult: Copyrights protect the expression of an idea; patents protect inventions. This developer seems to think that copyrights protect ideas.

> However, he failed to grasp some basic IP concepts

Indeed. His patent was abandoned, according to the USPTO's PAIR website at [1], after being rejected for non-patentability. Aside from being apparently non-patentable subject matter, the examiner noted that Philips's application was similar to a previously rejected application no. 10/454,261, and rejected the former on the some of the same grounds as the latter.

(I am not a patent lawyer.)

[1] http://portal.uspto.gov/pair/PublicPair

According to the USPTO, his patent is abandoned after he failed to respond to a non-final rejection back in 2011.

Re-writing the code using the original source as a guide means it is a derivative work if you want to get picky. Changing the programming language doesn't make it non-derivative.

If you want a non-derivative work you need to do something like a clean room implementation where the one writing the code doesn't have access to the code of the existing implementation: https://en.wikipedia.org/wiki/Clean_room_design

BTW this guy can not stop derivative works once he has released it as BSD.

> BTW this guy can not stop derivative works once he has released it as BSD.

could he just remove the BSD license from all subsequent commits to the code base? The existing code base will still continue to be BSD licensed of course.

Provided no one else has ever contributed yes he can. In fact this is not unique to the BSD, you can do that with any license. Even proprietary licenses do not force the author to continue using the same license since they own the original copyright.

Unless the license agreement for contributing specifically says the author forfeits their copyright, but no open source licenses I know of do this.

This is impossible in certain jurisdictions.

What's impossible? Reassigning copyright to the project maintainer?

Exactly.

Forfeiting copyright is not possible in some jurisdictions.

I'm not sure what is unclear about a refutation of a single sentence.

I'm presuming what you are referring to, and which is likely to confuse a predominantly English speaking audience is that a number of countries with legal systems typically based in Germanic or Napoleonic legal systems, copyright consists of the combination of moral rights on one side and economic rights on the other hand.

Moral rights are generally impossible to forfeit and assign. Economic rights usually (I don't know of any jurisdictions where assigning economic rights to the project maintainer would be impossible - are you?) are possible to assign.

In common law systems, the two are usually traditionally much more closely tied, and when we talk about copyright in English, it is usually the economic rights we're referring to.

While there aren't any software licenses that do that, many projects do it as a condition of accepting contributions. As an example here is GCC's contributor documentation: https://gcc.gnu.org/contribute.html

The short version is assign FSF copyright, or put it in the public domain.

Isn't this generally what Contributor Agreements are for - not giving up copyright, but jointly assigning it? E.g. https://www.clahub.com/

I know to contribute to Clojure/ClojureScript-proper, I had to sign http://clojure.org/contributing

How would the enforcement of that work? What if I have cloned the version of the repo that was BSD, and I'm working on a yet-unrelated derivative work when the author changes the license? The answer that seems reasonable to me (not that I expect any correlation between that and the actual law) is that any version of the code that was released with a given license is perpetually under that license.

No, he can do that regardless if it's BSD code, as long as he keeps the copyright notice intact.

I can take any BSD code, close source it, develop it further inside my company, then sell it as a proprietary, closed source app.

Or re-license to GPL.

> BTW this guy can not stop derivative works once he has released it as BSD.

Aside: Isn't is possible to revoke a license?

No, not unless the original license text contained such a revocation clause, which isn't the case for BSD licenses.

Huh? Where does the law say this? It is my impression that the copyright owner has all rights unless he explicitly relaxes them. A license by definition cannot create more rights, it can only relax them.

Yes, but by publishing under the BSD license he has relaxed his rights, and he cannot retroactively change that.

A license doesn't "relax" rights, it grants rights to others (and sometimes/in some jurisdictions also can limit how the copyright owner can make use of his rights)

If you give someone the right to do something and don't specify how you can take it away, you can't take it away again. Without termination clauses a license is a contract thats valid indefinitely.

And why can't you take it away? If I give someone a permit to cross my bridge, I can revoke it at any time. Usually when something is perpetual, you have to write in it: "perpetual" for it to actually be so.

We are not talking about permits (which are typically temporary as per whatever conditions they have). We are talking about software licenses, which often do not allow the copyright holder to revoke.

These licenses are explicit about what they do/do not grant. p

Let's keep it with software. The bridge metaphor is more applicable to a service offering where you maintain infrastructure and adjust pricing based on the cost of maintaining it.

In software, the license is what you sell. I don't buy MS Windows or Photoshop, I buy a license for it. If you sell me a 3-seat license of software v1.0 allowing me to install it on up to 3 computers, you can't come back 2 years later and change the terms to only 1 computer. Now, in 2 years, you might have v2.0 and require a new license for that. But the license you sold me for v1.0 remains in place.

By releasing the software under the BSD license, he basically sold us a license (price immaterial) granting permission to redistribute and alter the code, provided that new code includes the BSD license.

I understand that wasn't his intention. Another commenter pointed out that the author gave permission to another project which was being released under the BSD license. Now anyone that was "sold" the software with that license has been granted those redistribution rights.

I did think of this, but surely a transaction between two parties is not the same as simply posting a license on a website?

If I pay money in return for a license to use Photoshop, there is a reasonable expectation that I can use that indefinitely. I give then money, they give me permission.

If I simply download a piece of open source software from the internet, that isn't the same thing. There's no transaction. There's no anything. If the author subsequently tells me "I hereby revoke all previous licenses", I don't see how that wouldn't have legal weight.

"If I pay money in return for a license to use Photoshop, there is a reasonable expectation that I can use that indefinitely. I give then money, they give me permission."

Even when paying money, it isn't a reasonable expectation to expect to be able to use it forever for all software. With shrink-wrap or click-through agreements, perhaps, by convention, but plenty of software is sold on subscription for example, or may have revocation clause without refund which is common with MMO games for example.

Some software also may naturally break some day due to incompatibility or disinterest by the author. Other than limited warranty protections by law, there's not much a buyer can do about it. This is of course subject to local laws which may allow moral revocation (France) or stricter warranties.

With regards to downloading a piece of open source, the downloader is consenting to the copyright license it is offered under: it's the same as a click through.

If there is no license, you technically have no right to use or redistribute the software (all rights are reserved).

If there is a license, usually that will explain the author's intentions for fees, redistribution rights, and rights of revocability.

The OSI exists to approve licenses as "open source" when they (among other clauses) explicitly denounce revocability. The only recourse is that an author can refuse to OSI license future modifications or releases of the software (basically making a private fork).

If you just tell someone you can use the bridge then you can probably revoke it. But if you keep letting them use it and they build a house on the other side of the bridge or something then you've probably granted an implied easement[1] and can't, in fact, suddenly stop letting them use the bridge. But in this case there's actually a legal document saying that anybody can use the bridge so that would be analogous to an express easement.

[1]http://en.wikipedia.org/wiki/Easement

The entirety of the license is the text of the license. If there is no revocation clause specifying how revocation would happen, the answer is no, it can't be revoked.

Assuming he holds the copyright for the entirety of the program, he could change the license for all future versions, and he also could stop distributing old versions under the old license (putting a new license on it, or simply discontinuing distribution). But, the old license has already granted thousands, or millions, of people, the right to distribute it under those terms.

For future modifications, yes, but you can not retroactively revoke a license. Although I am sure if you get a lawyer involved he can likely try to come p with reasons why it couldn't have legitimately been released as BSD in the first place, thus declare the first BSD licensing of the code as invalid.

Unless there's a term in the license it never ends, so my BSD copy stays that way. Anyone could keep distributing it and derivatives.

The other answers to your question are not correct. In some countries, authors' "moral rights" can include the right to withdraw the software, saying "I don't want you to continue distributing the software", which is similar to retroactively revoking the license. For the situation in France, see:

http://ifosslawbook.org/france/ ("Moral Rights" heading)

The GPL actually has a clause agaisnt revocation in section 2:

    All rights granted under this License are granted for the
    term of copyright on the Program, and are irrevocable 
    provided the stated conditions are met.

How does France work against this?

I happen to know about this "France problem" because for a while it affected the OCaml distribution (it has now been resolved by some French-specific legal wrangle).

I don't know how this affects the GPL specifically, but you can be pretty sure that if the GPL doesn't contain France-specific French-language legalese to work around it, then it's likely to be revokable whatever the license says. Of course this only affects you if you're in France or have French contributors.

France doesn't need to "work against this".

If that's the law in France, it trumps the license text.

Just as the law trumps any clause requiring the sacrifice of the licensee's firstborn on an altar.

Doesn't this make it illegal to distribute GPL software in France under clause 12?

    If conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License.  If you cannot convey a
    covered work so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you may
    not convey it at all.

Since allowing the licensor to revoke the licence would be an extra condition.

It doesn't make the distribution illegal per-se, but it does make the license invalid and thus the software unlicensed. Same as "public domain" licensing.

No it doesn't. If you don't have a license for the software, you cannot use it.

Unless I'm misreading it, that section specifically says that the author may not withdraw distribution rights for software:

> Nevertheless, the Intellectual Property Code provides some specific rules regarding moral rights over software. It provides that the author may not oppose modifications of the software, in as far as such modifications do not affect his honor or reputation, and exercise his right of withdrawal.

Yes. This article specially weakens moral rights for software.

The remaining issue is that you can still forbid modifications that "affect your honor or reputation".

[1] http://legifrance.gouv.fr/affichCodeArticle.do?cidTexte=LEGI...

This is an interesting question. I was at a talk at this years's GsoC summit where this was discussed and indeed, the language of the BSD license does not issue an `irrevocable` license as the language of a lot of other licenses does. Nobody has every tried revoking an MIT or BSD license before, but it would be an interesting legal argument to see if the courts would allow it.

Thanks for this. I would be interested to know if, in practice (in a court of law), attempt to show something is derivative work when it's not is a more common instance than when it actually is. How easy (or hard) is it to prove something is a derivative work? (i am especially thinking of 2 pieces of code doing basically the same thing with the same algorithm, no patents)

There is done of case law regarding derivative works both in general as well as software. Some high profile examples:

https://en.wikipedia.org/wiki/Oracle_v._Google https://en.wikipedia.org/wiki/SCO%E2%80%93Linux_controversie...

There are tons and tons of cases in this area.

Clean room design is a sufficient but not necessary condition to establish that something is non-derivative. It's possible that enough changes to the source make it non-derivative under copyright law.

As the Wikipedia link you gave says:

> Clean room design is usually employed as best practice, but not strictly required by law. In NEC Corp. v Intel Corp. (1990), NEC sought declaratory judgment against Intel's charges that NEC's engineers simply copied the microcode of the 8086 processor in their NEC V20 clone. A US judge ruled that while the early, internal revisions of NEC's microcode were indeed a copyright violation, the later one, which actually went into NEC's product, although derived from the former, were sufficiently different that they could be considered free of copyright violations.

As another example, BSD Unix evolved sufficiently away from AT&T Unix that only a couple of files needed to be replace to get away from AT&T's copyright.

Both derive from someone else's works, but that's a different sense of "derivative" than what copyright law cares about.

The project ought to rip that code out ASAP (or talk with a lawyer), as the guy does appear to have some kind of patent, doesn't appear to have a good grasp of intellectual property and is acting like a loose cannon. Maybe tomorrow he won't approve of Canadians using his algorithms or banks, or YC startups, or who knows what. Or he could sell the patent to someone who could then go after the users of the open source package.

Why is he acting like a loose cannon? BSD does not include anything about patents, and he apparently offered a patent grant only in the context of Open Refine.

So you think it's deliberately malicious? Get a bunch of people to use the code and then shake them down with the patent? I don't read it that way, but either way it's toxic stuff for an open source project used by companies.

You put out code under a BSD license and people have some reasonable expectations that they can use that code.

I don't see anything about a patent grant - do you have a link to that?

What's more, his patent application was rejected, both for non-patentability, and on similar grounds as a previously rejected patent of a similar nature. Type the application number into USPTO's PAIR website at [1] for details. (Edit: app. no. 11/890,334)

[1] http://portal.uspto.gov/pair/PublicPair

Indeed, the copyright is asserted onto the written work. The algorithms, general idea, etc. are not copyright-able and except for US not even patentable.

The problem is many people don't understand what "open source" means.

Reply on news.ycombinator.com