From 5d6f7b414de4b04ddc19629ac6d1f5e5f3cb42ac Mon Sep 17 00:00:00 2001 From: Tong Hui Date: Fri, 25 Mar 2016 16:52:03 +0800 Subject: first --- docs/applying-free-sw-criteria.md | 323 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 docs/applying-free-sw-criteria.md (limited to 'docs/applying-free-sw-criteria.md') diff --git a/docs/applying-free-sw-criteria.md b/docs/applying-free-sw-criteria.md new file mode 100644 index 0000000..3f1560e --- /dev/null +++ b/docs/applying-free-sw-criteria.md @@ -0,0 +1,323 @@ +--- +Generator: 'texi2html 1.82' +description: Untitled Document +distribution: global +keywords: Untitled Document +resource-type: document +title: Untitled Document +... + +1. Applying the Free Software Criteria {#applying-the-free-software-criteria .chapter} +====================================== + +The four essential freedoms provide the criteria for whether a +particular piece of code is free/libre (i.e., respects its users’ +freedom).[(1)](#FOOT1) How should we apply them to judge whether a +software package, an operating system, a computer, or a web page is fit +to recommend? + +Whether a program is free affects first of all our decisions about our +private activities: to maintain our freedom, we need to reject the +programs that would take it away. However, it also affects what we +should say to others and do with others. + +A nonfree program is an injustice. To distribute a nonfree program, to +recommend a nonfree program to other people, or more generally steer +them into a course that leads to using nonfree software, means leading +them to give up their freedom. To be sure, leading people to use nonfree +software is not the same as installing nonfree software in their +computers, but we should not lead people in the wrong direction. + +At a deeper level, we must not present a nonfree program as a solution +because that would grant it legitimacy. Non-free software is a problem; +to present it as a solution denies the existence of the +problem.[(2)](#FOOT2) + +This article explains how we apply the basic free software criteria to +judging various kinds of things, so we can decide whether to recommend +them or not. + +### Software Packages {#software-packages .subheading} + +For a software package to be free, all the code in it must be free. But +not only the code. Since documentation files including manuals, README, +change log, and so on are essential technical parts of a software +package, they must be free as well.[(3)](#FOOT3) A software package is +typically used alongside many other packages, and interacts with some of +them. Which kinds of interaction with nonfree programs are ethically +acceptable? + +@firstcopyingnotice{{@footnoterule @smallskip Copyright © 2015 Richard +Stallman\ + This article is part of @fsfsthreecite} + +We developed GNU so that there would be a free operating system, because +in 1983 none existed. As we developed the initial components of GNU, in +the 1980s, it was inevitable that each component depended on nonfree +software. For instance, no C program could run without a nonfree C +compiler until GCC was working, and none could run without Unix libc +until glibc was working. Each component could run only on nonfree +systems, because all systems were nonfree. + +After we released a component that could run on some nonfree systems, +users ported it to other nonfree systems; those ports were no worse, +ethically, than the platform-specific code we needed to develop these +components, so we incorporated their patches. + +When the kernel, Linux, was freed in 1992, it filled the last gap in the +GNU system. (Initially, in 1991, Linux had been distributed under a +nonfree license.) The combination of GNU and Linux made a complete free +operating system—GNU/Linux.[(4)](#FOOT4) + +At that point, we could have deleted the support for nonfree platforms, +but we decided not to. A nonfree system is an injustice, but it’s not +our fault a user runs one. Supporting a free program on that system does +not compound the injustice. And it’s useful, not only for users of those +systems, but also for attracting more people to contribute to developing +the free program. + +However, a nonfree program that runs on top of a free program is a +completely different issue, because it leads users to take a step away +from freedom. In some cases we disallow this: for instance, GCC +prohibits nonfree plug-ins.[(5)](#FOOT5) When a program permits nonfree +add-ons, it should at least not steer people towards using them. For +instance, we choose LibreOffice over OpenOffice because OpenOffice +suggests use of nonfree add-ons, while LibreOffice shuns them. We +developed IceCat[(6)](#FOOT6) initially to avoid proposing the nonfree +add-ons suggested by Firefox. + +In practice, if the IceCat package explains how to run IceCat on MacOS, +that will not lead people to run MacOS. But if it talked about some +nonfree add-on, that would encourage IceCat users to install the add-on. +Therefore, the IceCat package, including manuals and web site, shouldn’t +talk about such things. + +Sometimes a free program and a nonfree program interoperate but neither +is based on the other. Our rule for such cases is that if the nonfree +program is very well known, we should tell people how to use our free +program with it; but if the proprietary program is obscure, we should +not hint that it exists. Sometimes we support interoperation with the +nonfree program if that is installed, but avoid telling users about the +possibility of doing so. + +We reject “enhancements” that would work only on a nonfree system. Those +would encourage people to use the nonfree system instead of GNU, scoring +an own-goal. + +### GNU/Linux Distros {#gnulinux-distros .subheading} + +After the liberation of Linux in 1992, people began developing GNU/Linux +distributions (“distros”). Only a few distros are entirely free +software. + +The rules for a software package apply to a distro too: an ethical +distro must contain only free software and steer users only towards free +software. But what does it mean for a distro to “contain” a particular +software package? + +Some distros install programs from binary packages that are part of the +distro; others build each program from upstream source, and literally +*contain* only the recipes to download and build it. For issues of +freedom, how a distro installs a given package is not significant; if it +presents that package as an option, or its web site does, we say it +“contains” that package. + +The users of a free system have control over it, so they can install +whatever they wish. Free distros provide general facilities with which +users can install their own programs and their modified versions of free +programs; they can also install nonfree programs. Providing these +general facilities is not an ethical flaw in the distro, because the +distro’s developers are not responsible for what users get and install +on their own initiative. + +The developers become responsible for installation of nonfree software +when they steer the users toward a nonfree program—for instance, by +putting it in the distro’s list of packages, or distributing it from +their server, or presenting it as a solution rather than a problem. This +is the point where most GNU/Linux distros have an ethical flaw. + +People who install software packages on their own have a certain level +of sophistication: if we tell them “Baby contains nonfree code, but +Gbaby is free,” we can expect them to take care to remember which is +which. But distros are recommended to ordinary users who would forget +such details. They would think, “What name did they say I should use? I +think it was Baby.” + +Therefore, to recommend a distro to the general public, we insist that +its name not be similar to a distro we reject, so our message +recommending only the free distro can be reliably transmitted. + +Another difference between a distro and a software package is how likely +it is for nonfree code to be added. The developers of a program +carefully check the code they add. If they have decided to make the +program free, they are unlikely to add nonfree code. There have been +exceptions, including the very harmful case of the “binary blobs” that +were added to Linux, but they are a small fraction of the free programs +that exist. + +By contrast, a GNU/Linux distro typically contains thousands of +packages, and the distro’s developers may add hundreds of packages a +year. Without a careful effort to avoid packages that contain some +nonfree software, some will surely creep in. Since the free distros are +few in number, as a condition for listing that distro, we ask the +developers of each free distro to make a commitment to keep the distro +free software by removing any nonfree code or malware. See the GNU free +system distribution guidelines, at +. + +We don’t ask for such promises for free software packages: it’s not +feasible, and fortunately not necessary. To get promises from the +developers of 30,000 free programs to keep them free would avoid a few +problems, at the cost of much work for the FSF staff; in addition, most +of those developers have no relationship with the GNU Project and might +have no interest in making us any promises. So we deal with the rare +cases that change from free to nonfree, when we find out about them. + +### Peripherals {#peripherals .subheading} + +A computer peripheral needs software in the computer—perhaps a driver, +perhaps firmware to be loaded by the system into the peripheral to make +it run. Thus, a peripheral is acceptable to use and recommend if it can +be used from a computer that has no nonfree software installed—if the +peripheral’s driver, and any firmware that the system needs to load into +it, are free. + +It is simple to check this: connect the peripheral to a computer running +a totally free GNU/Linux distro and see if it works. But most users +would like to know *before* they buy the peripheral, so we list +information about many peripherals in [h-node.org](h-node.org), a +hardware database for fully free operating systems. + +### Computers {#computers .subheading} + +A computer contains software at various levels. On what criterion should +we certify that a computer “Respects Your Freedom”? + +Obviously the operating system and everything above it must be free. In +the 90s, the startup software (BIOS, then) became replaceable, and since +it runs on the CPU, it is the same sort of issue as the operating +system. Thus, programs such as firmware and drivers that are installed +in or with the system or the startup software must be free. + +If a computer has hardware features that require nonfree drivers or +firmware installed with the system, we may be able to endorse it. If it +is usable without those features, and if we think most people won’t be +led to install the nonfree software to make them function, then we can +endorse it. Otherwise, we can’t. This will be a judgment call. + +A computer can have modifiable preinstalled firmware and microcode at +lower levels. It can also have code in true read-only memory. We decided +to ignore these programs in our certification criteria today, because +otherwise no computer could comply, and because firmware that is not +normally changed is ethically equivalent to circuits. So our +certification criteria cover only the code that runs on the computer’s +main processor and is not in true read-only memory. When and as free +software becomes possible for other levels of processing, we will +require free software at those levels too. + +Since certifying a product is active promotion of it, we insist that the +seller support us in return, by talking about free software rather than +open source[(7)](#FOOT7) and referring to the combination of GNU and +Linux as “GNU/Linux.”[(8)](#FOOT8) We have no obligation to actively +promote projects that won’t recognize our work and support our movement. + +See for our +certification criteria. + +### Web Pages {#web-pages .subheading} + +Nowadays many web pages contain complex JavaScript programs and won’t +work without them. This is a harmful practice since it hampers users’ +control over their computing. Furthermore, most of these programs are +nonfree, an injustice. Often the JavaScript code spies on the +user.[(9)](#FOOT9) JavaScript has morphed into a attack on users’ +freedom. + +To address this problem, we have developed LibreJS, an add-on for +Firefox that blocks nontrivial nonfree JavaScript code. (There is no +need to block the simple scripts that implement minor user interface +hacks.) We ask sites to please free their JavaScript programs and mark +their licenses for LibreJS to recognize. + +Meanwhile, is it ethical to link to a web page that contains a nonfree +JavaScript program? If we were totally unyielding, we would link only to +free JavaScript code. However, many pages do work even when their +JavaScript code is not run. Also, you will most often encounter nonfree +JavaScript in other ways besides following our links; to avoid it, you +must use LibreJS or disable JavaScript. So we have decided to go ahead +and link to pages that work without nonfree JavaScript, while urging +users to protect themselves from nonfree JavaScript in general. + +However, if a page can’t do its job without running the nonfree +JavaScript code, linking to it undeniably asks people to run that +nonfree code. On principle, we do not link to such pages. + +### Conclusion {#conclusion .subheading} + +Applying the basic idea that *software should be free* to different +situations leads to different practical policies. As new situations +arise, the GNU Project and the Free Software Foundation will adapt our +freedom criteria so as to lead computer users towards freedom, in +practice and in principle. By recommending only freedom-respecting +programs, distros, and hardware products, and stating your policy, you +can give much-needed support to the free software movement. + +
+ +------------------------------------------------------------------------ + +### Footnotes + +### [(1)](#DOCF1) + +@raggedright See @pageref{Definition} for the full definition of free +software. @end raggedright + +### [(2)](#DOCF2) + +@raggedright My article “Avoiding Ruinous Compromises” +(@pageref{Compromise}) elaborates on this issue. @end raggedright + +### [(3)](#DOCF3) + +@raggedright See “Free Software Needs Free Documentation” (@pageref{Free +Doc}) for more on this issue. @end raggedright + +### [(4)](#DOCF4) + +@raggedright See “Linux and the GNU System” (@pageref{Linux and GNU}) +for information. @end raggedright + +### [(5)](#DOCF5) + +@raggedright For the reason why GCC prohibits nonfree plug-ins, see my +response on the GCC mailing list, at +. @end raggedright + +### [(6)](#DOCF6) + +@raggedright See . @end +raggedright + +### [(7)](#DOCF7) + +@raggedright See “Free Software Is Even More Important Now” +(@pageref{More Important Now}) and “Why Open Source Misses the Point of +Free Software” (@pageref{OS Misses Point}). @end raggedright + +### [(8)](#DOCF8) + +@raggedright See “What’s in a Name” (@pageref{Whats Name}). @end +raggedright + +### [(9)](#DOCF9) + +@raggedright See “The JavaScript Trap” (@pageref{JavaScript Trap}). @end +raggedright + +
+ +------------------------------------------------------------------------ + +This document was generated by *tonghuix* on *March 25, 2016* using +[*texi2html 1.82*](http://www.nongnu.org/texi2html/).\ -- cgit v1.2.3