Hacker News Reader

Comment by lr | Hacker News Reader

Quote: For software to be truly free, “users have to have control to run the program as they wish and to study the program’s source code and change it,” Stallman said. “This is based on two essential freedoms: to make exact copies and to copy and distribute your modified versions as you wish.”

The distribution part describes the BSD Licence, not the GPL. With the GPL, you are not free to "distribute your modified version as you wish." With the GPL, if you distribute a modified version to others, you must provide the modifications. That's not freedom to choose.

Stallman's idea of freedom in terms of the GPL is that, if you don't like the many pages of terms, then you are free to choose to not use the software, which is a freedom you already have.

If you have to have as many pages of stipulations as the GPL has, I can't see it as freedom. The BSD license is, in my opinion, a free license, as you release it, and the consumer of it is truly free to do what they want with it.

View on HN

Your view is developer centric. For someone that does not develop software, the restriction on distribution is irrelevant. The GPL is more free for the users. BSD is more free for the developers.

There are far, far more users in the world than there are developers.

This. Also, users are often unaware of what Open Source components are used in a software or a device they use. Organization reselling MIT/BSD products with some rebranding and marketing can mislead the users into thinking their products are entirely made from scratch. This:

- prevents power users from getting in touch with the original developers and becoming active contributors (testing, bug reporting...)

- discourages users from learning to code

- prevents power users from getting features / fixes / security updates from the original developer

- removes the opportunity for the original developers (and others) to receive donations from the users or be paid to work on the project

- fragments the community

>There are far, far more users in the world than there are developers.

The discrepancy would be even higher if you hinder the ability for developers to earn money through the GPL. Money has to come from somewhere, usually that is non-free software or ads.

I wonder how much free or open source software is truly independent of non-free software. I would argue almost none. Many OSS developers work at a company producing non-free software, enabling them to create free software in their free time. The big foundations are supported by the big software companies. Most companies producing free software do so for a market of non-free software developers.

If you decrease the freedom of developers you also decrease the ability for users to do anything, because there would be much less software. Software would be a small elite circle.

The world is a complex place, fundamentalism very rarely accounts for that.

What use is the GPL to someone who is not a developer?

Serious, non-snarky question. If you don't have the ability to modify or interpret the source code due to lack of time or knowledge, what exactly is the benefit?

What use is the freedom of the press to someone who isn't a journalist?

It's a benefit to readers / citizens to have information that is not completely controlled by a government, party or corporation.

Correct! And it's a benefit to users to have software that is not completely controlled by a government, party or corporation.

    <post type="devils-advocate">

Instead, it's controlled by an unaccountable mass of people who may or may not be working with their best interests in mind. Instead of abusing a user's wallet, they instead abuse their time, attention, or data.

Off the top of my head, Ubuntu's Amazon integration, Freedesktop's push to Systemd all the things, Firefox's new page ads...

    </post>

The difference between a corporation and a large FOSS project is limited to their goals and probably values. Both are generally subject to a central figurehead or committee who makes all the decisions and chooses how the project will evolve. I can't go propose a change to the Linux kernel unless Linus likes it. I could maintain my own fork, but it would consume nearly all of my free time.

It seems to me that all this talk of freedom is mostly philosophical, rather than practical.

> I can't go propose a change to the Linux kernel unless Linus likes it. I could maintain my own fork, but it would consume nearly all of my free time.

But if that change is not that big or fundamental you can still apply a patch with relative ease. Thats already huge compared to most proprietary Software.

> It seems to me that all this talk of freedom is mostly philosophical, rather than practical.

I disagree. It may not be always that easy in practice to take advantage of your freedom but that makes it not worthless. Maybe it's too much work for you to maintain a (partial) fork of the Linux kernel but if you find yourself a group of like minded people it may be perfectly possible. Free software also is by far unable to magically fix all of our societies problems but it is one tiny part of making the world better.

Free software fosters collaboration. You don't only benefit from being able to study and modify the source code yourself. You also benefit from others being able to do it. Because then they can help you.

The benefit is that the Four Freedoms[1] are preserved.

[1]: https://www.gnu.org/philosophy/free-sw.en.html

Freedom 0 exists with BSD code, 1-3 are worthless as a non developer.

So I'll ask again: What's the benefit to someone who isn't a developer?

