Risto H. Kurppa recently posted about a bad experience with a free software hacker when Kurppa tried to get access to the most recent revisions of an unpublished program’s source code. We aren’t told what program this is, except that source code is published with certain versions (called “release” versions, ostensibly versions the developers believe are suitable for widespread use, as opposed to other versions of the code which are primarily intended for developers) and the program’s source code is licensed under the GNU GPL version 2.
Kurppa framed the issue in terms of the open source movement: a splinter movement founded in 1998 which maintains that developmental efficiency (chiefly to benefit business) is most critical because that’s when other programmers are able to help improve software. This movement specifically eschews the philosophy of the older free software movement. The free software movement is a social movement started in 1983 which campaigns for increased social solidarity by granting and protecting specific freedoms for all computer users—running, sharing, and modifying published computer software. The Free Software Foundation has published articles (1, 2) which describe the differences between these two movements including how the open source movement’s philosophy ironically leads to short- and long-term practical disadvantages. I highly recommend reading both essays for a more complete understanding of the ethical argument free software makes and how the open source philosophy falls short.
Kurppa tried to get more recent code from the project’s maintainers and was rejected. Kurppa wrote, “So, I thought.. There’s an author not sharing his code.”. This is where Kurppa first went wrong. Kurppa wrote that this project was sharing their code but they choose to do so only for release versions. They released their code all at once with each release version and never released developer code.
Kurppa revealed the crux of the real issue later on: “To me this sounds like that the the development isn’t as efficient as it could be and this means that the software is not as good as it could be, if only some things were done in a different way.”.
This view is a direct result of the open source philosophy. The ramifications of that philosophy are best understood when considering the differences between that philosophy and the older free software movement’s philosophy. Had Kurppa looked at this situation in terms of a user’s software freedom, developmental efficiency would be prioritized lower as a detail.
It may be inconvenient to not have access to the latest source code straight from the maintainer’s computer but (it’s reasonable to guess that) nobody is being denied their software freedom here. The critical issue, the issue to get upset over, is whether a user’s software freedoms are being respected. We don’t know exactly what program Kurppa is talking about so we can’t be sure that user’s freedoms are being respected. Sadly some programs with proprietary software in them are distributed under the GNU GPL (for example, Linus Torvalds’ variant of the Linux kernel contains proprietary software which allows Linux to communicate with various hardware. Other variants of Linux such as the kernel-libre project distribute a truly free Linux kernel). Such programs are a ruse for users seeking to use their computers in freedom. Fortunately this is not a widespread problem; most GPL’d programs respect user’s software freedoms so it is highly likely that the program Kurppa is talking about does too.
There are no obligations to share a program using a particular methodology, to share source code to programs one doesn’t distribute, or to accept someone’s patches into a program. It’s convenient and nice to distribute developmental versions of programs and to integrate patches from others so many hackers can help improve the program. But these are niceties, not requirements. The ethical obligations to distribute software that respects users freedoms are at the heart of the free software movement. Focusing on software freedom helps keep our priorities straight when considering the consequences of using and sharing computer software.