HDTenEightyP/NetNews huggingface dataset:
From: mday@jukebox.lcs.mit.edu (Mark Day)
Newsgroups: comp.object
Subject: Re: comparing object-oriented platforms
Date: 11 Oct 92 17:35:41 GMT
	<1992Oct6.003602.21078@beaver.cs.washington.edu>
	<1992Oct6.190729.24367@ucc.su.OZ.AU>
	<1992Oct11.003711.21659@netcom.com>
Organization: MIT Laboratory for Computer Science


   objsys@netcom.com (Bob Hathaway) writes:

   >> chambers@cs.washington.edu writes:

   >>Ad hoc ("OO-style") polymorphism is not more restrictive than
   >>parametric ("Milner-style") polymorphism; the two are incomparable in
   >>expressive power.  Certainly things like arrays of mixed integers,
   >>rationals, and floats cannot be statically-typed in ML.  

   This is jibberish.  Ad hoc polymorphism is overloading, OO typically
   provides the parameteric form based on inclusion polymorphism.  And
   since ML is statically typed, it is weaker than OO polymorphism; what
   are you thinking???

Would it be too much to ask that you understand what someone is saying
before you start shrieking at him?  Otherwise you do tend to look like
rather a twit, even though yours is a common and reasonable
misunderstanding.

Craig Chambers is correct when he says that the two approaches are
incomparable in expressive power.  Start with the universe of all
specifiable data structures.  Consider A, the proper subset of that
universe that can be correctly typed in a system with parametric
polymorphism.  Now consider B, the proper subset of that universe that
can be expressed in terms of subtypes and dynamic dispatching.  A is
not a subset of B, nor vice-versa.

Here's an example of something that's in A but not in B: If you want
to say that a list is of homogeneous type, with all elements of type T
and none of a subtype of T, you can do that in a system with
parametric polymorphism.  There is no way to express that constraint
in a system with only subtyping; the best you can do is to write a
comment to that effect and dynamically check whenever you're about to
add something to the list.

This "subtyping-always-allowed" quality is usually considered as an
advantage of OO systems, but there can be times when it's a problem;
and as a pure theoretical issue, it demonstrates that "OO
polymorphism" does not subsume parametric polymorphism.

It's too bad, really, because the intersection between A and B is
quite large.  It would be nice if you could use only one mechanism and
have all the expressive power of both, but you can't.

--Mark Day

mday@lcs.mit.edu
From: kono@csl.sony.co.jp (Shinji Kono)
Newsgroups: comp.object
Subject: Re: OO Concurrency Control (Was: OO Concurrency)
Date: 15 Oct 92 23:17:55 GMT
Reply-To: kono@csl.sony.co.jp
Organization: Sony Computer Science Laboratory, Inc.

In article <1992Oct14.114158.239@dsg.cs.tcd.ie> , 
	cjmchale@dsg.cs.tcd.ie (Ciaran McHale) writes 
>	/1/ synchronisation is an implementation issue and should *not*
>	    be visible in the object's type specification.
>	/2/ object's sychronisation *should* be visible in its type
>	    specification.
>The observant reader will notice that /1/ and /2/ contradict each other.

I agree. If you require a consistency which is visible in a group of 
object, it must be visible in the group. 

But what we need is abstraction rather than information hiding. It possible
to design concurrency control which is visible and well encupslated. For
example, you can add reliability of information, that is
you can see the state of object but you cannot relay on it. 

---
Shinji Kono @           kono@csl.sony.co.jp
Sony Computer Science Laboratory, Inc,Japan
Newsgroups: comp.object
From: hall@dec254.uucp (Phil Hall)
Subject: Polymorphism (was: Re: comparing object-oriented platforms)
Organization: Cincinnati-Milacron, Inc.
Date: Wed, 14 Oct 92 20:04:08 GMT

In hopes of helping clear up some terminology issues I have a question 
concerning parametric polymorphism.

chambers@klamath.cs.washington.edu (Craig Chambers) writes:

craig> [In] Wegner's excellent survey article 