You're entirely missing the point of what freedom means. The point is that you have the freedom to exercise 1-3 if you choose to do so. It doesn't matter if the user isn't currently a developer, and it doesn't matter if there is any practical benefit. The freedoms themselves are inherently valuable.

To me, the free software philosophy assumes that every user is a developer, or at least, it asserts that any user should be capable of comprehending and modifying any code that runs on their system, and defends their right to do so. The distinction between the two ("user" and "developer") exists because proprietary software and commercial software created a fundamental disconnect between the processes of ownership and development, and because computers have gotten too complex for any single person to fully comprehend. But it's not a distinction that should exist.

Or, it exists because there are infinitely more people who use software than even know how it works. Let's say that tomorrow, society gets together and mandates that any and all computer code is subject to the GPL.

Do you maintain that the user/developer distinction goes away? I don't think it does.

>Do you maintain that the user/developer distinction goes away? I don't think it does.

I would argue that wouldn't be sufficient to remove it in practice, since a good part of that distinction is cultural. People aren't taught to interact with their code because most computers are closed systems, making such interaction impossible, and most software is merely a product to be consumed.

Almost no one (understandably) wants to know how to use a c compiler to build the source code for their applications, much less take the time to review and modify it, no one wants to configure and maintain, even in the open source world it's unusual to actually contribute.

However, it would at least be a distinction without a legal difference.

I can't agree with that. I know how to read and write code, but I do not have the time to maintain, say, a fork of Firefox to fix their questionable UI direction, much less deal with the politics of getting my changes into the mainline app.

Stallman's ideal world, and by the sound of it, yours, is one in which everyone is a programmer. Put simply, as nice as it would be, this is totally impractical and unrealistic. Opening up a field to all comers does not meaningfully change what people enjoy and specialize in and spend their time on.

It's definitely impractical, as ideal worlds usually are. It made a lot more sense when most computers were in universities, being accessed by engineers, and when compiling from source was just what you had to do, and "software" was a much more fixed concept. But complexity has a way of undermining many utopian visions. I'm not certain the modern web would exist in an all free-software world, or what it would look like.

I'm more of an open source than free software person, since I don't buy into the fundamental moral argument of free software, but I have to admit I find the general principle that all software should be editable to be appealing. Knowing how to write software and choosing not to, or at least having the choice one way or the other, to me, is better than not having the choice to begin with.

Freedoms 1-3 exist with BSD, too, they just aren't protected.

