From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.5-pre1 (2020-06-20) on
	ip-172-31-74-118.ec2.internal
X-Spam-Level: 
X-Spam-Status: No, score=0.0 required=3.0 tests=BAYES_20,MSGID_SHORT
	autolearn=no autolearn_force=no version=3.4.5-pre1
Date: 16 Sep 91 00:39:39 GMT
From: ajpo!wellerd@sei.cmu.edu  (David Weller)
Subject: Large System Decomposition II
Message-ID: <798@ajpo.sei.cmu.edu>
List-Id: <comp.lang.ada>

Well, here's another round of the "Large System" discussion:
 
I have had considerable support and pats-on-the-back for my comments.
This is not to say I am smug in my conclusions (that large systems
require something beyond what OO texts discuss), indeed, I am in fact
frightened.  A large percentage of my replies were something like: 
"Please summarize and repost, we're having the same problems here!"
 
I have had some wonderful replies from people I consider noteworthy
in the field of architectural organization of software, and have
also had some excellent suggestions from others.  I will post a summary
later in the week when I replace my sick modem.

To the point:  I have had a document sent to me on HOOD, the European
Space Agency's Hierarchical Object Oriented Design.  Although I vaguely
remembered some complaints about this method (mostly related to it
being a Functional wolf in Object-oriented sheep's clothing) a couple of
years ago, the document does appear to have some merit in approaching
the decomposition of large systems.  Although their end references are 
short, their approach seems sensible.  It seems to be a (fairly) pleasing
add that Becky's document was not in the reference).  
 
I am looking for testimonials either for or against the usage of HOOD
for large system decomposition, particularly those of you who could
provide or refer artifacts to support your comments.  I am also interested
in acquiring artifacts of large systems built with an OO approach. 
(I will, for the sake of argument, suggest that "large" will entail 
a system that exceeds 200 KLOC -- no "code density" or "artificial
constraint" flames, please).  Mind you, I'm not looking for source
code, rather some exposition or documentation that reveals how the
architecture of your system(s) was/were decomposed.

To the educators that read this sub: (Mike Feldman, I KNOW you're
reading this :-)  Do you even begin to hint as to what your students
will see when involved with large system development?  How do you
indicate what "large" really looks like?  (I fondly remember trying
to explain how big "space" was to my son many years ago)
 
AdvTHANKSance,
David Weller
<Insert Impressive Title Here>
<Insert Large Company Here>     (I have neither, so I left them blank!)

Notes:
[1] Booch, Grady.  Software Engineering with Ada (2ed). 1987
[2] Buhr, R.J.A.   System Design with Ada. 1983
[3] Wirfs-Brock, Rebecca and Wilkerson, Brian.  
        Object-oriented Design: A Responsibility-Driven Approach
        OOPSLA proceedings, 1989.
 
-----------------------------------------------------------------------
God's 1st Law of Colonization:  One Planet Is All You Get!
-----------------------------------------------------------------------
-