NetNews Usenet Archive 1992 #30/NN_1992_30.iso/spool/comp/software/4925

Internet Message Format | 1992-12-13 | 3.2 KB

Path: sparky!uunet!cbmvax!devon!sojurn!mike
From: [e-mail] (Mike J. Sangrey)
Newsgroups: comp.software-eng
Subject: metamodels, metalanguages, templates, domain models ...
Message-ID: <[e-mail]>
Date: 13 Dec 92 20:30:11 GMT
Organization: Humble Pilgrimage Palace
Lines: 58
Summary: What are the metalanguages that you've found and use?

I've been reading Yourdon's book: "The Decline and Fall of the
American Programmer," and in that book he brings up meta-languages.
He gives an illustration from a three volume work about Architecture
(which I don't believe to be computer architecture, but about
buildings, villages, etc.)  The work suggests that as a technology
matures, it develops a set of pattern languages that are used because
they provide simple, elegant, efficient solutions to the problem
domain.  While you drive down the road, you'll notice certain
architectural patterns, repeated again and again.  Rectangles are
frequently 2 times longer than they are wide; bricks for example.
These patterns work, both to the eye as well as functionally.  Up here
in the north east (Penna.) we have porches on the front of most
houses.  That pattern serves many functions and does so efficiently,
and, many times, rather elegantly.

Yourdon says, "This fits nicely into the concept of `application
domain models' that many researchers are currently exploring.  It
should be possible to provide a handbook to system designers that
says, `Look, if you're building a sales order entry system, you should
expect to see these 20 basic classes of objects and the following
class hierarchies.  You may encounter some variations and extensions,
but this is the general pattern.'"  In other words, ``when ya build a
house in Pa., ya gone'a to see da object `porch'.''

Now, this brought to my mind a question, albeit on a slightly
different plane.  There seems to me to be a certain set of patterns
that, when incorporated into software, provide a great deal of
flexibility and efficiency.  For example, the ``read-write-open-
close'' pattern.  We (my organization) have applied that pattern to
many things, unix message queues, dynamically sized priority queues,
and others, not to mention unix' use of it (which is where we got the
idea:-). Maybe another might be provision for dynamically redirecting
the flow of information from one object to another; unix, again, comes
to mind with its I/O redirection.  I see some of this in our software;
though it wasn't purposely designed in at the time.

Here's the question for discussion:

    What patterns should a software engineer look for and lean
    towards using, when doing analysis and design of a software
    system?  I'm looking for cookbook answers and justification
    for it's inclusion into this cookbook list.

        1)  read-write-open-close
    2)  dynamic redirection of information flow
    3)  ???
    4)  ...

Thank You.

Please post any contributions; you may email to me if you like.  I'll
post a summary sometime in the future, if there is enough input.

[e-mail]
--
  |  UUCP-stuff:  ...!pitt!devon!sojurn!mike | "You can't save a bad idea    |
  |  Internet  :  [e-mail]      |  by great execution."         |
  |  Fast-stuff:  [phone]             |                Moses Porter   |