Hacker News Reader

Comment by boris | Hacker News Reader

However, we can lament the fact we can not use/extend (namely - import) your code to add to it without triggering the GPL requirements within our own code.

Zed's point is that the "BSD folks" seem to complain more when someone releases their code under the GPL than when a company releases this same code under a completely proprietary license. In case of the GPL'ed code you can at least study it, get some ideas, and perhaps provide your own BSD'ed implementation. In other words you complain more about people that give you something than about people that give you nothing. I do find this strange.

View on HN

If I can sidetrack this for a moment, could someone explain (or, far better, point me to a thorough analysis) the ramifications of if somebody were to "study" a GPL-licensed program's source for its algorithms, formulas, etc., and then completely re-implement the package from scratch? I don't think I've seen this addressed in license FAQs.

For a specific example, there is a book called _Calendrical Calculations_ which collects algorithms (and source, in Common Lisp, IIRC) for doing numerous time/date-related conversions. The authors patented the algorithms and the formulas as presented in the book. This seems a bit odd to me - it's not like they designed the Mayan calendar; while I respect that they did quite a bit of thorough research, that seems like the epitome of prior art. OTOH, the algorithms are also released under the GPL, in the form of the Emacs calendar mode.

The book's license: (http://emr.cs.iit.edu/home/reingold/calendar-book/first-edit...)

I'm a bit confused about the ramifications here - must one just ignore all of his research if you want to release date arithmetic code under a non-GPL free license? (I prefer the MIT/ISC and LGPL licenses) I thought the GPL only covered the implementation, but the apparent issue with the book's license really confuses me. I'm interested in writing a date arithmetic library in Lua or C, since having such a library specifically inside Emacs is of limited use, and my background is in history.

In that specific case, the authors are probably willing to negotiate (and I may just be misunderstanding things) - I'm more interested in how that situation plays out in general.

I think this is bizarre as well -- to not complain about the company that uses BSD code as part of the most closed OS in common use today, but get all uppity when someone decides to go GPL.

I figure the most plausible reason for this inconsistency is this: the GPL code is that much more tangible -- it can be read and used, just not distributed the way they'd like. Versus BSD code used in proprietary software whose code is completely inaccessible. GPL gets the flak because code released under it feels more within reach.

Well, I look at it as an argument over what "free" and/or "open" mean.

Suppose Alice releases some code under the BSD license, and Bob releases some code under the GPL.

Both of them can claim that their code is "free" and "open" and other wonderful adjectives. But Bob can incorporate Alice's code without making any changes to his license terms, while Alice would have to change her license terms in order to incorporate Bob's code.

Thus, to Bob, Alice's code is "free" and "open". But to Alice, Bob's code isn't -- from her point of view she can only use Bob's code if she accepts restrictions on modification and distribution.

And so Alice -- regardless of whether it's objectively right to do so -- probably ends up feeling that Bob's putting one over on her when he says his code is "free".

In other words, it's not about someone saying "I chose this permissive license and now I'm upset that other people abused my code", it's about someone saying "that other dude claims his software is 'free' but it doesn't look that way from where I'm standing".

"Bob can incorporate Alice's code without making any changes to his license terms, while Alice would have to change her license terms in order to incorporate Bob's code"

This is an inaccurate way of describing what happens. It buys into an incorrect idea of "GPL as virus". Alice's code remains Alice's, regardless of whether she incorporates Bob's code. Her licensing is unchanged. The combined work has to be distributed according to all licenses that make up that work. That includes the BSD and the GPL licenses. Because the BSD requirements are effectively a subset of the GPLs, and there is no incompatibility between the requirements (i.e., BSD is GPL-compatible), then it's as though everything was under the GPL. But Alice is free to deincorporate Bob's code, and everything is as it was.

The very text you quoted was talking about Alice's ability to make use of Bob's "free" code. Were you not reading what you quoted?

Consider this, also, when thinking about which is "more free":

