HDTenEightyP/NetNews huggingface dataset:
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.object
Subject: Re: FAQ (Part 1 of 2)
Date: 26 Jan 93 14:00:59 GMT
Organization: Department of Computer Science, University of Manchester
In-reply-to: objsys@netcom.com's message of 23 Jan 93 07:10:36 GMT

In article <1993Jan23.071036.141@netcom.com> objsys@netcom.com (Bob Hathaway) writes:
   I'm posting this incomplete FAQ (we're still not done arguing yet) ...
   [deleted]
   Objective:
     In the spirit of other FAQs, to provide a simple document to answer the most
     frequently asked and recurring questions and to allow new users to understand
     frequently discussed topics and terms used in comp.object.
   [body of FAQ deleted]

IMHO, the spirit of a FAQ is captured in the first part of the above
objective, but the second part is outside the domain of a FAQ.  By
definition a FAQ should contain frequently asked/answered questions.
However, most of the body of part 1 of the FAQ contains questions and
answers I've never seen in this group%.  Maybe I'm just being a pedant,
but wouldn't it be better to have the FAQ contain what its name
implies and leave the other information to a separate message?
For example, part 2 of the current FAQ could become "List of available
OOL/OODBMS implementations".

bevan

% There is plenty of discussion about them (mainly prompted by the
posting of the current FAQ :-), but most of the issues have not been
asked independently and certainly haven't been asked frequently.
Newsgroups: comp.object
From: vinoski@apollo.hp.com (Stephen Vinoski)
Subject: Re: FAQ
Date: Wed, 27 Jan 1993 19:36:34 GMT
Organization: Hewlett-Packard Corporation, Chelmsford, MA


Alan Snyder has an article in the January 1993 IEEE Software magazine
called "The Essence of Objects: Concepts and Terms" which is
excellent.  After reading it I truly believe that FAQ should simply
state something to the effect of "read Snyder's article."  Then the
readers of this newsgroup wouldn't have to continue to wade through
the endless (and mostly worthless) arguments over terminology that
we've been subjected to lately.

-steve
--
-- 
Steve Vinoski  (508)436-5904   vinoski@apollo.hp.com
Distributed Object Computing Program
Hewlett-Packard, Chelmsford, MA 01824       These are my opinions.
Newsgroups: comp.object
From: mpaul@neuro.informatik.uni-kassel.de (Manfred Paul)
Subject: Re: What is polymorphism?
Followup-To: What is 'polymorphism'?
Organization: Dept. Comp. Science - Uni Kassel
Date: Tue, 26 Jan 1993 17:11:43 GMT


In article <PCG.93Jan25220542@decb.aber.ac.uk>, pcg@aber.ac.uk (Piercarlo Grandi) writes:
|> 
|> >>> On 21 Jan 93 02:44:52 GMT, objsys@netcom.com (Bob Hathaway) said:
|> 
|> Hathaway> What Is Polymorphism?
|> 
|> Hathaway> For a Brief Answer: Polymorphism is the ability of an object
|> Hathaway> to assume or become many different forms of object and for
|> 

(stuff deleted)

|> Neither polymorphism (inclusion or parametric) nor ad hoc polymorphism
|> involve any ability for an object to assume different forms.
|> 
|> Polymorphism is about how restricted is the set of classes that a
|> pointer value may denote (and pointer values are not, in virtually all
|> languages, objects themselves), and ad hoc polymorphism is about
|> procedure names and signatures, which are not objects either.
|> 
|> --
|> Piercarlo Grandi <pcg@aber.ac.uk> c/o Dept of CS
|> University of Wales, Penglais, Aberystwyth SY23 3BZ, UK

I don't want to interfere in the discussion (frankly I haven't got time
enough to spend on this). BUT: 

You seem to have read Cardelli/Wegner's paper on types. Please reread it.
Polymorphism occurs in languages with some notion of types, and it (usually)
means, that a given object "has more than one type" (put very (!) informally).