[CARD85]  Cardelli, L. and P. Wegner, "On understanding types, data
          abstraction, and polymorphism," Computing Surveys, vol. 17
          no. 4, ACM, December 1985.

craig> polymorphism
craig>     universal
craig>         parametric
craig>         inclusion
craig>     ad hoc
craig>         overloading
craig>         coercion
craig>
craig> [...]  Parametric
craig> polymorphism describes the situations that parameterized
craig> types/generics/ML-style polymorphic functions cover.  [...]

But [CARD85] says:

  "The semantics of generic procedures is macroexpansion driven by the type
   of the arguments.  Thus generic procedures can be considered
   abbreviations for sets of monomorphic procedures."

I am not familiar with "ML-style polymorphism" but I expect it is the
same as "generic procedures" above.

The way I understand [CARD85]'s parametric polymorphism is that 
the same *implementation* accepts a parameter of any type or some set
of types.  I've heard the "any type" version refered to as "pure" 
polymorphism.  This assessment would label "parameterized
types/generics/ML-style polymorphic functions" as overloading
rather the parametric polymorphism.

Is this a correct assessment?

Phil.
-------------
Philip W. Hall                    Internet:  ...UUCP!dec254!hall
Cincinnati Milacron, Dept. 82G               hallpwcd@ucunix.san.uc.edu
Advanced Manufacturing Systems Division
4701 Marburg Avenue, Cincinnati, Ohio  45209    
Newsgroups: comp.object
From: Bob Hathaway <objsys@netcom.com>
Subject: Re: OOP not GUT of programming?
Organization: Object Systems
Date: Mon, 12 Oct 1992 00:37:40 GMT

In article <TMB.92Oct11222915@arolla.idiap.ch> tmb@idiap.ch writes:
>In article <1992Oct11.003041.20992@netcom.com> objsys@netcom.com (Bob Hathaway) writes:
>
>   And since OO advocates encapsulation and reuse (and etc.), it is a superior
>   methodology to whatever else is out there.
>
>Several programming technologies besides OOP advocate encapsulation
>and reuse. OOP certainly is better than some methodologies out there,
>but it is not clearly better than all other methodologies.
>
>                                        Thomas.

Granted, but OO is the only one that *I'm* convinced has these facilities
in a practical, straightforward, fully functional and easily understood
fashion.  I'll rescind and append this doesn't infer that there doesn't exist
any other methodologies that have these desirable qualities.

bob
objsys@netcom.com
Newsgroups: comp.object
From: Bob Hathaway <objsys@netcom.com>
Subject: Re: comparing object-oriented platforms
Organization: Object Systems
Date: Sun, 11 Oct 1992 00:37:11 GMT

In article <1992Oct6.190729.24367@ucc.su.OZ.AU> maxtal@extro.ucc.su.OZ.AU (John MAX Skaller) writes:
>In article <1992Oct6.003602.21078@beaver.cs.washington.edu> chambers@cs.washington.edu writes:
>>In article <TMB.92Oct4182305@arolla.idiap.ch>, tmb@arolla.idiap.ch (Thomas M. Breuel) writes:
>>|> OO-style polymorphism is more restrictive than Milner-style
>>|> polymorphism, and also too restrictive for my tastes in the presence
>>|> of a static type checker.
>>
>>Ad hoc ("OO-style") polymorphism is not more restrictive than
>>parametric ("Milner-style") polymorphism; the two are incomparable in
>>expressive power.  Certainly things like arrays of mixed integers,
>>rationals, and floats cannot be statically-typed in ML.  

This is jibberish.  Ad hoc polymorphism is overloading, OO typically provides
the parameteric form based on inclusion polymorphism.  And since ML is
statically typed, it is weaker than OO polymorphism; what are you thinking???

bob
objsys@netcom.com
Newsgroups: comp.object
From: rfm@access.digex.com (Bob Myrick)
Subject: Re: Wanted: info about Object Magazine
Organization: Express Access Online Communications Service, Greenbelt, Maryland USA
Date: Fri, 9 Oct 1992 02:10:26 GMT

