🚀 go-pugleaf

In article <11963@boulder.Colorado.EDU> scotth@boulder.Colorado.EDU (Scott Henninger) writes:
>  I claim the dead end in
>software reuse is cognitive overload.  It will take thousands or
>millions of components to make a truly useable software reuse
>environment.  There is no way that a human can keep track of what is
>available at that kind of scale.

  The trick is to let the computer help with this, and find a
reasonable way to organize the components.  There were those who
claimed in the 17th century that widespread printing would lead to a
disaster--libraries would be overloaded and it would be impossible to
find the texts on a given subject.
  What happened?  Library science started appearing.  It tackles
exactly the same problem which will occur with re-use in software
engineering: millions of components, all doing slightly different
things.  The library on campus here has somewhere between 1 and 2
million books; yet, when I go to look for a book on finite automata, I
can find a set of them easily.  We need to develop a similar
organizational technique for software components.

>The cognitive overload also comes in understanding what a component does
>for you.  Do you realize how hard it is to get novice programmers to
>understand what a stack does?  And this is one of the simplest
>constructs in computer science.

  Yes, but it gets easier to understand new data structures as one
goes along.  I've only been programming for 8 years or so, but I can
look at a data structure description in Knuth and understand it in an
hour or two (as a general rule :-).  I can even define what I need
("a priority queue with fast removal of the first element and a fast
way to merge two queues") and go find a data structure for it.  Of
course, there aren't enough books which describe the structures....

>I also must emphasize that the problems of reuse ARE LANGUAGE
>INDEPENDENT.

  Definitely true.  I reuse a good chunk of my Pascal code...just
change the names of the structures and key fields.  Now, a nice way to
do this automatically (without manual editing) would be nice--that's
what Ada gives you.  But the basic problem isn't going through and
making the minor fixes, it's figuring out what you can reuse and how
to do it.

[ stuff about why "standard" doesn't necessarily mean "best" ]

  I agree and disagree with this, I guess.  Having a standard is good
because it means that components are more portable.  Right now, I have
a lot of Pascal libraries using VAX Pascal-specific constructs (i.e.
modules); moving these to other systems is possible, but quite a bit
of work.  On the other hand, I can move Ada code around without any
problems (barring compiler bugs/features :-).
  Using the library analogy, most of the books here are in English.
There are some in German, Spanish, and other languages.  If someone
wants to take the time, they can translate them, and it will take less
effort than writing them from scratch.  On the other hand, if I knew
how to read all the languages in the library, I could use every book
as a potential source.
  Similarly, I think more attention should be paid to interfacing
different languages together.  Calling Pascal or FORTRAN code from Ada
ought to be trivial, as long as certain Ada-specific semantics (such
as exception handling) are handled right.  Right now, I only know of
one operating system (VMS) which lets me mix languages freely without
worrying too much about their idiosyncrasies.  It might be nice to
have more development environments which handle multiple languages.
  Just my thougts....
   
+----------------------------------+------------------+
| Anton Rang (grad student)        | rang@cs.wisc.edu |
| University of Wisconsin--Madison |                  |
+----------------------------------+------------------+

"You are in a twisty little maze of Unix versions, all different."