If the type expression describing the object's type contains (type) variables,
you have parametric polymorphism (an instantiation may supply a type for
this variable according to some constraints (again informally)). If only
substitution along an inheritance path is allowed, you have inclusion poly-
morphism.

POLYMORPHISM HAS NOTHING COMMON WITH void * IN C / C++!!!! Your "examples"
suggest a misconception on that one. 

BTW, having "polymorphic type" is in no way restricted to procedures (or
functions)! If you declare a type "  Stack[ alpha ] " (alpha being a type
var) then an object of this type is a polymorphic object. Just because this
isn't C(++) doesn't rule this thing out, there are other languages! I admit
that the term is used mostly in connection with methods, but I wonder if
it is really well understood (especially by writers of 'glamour ads' promo-
ting system FOO).

BTW, ever came across SmallTalk, where methods (and blocks) are first-class
"functional _objects_"?!

-- 
+----------------------------+----------------------------------------+
| Manfred Paul               |                                        |
| Dept. Comp. Science        |                                        |
| University of Kassel       |                                        |
| Germany                    |                                        |
+----------------------------+----------------------------------------+
From: pkeddie@axion.bt.co.uk (Paul Keddie)
Newsgroups: comp.object
Subject: Maintenance and OO
Date: 25 Jan 93 09:31:00 GMT
Reply-To: pkeddie@axion.bt.co.uk (Paul Keddie)
Organization: British Telecom Research Labs


Hi!

I am reasonably new to the OO paradigm and would like to know of
people's real experiences in having to maintain lager 00 programs written
in C++.

I know that, in theory, the benefits OO gives to developers should also
count for maintainers (data hiding, etc) -- but does this bare up in
practise? Specifically:

1) Are 00 programs harder to maintain than normal functional programs?
2) Do maintainers need to adopt new approaches to maintenance for 00
   programs?. For example, I've found trying to track function calls can
   lead to dead ends if you come to a call to 'Handle' in an event-driven
   program. Is my approach wrong?

3) Are there more difficulties because of C++ rather than the 00 paradigm?
4) Is badly written C++, 00 programs worst than the equivalent C programs?

I think that is enough for now, thanks in advance for your comments

Paul
Software Maintenance Group, Software Technology Division, BT
Research Labs, Martlesham Heath, Ipswich, IP5 7RE, UK
E-mail:  pkeddie@axion.bt.co.uk
Phone:  +44 473 649154
Fax:    +44 473 643019 
Newsgroups: comp.object
From: LANG@nvdv.e-technik.uni-stuttgart.dbp.de (MARTIN LANG)
Newsgroups: comp.object
Subject: Re: Booch question: new class relationship?
Date: 27 Jan 1993 14:46:27 GMT
Organization: University of Stuttgart, IND (Germany)
Distribution: world
NNTP-Posting-Host: nvdv01.ind.e-technik.uni-stuttgart.de
X-News-Reader: VMS NEWS 1.24

> The "using" relationships described in his book have been replaced
> with:
> 
> 	Contains by Value
> 		Which is a black circle, a double line and a black box
> 
>                 *=========#
> 
> 	Contains by Reference
> 		A black circle, double line and a white box
> 
>                 *=========[]
> 
> 	Uses
> 		A white circle, double line and no box.
> 		
> 		O=============
> 
> Robert Martin       | Design Consulting    | Training courses offered:
> R. C. M. Consulting | rmartin@rational.com |  Object Oriented Analysis
> 2080 Cranbrook Rd.  | Tel: (708) 918-1004  |  Object Oriented Design
> Green Oaks, Il 60048| Fax: (708) 918-1023  |  C++


Which class relationship is appropriate if you have two relations at the
same time, e.g.

class ValueAndUse {
  void AddValue(Value & val);
  
  Value X;
};
 
or

class ReferenceAndUse {
 void AddRef(Ref & r);

 Ref * ref;
};

or

class ValueAndReference {
 Member x;
 Member * y;
};