There are few cases where freedom 0 exists without the other 3, but one case where that's true is with some of the Microsoft tooling around the CLR. In such cases, I, as someone who doesn't know low-level Windows programming, can't realistically change the software myself, but I could pay someone else to do it. But since I don't have freedoms 1-3, my only option is to pay MS if I want that modification. There is a very small group of people in the world who can afford to pay Microsoft for customizations. So even as someone who would never make modifications to the software, I care (and my boss who wasn't even a developer would care) because we had to work around limitations of our tools rather than paying someone to fix them.

By receiving GPLed software (with sources), compared to closed-down software that contains non-copyleft code?

- No lock-in, no artificial obsolescence. This is huge.

- Better security: Much lesser risk of backdoors, homecalling "telemetries", weakened crypto, adware

- Ability to pay 3rd parties to perform auditing, bugfixes, improve compatibility, even resurrect dead projects if needed

If I don't know how to interpret and write code, the first thing is meaningless to me.

If I don't check every single compiler and binary I ever run, the second thing is meaningless (open source malware is still malware), and I think Heartbleed is a great counterpoint to Linus' law. Availability of code does not change people's specializations or give them more hours in a day.

The last one is probably the only fair point, but then again, incompatible data formats happen among open source projects too.

You only need _one_ power user to disable the lock-in mechanism or to discover the security holes. After that, every user benefits even if they themselves cannot do such things.

Of course open source projects also suffer from bugs and incompatibilities, that's obvious and uninteresting. The point is that when you run into one of those, you have options available other than calling Larry Ellison and begging him to please fix your problems.

I only need __one__ power user (or employee) to do the same thing with the proprietary software. It happens all the time.

Yeeeeeah, that's kinda like saying you can get your drugs from a police evidence locker. You only need __one__ burglar or rotten cop! It happens all the time! Why do we need dealers or legal distribution anyway?

Plus you're contradicting your own argument. First you state that open source doesn't matter unless you can personally read and modify the code. Now you state that you're fine with proprietary software, because you only need one of the company's employees to remove lock-ins and fix security holes for you. Which one is it? Do you require being able to solve problems yourself, or can you rely on others?

I think you've misunderstood my argument (and not to mention mischaracterized with this loaded comparison of software to drugs!)

One way or another, you're always relying on others. The contrived person who audits all their own source for all their apps down to the compiler level does not exist. Systems are too complicated for that.

At that point, the question becomes "who do you rely on?" - and especially given recent history, I'm not convinced that "everyone who knows how to make a pull request" is a better answer than "only the people that made it". Certainly not convinced enough to begin moralizing about software development schemes...

Quite a few strawmen here.

> If I don't know how to interpret and write code, the first thing is meaningless to me.

No. Knowledge like, for example, mathematics is unencumbered by patents and accessible to everybody. All humanity, directly or indirectly, benefits from it. Same for the freedom to read and modify code.

> If I don't check every single compiler and binary I ever run, the second thing is meaningless (open source malware is still malware)

Mandatory food labeling, traceability and hygiene standards clearly improve food safety for everybody. Same here.

>I think Heartbleed is a great counterpoint to Linus' law.

Not at all: given enough eyeballs

Besides, perfect security is impossible and some cases of food poisoning don't disprove the effectiveness of food quality standards.

> Availability of code does not change people's specializations or give them more hours in a day.

Availability of code allowed me and others to learn and review code.

> incompatible data formats happen among open source projects too.

Cherry picking again? Deliberate use of incompatible formats in order to create lock-in is very infrequent in comparison with closed source.

Completely agree. And extending the last point: the ability to, if needed, learn how the thing works by yourself and try to fix it/modify it to fit your needs.

You don't need prior knowledge of plumbing to try and fix your broken kitchen, specially on today's world, with so much free information available. In a similar way, you don't need to be a software developer to hack your way through and learn how a program works and try to change it.

You can hire someone to interpret it for you if you need to. For example, hiring a specialist to do a security audit, a task which is beyond the normal expertise of most developers.

Stallman's view is even more developer-centric.

Who cares about source code? Not most users.

If the aim was to make software that's easily user-modifiable - user-modifiable, not developer-modifiable - free software has been a complete failure.

There's certainly a net benefit in distributing software with free access to source code so it can be modified by experienced developers.

But that has never been Stallman's stated aim. If Stallman and the FSF really cared about users - not developers - they'd have spent more time creating software systems that were user-editable.

In fact the industry, including Stallman, has stampeded in the opposite direction.

It's harder for ordinary users to make modifiable software now than it's ever been in the past. We no longer have HyperCard, VB and VBA are dying arts, and the insides of all operating systems - including Linux - are absolutely horrible environments for non-developers to work in. We don't even have BASIC or those make-your-own game systems we had in the 8-bit days.

Those were bare minimum systems. Has it really been impossible to invent something better for more than 30 years?

No one knows. But for all the rhetoric, the question interests Stallman as little as it interests the rest of the industry.

The GNU project boasts some of the most hackable software ever made. GNU Emacs is the most notable. RMS has been an advocate for languages like Lisp over languages like C because programs written in Lisp, like Emacs, are user extensible.

> The GNU project boasts some of the most hackable software ever made. GNU Emacs is the most notable.

Politics sometimes stops the hackablity https://news.ycombinator.com/item?id=8861360

If that were the case, how does that explain the "plugins for gcc" issue.

> Who cares about source code? Not most users.

That's not correct. People care about their problems being solved. Hence they care about the source code implicitly.

When my car is broken or needs an oil change, I don't do it myself, I take it into a car repair shop and I like the freedom to go to any car repair shop I want, because those folks from our local Peugeot representative charge an arm and a leg.

That's how freedom works dude ;-)

Your point relies on a significant number of users caring about such things, but empirically, they just don't. No number of car analogies will make GPL-style software freedom meaningful for the vast majority of people.

Users definitely care about not being tied to a certain provider.

Do you remember when Internet Explorer was the only kid on the block, and then Firefox came out and was a breath of fresh air? I know a lot of non-programmers who cared about that, and that's a direct result of the ability for anyone to modify software. Remember that Firefox was based on Netscape, which had previously been knocked out of existence by IE. The difference between Netscape and Firefox was freedom to distribute modifications, and that made a lot of difference to a lot of users.

"Who cares about source code? Not most users."

I agree with bad_user that they care implicitly. They care when Oracle is gouging them at $40-70k when it could be free to $5k. They didn't like Microsoft taking away their start button, which was easy to bring back for FOSS GUI. Many didn't want to spend much on a computer for basic tasks, which Linix distros on Netbooks helped with. Many wanted more or specific applications for their smartphones, which Android lets you have. Many want their OS to not spy on them like Windows 10 does, which requires being able to inspect or modify it.

So, they care. They just rarely see it put in terms they understand. Whenever I do, they always support the alternative even if they won't buy it occasionally due usually to backward compatibility with locked-in stuff (eg Office, Oracle, SAP) Stallman warned about or just their personal preference (eg iPhone over Android).

"If the aim was to make software that's easily user-modifiable - user-modifiable, not developer-modifiable - free software has been a complete failure."

Yeah, that's true. It also, as you note later, hasn't been easily developer-modifiable either with how they write it. One of reasons for LLVM's existence was how much of a pain it was to work with GCC. And all kinds of people want to improve FOSS software but few can or do. The dream and reality are quite different.

> Who cares about source code? Not most users.

Mot users probably don't know that it's something to care about.

> There's certainly a net benefit in distributing software with free access to source code so it can be modified by experienced developers.

Even if a user is unable to do modifications himself, there is still a huge indirect benefit because he can use modifications others make or he may hire somebody to do modifications.

> But that has never been Stallman's stated aim. If Stallman and the FSF really cared about users - not developers - they'd have spent more time creating software systems that were user-editable.

The stated aim is to make it possible to freely share and modify software, not to make everyone an expert in the field. Sure educating people and lowering the barrier at some points would perfectly align with the goal of free software but it's still something different.

> Those were bare minimum systems. Has it really been impossible to invent something better for more than 30 years?

Also a lot less capable systems.

Why should there exist a distinction between users and developers?

If more people were educated in the basics of software development, enough to help them in their chosen profession and to understand the technology around them, those people wouldn't be so easy to abuse in the first place. Basically this line of thought is a huge mistake, playing on the tune of the software companies and state agencies that abuse people and break their freedoms.

And in fact, I'm pretty sure that Stallman disagrees with you. After all, this distinction is why he was pissed off and started GNU and the GPL in the first place ;-)

Yet the developers are the ones who can and choose their software licenses.

Without developers choosing BSD or MIT over GPL, GPL loses some of its influence.

> With the GPL, you are not free to "distribute your modified version as you wish."

Yes you are. Unless you opt of that freedom by creating non-free software. Supporters of the GPL are are not concerned with the self created problems of creators of non-free software.

So, excluding the "as you wish" part. You are not free to distribute it as you wish, but as the GPL directs you. (I support both GPL and BSD style OSS, and I am usually pro-Stallman, but the OP really has a good point here)

Yes, the OP (lr) does have a point. But so does mike-cardwell.

Think in terms of generations. Generation 1 (G1) writes the original software, and makes it available under either the GPL or BSD license. G2 receives it, modifies it, and passes it on to G3.

Now, under the GPL, G3 receives G1's and G2's software with all the rights intended by G1's author. That's a restriction on G2, but it's a freedom to G3 (and also a restriction, if G3 is going to modify it for G4). Under the BSD, G3 gets G1's code with all the rights given by the author, and possibly gets G2's code with no rights at all. That's a freedom to G2, but a restriction to G3.

Which is "right", or even just better? I don't know. But I think it's important to notice that in both cases, freedom is being both given and taken away, just from different people.

It depends onto what "as you wish" is applied here. You may >>distribute<< it to whom you wish, when you wish and under the conditions you wish. What you can not do as you wish is to dictate further restrictions to the receiver after the distribution process is over.

The point of the GPL is to ensure that free code remains free. So long as you do not try and restrict someone else's access to free code and modifications to it, you do not run afoul of the GPL.

Put another way, if an end user gets a product which includes free code, they should also have access to the source code.

All of the legalese is merely an attempt to codify this simple concept into the language of law.

Ultimately, as a developer, if you want to use GPL'ed code in your own projects, you need to be prepared to pass on those freedoms you're taking advantage of. Otherwise, write it your own damned self. :)

