Posts tagged with "BSD"
Sunday, September 16, 2007 9:13:02 AM
Free software is important. Not the most important thing, but one of many important things.
Free software is about putting the user's freedom in focus. No one else that the users themselves are better to protect their own freedom. Information will help users to protect their freedom. Protecting the freedom by force (GPL) will in the end backfire and reduce freedom.
Certification is a good way of informing the user about free software. Just releasing software under a non-copyleft license is not enough, since it does not give the user enough information.
Sunday, September 16, 2007 9:11:11 AM
I think branding of a product is an important right for a distributor of a software.
Therefore, I think the FSO license must include some way to protect a the software distributors brand. I do not know enough about these things, but something like this maybe:
- If a distributor want to add brand protection to its software, it must send the branding license that will be included in the software to FSO, before the software is distributed.
- FSO will approve or decline the branding license, if approved, the distributor can then include the branding license and distribute the software.
- FSO will need some directions for how to judge a branding license. The software distributor must be able to protect its brand, but the one that wants to build something on the software must not be too restricted. The branding should at least be easy to remove, if the demands to keep it are too high to be accepted.
Branding support in the certification will make the certification more business friendly, I think, and still not sell out the user's freedom.
Sunday, September 16, 2007 9:07:36 AM
FSO will put the control of the free software in the hands of the user. The user will select FSO certified products if they find the free software to be good in all aspects. (including the criteria that it is free software)
FSO will lessen the power of the developer. The user will be able to make an informed choice, and the developer who wants to limit the way the code is used by using GPL will not be able to be certified.
So, what is the weakness with FSO? A business may want to go with GPL, since it does not want to share code with other companies that wants to share the code back, and it does not make it possible to dual license the software.
So how does FSO tackle this weakness? It tackles the weakness by making sure that the user will request FSO certified software. The GPL dual licensing company may then be forced to change business model to stay alive.
In the next part, I will add some notes about branding.
Sunday, September 16, 2007 9:04:48 AM
In part 6, I sketched how free software could be protected by certification.
A sketch is good, but seeing the details will make it easier to understand.
- A "Freedom software" organisation is formed (FSO).
- FSO creates a license including what it takes to be certified as Freedom Software.
- FSO creates a logo that is registered.
- FSO will receive requests from those who wants to distribute a Freedom Software certified product.
- FSO will grant or dismiss the request.
- FSO will protect the usage of the "Freedom software" logo.
So, that is basically what FSO will do.
One thing to note, is that FSO will certify a specific distribution of a software, not the actual code. FSO will not include a software license in its license, it will just tell you what is needed for a software license to be compatible with the FSO license. Licenses like BSD and MIT will be compatible, GPL will not.The rules in the FSO license:
So, the process is:
- All source licenses used in the software must be included and followed.
- The source licenses must follow the four free software freedoms, and can only force the inclusions of the source license in changed software, the source can not be forced to be released.
- The software must include its checksum.
- If the software has any form of binary data, all source code needed to generate the binary data must be included in the software, or in a separate source package, including instructions for how to build the binary data.
- If a separate source package exists, the software must include a pointer to the source package, plus include the source package's checksum.
- The result of building any included binary data from source, must result in the exact same software (same checksum) as the distributed software.
- Before the software is distributed according to the FSO license, a request to FSO must be sent, including info about where to find the software package, and what its checksum is.
- If all the above things are fulfilled, the "Freedom software" logo can be included in the software. However, if FSO finds that the software cannot be certified as "Freedom software", the software distributor will be asked to stop distributing this software package.
And the user:
- You build a software product that is meant to be Freedom software.
- You check that the FSO licence is fulfilled.
- You send a request to FSO.
- You distribute your software.
- FSO adds your software, in the form of the checksum, to their open database, listed as under investigation.
- FSO checks the software and gets back to you, telling you if you are certified or not.
- FSO adds the software (by using its checksum) to its open database, with certified, or violating the FSO license.
- Gets a package that says it is Freedom software.
- Checks that the checksum of the software is correct.
- Connects to the FSO open database to see if the checksum is a certified product or not.
- If the checksum is not reported to the FSO, the user can report it to FSO, since it clearly violates the FSO license.
- If FSO lists the software as certified, the user can just go ahead installing the software.
- If FSO lists the software as in violation, the recommended action to the user is not to install the software.
- If FSO lists the software as under investigation, the user can wait for the investigation to finish before installing, or trust the distributor and install it directly.
- The user can check back to the FSO open database later, to see the current status of the software that is installed.
An important aspect of the certification process is that you will be allowed to distribute software as "Freedom software"-certified even if it is not yet certified. This is to avoid the problem with delaying the release of a software. If certification will mean that you are delayed one week or more, less software will get certified. Some users will of course wait for the software to be certified, but the same thing will happen today too, some will wait for others to find the newly introduced bugs before installing the new version.
Sunday, September 16, 2007 8:27:52 AM
In part 3, I promised to present a free software philosophy based on the semi-liberal view. Well, it is time to live up to that promise.
First of all, we should not limit how the code is used. So, the BSD license is good enough, but the GPL is not good enough. Actual limitations on how the code is used is not acceptable in the semi-liberal view.
Of course, public domain code is also good enough.
In the semi-liberal view, it is important to be able to inform the user about free software and its values. (just like informing about the dangers of sugar was important in the real-world example)
One way to inform the user, is to certify a product as being free software. A product can use the "Freedom software(TM)" logo in the product. That way, it is easy for the user to see if a product is free software or not, and make an informed choice if they want to support free software or not.
The "Freedom software organization" will certify the product so that it can use the "Freedom software(TM)" logo.
That is basically it. Use a free software license (non-copyleft) for the code, make software distributors to have a chance to certify their product as "Freedom software(TM)", and let the user do an informed choice.
In the next part, I will describe the details in my suggested license/certification program.
Sunday, September 16, 2007 8:23:52 AM
So, what is wrong with BSD? The main problem with BSD is that it has no strong enough way to make sure that the software stays free.
So, why do BSD work today anyway? It is mostly because the developers are interested in not having to fix things over and over again, and even if it is used in a proprietary product, the code will become better. The more products code can be used in, the better it will become because of bug fixes.
Also, the amount of code that is not returned to the free software product will help the product, even if it is not 100%. If, for example, using BSD will give twice as many developers that using GPL, and 100% of the improvements will go back to the GPL code, it is enough for the BSD product to get back 50% of the code for the same net result.
Oh, and I forgot to tell you about the real weakness of BSD, it has not enough support to make sure that the user can protect its own freedom.
Sunday, September 16, 2007 8:20:26 AM
So, what is wrong with the GPL? The main problem with GPL is that it has a very limited belief in that the user is able to use its will to influence the market to keep the software free. The second problem is that it is viral, and therefore we will have to live with the GPL even if we later find that the GPL is not the best way to protect the user's freedom. The third problem is that GPL does not make it possible to release as proprietary, even if that would make the user more free, according to the reasons I listed in part 1.
The GPL weakness is also part of its strength. The GPL does not need that the user believes in free software, as long as the software is good enough for the user, the user will use GPL:ed software. Companies will use and improve GPL:ed software and give it back, as long as the cost of not using GPL:ed software is higher.
Also, like religious sects, it is very easy to create strong following through a simple black and white way of looking at things. To this, add the people that can use GPL because of pragmatic reasons, not related the the user's freedom at all.
But, in a society that understands free software and the implications of free software, there is no reason to use force to protect the user. I think that we may live in such a society today.
Sunday, September 16, 2007 8:16:56 AM
In part 2, I compared how you could believe in free software in 2 completely different ways, and still be able to agree on the 4 freedoms. In this part, I will compare the 2 philosophies with real-world philosophies, and also introduce a third philosophy.
Sugar is not healthy. What do we do about it?
Non-liberal (GPL): If we forbid sugar, we have been able to protect the citizen. The citizen will be more free than if we did not forbid sugar, since sugar will make the citizen less healthy, and health is an important aspect of freedom.
Liberal (BSD): We should not restrict sugar in any way. The citizen is able to make its own choices. If we do not regulate, the total amount of freedom for the citizen will be higher that if we do regulate.
Semi-liberal: Yes, the citizen is able to make choices. However, we need to make sure that the citizen makes informed choices. The right way to protect the citizen, and preserve freedom, is to label food with the amount of sugar it includes.
I am a strong believer in the semi-liberal view. So, if we go back to free software philosophy, I am pretty sure that I do not agree with the way the GPL philosophy or the BSD philosophy tries to ensure the user's freedom through free software.
I will later go into how free software can be ensured by a philosophy inspired by the semi-liberal view.
Sunday, September 16, 2007 8:07:13 AM
In part 1, I concluded that I believe in free software. In this part, I will compare 2 philosophies, how to make sure that free software will in fact increase the user's freedom.The GPL philosophy:
- Protect the freedom of the user by introducing limits on what a developer can do with the code.
- Protect the freedom of the user by force.
The basic idea, is that unless we do something, software will not stay free.The BSD philosophy:
- Make sure that the free software freedoms are preserved.
- Believes that the user will choose free software, and enough of the changes made to the code will be made available to the user.
- Let the user itself protect its freedom.
- The invisible hand will make sure that a user's freedom is protected.
The basic idea, is that we do not need to do anything, free software will survive since the user wants the freedom that free software give the user.
Sunday, September 16, 2007 8:01:55 AM
This is the first part of a series of blog posts about my view on free software, and will end in a suggestion on how to improve free software.
First of, I have a problem with a number of things in the free software/open source movement. I will list them, to get them out of the way:
- Separates the money making from the actual software making, which changes the business model for software companies. The consequence is often that free software is controlled by large companies.
- Has a hard time creating software that is good for the user. (software is created based on a developer's own needs, or a company's desire to make money on something else)
- Innovation does not happen that often.
- The belief that open source is a superior way to create quality software.
- The way the movement separates software running on your own hardware, from software running on a server.
- The belief that open source is more important than open standards.
So, that's it. I will not talk anything more about open source from now on, I will concentrate on free software.
I believe in free software, as defined by the 4 freedoms in http://www.gnu.org/philosophy/free-sw.html
. I believe that given two identical products, it is better for the user if the software is free software, since it
increases the user's freedom. However, free software is not the only thing that increases a user's freedom. Open standards, a tool that saves the user time, a tool that actually solves the user's problems can actually do more for the user's freedom than the fact that the software is free.