Martin Lang
University of Stuttgart
Newsgroups: comp.object
From: skershaw@bnr.ca (Sam Kershaw)
Subject: Configuration Management for OO development ?
Organization: BNR Europe Ltd, Maidenhead, UK
X-Newsreader: TIN [version 1.1 PL8]
Date: Fri, 22 Jan 1993 14:44:17 GMT

I'm interested in identifying the special configuration management issues 
which should be addressed when software development is performed using an 
object oriented approach. 
I'd like to define a configuration management plan which encompasses the 
entire development process (specification through to maintenance) and then 
use a tool(s) to automate areas such as 

	Version control (for all derived components) 
        Build management   
	Discrepancy reporting and correction management
        Release management
	etc

Nothing new here of course, but should the following be considered ?

	Inheritance
        Polymorphism
        Distributed Objects
        ReUse 
        Object Browsing
        Requirements Traceability
        Domain Analysis

        Anything else ?

I'm fairly new to OO development and would appreciate any suggestions, ideas,
references etc.

Thanks.

Sam Kershaw.
From: pcg@aber.ac.uk (Piercarlo Grandi)
Newsgroups: comp.object
Subject: Re: FAQ  Part 1 (of 2) [ polymorphism or latent typing? ]
Date: 27 Jan 93 18:31:22 GMT
Organization: University College of Wales, Aberystwyth

>>> Regarding Re: FAQ Part 1 (of 2) [ polymorphism or latent typing? ];
>>> hall@dec254.uucp (Phil Hall) adds:

Hall> In <PCG.93Jan20002119@decb.aber.ac.uk> pcg@aber.ac.uk (Piercarlo
Hall> Grandi) expounds:

pcg> I would find it rather hard to agree with those who say that latent
pcg> typing of variables is an essential aspect of an OO language, as
pcg> IMNHO one can still apply the OO paradigm without it.

Hall> Without "latent typing" there really is very little to distinguish
Hall> object-orientedness.

Uhmmm, I think this is too pessimistic, and the reverse may be truer.
Weak/dynamic/latent typing is used to good effect also in many non OO
languages, e.g. Lisp, and I think that it is not the discriminant for
OO-ness; I think you have almost gotten there when you wrote later on:

Hall> I guess OO can be defined as: 
Hall>       My superior method for clustering functions and data.

But not *any* superior method -- the OO method is _very_ specific and
clearly defined. So I would think that you are not right on this:

Hall> I would argue that languages without late binding are better
Hall> refered to as modular languages; OO is a more restricted paradigm.

Modular programming just states that better reuse is achieved
clustering functions and data so that intermodule dependencies and
connections are minimized, but does not give any guiding principle on
how to achieve this.

The OO method is to put into a cluster/module/class one and only one
type/mode/data representation definition and all and only the procedures
that know its internal details.

Indeed from an abstract viewpoint a class is a module that only contains
one data type and the related operations (this is what is achieved by
default, for example, by the classic procedure/class and closure/object
technology).

This is what uniquely distinguishes OO-ness, and whether the language is
pointer based, has latent typing, is compiled, interpreted, interactive,
batch, or whatnot is basically irrelevant.
Xref: sparky comp.object:5104 comp.lang.eiffel:1460 comp.lang.c++:20058
From: bss_tom@vd.seqeb.gov.au
Newsgroups: comp.object,comp.lang.eiffel,comp.lang.c++
Subject: Business Domain Class availability (2)
Date: 28 Jan 93 12:41:50 +1000
Organization: South East Queensland Electricity Board


SUBJECT:Availability of Domain Classes: Electricity Net (2)
SENDER:Tom Davis, email:bss_tom@seqeb.gov.au
ORGANISATION: South East Queensland Electricity Board,
       SEQEB, Business Systems Division, System Support
       Department, 150 Charlotte St. BRISBANE Qld, 4000
       GPO Box 1462 Brisbane Qld. 4001.Australia.
       Telephone; +61 7 223 4404
       Facsimile: +61 7 221 7556
