How does GNU software development sustain economically?

Question

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?

Answer 1

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

Answer 2

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.

Answer 3

Many of the premises of your question are wrong in part or in full, making it somewhat hard to answer. The existing answers already gave some reasons.

I think the simple answer is that a lot of projects do fail or get abandoned half-way, sometimes for the reasons that you suggested. Other projects keep progressing and working, so it's not easy to give a general answer that covers all, you'd rather have to look on a case-by-base basis at different projects to see what were the motivations for people to create them, to work on them, and if they ended, what were the reasons they ended and/or got abandoned.

Why is there people contributing to large GNU project, if they aren't getting a salary for it?

Again, each person has their own motivations. As you already mentioned, in many cases companies are funding the development and thus the developers are getting paid. This will mostly be because the company has use for the project and needs it to be kept alive or developed further, so it's like normal software development from the developer's perspective, just not kept internally in a single company.

Other reasons that people would contribute for free can be

• For fun
• For learning
• To be part of the community
• To create a name for themselves / improve their CV
• Because they use the software themselves and want to improve it