ggolden@msen.com (Glenn Golden) writes:

>I am reading the latest issue of Object Magazine
>(published by SIGS). I recommend this to object fans.

>I am inspired by the articles I am reading, and want
>to converse with the authors, or even the editor
>or publisher ... but there are NO EMAIL addresses or
>even phone numbers listed in the issue!  I can't even
>get a phone # for the magazine, based on the NY address
>listed in the issue!

>You would think that communications would be encouraged
>in a new, high tech, emerging field such as this!  I do!
>(even if it has been emerging for 25 years!)

>***

>If anyone has an EMAIL address for this magazine, or for
>the editor, Marie Lenzi, or the published, Richard
>Friedman, please EMAIL this to me!

>***

>If anyone associated with magazine is reading, please
>take this as a request to include this information about
>your staff and authors in future issues.

>Thanks!

>- Glenn R. Golden, Dexter  MI.
>  (home) ggolden@msen.com
>  (work) ggolden@comshare.com

Marie Lenzi can be reached as follows: (from her business card)

Syrinx Corporation
236 West 26th Street
Suite 7SW
New York, NY 10001
Voice: 212-229-0320
Fax: 212-807-9111
Compuserve: 70754,1111
-- 
--
Bob Myrick (rfm@access.digex.com)
-------------------------------------+-------------------------------------
These ideas and others like them can | These opinions are mine and mine.
Newsgroups: comp.object
From: jeffery@flood.com (Jeffery Cavallaro)
Subject: Re: Documenting programs written in OOLs
Organization: The Flood Group, Inc.  Torrance, Ca.
Date: Thu, 15 Oct 92 18:01:21 GMT

In article <1992Oct15.032937.1909@syacus.acus.oz.au> ian@syacus.acus.oz.au (Ian Joyner) writes:
>mwu@orion.oac.uci.edu (Matt Wu) writes:
>> 
>>Is there a particularly good way to document classes/application code
>>that works especially well with object-oriented languages?
>
>Yes, if the language is consistent, simple, and lends itself to a
>neat style, it is the program itself.

I totally disagree - especially with regard to OOL.  Statements like this
assert the idea:

	CODE SYNTAX == PROBLEM SEMANTICS

Although mathematically, this might be a nice situation, it does not hold
water wrt programming today.  I hearken back to a posting from a couple of days
ago that yearned for a complete (sorry Godel) mathematic model for OOP.  Today
there is none.

The point is that the programming language syntax and the comments are
describing two different problem spaces.  Syntax describes a mechanism space,
and comments describe a problem space.  Although these two spaces are not
necessarily orthogonal, one cannot always directly (at a glance - which is
the ideal documentation requirement) glean the problem semantics.  I believe
that this situation is compounded with advanced OOL's that have meta-semantic
hooks (e.g., before/after methods).

>... current debacles of languages like C++,

Showing your true colors.

>then one document can be used to capture all the relevant information
>about a project. Viewing a program as a document has quite a
>number of benefits. Firstly, a language is formal, and can therefore
>be processed in many ways, in addition to straight compilation.
>Secondly, changes made to the program, are implicitly in the
>documentation. This saves cost and effort in updating separate
>documentation, but also saves as mistakes will not be made. Anyway,
>I shan't write a treatise on the benefits here, but leave you to
>think about them.
>
>The word 'code' implies something cryptic.  Many current programming
>languages back up this viewpoint, as programs do tend to be cryptic. 
>


When there is a generic programming environment such that the entire program
can be something like:

Hey Computer,
    Balance my checkbook right now!
Thank you.

I will agree with you.  Until then...

BTW:  Using the mechanisms of an existing language to simulate something like
the above doesn't count, because then the simulation needs relevent doc.  You
just shift the burden.

Newsgroups: comp.object
From: rjk@world.std.com (robert j kolker)
Subject: Basis of OOP
Summary: What is underlying model (if any of OOP)
Keywords: OOP,Mathematics
Organization: The World Public Access UNIX, Brookline, MA
Date: Sat, 10 Oct 1992 01:15:34 GMT

