Impact of open source in the total cost of ownership

An analysis of business models is not, per se, enough to justify an interest in open source software in companies not directly related to the development, consulting or maintenance of software. The presence of new opportunities could not be a reason sufficient to extend this model to other more traditional development environments, and especially to companies which main business is not directly related to information technologies (although it could be based on them). For this reason, in this section we are including a simple analysis of the impact of open source on total cost of ownership for a company using information technology. A more detailed analysis can be found in [21].

Total cost of ownership (TCO) is a widely used parameter to measure the effective cost of a software or hardware/software combination within an organization. It tries to capture all the real costs of deploying an information technology system, at all stages. However, it does not try to measure the advantages gained by using a given information technology, for which usually another parameter, the return on investment (ROI) is used.

In this section, we will discuss how the use of open source software compares in terms of TCO with proprietary systems. We do not include any discussion on the impact on the ROI, since it depends on the quality of the information technology system, and its suitability for the goals and the business of the of the organization where it is used. Therefore, assuming similar quality and suitability, whether the system includes open source software or not should not have any impact on the ROI.

Total cost of ownership is the effective, combined cost of acquisition and deployment of an information technology throughout all its perceived useful life. We can subdivide this life in several stages: information gathering, acquisition or creation, deployment, training, common use and maintenance, and abandon or transition to a new technology. Let's discuss all of them:

• Information gathering and `draft' project. This is the `shopping around' stage mentioned by some magazines. It consists of the acquisition of data on the possible solutions available to the organization. As was already mentioned, it is sometimes difficult (at least for the lesser known projects) to gather information on the existence of potentially useful components and their degree of completeness and usefulness when open source projects are considered. There is not much advertising, no central repository of code and sometimes not even an archive of available information. This makes it sometimes more costly to gather information on open source software.

  However, this should be balanced with the fact that information gathered in this stage is more realistic for open source project than for proprietary systems, since the availability of source code, the simplicity for carrying out tests (usually, just download and run), and the usual direct contact with the user community help to avoid exaggerations or understatements in commercial advertising.

• Acquisition or creation. Sometimes the software is just acquired, if a suitable product already exists, but usually some kind of creation (or at least integration) of new software is also needed. Acquisition has, of course, a lower cost with open source software because there are no per-copy or per-use fees. The lower cost is particularly evident if the system must be deployed on many platforms, which is common within large organizations. Creation has also a lower cost, because many more programmers can participate in the making and the debugging of the software, if the organization can work with the framework of an open source project.

• Deployment. This is a difficult point to evaluate, because deployment is considered in different ways depending on the author. We will consider the deployment phase as the steps needed to bring the information system to a complete working implementation, and in place on all required platforms. This is different from some common definitions, where deployment is considered to cover only the `installation' phase, or bringing the software to the computing platform.

  In any case, deployment time is apparently shorter with proprietary software, thanks to better installation strategies. Open source software usually tends to adapt better to many different situations and even operating systems, and this flexibility is paid for in terms of increased complexity. This is rapidly changing, thanks to better installation and compilation systems¹⁶ which in some cases are even better than proprietary installation procedures. In the long term, as more and more open software projects and companies are giving more attention to the installation phase, there will probably be no noticeable difference. On the other hand, the higher configurability, and the availability of the source code of the installation systems makes further customization possible, and helps in large scale deployment.

• Training. This is largely independent of the fact that the system is proprietary or open source. A limited advantage in favor of open source software is given by the possibility to check, by reading the source code, those aspects where documentation is scarce. On the other hand, proprietary software producers tend to create large scale training processes, documentation, and teaching material that is made easily available to all interested parties. In open source software, the first documentation projects started just a few years ago, and in general are still not producing the same kind and quality of documentation.

  However, as more and more companies, including technical publishers, join the open source movement, this is also changing. Once more, in the long term, it is difficult to foresee any difference in documentation or training difficulties due to the software being open source or proprietary. An special case is of course the software developed in-house, where there are obviously no advantages for proprietary software. Perhaps, making the software open source and distributing it to other interested parties will help the development of good quality documentation by third parties, at a reasonable cost.

• Common use and maintenance. This is usually the predominant part of the TCO, and this is also the point where the largest advantages of open source software are apparent. The availability of the source code allows for immediate bug fixing and improvement, in contrast to proprietary software, where this is a more difficult and slow process, and sometimes even impossible (for example if the software is no longer supported). Even when it is possible to obtain the source code of a proprietary system, usually bug fixing must be done by the software manufacturer itself, and this renders the code availability useless. On the contrary, in the GNU/Linux world, for example, fixes to critical bugs are usually found within hours of the discovery of the problem, and in general it is always possible to fix anything. Also, enhancements and adaptation to changing computing platforms helps in the achievement of a longer lifetime for the software, and for incremental reuse and improvement.

• Abandonment or transition to a new technology. This stage is overlooked in many cases when TCO is calculated, since the abandonment is not really a part of the real use of a technology. However, information technology systems are usually built to replace existing systems, so that the transition process must be streamlined and easy to achieve. Open source software helps in this stage by making it possible to create a temporary code base to ease the transition. It also helps in the data transition itself. This point is of particular importance, because pure data is in many cases the real value of an information system. Data translation is often a difficult process, and can even become impossible to achieve if there is not enough information on the format used for the storage or interchange. However, open source software can be ported and adapted to new architectures, and data can be read and translated to new formats in a clean and portable way. If proprietary systems are involved, data loss or recoding (always an expensive process) may be needed when the only platform that runs the software is no longer supported.

As a conclusion, it can be said that of the many stages that are to be considered for TCO estimation, in some of them there are no significant differences due to the open source nature of the software, and when these differences are against open source, they are hoped to become negligible as the model matures and is used more and more. However, there are at least three stages (acquisition, maintenance and transition) where using open source systems provides clear advantages.

Footnotes

... systems¹⁶

Examples of these systems are the autoconf engine from the Free Software Foundation, and the RPM and DEB packaging systems from Red Hat and Debian.