Or find the (almost always available, almost always higher quality) equivalent under a license that doesn't try to make software into a religion. That option has served me well for over a decade now.

> doesn't try to make software into a religion

This seems silly - why does having a point of view grounded in reality (too much software actively works against its users), constitute a religion? Is the UN is also a religion, because they uphold that basic human rights exist and should be enforced?

> That option has served me well for over a decade now.

Yup, that is the other option, though you're bound by their license agreements as well. They just tend to focus more on waiving liability and responsibility.

This is such an absurd fallacy that FSF nuts have been using since at least the early 90s.

The GPL does not ensure jack squat. It ensures source code availability as much as the BSDL does.

Consider the following function:

defmodule Jail do def jls() do System.cmd "ls", ["-la"], into: IO.stream(:stdio, :line) end end

Regardless! of which license that code is released under, that function is now open source, for the entire world to see and use. Period. It is never going away, it's never going to be unavailable. Or locked up. Or "closed". And "closed"? How stupid a statement is that about open source. Look, you cannot close open source! You can use it but the same open source code you are using is still out there and available! You can't make it disappear.

What you CAN do is ADD to that code. It's called adding value. And that added value code is yours to do with as you wish. Release it open source or not. I don't give a crap, my function is still free, still open source, and still available for anyone to use no matter what you have done with your copy of it.

