🚀 go-pugleaf

From johnson@p.cs.uiuc.edu:
> In particular, he said "It seems to me that separation of functional
> specification from implementation is at least a Good Thing, [...]
> This is a very common claim.  I disagree with it.  This is only important
> in a library of data structures, 

   Then it's at least a Good Thing, right?

   Furthermore, domain-specific packages will define domain-specific
   data abstractions, for which once again we encounter the need to
   separate specification from implementation.  Thus, the separation
   is important regardless of the type of code reused.

> Most of the code that we write is not heavily dependent on 
> algorithms, and so performance will not be a big deal.

   Most of the code that YOU write, maybe...  but you're in a
   Smalltalk "experimental programming in the small" environment.
   Since the programming is experimental, performance is not a
   major issue; since you are programming in the small, the fact 
   that Smalltalk does not provide any separation of specification 
   from implementation does not create communication problems among 
   the hundreds or thousands of programmers who would have to interact 
   if you were programming in the large.  For software engineers doing 
   programming in the large, the separation of specification from 
   implementation is absolutely essential.  Hopefully, the ideas of
   Wilf LaLonde regarding programming via exemplars (in which there are
   separate inheritance lattices for specification and implementation)
   will eventually result in the development of object-oriented systems 
   which are more suitable for programming in the large.

> Specifications are important because they help the potential reuser
> to understand the component.  Thus, they are very important.  However,
> I don't buy the idea that we will need lots of implementations that
> meet the same spec.  And yes, I've read Booch's "Software Components
> with Ada".  It is all about data structures.

   Then read Booch's "Software Engineering with Ada", and discover
   how the separation of specification from implementation can
   apply equally well to reuseable subsystems.


   Bill Wolfe, wtwolfe@hubcap.clemson.edu