PURPOSE: Apology for loss of some responses. 
DETAIL:Our Internet server went down for the count and
       in the process of endeavouring to recover from
       the problem we lost a whole host of news items
       and incoming electronic mail. If you have sent
       an email or a posting about my earlier request
       for Business Domain Classes, and you have not had
       a reply by phone or email, would you please
       retransmit the email message.

       I have had telephone and email response from
       Australian Telecom who have wisely suggested that
       I look at the emerging standardisation of managed
       objects proposed by OSI Network Management and
       by CCITT and the Object Management Group as well
       as X/Open Snapshot XMOG about Managed Objects.
       We are looking at these emerging standards and the
       direction that they imply.

Thanks, and apologies,

Tom Davis


From: kers@hplb.hpl.hp.com (Chris Dollin)
Date: Thu, 21 Jan 1993 09:41:41 GMT
Subject: Re: Re: FAQ  Part 1 (of 2) [ a bit of polemic ]
Organization: Hewlett-Packard Laboratories, Bristol, UK.
Newsgroups: comp.object

This is not a pipe, sorry, long post. 

In article ... Bob Hathaway <objsys@netcom.com> writes:

   Anyway, how about a critique of my new polymorphism def?  You made a point
   I've made many times here to, and its been assimilated.  I'll have a new and
   improved faq out soon, its got a great new and improved anon ftp section.

   What Is Polymorphism?

   For a Brief Answer:
   Polymorphism is the ability of an object to assume or become many different
   forms of object and for these various forms to exhibit explicit phenotype-
   like expression.  

This is not how I understood polymorphism was interpreted -- either in OO or
more traditional CS. (It would, however, fit into D&D :-)

Your definition makes *objects* polymorphic. I thought the usual interpretation
was that *methods* (procedures, routines, whatever) were polymorphic. For the
usual OO case of inclusion polymorphism, I would say something like

 A method is *polymorphic* in an argument A of type T if it may also be called
 with objects of type T' in the A position whenever T' is a subtype (derived
 class of, subclass of, inherits from) T.

This fits Eiffel (features are redefinable) and C++ (with virtual methods
applied to indirect objects). With a reasonable amount of goodwill about what
``type'' means, it also applies to Smalltalk and the Lisp-based OO systems.

