I have been asked to provide some information about the number of lines of
code in LISTSERV, the time it took me to write it, etc. I do not believe in
evaluating the amount of programming time required by a project by dividing
the amount of lines of code by some managerial constants which supposedly
represent the average efficiency of a programmer, but I respect the religious
beliefs of other people, so here's the info.
LISTSERV is comprised of 12750 lines of documentation and 35500 lines of code,
of which 6300 are in assembler (the rest being REXX). The documentation is
quite a bit verbose, as I enjoy writing in English (I take documentation as a
pseudo-literary break in my grim everyday world of americanized technical
jargon). However, the code is relatively compact, because I am very lazy :-),
and do not particularly enjoy writing these meaningless sentences using this
ridiculous vocabulary of 50 words or so. Have a look at the REXX part of the
survey exec for an example; another example could be the LISTSERV database
functions, which fit in 2400 lines of code (1100 assembler, 1300 REXX). The
REXX code contains almost no comment (comments are for freaks who can't read
core dumps :-) ); the assembler code usually has one comment a line, plus a
number of block comments (I can't stand waiting for the core dump to get
printed ;-) ).
The internals of LISTSERV were rewritten twice since the first version, not in
the "stop and start from scratch" way but through a constant evolutionary
process: whenever I needed to change a module to fix a bug, I would carefully
review all the routines and usually rewrite them, the first time to use more
powerful and efficient REXX programming techniques that I did not know when I
wrote the very first version, and the second (and most important) time to
adapt the code to the unexpected growth of the product and resulting
requirements. The first time LISTSERV had something like 1/5th of the code it
has today, and everything was rewritten. The second time, it had about 2/3rd
of today's size, and maybe 2/3rd of the code was rewritten. That is, the
actual amount of code I ended up writing is about 60000 lines.
Most of LISTSERV was written during the 3 years that I was a student in Metz
and Paris. I used to escape the grim world of Supelec every weekend and come
to work in Centrale (FRECP11). The first morning was spent reading and
answering my weekly couple of hundred mail files, the afternoon being spent
working on the system or on other smaller programs like CHAT or RELAY. Sunday
was usually dedicated to LISTSERV, as I prefer to work with large time slices.
That is, most of LISTSERV took around 150 sundays to write (14-hours sundays,
but then any managerial book or Supelec teacher will tell you that the amount
of lines you can write a day does not depend on the number of hours you worked
that day, nor on the programming language you have used). The rest (mostly the
UDD) was done at LEPICS, where it is much more difficult to count the days
since I am not forced to be away 5 days a week.
That type of work is not something that you can bend into the rules of
computing project management books. It is not something you can put into an
equation, as in "150/20 = 7.5 months" or "60000/150 = 400 lines/day". It is
not something you can control, plan, schedule, monitor, explain, evaluate,
audit, etc. It is something that may happen, or that may not happen, but which
will take place or fail to take place regardless of any of these
"environmental parameters" that can be controlled by managers. It is clearly a
process that cannot be owned and cannot be controlled, and therefore something
that no manager or politician wants to have to deal with.
Eric
|