So don't give me this crap the GPL ensures code "remains free", it doesn't. That is a load of hogwash. And always has been.

The point of the GPL is to force others to release their value added code. To virally infect non free software to become GPL licensed open source code. And before you say "no one forces you to use GPL'ed code", you are right no one does, but then don't also claim your code is free. It's not.

The bottom line is the GPL accomplishes nothing the BSDL does not already accomplish. Except forcing anyone who uses it to license their value added code under the GPL and play by some socialist zealots rules.

The GPL is a one way technology blackhole. It sucks up other code licensed under more liberal/free terms but can't be used by them in reciprocation.

And your last statement is classic GPL thinking! "Play by MY rules or I am taking my ball and going home!" How freedom loving. We could all learn to embrace such a wonderful concept of freedom as that.

I think you have to understand this as a question of strategy. GNU and GPL does not exist only as a free alternative as a gift to the world. They are both strategic creations to further the aims of the free software movement.

Your argument is more or less correct, but it's a feature, even as seen by free software advocates. Not really a fallacy.

Compare it to the argument for gender quotas. A fair criticism, along similar lines, is that if you really do believe in equal rights and fair chances then you shouldn't argue for gender quotas, as they are, in fact directly opposed to equal rights.

In both cases the argument fails because it conflates interim strategies, designed as bootstraping mechanisms, as an application of the principles it's supposed to further.

"Strategy" is not an significant concept for free software critics like the parent. They have seen this argument, but they are strictly first-order thinkers so it hasn't registered for them.

I think the GPL can be seen as a clever law hack (in the sense of creatively using something in ways not originally intended). In this case not to enforce restrictions in usage but to actually enforce the opposite.

> socialist zealots

As if what-the-hell-is-an-externality free market "libertarian" zealots were any better.

> that function is now open source, for the entire world to see and use. Period. It is never going away, it's never going to be unavailable. Or locked up.

Sure. It's completely inconceivable that the moderation team might take down your comment, add "value" (read: adverts and malware) to your code, compile it into a binary and then charge $499.99 for a copy. Though even if something like that happened, you should be fine with it, right? If you don't like this outcome, you wouldn't publish it here in the first place. Everyone did exactly what they wanted and everyone should be happy. Total freedom!

Copyleft guarantees freedom for the recipient of the software, whichever hands it passes through. Were it not for copyleft, proprietary software vendors could always take the open source code, do some "adding value" without releasing source code, lock in users into a proprietary platform using network effects or whatever, and in the process make the original software useless and drive it out of business ("Why do you keep using this OpenBSDM crap instead of buying EvilEmpireCorp LiteralKillerApp 9002™©®™® like everyone else? It has shiny rounded corners!"). Copyleft doesn't always remove this advantage completely, but it often helps level the playing field.