Since I wrote this definition down in about sixty seconds, I freely admit it's
not perfect. But I think it's closer to what's normally understood than what
you wrote. (It may be that you've defined a perfectly reasonable concept, and
it's just a shame that the name is already taken.)



--

Regards,    | "You're better off  not dreaming of  the things to come;
Kers.       | Dreams  are always ending  far too soon." - Caravan.
Newsgroups: comp.object,comp.software-eng,comp.lang.c++
From: harvey@opl.com (Harvey Reed)
Newsgroups: comp.object
Subject: Re: Maintenance and OO
Date: 27 Jan 93 23:46:21 GMT


I got some good response, so I will summarize:

harvey@opl.com (Harvey Reed) writes:
>...
>the design. Maintaining OO (and C++) requires a more global understanding
>of the system than with C.

>I think this is a result of the fact that well designed OO packages
>(class, whatever) tend to get reused over and over, so the end result
>is that fixing a line of code can have impact throughout the system.


[Dave Cline, et. al.] correctly point out that a common trait
of traditional C (let's call it "flat") systems that used globals
was that - maintainers needed to know a lot about the system. Add
to that the "Globals Considered Harmful Paper"...
I want to draw a distinction between the knowledge that an
OO maintainer needs and a "flat" maintainer needs.

-----------------

What's the difference? Let's start with a class. In many respects
an OO class is analogous to a FLAT library. The big difference
is that the OO class is typically finer grained (smaller API), and
the dependencies between the OO classes are more complex than the
dependencies between FLAT libraries.

If the designer of an OO system eliminated relationships between
OO classes, the resulting system will be a lot closer in look
and feel to the FLAT system. However it is precisely these relationships
that give OO the power (inheritance, containment, polymorphism, etc.)
to express more with less. These OO relationships protect the 
system from a FLAT-ness where the responsibility to update globals 
is spread out. As my manager says... "spread out responsibility 
is no responsibility".

-----------------

SOOOOO... just what does the maintainer need to know? Well, in the
OO system, more global knowledge, but of a type that is (after training)
easier to comprehend. The maintainer must understand all the OO
relationships between the classes (libraries) that is in the 
immediate vicinity of where a bug-fix or enhancement will go.

IMO this is of a completely different nature than global variables,
and much easier to deal with.




-- 
++harvey
===========================================================================
internet:       harvey@opl.com  /  hreed@cs.ulowell.edu  /  h.reed@ieee.org
voice/fax:      617-965-0220    /  617-965-7599
From: kers@hplb.hpl.hp.com (Chris Dollin)
Date: Thu, 21 Jan 1993 10:06:55 GMT
Subject: Re: Re: FAQ  Part 1 (of 2) [ a bit of polemic ]
Organization: Hewlett-Packard Laboratories, Bristol, UK.
Newsgroups: comp.object

In article ... kers@hplb.hpl.hp.com (Chris Dollin) writes:

  A method is *polymorphic* in an argument A of type T if it may also be called
  with objects of type T' in the A position whenever T' is a subtype (derived
  class of, subclass of, inherits from) T.

The previous paragraph had mentioned inclusion polymorphism, but this
definition didn't. I hereby serve notice that I did *not* intend to limit
polymorphism to only this case; in particular, the other common case is
*parametric* polymorphism:

  A method is *parametrically polymorphic* in an argument A if it is
  independant of the type of A and so can be applied with values of
  any type in the A argument.

In Eiffel, this is genericity; in C++, it can be obtained using template
functions (the argument A must then be one of the template argument types).
Dynamically typed (or, using Piercarlo's term, latently typed) languages
usually have this as an automatic property.

I don't know if it's easy to unify the two kinds of polymorphism in a
single framework. Even if so, it might be useful to distinguish them.
--

Regards,    | "You're better off  not dreaming of  the things to come;
Kers.       | Dreams  are always ending  far too soon." - Caravan.
Newsgroups: comp.object
From: wbc@lookout.it.uswc.uswest.com (Brad Cleavenger)
Subject: OOA class recommendations
Organization: US WEST Information Technologies
Date: Wed, 27 Jan 1993 16:35:33 GMT

Hello,
   Can anyone recommend a good OOA class - preferably one that could
be brought in house?  

   Thanks in advance.

Brad Cleavenger
USWest Communications
wbc@uswest.com
Newsgroups: comp.object
From: smccoy@dw3g.ess.harris.com (Scott McCoy)
Subject: Re: relation betweem OOM and IDEFo and EXPRESS language
Date: Wed, 27 Jan 1993 17:01:15 GMT
Organization: Harris Corporation Information Systems Division

In article <1993Jan27.124431.16827@lut.ac.uk>, A.H.Al_ashaab@lut.ac.uk (AH
Al_ashaab)  writes:
|> 
|> OR Iam wrong and using any OOM is enough to do all our work from the
|> beginning
|> 

IMHO, you're wrong.  :-) IDEF0 is a functionally oriented, hierarchically
decomposed modeling notation.  It typically is  used to capture the 
business or manufacturing practices of an organization.

I suppose you could use IDEF0 to capture/specify the sequential behavior
of a software system, but since there are no data stores or the like
defined in IDEF0, you might as well just use DFD's (yucko).  So if the
OOM of choice provides a behavioral specification notation, why bother
with IDEF0 at that level of detail?

IDEF1X does provide a good data modeling notation.  But, if the OOM
of your provides a data model technique, then why cloud the issue with
yet-another-diagram?

If you really want to mix IDEF0/1X and an OOM, you could:

1.  Analyze the business practices using IDEF0
2.  Build a corporate data model using IDEF1X
3.  Determine which portion of the business you want to automate
4.  Begin OOA/OOD, using the IDEF0/1X models for context

Again, just MHO.

-- 
Scott McCoy	Harris ISD	Opinions expressed are my own.
Staff Eng - SW	Internet: 	smccoy@dw3g.ess.harris.com
From: csjohn@knuth.mtsu.edu (John Wallace)
Newsgroups: comp.object
Subject: Anyone running Ontos OODB on Ultrix?
Date: 22 Jan 1993 12:14:09 -0600
Organization: Dept of Comp Science, Middle Tenn State Univ, Murfreesboro, TN
NNTP-Posting-Host: knuth.mtsu.edu
Summary: Anyone running Ontos OODB on Ultrix?

If you are running the Ontos Object-Oriented Database System on Ultrix,
can you send me a message?  If you know the version of Ontos and the
version of Ultrix that you have, it would be helpful to me if you
included that information in your message.  If you don't know, that 
is fine.  Thanks.

-- 
John Wallace   ||   INTERNET: csjohn@knuth.mtsu.edu
> > >    We have the government we deserve.   < < <     
Newsgroups: comp.object
From: buck@siswat.hou.tx.us (Lester Buck)
Subject: Re: Any hints/heuristics/lessons about Booch and other OOA/OOD Methods?
Organization: Photon Graphics, Houston
Date: Thu, 21 Jan 1993 06:44:13 GMT

In article <walkerl-180193203247@3.7.192.190> walkerl@med.ge.com (Larry Walker) writes:
>STD's may be well understood, but all of the OOA/OOD books I've surveyed
>are curiously silent on any implementation details. Can anyone suggest good
>sources for practical implementation techniques for "realistic"
>applications of state-machines?
>
>Larry Walker

Check out the following article for several code samples, optimizations,
semantic sparse tables, normalization, etc:

Build Applications Faster with State Transition Automatons
    by Alan Cline
C User's Journal, Dec 1992, v10 n12 p.93-108


-- 
A. Lester Buck   buck@siswat.hou.tx.us   ...!uhnix1!siswat!buck
Newsgroups: comp.object
From: Bob Hathaway <objsys@netcom.com>
Subject: Re: Re: FAQ  Part 1 (of 2) [ polymorphism or latent typing? ]
Organization: Object Systems
Date: Sat, 23 Jan 1993 05:53:12 GMT

In article <KERS.93Jan22095935@cdollin.hpl.hp.com> kers@hplb.hpl.hp.com (Chris Dollin) writes:
>property of *entities*, not *objects*. Meyer describes [p73, OOSC] an
>``entity'' as the object-oriented equivalent of a variable. In Eiffel, entities
>of a class hold references to objects.
>
>Thus, in at least this one case, polymorphism is a property of *entities*, not
>*objects*. 

This is silly.  This even proves what piercarlo was saying is wrong because
piercarlo claimed such references are not polymorphic.  Meyer clearly agrees
with me, um, I mean I clearly agree with him on this.

>Not in the natural sciences, perhaps. Different fields of inquiry are
>characterised by different linguistic perversions, sorry, developments.
>How else could it be? There are different clusters of people doing the 
>work, with their own linguistic history, and the subject matter itself
>suggests its own metaphors.

Boy did you get this one wrong.  After posting, I looked up the definition
of polymorphism in the old Webster's.  I hate to tell you this, but
polymorphism has been well defined as referring to objects that can
assume different forms long ago (its the literal translation, for God's sake).
Sorry I don't have the dictionary here with me or I'd quote it for you.  The
sciences are using the standard definition, if anyone really got away from it,
it was Strachey (and current followers) in his notes in passing, which is
obvious!

Regards Chris,
bob
objsys@netcom.com

P.S.  Are there any other true object-oriented followers out there?  There
  seems to be lots of functional ones...