Re: Software reuse

[Ari Lukumies <Ari.Lukumies@la.ccfo.carel.fi>]

Bob Stout wrote:
> 
> 
> I heard a talk by Plauger once where he suggested there was a fundamental
> difference in mindset between the two types of programmers (this is true no
> matter what you call the two groups, applications vs. libraries,
> applications vs. systems, etc.) I tend to agree with this and believe it has
> a lot to do with an individual's most natural way of deconstructing a
> problem. The top-down people are apps programmers, the bottom-up people are
> library/systems programmers.

This is a very interesting problem that I've been wondering about for a long 
time, since I've been working for years in (agreed, somewhat small) projects 
involving 10 to 30 programmers. It seems that many programmers do not "see" that 
some particular piece of code could be reused (when taken out of the current 
context with perhaps some modification) and yet some do (there are not as many 
of these people, though, it seems). It seems that this does not have anything to 
do with the educational level, position or experience. One thing I've recognized 
is that the people that write with reusable code in mind (even when they would 
be writing a program to do something very dedicated) often (but not all of 
them) play chess, too. So it might have something to do with pattern recognition 
or something like that.

About the top-down (apps programmers) vs. bottom-up (lib/sys programmers), I 
don't quite agree. I've seen many people start off with the general problem, 
breaking it down to smaller pieces and resulting to well reusable code. Also, 
I've seen many people starting with some small piece of code (reusable) and 
building on top of it, still retaining as much reusability as possible.

A way I often use is to write a program and then go through it to find common 
parts (algorithms, places that could be generalized etc) and then rewriting 
these. It's a little more work at first, but as time goes by, it'll cut down the 
need of rewriting tremendously. (But then again, I'm too lazy to rewrite 
anything so I try to make everything as general as possible :)

Finding out why these distinguished groups of people are distinguishable would 
result to better ways to divide the work between people (resource allocation). 
I've seen some projects where the writing of common parts were given to people 
who didn't have the "insight" to do it properly, or where some people able to 
write reused code where given tasks that did not need (or needed very little) 
generalization. This always slowed the projects down somewhat. As a 
designer/programmer/analyst and teacher of computing and programming, this 
problem is very close to my heart, not to mention that it might add something to 
our understanding about how a human mind works. I think there must be many 
people with many ideas about this out there. Am I correct?

Later,
 AriL
-- 
All my opinions are mine and mine alone.