Results of counting Debian

The main results of our current analysis of the Debian 2.2 GNU/Linux release can be organized in the following categories:

Size of Debian potato

We have counted the number of source codes of Debian GNU/Linux 2.2 in three ways, with the following results (all numbers are approximate, see appendix for details):

For details on the meaning of each category, the reader may revisit the subsection "Downloading and collecting data". In short, the count of upstream packages could be considered as the size of the original software used in Debian. The count of Debian source packages represents the amount of code actually present in the Debian 2.2 release, including both the work of the original authors and the work of Debian developers. This latter work includes Debian-related scripts and patches. Patches can be the work of Debian developers (for instance to adapt a package to the Debian policy) or be the downloaded from elsewhere. The count of Debian packages without the debian directory excludes Debian-related scripts, and therefore is a good measure of the size of the packages as they are found in Debian, excluding the specific Debian-related scripts.

It is also important to notice that packages developed specifically for Debian have usually no upstream source package. This is, for instance the case of apt, which is present only as a Debian source package.

Programming languages

The number of SLOC classified by programming language are (roughly rounded) as follows (numbers for Debian source packages):

Below 0.5% we find some other languages: Yacc (0.46%), Java (0.20%), Expect (0.20%), Lex (0.13%), and others below 0.1%.

When we count the lines in the Debian source packages without the debian directory (which contains package configuration files and maintainer scripts), the numbers are similar. This means that the maintainer scripts are not a significant part of the distribution. The main difference is in Shell lines (about 150,000 less) and in Perl lines (about 80,000 less), which uncovers the preferred languages for those scripts.

However, when we count original (upstream) source packages there are some remarkable differences: about 2,000,000 lines of ANSI C code, 300,000 lines of LISP, 200,000 lines of FORTRAN, and minor variations in other languages. This differences can usually be amounted to patches to upstream packages made by the Debian developer. Therefore, looking at this numbers, we can know in which languages are written the most patched packages.

The largest packages

The largest packages in the Debian potato distribution are:

Numbers in parenthesis are approximate number of SLOC of upstream packages, the rest of the numbers are approximate number of SLOC of the Debian source packages. Only data for the more relevant languages found in each package are reported. The reader may notice that in most cases, the numbers is both cases are roughly equal, showing evidence that, in those cases, the additions done by Debian developers are minimal (although modifications could be more important).

The release numbers of the packages are obviously not current, but those were the ones available at the time of the freeze for Debian 2.2 (Spring 2001). The classification could be different had Debian developers to package things in other ways. For instance, if all Emacs extensions were in the Emacs package, it would have been much larger. However, Debian source packages match usually well the idea of package who have upstream authors, and the one generally considered.

The next packages by SLOC size (between 350,000 and 500,000 SLOC) are Binutils (GNU assembler, linker, and binary utilities), TenDRA (C and C++ compiler and checker), LAPACK (a set of linear algebra routines), and Gimp (the GNU Image Manipulation Package). Except for LAPACK (which is composed mainly of FORTRAN files), these packages are mainly written in ANSI C.

Effort and cost estimations

Using the basic COCOMO model, the effort to build a system with the same size as Debian 2.2 can be estimated. This estimation assumes a "classical", proprietary development model, and therefore is not valid to estimate the effort which has been applied to build this software. But it can give us at least an order of magnitude of the effort which would be needed in case a proprietary development model had been used.

Using the SLOC count for the Debian source packages, the data provided by the basic COCOMO model are as follows:

For calculating the cost estimation, we have used the mean salary for a full-time systems programmer during 2000, according to Computer World, which is of 54,000 USD per year, and an overhead factor of 2.4.