10
$\begingroup$

I apologise if this question is out of topic, but it is simultaneously an economy and a programming question. If it should go to another SE communality, please indicate me.

In theory, GNU software is entirely developed by volunteers during their free time, or by companies that voluntary fund programmers to develop GNU software (by using income from another sector of their activity).

I understand how it can work perfectly fine for small-scale project that can be done in a couple of rainy weekends by a single individual (let's say for example a sudoku game), because after all computer programming is an extremely fun and rewarding hobby, and I have no problem seeing people developing small or medium programs during their free time and sharing them to the world.

The problem is that this scales extremely poorly for larger programs for the following reasons:

  1. As fun as programming is, as the project that have to be implemented becomes larger, the time it takes to implement the desired functionality grows extremely quickly. A larger scale program takes an incredible amount of time to develop, for instance it could easily take 15 years of free time and vacation time for an individual to program an operating system, and by the time his software is released it'll be completely obsolete.
  2. As other people write programs in another way that the way you would have done it, reading and understanding someone else's code takes a lot of time, in most cases as much as would writing your own code from scratch. Modifying another people's code and try to improve it, as it is encouraged by the GNU philosophy, is almost just as time consuming as developing your own clone of the said program with the functionality you'd like to add.
  3. As soon as 2 or more people will have to collaborate to develop a larger program, this creates lots of decision-taking issues that would never arose on a single-developer project. The result is that, for example if a group of 2 programmers collaborate for a project that would take 10 years for a single man to make, they won't make it in 5 years but probably in 8.
  4. If people that collaborate for the same project meets on the internet solely, it is easy for one member of the project to vanish suddenly (either because he lost interest or because he physically can't be on the internet anymore), thus making collaboration even harder

So, while I understand perfectly how simple programs can be developed with the GNU mindset, I absolutely don't see how such huge programs such as GNU/Linux or gcc are possible on this model. gcc is around 7 million lines of code. I know lines of code does not mean much, as in a later stage of a project the more productive programmer is the one that will actually remove lines of code (simplifying and/or optimizing the project), but this gives an overwiew how massive of a project gcc is.

So in theory, anyone can freely modify gcc during their free time, but in practice? It was developed by very professional people as a job, not as a hobby. Anyone making a compiler as a hobby will eventually give up as the cost/benefit is not worth it:

  • Developing a large program is such a long term huge project, they'd rather use their free time to have other activities that are more rewarding or more enjoyable in the short term
  • If they were to develop a large program anyway, they'd rather do it for a company that will pay them than doing it for free

In order to get people interested at developing a program such as GNU/Linux, gcc or Open Office in the long run, it should be rewarding. So my question is: Why is there people contributing to large GNU project, if they aren't getting a salary for it?

$\endgroup$
  • $\begingroup$ Could you provide some evidence for points 2, 3 and 4? I disagree with point 2 the most, but 3 and 4 are also interesting points of view that I haven't really experienced when developing open source software. I'll update with my own experiences when I get time $\endgroup$ – christopherlovell Apr 28 '15 at 14:27
  • $\begingroup$ Well 2 depends heavily on the programming language, and effort put in documentation of the program's architecture. As for the evidence, I can find this, this and this $\endgroup$ – Bregalad Apr 28 '15 at 15:07
  • $\begingroup$ @Bregalad two of your examples in your comment are over 9 years old. Open source software has come a long way since then, enabled by the evolution of the web and popularisation of tools such as git that make sharing and developing good, readable code a lot easier. $\endgroup$ – christopherlovell May 6 '15 at 11:27
  • 1
    $\begingroup$ @Bregalad in your other example from SE/Programmers, almost every highly rated answer disputes your second reason for greater complexity, namely that reading code is not necessarily harder than writing it. The final sentence under this point, that cloning a project from scratch might be easier than adding to it, assumes that you know, without even reading the code, how it works and how to recreate the algorithm. I can tell you from experience that inventing an elegant and performant algorithm for a problem is a much more difficult task than coding it up :) $\endgroup$ – christopherlovell May 6 '15 at 11:32
5
$\begingroup$

I would like to start by saying that I'm not a programmer and I have never contributed to any open source project. However, I have been interested in open source for a long time and I believe that I understand the general concepts of open source and how it works.

To start of, I would like to say that open source does not mean that you cannot make money on the software. It just means that the code has to be publicly available. Companies like Red Hat and Canonical make money not by selling the software, but by selling their expertise. If i wan't my company to run a Linux server, I can get the software for free. But I need somebody to install it, set it up and give support. This is where specialist from e.g. Red Hat comes in and makes money. For the company it makes sense, because hiring their own specialist would probably be much more expensive. This also gives these companies an incentive to contribute the the code. They want their product to be good so people will use it and by their services.

But lets talk about your points about scalability.

  1. The cool thing about open source is that you do not have to develop everything from scratch. An operating system like Ubuntu has not been build by a single person. Instead a lot of people has contributed to different parts of the system (actually I think it would be hard to find one person with all the skills to make and effective operating system). For example, the Ubuntu people does not develop the Linux kernel. They just use one developed by others. So what was without open source probably impossible, is now possible,because you can build on other peoples work.

  2. Reading and understanding others code it not more time consuming than writing your own. At least not in many cases. Beyond that, you do not have to understand all the code you use. If I want to write a program for Linux, I do not have to understand how all the parts in that program works in detail. I just have to know what they do. I can then take these parts and put them together with other parts to create my program. Or I can take an existing program and modify it for my needs.

  3. tools like git and github makes it incredibly easy to collaborate. You just get the code and make modifications. You then submit them to the person in charge of the project. If it is good, it will be accepted.

  4. people go in and out of projects all the time. But if the project is popular, enough will be working on it.

Here are some reasons why open source works.

  1. I think the main reason that open source software has become so good is that the large number of people working on the a project, insures a level of expertise that i hard to archive in a small team of developers. While it might seem weird, this single fact, seems to outweigh all the negative problems that can arise in open source.

  2. In commercial programming, the project dies with the firm. Lets say you by some software from a company that then closes. Then your screwed, as you will not receive updates and bug fixes, and you will need to by new software to keep up. With open source you can just find another company to support you software or develop it yourself.

If you are still interested, I suggest you read The Cathedral and the Bazaar

$\endgroup$
  • $\begingroup$ I don't disagree with any of what you said, but really, I can't accept the answer, because it does not answer my question. You seem to try to convince me how great GNU is, but there's no use because I'm already convinced since a long while. You also seriously underestimate the difficulties of modifying and adapting someone else's code, as well as coordinating multiple people working on a software project. I might have exaggerated the issues in my questions, but still, it can be a major issue. I still don't know how the large GNU software sustains economically. $\endgroup$ – Bregalad May 1 '15 at 8:57
  • $\begingroup$ Maybe you should post it on stackoverflow and get an answer from some real programmers. They can properly give you an answer based on real experience. $\endgroup$ – Rud Faden May 1 '15 at 9:00
  • 1
    $\begingroup$ Your point about Red Hat stands, but after a quick look at their job proposals, most of them are related with sales, marketing and technical support, and only a small percentages are development opening. (This gives a good indication as where their income comes from and how their revenue is distributed). Also, this question would probably be flagged off-topic on Stack Overflow (although I'll have to re-read the help in order to be sure) $\endgroup$ – Bregalad May 1 '15 at 9:21
  • $\begingroup$ @Bregalad But even if you are modifying somebody else's code; you have a community to draw on, to ask them how something works. (This may be a concept foreign to proprietary software developers or even business in general, since there the focus is on the individual or money, and not the betterment of the software...for the whole community). Also, the people in the community also have an interest in keeping that software running since they also likely use it for something themselves; otherwise why are they contributing? (maybe fame...but if your open source project died, how would that help?) $\endgroup$ – leeand00 Oct 19 '16 at 1:33
  • $\begingroup$ @Bregalad Also, the project's sustenance on several companies (companies that use as well as code the software) rather than a single software development company point of failure ensure that you're less likely to have to Extract Transform and Load your data into another system when some other company fails or is eaten up by the market. $\endgroup$ – leeand00 Oct 19 '16 at 1:40
2
$\begingroup$

Open-source software development is done for diverse reasons, but it's a common misunderstanding that it's done primarily by hobbyists or professionally but as a side-project. I'm answering this question for open-source in general, not GNU-licensed software in particular. But my answer is inclusive.

Let's say I'm a software developer (I am), and I'm working on a complex software project (I am). Good architecture breaks a problem down into independent pieces, and as development proceeds the developers will often recognize that some piece they need is one that's common to a lot of problems. Here are some typical paths forward:

  1. They develop that piece themselves and it becomes property of the company. Or they buy a closed-source solution from another company.
  2. They find an open-source project that solves this problem and it's a perfect fit and the license is suitable. They just incorporate it into their project, which may or may not need to be open-sourced depending on the license and how it's used. They don't contribute back to the project.
  3. They find an open-source project that almost solves this problem but has either defects or deficiencies. They improve on it and they may contribute those improvements back to the base project.
  4. They don't find anything they like enough, so they start their own project and decide to open-source it.

The advantages of 2-4 are that more people end up contributing to both the design and the code of the project, and it goes into a kind of ecosystem where strong ideas survive (by procreation if you will) and weak ones don't. Bugfixing and feature addition become community efforts. In scenarios #2 and 3, the developers adopting the project benefit from sound engineering principles and mature code. 3 and 4 are correlative. In scenario #4, the developers benefit when other people adopt and improve the code and give back (#3). It's advantageous to contribute back to the project so that your improvements get cemented in as other fixes and improvements go in on top of them, which you continue to benefit from. In my experience, all of these scenarios are commonplace.

On my current software project, I'm one of about 12 developers and have worked on a system for about two years. We have incorporated about 5,000 open-source projects! We have spawned only a few new FOSS projects, and contributed back to maybe half a dozen. We aren't particularly good citizens in this case (other companies are much better), but this shows you the sheer scale of how this all works. Even on small projects, contributions from open-source can easily number in the dozens or hundreds. If we did not use any open-source software, development costs would balloon by a factor of 100-10,000.

Scalability happens because of modularity of design and also through this kind of survival-of-the-fittest process where code can get refactored, forked, and so on. Survivability is usually better than proprietary alternatives because even if the code is no longer maintained, it's out there and other people who find value in it can maintain their own fork of it. Companies come and go and employees are hired and quit even faster. If you add a software dependency that you don't have the source code for or have only a small in-house team to maintain, you have incurred substantial risk. Big projects like the Linux kernel, gcc, Android and others often have a large number of companies actively contributing.

It's not true that it's easier to write good and correct code than it is to read it (in most cases). Nor do you have to read all of the software you're using even if you are making modifications. You have to dive deeply into sections of it and read a lot, but not the whole. I could say more here about unit tests, but will omit that for brevity.

The majority of open-source software is not developed by people in their free time. The practice is so phenomenally beneficial that it works without an optimizing marketplace. I personally suspect some kind of market-driven approach would greatly help, but I don't know what that approach might look like. People argue that there is a marketplace where reputation is the currency, but I don't think that's an accurate model. One currency at work is the time it takes to adopt a new piece of software. You want to find and use something that is active, simple, has good documentation, etc. So like a shopper you're looking for the best quality product for the least amount of time invested.

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.