Which person's code can be used with code that is distributed under a different copyleft license?

Which looks "more free" to the person (perhaps Charlene) who wrote the code under that third license?

But Alice did release her code under BSD...........so she should not really care what Bob does with her. After all, she does not care what Apple, Google or other do with it.

So in this a case of double standards by Alice?

No, I think you skipped the last paragraph of my comment. It's not about how other people use BSD code; it's about the word "free", and the feeling that "you can modify and distribute this only if you accept my terms and restrictions" is perhaps a strange definition of that word.

it's about the word "free", and the feeling that "you can modify and distribute this only if you accept my terms and restrictions" is perhaps a strange definition of that word.

Only strange because you're framing the issue with individualism. The GPL was created by a socialist and values social freedom more highly than individual freedom.

The two ideas of freedom are always in contention. Like the freedom to swing your fist wherever you like vs the freedom from getting hit in the face by random people.

BSD: http://en.wikipedia.org/wiki/Negative_liberty

GPL: http://en.wikipedia.org/wiki/Positive_liberty

I have no idea where you stand on the issue of which is the more "important" definition of freedom, but the way you frame the issue is pretty much spot-on (especially since it perfectly mirrors my own take on the difference, and reinforces my thoughts on what's actually "more free" in both political and software senses of the term).

If humans are "free", why I cannot capture them and sell as slaves? Are they really "free"?

Word "free" has lot of meanings in English language. In my native language, word "free" in context of BSD licensed code should be translated as "svoboda" (fully unrestricted state of something), and in context of GPL licensed code as "volya" (has it own rights, abilities, goals, like free human).

I think this is the best description of free-beer versus free-speech I've ever read. Thank you.

I think that falls apart when you realize that, by using a license identical to the GPL but with all instances of "GPL" replaced by some other term (say, "RCL" for "really cool license"), the code distributed under each license is unusable in projects using the other license. Where's the freedom to cross-pollinate?

So, your post can be summed up by: BSD people don't think that the GNU people should use the word "free."

Uh, yeah.

I guess GNU people are perfectly welcome to use the word "free", but they should stop acting like they're using "free" in some manner that makes the recipient of the code more "free" than less restrictive licenses.

Those restrictions are intended to preserve others' freedom while cutting individual freedom. That's a Social Contract: we agree to apply some restrictions on our individual freedom to ensure that, overall, freedom stands high.

If Alice lives in a society where murder is permitted, and Bob doesn't, Alice may feel she is "free" whereas Bob is not. From her point of view she can go live with Bob only if she accepts restrictions on what she can do. But Alice is missing the fact that by exercising her right to murder she is depriving others of their rights. And what if Alice herself gets murdered? How "free" would that leave her?

Defining concepts basing ourselves on "points of view" or "feelings" is pseudoscientific, leads to contradictions and is completely useless. So no, I don't think one should decide how free she is by merely substracting the number of things she is allowed to do from the number of things someone else is allowed to do. I'd try to grasp the big picture and figure out which set of rules will lead to a higher number of free and happy people.

That's absurd. Murder? Seriously? Are you really comparing the ability to use code with fewer restrictions with "murder"?

Is "murder" the new "Nazi" or something?

edit: . . . and I'd like to see your statistical evidence for the GPL actually resulting in "more free and happy people". I think the BSD License is a great and subtle fishhook for pulling people into the world of free and open source software, whereas the GPL is a gigantic barbed hook the size of my head with blood and gore dripping off it (at least in the eyes of many businesses), so obvious in its intent and the difficulty of getting unhooked after taking a nibble that many of them may never give it a chance.

In short, I'm not convinced that the GPL helps. Maybe it results in a marginally higher rate of return among those who use the code. Maybe. Then again, maybe it also results in fewer people using the code, and maybe overall that results in a lower rate of return. 50% of 100 isn't as much as 20% of 1000, after all.

I never use GPL'd code in any of my projects, because I publish code under a copyfree license (http://owl.apotheon.org). My code often gets reused in proprietary software for resale -- and I'm happy with that, but the GPL simply cannot exist there.

I wonder if the reactions are from gut-level social norms? It feels like Zed is violating a social norm for equal exchange--like showing up at a party empty handed. Maybe Apple showed up empty handed, but Zed showed up with a pie and refused to share it which seems worse.

The BSD code he is using was given with no restrictions and his "reciprocation" is restricted code that cannot be shared in a BSD project without ruining the license.

I think you're close. When we download an OSS project I think we have the expectation of being able to integrate it into our own projects, and there's some amount of disappointment when it triggers a GPL conversion.

When Steve Jobs comes to the party, you don't say to him "Look, you're not sharing your cake with us, so we're going to kick you out." You say "Holy crap! Steve Jobs!" But when Joe-decent-coder-not-a-celebrity does the same thing, it leaves a different taste in your mouth.

I think another (similar) part of the equation is the hoity-toityness of the GPL and/or FSF. Just read the GPL preample (WTF does a license have a preable for, anyway?). The first time I read it, it sounded to me like Stallman and/or the FSF were called forth from the burning bush to save us from the horrible slavery of permissive licenses. If you ask a random person off the street what sort of license an organization called the "Free Software Foundation" would use, I guarantee they wouldn't invent a whole Gettysburg address worth of rhetoric for why free software needs a handful of restrictions.

We can have a debate about whether copyleft is good or bad in the long run all day long. I'm just saying, on a gut level, on a prejudicial level, if somebody presents you with a barely-half-page BSD/MIT license of "Use this and don't sue us", and then an epic novel about how you can have patents as long as they're nondiscriminatory, or granted prior to March 28, 2007, or that we'll put you on probation for 30 days (or maybe 60) if you violate something-or-other, and you must provide installation instructions with such-and-such, and you can't distribute such-and-such in a password protected RAR... On a gut reflex level, the second one hardly sounds like free software. Maybe after researching it, you come around to their point of view. But most people don't research it, and some of the ones who do disagree.

To be fair: that's a little spun. He certainly didn't refuse to share it.

To extend the metaphor past the breaking point: he offered it only to those willing to bake pies for others. But the partygoers just wanted dessert, they didn't want to be stuck baking for others. If you like pies and think people should bake them for each other, that's hardly a crisis.

But you're absolutely right that this is about social issues, and not pies or licenses at all. What people are really angry about isn't the pie they have to bake, it's that Zed showed up with a blueberry pie, when everyone had agreed that they would eat only apple pies. And even though that blueberry pie looks good, it marks Zed as one of the enemy. So he must be shunned.

By sharing, I meant that he is not sharing his code in such a way that they can feed it back in their own BSD...pies.

No no no . . . it's more like the others didn't want to be required to demand that other people bake pies for them.

"Look, when I bake a pie and give it away to other people, I just want other people to have the pie and be happy. Why the fuck do I have to promise to demand that other people bake pies for me if I use your recipe when I bake pies for them?"

I think it's a perception issue, and a bit of rivalry. Most companies that release proprietary, closed-source software don't even pretend it's "open" and "free". For quite a while, the GPL was the perceived pinnacle of "open" and "free". The problem is, it's decidedly less open and free for authors who prefer a more permissive license.

Re-implementing code with another license is a massive gray area, btw. This is why reverse engineering groups go to great lengths to make sure the people working on things have never seen the licensed code they're attempting to emulate.

But here lies the whole point of (L)GPL. I would argue that one of the most important open source projects in use today is WebKit. It started as KHTML, moved to Apple as WebKit, then moved its way into Nokia (S60WebKit), moved its way into MobileSafari, and then moved into Chrome, and now a whole OS (Chrome OS), not to mention many other projects that use it.

One of the big reasons it has spread so much and done so much good in the open source community is precisely because it is LGPL. Consider whether you think Apple, or Nokia, or any other company along that chain wouldn't have just closed sourced it at some point if it wasn't because it was specifically "copyleft".

We don't know what would have happened if it had been BSD-licensed.

Maybe Apple, Nokia and Google would have contributed any changes they make anyway, because it makes merging easier and any competitive advantage they have does not come from their rendering engine.

Maybe more companies would have used it, possibly instead of licensing Opera. Maybe some of these would have contributed their changes back as well.

Possibly the tradeoffs involved in BSD versus (L)GPL can be measured, but pointing out examples of successful/failed projects using one or the other is not helpful.

Of course we can never know for sure, but we can certainly draw very educated guesses and conclusions.

For starters, the argument that "perhaps some" of them would have behaved the same is no where near as nice (in open source terms) as "absolutely all" behaved this way and will continue having to behave this way.

We can also analyze the behaviors of some of these companies. Just look at Safari for example: the open sourcing stops precisely where the licensing requirements stop: the engine is open source but the browser itself is closed source. Apple has unquestionably contributed the most to this web engine, and they are unwilling to contribute any more beyond their legal requirements.

Additionally the effect this has created in the web world is pretty powerful. Companies are now in a position where their choices are investing a tremendous amount of work in creating a new web engine or using the best existing web engine to be competitive but having to contribute all their changes back. This is particularly true in the mobile web space where WebKit is essentially the only engine that has proven itself capable of providing a desktop caliber experience. In terms of open source goals, there could be no better situation. You basically have to use an open source engine to be competitive, and the most competitive of these engines requires you to contribute back to the community in a space that is dominated by commercial investment.

For apple I think the theme is engine / skin not what the license requires.

osx : darwin :: safari : webkit

Notice how the relationships revolve around the engine vs skin, not what the GPL requires. In other words, apple protects what makes them apple, not the underpinnings, at least in these examples.

Perhaps they wouldn't all have contributed code back.

On the other hand, maybe yet more would have used the code, and some of them would have contributed code back.

Copyleft vs. copyfree is not a zero-sum game. Choice of license doesn't only affect the restrictions placed on those who use the code; it also affects the likelihood that someone will use it at all, and we really don't know how many people avoid using some code for a given license and might have contributed their improvements to the community.

The amount of work we've already seen entombed in failed BSD and SysV forks is also good evidence.

It's evidence of something.

I wonder how many failed Linux distributions there are.

"The problem is, it's decidedly less open and free for authors who prefer a more permissive license."

GPL-licensed software is Free software that stays Free. BSD software can become closed any time, something GPL software cannot. If you contribute to a BSD'ed project you take the risk of your competitor taking your code and making it a competitive advantage against you.

We may say GPL'ed software is "imprisonment resistant".

As for taking in Lamson code into Django, all that's needed is a GPL'ed fork of Django that can follow trunk very closely. GPL'ing Django is, in fact, turning that "imprisonment" mechanism on its head.

Any such code, of course, would have to be kept out of Ellington, for instance.

edit: second part of second paragraph was wrong

Oh, yeah, I forgot something in my other response.

> If you contribute to a BSD'ed project you take the risk of your competitor taking your code and making it a competitive advantage against you.

The GPL actually has more value as a tool of anticompetitive advantage than the BSD License:

http://sob.apotheon.org/?p=622

BSD code used in proprietary software is not "imprisoned" -- the original work remains free no matter how someone uses it.

> GPLed software is Free™ software that remains Free™.

FTFY

Maybe it's because we expect that our complaints to developers will be heard, but complaints to companies will fall on deaf ears. Even though the value of a company like Apple coming around to your point of view is high, the expected value of complaining is still quite low.

Maybe it has something to do with the fact that "big, evil corporations" are a write-off, and we expect them to be evil -- while people who take BSD-licensed code and wrap it up in a "thou shalt not touch" layer of GPL should know better.

Reply on news.ycombinator.com