Next: Perceived disadvantages of open
Up: Development models
Previous: Developers motivation
  Contents
Advantages of open source software
Motivations for using and developing open source software are mixed,
ranging from philosophical and ethical reasons to pure practical
issues. In this subsection, some of the most widely
proposed practical advantages will be introduced.
For a discussion on
some of the ethical issues (which is not covered in this document), refer
to [25].
Usually, the first perceived advantage of open source models
is the fact that open source software is made available
gratis or at a low cost. But this
characteristic is not exclusive to open source software,
and several proprietary
software products are made available in similar ways (a prominent case
could be Microsoft's Internet Explorer).
What really distinguishes open source software from software available
without fee is the combination of effects due to the characteristics
discussed in
section 3.1. All of them combined
produce a synergistic impact which is the cause of the real advantages of the
open source model. Let us provide some more detail on how do these
characteristics turn into advantages:
- The availability of the source code and the right to modify it
is very important. It enables the unlimited tuning
and improvement of a software product. It also makes it possible to
port the code to new hardware, to adapt it to changing
conditions, and to reach a detailed
understanding of how the system works. This is why many experts are
reaching the conclusion
that to really extend the lifetime of an application, it must be
available in source form. In fact, no binary-only application more than 10
years old now survives in unmodified form, while several open source
software systems from the 1980s are still in widespread use (although in
many cases conveniently adapted to new environments).
Source code availability also makes it much easier
to isolate bugs, and (for a programmer) to fix them.
- The right to redistribute modifications and improvements to the
code, and to reuse other open source code, permits all the advantages
due to the modifiability of the software to be shared by large
communities. This is usually the point that
differentiates open source software
licences from ``nearly free'' ones. In substance, the fact that redistribution
rights cannot be revoked, and that they are universal, is what
attracts a substantial crowd of developers
to work around open source software projects.
- The right to use the software in any way. This, combined with
redistribution rights, ensures (if the software is useful enough), a
large population of users, which helps in turn to build up a market
for support and customization of the software, which can only
attract more and more developers to work in the project. This in
turn helps to improve the quality of the product, and to improve its
functionality. Which, once more, will cause more and more users to
give the product a try, and probably to use it regularly.
The issue about non-exclusive rights on the software, which has just
being mentioned, deserves some more attention.
When no one holds exclusive rights on a given code (sometimes mentioned as
``life or death rights''), several traditional problems of the
proprietary software model can be overcome:
- There is no one with the power to restrict in a unilateral
way how the software is used, even in a retroactive way. Such a power
manifests, for instance, when a proprietary software vendor decides
not to upgrade some software product for some old
platform. In this case, customers can only stick to the old version
of the software, or switch to another product. If open source
software is used, customers can also fund some development for the
desired platform, or look for other vendors to provide the upgrades
(of the very same product).
- There is no single entity on which the future of the
software depends.
This is a very common concern with proprietary software. Let us say
that a company uses a software product, and relies on the software
manufacturer for upgrades and continued development. If the software
manufacturer closes doors, or
decides to discontinue development of the product, no one has the right to
take the program and continue development on it, effectively killing its
usability in the market. This has happened many times, and this problem is
amplified by the recent mergers in the software market, that usually lead to
``cannibalization'' of some software product to allow just one or two to get
to the market. Open source software effectively protects against
this, because if the group or company that originated the code
decides to stop development, it is always
possible to fund another software group to continue the maintenance
and improvement, without legal nor practical limitations.
- No ``black boxes'' are possible. This point is so important that
open source is now considered by many
experts as one of the necessary conditions for dependable applications.
There are several reasons for this importance. One of them is related to
the dependability of the services provided by a given software. By
having the source code
available, it is possible to perform a thorough inspection and verify the
correctness of the algorithm and the implementation scheme used. This is
also possible in part even with closed source or nearly free licences. The
difference lies in the fact that users are allowed to modify everything they
find appropriate to suit their needs. A glaring example is the Linux kernel
and its ``international patches'', a set of enhancements with legal
problems in some countries. These patches include support for
encrypted communications, and can be legally used in large parts of
the world. The patches have being developed by concerned parties in
countries where such a development is allowed, and therefore users in
those countries can use those enhancements.
With binary only products no inspection is possible, with closed source or
nearly free licences inspection is possible, but modifications are
forbidden, so the inherent advantage of having source code available is
rendered ineffective.
- There is always the possibility of ``forking'', or creating
an alternative
code base if the current one is in some way perceived as wrongly
managed. This is sometimes considered a disadvantage, having to manage not
only one code base, but two. A ``fork'' is a subdivision of the code
base in two
different parts, each managed by a different group. Forks happens for
technical or licence reasons, for example because a particular release is
made under a non-free licence, the previous one is used as a base for
subsequent free releases. Technical motivations are common, because there
are sometimes many different way to perform a task, and it is not possible
to decide which is better. So if the two camps cannot reach a consensus and
the user base is large enough the code splits in two, and both continue
development.
If the reasons for the split are overcome, usually the two camps agree on a
reunification. A recent example is the decision to reunify the compilers
gcc and egcs, and to make one of them (egcs) the new base compiler.
In other cases a fork is used as a way to coordinate work. An example is the
Linux kernel, where two distinct code bases are used, one ``stable'' and one
``experimental''. This way it is possible to introduce new and potentially
dangerous technologies without disrupting the stable ones. So, people
interested in leading edge technologies can try them, and people that uses
the Linux kernel in production environments can count on stable and
tested features.
But the main point about forking is that it introduces several
levels of competition within the model. For instance, before
forking, several programmers can work harder to keep everybody happy
integrating as many well-engineered features as possible, to
prevent a fork by people whose needs are not addressed. After a
fork, both branches tend to compete for the user base with very
similar products: only good quality and quick improvement can
maintain them in the market.
- No per-copy fees can be asked for modified versions, and
anyone can use
the current code base to start new projects. Working knowledge can be
gathered at a minimal cost.
This is what made Internet software systems such an
important factor in the new economy: students, and people trying new
technologies were able to integrate and adopt them immediately,
without the hurdles of commercial or non-disclosure
licence agreements. In addition, the right to freely modify them
allowed for the incredible expansion in the number of communication
protocols and systems, each perfectly tailored to the needs of their
users. This is also a reason for the overwhelming success of the
Linux kernel, widely employed by students thanks to its near-zero cost,
and subsequently used by the same students in the startups
originated by them, when they turn into entrepreneurs after leaving
University.
- There are fewer conflicting priorities due to marketing pressures.
This is a simple consequence of the fact that there is no single
commercial entity pushing for precise delivery dates or features
that must be supported. Usually open source software is
delivered ``when it is ready'', and when the development team feels
that its quality is good enough. This means that software usually does not
need as many ``service packs'', updates and such, reducing the maintenance
cost. Of course this could be turned into disadvantage if a product
is indefinitely delayed, or if some feature is missing one release
after another. But in this case, the competition between projects
may help. If a project starts failing to meet the expectations of
its users, it often happens that a new project is forked, using the
same code base, to fill this gap. This happens especially if a market exists
for some new features, or for better quality versions of the application.
- It provides a new forum for democratic action. As individuals and
companies decide where to make improvements in the system, the
collective desires of the community determine the overall direction of
progress, and yet without compelling anyone. People with opinions
about what direction is best can urge others to join in, request help,
and in this way influence the overall direction of progress, but
without any elections in which the majority overrule the minority.
Next: Perceived disadvantages of open
Up: Development models
Previous: Developers motivation
  Contents
Jesus M. Gonzalez-Barahona
2000-04-24