I have a meta-question about OOP.

The proper underlying mathematical model for relational databases is
either Relational Algebra with limited complementation or a restricted
first order logic for n-adic predicates.

The proper underlying mathematical model for LISP is lamba-calculus.

The proper underlying mathematical model for Prologic is first order logic
restricted to Horn Clauses.

Question: What is a proper underlying mathematical model for OOP?

I would be interested in your opinions.

Conan the Librarian rjk@world.std.com
"If you can't love the Constitution, at least hate the Government"
From: fjh@munta.cs.mu.OZ.AU (Fergus James HENDERSON)
Newsgroups: comp.object
Subject: Re: comparing object-oriented platforms
Date: 14 Oct 92 03:34:10 GMT
Organization: Computer Science, University of Melbourne, Australia

mday@jukebox.lcs.mit.edu (Mark Day) writes:

>Could you give some simple examples of what *you* mean by OO
>polymorphism, ad-hoc polymorphism, and parametric polymorphism?  You
>seem quite certain that subtype polymorphism isn't relevant here, so
>you can leave that out if you like.

According to *my* understanding of the terms, it goes as follows:
(with examples in C++)

* Ad-hoc poylmormorphism is another name for overloading:
	long square(long);
	double square(double);

* Parametric polymorphism is another name for generics or templates:
	template <class T>
	T square(T);

	template <class T>
	class List<T>;

* OO polymorphism, or inheritance polymorphism, is I think the same
  thing that you refer to as "subtype polymorphism", characterised by
  the use of virtual functions in C++:
	class Base {
	public:
		virtual void foo();
	};

	void bar(Base& b)  { b->foo(); }

-- 
Fergus Henderson             fjh@munta.cs.mu.OZ.AU      
This .signature virus is a self-referential statement that is true - but 
you will only be able to consistently believe it if you copy it to your own
.signature file!
Newsgroups: comp.object
From: chambers@klamath.cs.washington.edu (Craig Chambers)
Subject: Re: comparing object-oriented platforms
Reply-To: chambers@cs.washington.edu
Organization: University of Washington
Date: Tue, 13 Oct 92 19:45:20 GMT

After looking up Strachey's definitions in my copy of Cardelli &
Wegner's excellent survey article ("On Understanding Types, Data
Abstraction, & Polymorphism"), this is the breakdown:

polymorphism
    universal
    	parametric
        inclusion
    ad hoc
        overloading
        coercion

When I equated OO-polymorphism with overloading, I was a bit wrong.
OO-polymorphism equates with inclusion polymorphism, as Bob Hathaway
pointed out.  Inclusion polymorphism describes the kind of
polymorphism where any object that's a subtype of the type of a
variable can be stored in the variable.  However, inclusion
polymorphism is not a subset of parametric polymorphism.  Parametric
polymorphism describes the situations that parameterized
types/generics/ML-style polymorphic functions cover.  I referred to ad
hoc polymorphism instead of inclusion polymorphism because inclusion
polymorphism gets its power by being used in conjunction with
overloaded functions that are resolved dynamically, i.e. dynamic
binding/message passing/virtual function calling.  It is this ability
which is lacking in ML-style polymorphism.

I'm not sure that Thomas Breuel's point about simulating objects and
methods using records and lexically-scoped functions really works out,
particularly in a system with mutable state in objects, since the
coercion functions needed by the type checker would throw away
state/identity that's needed.  Perhaps a complete example, such as
mixed mutable cartesian and polar point objects, might convince me.

-- Craig Chambers

P.S.  Wouldn't it be great if people decided to use the terminology
that's accepted by the majority of the researchers in programming
languages?  Such a terminology, covering issues like typing and
polymorphism, does exist.  Please learn and use it, unless you like
creating misunderstandings.
From: objsys@netcom.com (Bob Hathaway)
Newsgroups: comp.object
Subject: Re: comparing object-oriented platforms
Date: 12 Oct 92 00:45:46 GMT
Organization: Object Systems

