[Fsf-friends] Ensuring quality and performance of free software

[Ramanraj K]

  The words "quality and performace" here are quoted from the GPL. 
 Recently, Fitzgerald Joy Sylvester <fjsylvester@rediffmail.com> asked 
why free software has no warranty, and if there is warranty, we could 
get more support for our cause, highlighting its necessity in mission 
critical applications.  Mahesh Pai <paivakil@yahoo.com> has already 
answered the query that entities could provide warranty for a fee.

But, more fundamentally, software could not be seen as "goods" 
attracting a warranty, particularly when it is given away free. 
 Software code is governed by copyright law.  Software is more like a 
book on mathematics, with a difference, in that both men and machines 
can read it and make sense out it.  It would be absurd to expect a 
warranty for the contents of a book.  Authors place their whole 
reputations on what they write, and this is the best check on ensuring 
the quality of a work.  Careless authors are soon forgotten and their 
works are discarded both by the public and the publishers.  In the 
ultimate analysis, it the quality of the work that matters, and since 
computers can execute an author's code, we can expect performance in 
accordance with a given specification.

Now, how to ensure quality and performance of software?

There is only one solution for this:  NEVER  TRUST YOUR COMPUTER

Sajith has again raised the question of warranty from another angle, 
about trusting free software.  RMS has already explained why "Trusted 
Computing" is only "Treacherous computing".  Here, I attempt to anwer 
the question about ensuring quality and performance of software, that 
would make warranties redundant and needless.

In the case of free software, the source code is always made available 
to the user under the terms of the GPL.  The user can study and 
understand how the program works, and satisfy himself about its quality 
and the performance that could normally be expected.  This is the most 
important quality of free software that makes it trustworthy.

But merely because a software is free along with source code, it does 
not automatically ensure that the progam will work well as expected 
according to the program specification.  An alert user ought to be able 
to verify the output from a program for himself, and satisfy himself 
about the correctness of an output.

Now, before we get down to software, a more general issue remains to be 
discussed.  Software deals with data.   Any software generally receives 
input, processes the input and gives an output.  Since millions of 
instructions can be processed efficiently by a computer, we save time. 
 Time and convenience are the two important reasons we use a computer to 
deal with our data.  We give the input, and we give rules for 
processing, and we know what outcome to expect.

Let us take a simple program wc which prints the number of bytes, words, 
and lines in files.  If you look at the info page for wc, we will 
further see that by word, we mean whitespace-separated words, and by 
lines we mean newlines.   Create a sample file called test.txt with the 
following two lines:

This is a test file.
The wc command is the test candidate.

Invoke wc as follows:

# wc test.txt       
      2      12      59 test.txt    

The output means that the file test.txt has 2 lines, 12 words, and 
occupies 59 bytes.  Now, to test if the output is correct we can 
manually open the file test.txt and count the words, lines and bytes.  
We can also try checking the result using other programs.

# ls -al text.txt 
-rw-r--r--   1 ramanraj users          59 Dec 14 09:20 test.txt       

To examine the bytes in the file test.txt, we could do an octal dump as 
follows:

# od test.txt
0000000 064124 071551 064440 020163 020141 062564 072163 063040
0000020 066151 027145 052012 062550 073440 020143 067543 066555
0000040 067141 020144 071551 072040 062550 072040 071545 020164
0000060 060543 062156 062151 072141 027145 000012
0000073  

      

We could invoke od with -bc option:

# od -bc test.txt
0000000 124 150 151 163 040 151 163 040 141 040 164 145 163 164 040 146
          T   h   i   s       i   s       a       t   e   s   t       f
0000020 151 154 145 056 012 124 150 145 040 167 143 040 143 157 155 155
          i   l   e   .  \n   T   h   e       w   c       c   o   m   m
0000040 141 156 144 040 151 163 040 164 150 145 040 164 145 163 164 040
          a   n   d       i   s       t   h   e       t   e   s   t
0000060 143 141 156 144 151 144 141 164 145 056 012
          c   a   n   d   i   d   a   t   e   .  \n
0000073                                              

We can count that the words separated by white spaces are indeed 12, and 
the newlines are 2 (represented by ascii 012), and we can count the 
bytes and see that the total is indeed 59.  We could verify the output 
from the wc program in a variety of ways through other programs.  

The whole point is: We should be able to verify the program output with 
our senses.

We need not take for granted what is output, but we can always check the 
validity of the output in other ways.  In the free software world, a 
reasonable means of checking would always be in sight or available to 
the user.  I request you to insist upon a means of checking the output 
directly with your senses.

I started out my adventure in programming with a simple script that will 
do fair rent calculation, as per Section 4 of the Tamil Nadu Buildings 
(Lease and Rent Control) Act.  This program is a free software script, 
and available at http://personal.vsnl.com/ramanraj/kr_tnfrc.html  The 
law applicable is given there, along with the source code.  I have 
included three test cases based on reported cases.  When you give the 
details required and give the command, calculate fair rent, the answer 
along with the reasoning done is displayed, so that you can verify the 
result for yourself in simple steps, with a piece of paper and pencil. 
 When you can verify the result directly with the rules applicable, you 
need not even worry about the source code, that may be difficult to 
follow for most average users.

Quality and performance can be made available in other better ways.

Now, does it really matter that free software comes without a warranty?