I will make one argument towards the necessity of closed source
I own a company and we have developed a large, very complicated scientific analysis software (approximately 100,000 lines). This software, in the most general sense, predicts the radar cross section of objects such as tanks and aircraft. This software blends many electromagnetic and computer graphics techniques together. This software has been painstakingly engineered over many years, and the code executed tens of thousands of times to verify that the algorithms have been implemented properly and that its results are to be trusted. Our customers depend on us for this software to operate correctly, and that the outputs are consistent and reproducable. A customer may invest millions of dollars in developing prototype hardware based on the outputs of this software.
Now, say we give the source code of this software to the end user, who may or may not have a background in electromagnetics or computer graphics. This person now decides to alter the code in a subtle way. However small this change may me, something VERY SIGNIFICANT has occurred. A person, who is not the developer, has altered the program. The outputs can no longer be trusted. Think about that for a minute.
I have a great amount of respect for Richard M. Stallman and the Free Software Foundation. We have used the GNU development tools such as gcc and gdb extensively in the development of this product. But we cannot give the source code of our software to the end-user. If they were to used a modified executable that produced erroneous results, this might lead to a failed project, and then the customer might have reason to sue us (even though this is prohibited by the end-user agreement). This could call the reputation of the software and of our company into question. This is why we cannot allow them to modify how the executable operates in any way. The software must remain in a known and controlled state at all times. It must remain closed source. Sorry, Richard.
RMS says that I should not have the freedom to retain the source code to myself. Well, I believe there are circumstances that open source software is good, and times that it isn't. Many software projects benefit greatly from the inputs of many people (linux). Conversely, some would be harmed greatly by it (the software we develop). A happy medium must be found, and I do not believe that it lies in RMS' totally open-source camp or with the malignant likes of our favorite friends at Microsoft.
Some followups to lj
's very good arguments. I would first state that I operate from the standpoint of engineering analysis software. Implementing algorithms that perform complicated numerical operations is not trivial
, and should be done only by persons qualified
to do it. For example, I am not qualified to work on the XFree86 window system. I am unqualified. I would not trust any modifications I made to it. I place my trust in the person(s) that have worked long and hard on it to make those changes.
I wholeheartedly agree that allowing end-users to have the source code is, at least on paper, a good idea. Providing a license that allows the user to examine the source code and recompile it to prove to their own satisfaction that it works correctly is a good idea. I would push for this type of developer-user interaction in a perfect world. Unfortunately, not every end-user groks the subject matter, or the programming language the tool is coded in, as well as the developers do. Looking back on my statements about XFree86, I do not have the slightest idea how it works, and I have no place trying to modify it. I would go as far to say, in industry, perhaps 5% of the users possess the required skills to significantly change and successfully recompile a commercial software application without breaking it. Open-source advocates are in the minority when it comes to the population; your average john doe simply is not a software god that can leap right in and be on the same page as the developer.
Consider the 2.4.15 kernel. This was blessed and released the the community at large last year. Shortly thereafter it was discovered that if you used this kernel, and allowed the system to shut down normally, it would corrupt your hard disk. Now, consider a commercial application, if the end-user changed the application slightly and recompiled it, and it ate his hard disk. The company whose hard disk has been eaten is going to be really pissed off. Who is going to be held responsible? The developer of course! (End-user license agreements are simply part of a legal defense, the end-user may still sue).
So we come back to the issue of trust. Most end-users simply do not have the necessary skills to examine source code and determine, in their own minds, that it is written correctly. Modification by unqualified persons of any part of the source code throws the legitimacy of any recompilation into doubt. This doubt cannot be allowed to flourish in a field where the integrity of the software is the cornerstone of the analysis. In a perfect world, where everyone is a code expert, this wouldn't be an issue, but that's not how it works in the real world.