In article <TMB.92Oct11222217@arolla.idiap.ch> tmb@idiap.ch writes:
>In article <1992Oct11.003711.21659@netcom.com> objsys@netcom.com (Bob Hathaway) writes:
>
>   [correct observations about different kinds of "polymorphism" deleted]

bob>       [The above referenced obsevations are by tmb]
bob> I don't think so.  You claimed that OO polymorphism is Ad Hoc, and
     this is simply not true.  Ad hoc polymorphism is the "fake" kind and
     is usually referred to as simple overloading.  This can be found in OO
     languages (such as C++) but is not the "OO" kind of inclusive
     polymorphism.  The parametric or "true" kind of polymorphism occurs
     when a formal object can be assigned to many different kinds of
     objects (as is the case in OO).  With inheritance, it can be any kind
     of object with the "Object" root class and in OO languages which also
     provide static typing can be restricted to a particular subtype
     relation if and when desired.

>   And since ML is statically typed, it is weaker than OO
>   polymorphism; what are you thinking???
>
>I think it is false to say that "since ML is statically typed,
>it is weaker than OO polymorphism". In fact, "OO polymorphism"
>can be expressed nicely within any static type system that has
>functions (it doesn't even have to have Milner-style polymorphism).
>
> [Example deleted but it looks like statically typed dynamically bound OO
>  to me, but I'll ignore that.]

I think you miss the point.  I've discussed adding dynamic typing to static
type systems myself but this is an idiom and shows that static typing can
emulate but is not as powerful as dynamic typing (or you wouldn't need to
emulate it).  I can perform dynamic typing in assembly language as well but
assembly language typing is weaker than dynamic OO typing (but you could
argue it is more flexible (as are goto's)).

>The converse is not true. Milner-style polymorphism (as found in
>ML) cannot be expressed in terms of an object system that has been
>grafted on top of a non-polymorphic type system.

I'm sorry, but could you explain why?

>                                                   This is why
>several OO languages have found it necessary to add "generic
>modules" or "templates".

I've used generics for so long (starting with object-based languages) that
I consider them an integral part of and principle reason for OO.  Perhaps
you're interpreting OO as strict inheritance and nothing else?  I don't
equate the two and prefer the more general first-class type variables
facility myself anyway (along with inheritance).  And BTW, actual generic
type parameters still carry subtype constraints.

bob
objsys@netcom.com
From: lmiller@aero.org (Lawrence H. Miller)
Newsgroups: comp.object
Subject: Re: C++ Component Toolkit Evaluation
Date: 12 Oct 1992 20:05:08 GMT
Organization: The Aerospace Corporation, El Segundo, CA
NNTP-Posting-Host: palomar.aero.org

In article <BvpLv6.Fut@vizbiz.com> pphilp@vizbiz.com writes:
>I am evaluating C++ component toolkits.  I am looking at Tools.h from Rogue Wave

	I've used tools.h++ (a library of data structure classes),
	and have been involved with a very large software effort
	for an outside organization that has used it and is happy.

-- 
Larry Miller		The Aerospace Corporation
lmiller@aero.org	PO Box 92957		
310-336-5597		LA, CA 90009-2957
Newsgroups: comp.object
From: tmb@arolla.idiap.ch (Thomas M. Breuel)
Newsgroups: comp.object,comp.lang.functional
Subject: Re: ad hoc vs. parametric polymorphism (Was Re: comparing object-oriented platforms)
Date: 9 Oct 92 02:01:24 GMT
	<1992Oct6.003602.21078@beaver.cs.washington.edu>
	<1992Oct6.190729.24367@ucc.su.OZ.AU>
	<1992Oct7.200903.19397@beaver.cs.washington.edu>
Reply-To: tmb@idiap.ch
Followup-To: comp.object
Organization: IDIAP (Institut Dalle Molle d'Intelligence Artificielle
	Perceptive)
In-reply-to: chambers@klamath.cs.washington.edu's message of 7 Oct 92 20:09:03 GMT

In article <1992Oct7.200903.19397@beaver.cs.washington.edu> chambers@klamath.cs.washington.edu (Craig Chambers) writes:

   In article <TMB.92Oct4182305@arolla.idiap.ch>, tmb@arolla.idiap.ch (Thomas M. Breuel) writes:
   > OO-style polymorphism is more restrictive than Milner-style
   > polymorphism, and also too restrictive for my tastes in the presence
   > of a static type checker.
   >
   >Ad hoc ("OO-style") polymorphism is not more restrictive than
   >parametric ("Milner-style") polymorphism; the two are incomparable in
   >expressive power.

Please let's get our terminology straight. There is "ad-hoc"
polymorphism, which as far as I know is synonymous with overloading,
then there is Milner-style polymorphism, and finally there is
OO-polymorphism, which means being able to substitute derived classes
for base classes.

From a practical point of view, I find that OO-polymorphism is "more
restrictive" than Milner-style polymorphism in the sense that you can
easily and safely simulate OO-polymorphism in a Milner type system,
but the converse is not true (otherwise C++ wouldn't have found it
necessary to add templates).

   I think numbers are a fine example of ad hoc polymorphism [he
   presumably means OO-polymorphism].  There are a number of different
   possible representations for numbers, but these representations
   share a common protocol. [...]  In a purely OO language, new
   numeric representations can be added to the system by programmers,
   as long as they continue to support the expected protocol.

I think generic arithmetic is a fine example where OO-polymorphism
fails to be a useful paradigm. First, you have to deal with the
problem that there can be operations that mix different kinds of
numbers. Second, you have to deal with the problem that the return
type of an operation may depend on the value of the arguments. It is
in the very nature of generic arithmetic that you cannot decompose it
nicely into separate "modules" or "classes", each responsible for just
one type.

Of course, you can still use the mechanisms of OO programming to
implement user-extensible generic arithmetic, but that's hardly
surprising--you can do the same in functional languages, Pascal, or
assembly.

					Thomas.
Newsgroups: comp.object
From: calliss@enuxha.eas.asu.edu (Frank W. Calliss)
Subject: Re: Object-Oriented Prolog
Organization: Arizona State University, Tempe, AZ
Date: Fri, 16 Oct 1992 20:47:49 GMT

In article <1992Oct15.205642.8624@netcom.com> thinman@netcom.com (Technically Sweet) writes:
>I just saw a book today called, "Logic & Objects".  It outlines
>a simple object extension to Prolog, called "L&O".  The book
>includes a preprocessor in Prolog that translates L&O into
>Prolog.
>
>You can FTP the code from some UK site listed in the book.
>

Can you give me more info on the book.  It sounds interesting.


calliss@asuvax.eas.asu.edu
From: thinman@netcom.com (Technically Sweet)
Newsgroups: comp.object
Subject: Re: Basis of OOP
Keywords: OOP,Mathematics
Date: 15 Oct 92 21:17:04 GMT
Organization: International Foundation for Internal Freedom

rjk@world.std.com (robert j kolker) writes:

>Question: What is a proper underlying mathematical model for OOP?

Great question!  OOP isn't based on mathematics.  OOP is based on linguistics!

Read the first two chapters of "Women, Fire, and Dangerous Things"
by George Lakoff.  OOP is an application to computer programming of
our fundamental linguistic process of categorization.  Reading this
book also sheds new light on why the currently available OO mechanisms
are all limited and klunky.

-- 

Lance Norskog

Data is not information is not knowledge is not wisdom.
From: sgg2@owl.cs.uofs.edu (Sudhir G Gajre)
Newsgroups: comp.object
Subject: Questions about OO analysis and design.
Date: 7 Oct 92 13:44:24 GMT
Organization: Department of Computing Sciences

I am trying to do some OO analysis and design.  I am following the Booch method.  I am not sure about the method.  Can anyone please give me a recipe or atleast clear guide lines as to how the classes and objects are identified and what steps are to be taken after that, till implementation.

Thank you,
Sudhir.