Copyleft exists for some very good reasons. To not recognise them, and to spew slurs on it claiming it's not "Real Freedom" doesn't reflect very well on your viewpoint.

> Regardless! of which license that code is released under, that function is now open source, for the entire world to see and use.

Only if you disregard the law. Copyright law says that no, that is not freely available to the world. It's owned lock, stock, and barrel by the person who wrote it. If you choose not to attach a license to the code, nobody else may legally use it (barring fair use).

What license you attach to it defines how others may legally use it, and with what restrictions.

The law is why you can obtain the source code to Microsoft Windows from Microsoft themselves, but you can't re-release it in any form.

The way to start thinking about Free Software is to focus on the first word of the Stallman quote: "Users"

Users are the people which Free Software is aimed at being around. We often consider our right when we work or publish or develop software, but Free Software is concerned with our users (of course we are also users of other peoples software too, if that makes it easier to understand),

GPL enforces "general freedom" by removing your right to freedom.

BSD removes "general freedom" by giving you the right to freedom

> If you have to have as many pages of stipulations as the GPL has, I can't see it as freedom.

Mad Max definition of freedom? Freedom from slavery, freedom of association and freedom of speech require quite complex legal framework to be clearly defined and therefore enforceable.

What is freer, a society where it is legal to kill each other, or a society where killing is illegal?

On this question, ceteris ain't paribus.

Sure it is! In one society, killing is legal. In the other it is not. That's the only difference.

In this construct there are less differences than between GPL and BSD.

This is the kind of word twisting I expected to hear. The bottom line is that bsd is freedom for the devs, and gpl is freedom for the users. Devs are also users, but users are not devs.

RMS is going to be looked back at in history and people are going to wonder why so few listened to him, hes a man ahead of his time.

The other thing I expect to hear is "RMS is just so abrasive, nasty, weird, extreme...." Trite and old responses.

While I mostly agree with you, I do think that once we have moved to a non-GPL world, nobody (or very few) will care or know about the alternative.

People get just used to the current state of affairs, even if that means not having rights that they do not even know are possible.

Because something has less legal text does not imply that it is _more_ free. It implies that it changes the default behavior of the law _less_ than a longer text. The BSD license defaults to however the law would otherwise resolve copyright issues. The argument of the GPL is that the default of the law is not sufficient.

The freedom to deny freedom to others is not freedom.

Yes, if it makes the system in its whole more free.

According to you, a society with the freedom to kill is more free than one without that freedom.

I've followed, and sometimes participated in, variations of this discussion since 1989. I wrote up an article about this topic on the Yakking blog, recently: http://yakking.branchable.com/posts/comparative-freeness/

It's not a useful discussion that will ever go well, so I'm not surprised it's a big subthread on HN.

> With the GPL, you are not free to "distribute your modified version as you wish."

Precisely. You don't have the freedom to deny others the freedoms you enjoyed. It's by design. The GPL was designed to keep everyone free, not just the first developers to touch something.

Public Domain (e.g. SQLite) is the freeest possible license. Anybody can do literally anything with it. Even things that might infringe on some future freedoms, like not ensuring source code versions of modification are available. The freedoms to make unfree, i.e. not right, choices is strictly more freedom than the GPL. The GPL tries to make it so that the only choice is to do the right thing, but in a set of choices (i.e. freedoms), the right thing is strictly a subset of all possible freedoms.

Stallman wants, real hard, for this restriction of freedoms to be viewed as somehow "more free", and is fairly hardline about it. I wish he'd stop using freedom as his motivator and just talk about ensuring information access, which is really what his goal is.

The usual reductio ad absurdum is: In another world, you are allowed to sell yourself into slavery. In this one, you are not. How can the world containing slaves be the one that's more free?

In other words, the code is free until it is added to, becomes proprietary and - if a network effect adheres - then that proprietary version can dominate and in effect extinguish the public domain version. Certainly extinguish nearly all its value. The once-again-enslaved code lives and thrives, the freeman code perishes, or nearly so. That's a good argument, but the whole problem is created by an IP system that perverts the concept behind copyright. Paintings don't prevent other paintings from competing, code with a network effect or lock in does. Copyright should either never have been applied to code, or be for a very short period. Let's say, four years or eight years. Then BSDL code going proprietary isn't a threat, it's a bonus: more free code soon enough.

Reply on news.ycombinator.com