HDTenEightyP/NetNews huggingface dataset:
From: Bob Hathaway <objsys@netcom.com>
Subject: Re: OOP not GUT of programming?
Organization: Object Systems
Date: Sun, 11 Oct 1992 00:30:41 GMT

In article <5OCT199215551226@elroy.uh.edu> st1lv@elroy.uh.edu (McLeod, Stephen) writes:
>I have been talking to a lot of people about this lately and some had the view
>that OOP was basically a good algorithm for handling the data base handling
>aspect of a solution be it an OS, a Database, or a guided missile program but
>that it was not appropriate for writing, say, a compiler, a text editor and
>so on.

Hi Steve,

I wouldn't want to work on a compiler that wasn't OO.  It would just be
a big unstructured maintanance problem waiting to be upgraded or replaced.
And reflection almost requires an OO compiler.  And without reflection-based
compiler and language design, you're without a modern compiler and language.

And since OO advocates encapsulation and reuse (and etc.), it is a superior
methodology to whatever else is out there.

bob
objsys@netcom.com
From: charles@probitas.cs.utas.edu.au (Charles Lakos)
Subject: TOOLS Europe 93 CFP anyone?
Organization: University of Tasmania, Australia.
Date: Fri, 9 Oct 1992 09:23:52 GMT

I have a note indicating that the deadline for papers for consideration at
TOOLS Europe 93 is October 24 1992, but I do not have the Call for Papers
giving the details of topics and required format.  Does anyone have it,
preferably in machine readable form?

--
Charles Lakos.                               C.A.Lakos@cs.utas.edu.au
Computer Science Department,                 charles@probitas.cs.utas.edu.au
University of Tasmania,                      Phone:    +61 02 20 2959
Sandy Bay, TAS, Australia.                   Fax:      +61 02 20 2913
Newsgroups: comp.object
From: anton@cc.gatech.edu (Annie I. Anton)
Subject: Structured Analysis & Object Oriented Design
Reply-To:  anton@cc.gatech.edu (Annie I. Anton)
Organization: Georgia Tech Software Research Center
Date: Sat, 10 Oct 1992 23:16:20 GMT


I'm interested in knowing if structured analysis is ever used 
(successfully) as a front-end analysis activity leading into an 
object oriented design.  Does anyone have any experience with this?
Can someone recommend some relevant papers/books?

It seems that using the products of a structured analysis as a
front-end to object oriented design is possible but certainly not
desirable.  Any comments?

-Annie Anton
 
-- 
 _   /|          Annie I. Anton
 \'o.O'   ACK!   Georgia Tech Software Research Center
 =(___)=         Ga Tech  --  1990 National Champions!!!!
    U    PTHFT!  Internet: anton@cc.gatech.edu
From: tmb@arolla.idiap.ch (Thomas M. Breuel)
Newsgroups: comp.object
Subject: Re: comparing object-oriented platforms
Date: 12 Oct 92 02:22:17 GMT
	<1992Oct6.003602.21078@beaver.cs.washington.edu>
	<1992Oct6.190729.24367@ucc.su.OZ.AU>
	<1992Oct11.003711.21659@netcom.com>
Reply-To: tmb@idiap.ch
Organization: IDIAP (Institut Dalle Molle d'Intelligence Artificielle
	Perceptive)
In-reply-to: objsys@netcom.com's message of 11 Oct 92 00:37:11 GMT

In article <1992Oct11.003711.21659@netcom.com> objsys@netcom.com (Bob Hathaway) writes:

   [correct observations about different kinds of "polymorphism" deleted]

   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).

All you need to do is to put functions that correspond to methods
into your data structures. Inheritance can be expressed using
explicit conversion functions. E.g., in ML:

	type counter = {step: unit -> unit, value: unit -> int}

	type int_counter = {count: int ref, step: unit -> unit, value: unit -> int}

Currently, you have to provide an explicit conversion function to
make an object of a "derived class" into an object of a "base class":

	fun int_counter_as_counter({step,value,...}:int_counter) =
		{step=step,value=value}

There are simple extensions of the ML type system that make defining
explicit conversion functions unnecessary while still keeping the type
system static.

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. This is why
several OO languages have found it necessary to add "generic
modules" or "templates".

					Thomas.
Newsgroups: comp.object,comp.lang.smalltalk,comp.lang.eiffel
From: richieb@bony1.bony.com (Richard Bielak)
Subject: Re: OO Concurrency
Organization: multi-cellular
Date: Tue, 13 Oct 92 12:52:27 GMT

In article <1992Oct8.135201.19699@dsg.cs.tcd.ie> cjmchale@dsg.cs.tcd.ie (Ciaran McHale) writes:

[...descriptions of querries and commands removed...]

>
>I didn't express myself clearly in my previous posting. I'll try again.
>Consider the following class:
>
>	Class Foo
>		"declare instance variables"
>
>		A(...)
>		{
>			something := x;
>		}
>
>		B(...)
>		{
>			y := ...;
>		}
>	end Foo;
>
>Basically, B is a writer on one part of the object (the variable "y")
>and A is an reader on a _different_ part of the object (the variable
>"x"). So, if concurreny is allowed, the synchronisation constraints on
>A and B might state that:
>
>	1. B cannot execute if B is already executing (i.e., mutex with
>	   respect to itself)
>	2. There is no restriction on invocations of A.
>
>Notice that the potential concurrency is greater than than allowed by
>labeling everything as either a "(whole object) reader" or "(whole
>object) writer". By recognising that some operations only read/write
>sub-parts of an object, while other operations read/write other
>sub-parts we can have more potential for concurrency.
>

I guess the question is, whether this is an "object-oriented" way to
introduce concurrency into OOPLs. I'm not sure *what* the
object-oriented way to add concurrency is, but your proposal doesn't
feel right to me.

Is a thread-of-control an object?


[...an explanation of how pre- post- conditions reduce possible
concurrency removed ...]

>
>What I meant by that comment is that programmers know they have to look
>at the code bodies of operations when they are deciding on a
>synchronisation policy for the object, but they may fail to _also_ take
>pre-/post-conditions into account when doing this. I think this issue
>is independant of whether one expresses synchronisation constraints in
>terms of guards, path expressions or keywords such as
>"reader"/"writer".
>

I'll have to think more about this :-).


...richie

P.S. Did you see the paper in Tools '92 "Concurrency Annotations
     Improve Reusibility", by Klaus-Peter Lohr.
-- 
* Richie Bielak   (212)-815-3072   |                                          *
* Internet:       richieb@bony.com | Rule #1: Don't sweat the small stuff.    *
* Bang {uupsi,uunet}!bony1!richieb | Rule #2: It's all small stuff.           *
*    - Strictly my opinions -      |                                          *
From: cwl@aber.ac.uk (C W Loftus)
Newsgroups: comp.object
Subject: Object-oriented operating systems
Date: 15 Oct 92 15:58:05 GMT
Organization: University of Wales, Aberystwyth

Could someone please provide me with some information and references on
object-oriented operating systems. I seem to remember hearing something
about Macintosh developing an OO os. To what extent are Amoeba and Chronus
object-oriented?

Many thanks

Chris
-- 
Chris Loftus,			  | PHONE: +44 970 622440
Computer Science Department,	  | UUCP : ...!mcsun!ukc!aber!cwl
University of Wales, Aberystwyth, | INET : cwl@aber.ac.uk
Aberystwyth, Dyfed, UK. SY23 3BZ. | ARPA : cwl%uk.ac.aber@nsfnet-relay.ac.uk
From: p00058@psilink.com (Ronald C. Schultz)
Newsgroups: comp.object
Subject: OODBMS As Integrating Platform for Heterogenous Data
Date: 7 Oct 92 16:12:23 GMT
Organization: Berard Software Engineering, Inc.
X-Mailer: PSILink (3.2)

I have been tasked with developing an architecture that will allow end 
users to download 'information' from a 'data warehouse.'  The location 
and access to the data will be hidden from the end user in a 'Data 
Access Manager' or 'Rules Manager', while the semantics of the data will 
be defined in a data dictionary.  Users will request information, (e.g., 
estimated sales or production volume), which will be received by the 
Rules Manager and interpreted.  Data will be gathered and procedures 
executed under the Rules Manager guidance, and the 'information' will 
then be delivered to the end user in some predefined forms (e.g., ASCII, 
WKS, .XLS,...).  Does anyone know of a product, or suite of products, 
that supports such an approach in a heterogeneous environment (multiple 
hosts running numerous protocols with many types of databases executing, 
as well as flat files).  In addition, I would be interested in 
corresponding with anyone currently doing this.  

In particular, I am interested in an approach that can assemble data for
heterogeneous sources, convert them into objects, and then allow them to
be manipulated as objects. Does anyone have any pointers to commercial or
academic research or products that provide this capability?

Thanx.

------------------------------------------------------------------------------
Ron Schultz 
Berard Software Engineering, Inc.
Columbus, Ohio Office                   Headquarters
5634 Claire Court                       101 Lakeforest Blvd.
Dublin, Ohio 43017-2440                 Gaithersburg, Md.  20877
(614) 798-0295 Phone                    (301) 417-9884 Phone
(614) 798-0296 FAX                      (301) 417-0021 FAX
ron@bse.com                             info@bse.com
------------------------------------------------------------------------------
Newsgroups: comp.object
From: st1lv@rosie.uh.edu (McLeod, Stephen)
Subject: Re: OOP not GUT of programming?
News-Software: VAX/VMS VNEWS 1.41    
Organization: University of Houston
Date: Thu, 8 Oct 1992 22:22:00 GMT

Okay... the initial responses are all extremely positive to OOP/OOD and seem
to say it is good for anything including taking out the dog.  Unfortunately,
the specific examples I gave seem to have blinded people to my intended 
question:

  As OOP experts, what do you find to be *difficult* when workign with OOPLs?
Okay, compilers are easy, text editors are a breeze, but what about lowlevel
OS things?  How about things where the boss wants something completely new and
he wants it quickly or there is no point in doing it?  I have the impression
that OOD pays off *late* in the project (in maintenance especially).  What
about size?  Are there any projects that are so big that adding OOD breaks 
the back of the hardware?  I.E.  Does the OOD paradigm have no limits or is
it the best thing since sliced bread?

As a last little tidbit, one of my respondents said that he found something
called "MVC" to be much easier using a declarative language called "GARNET" 
than doing it under an OOPL.  (I don't know what MVC is... :( ).

Thanks for all the input so far.  I just bought a new book by "BOOCH" and I'm
reading it now.  When I finish all the basic texts I'm going to start on the 
OOPs conference books.  To be honest, they look pretty dry.

---
Stephen McLeod
The Eternal? Student
Newsgroups: comp.object
From: thinman@netcom.com (Technically Sweet)
Subject: Re: OO Concurrency Control (Was: OO Concurrency)
Organization: International Foundation for Internal Freedom
Date: Fri, 16 Oct 1992 23:00:55 GMT

As someone recently pointed out: object concurrency, persistence,
distribution, (and I forget the fourth), are all the same problem.
Attempting to solve one in isolation will give half-hearted results.

-- 

Lance Norskog

Data is not information is not knowledge is not wisdom.
Newsgroups: comp.object
From: osstlm@eua.ericsson.se (Tomas Lundstrom)
Subject: new ODBMS product release
Reply-To: osstlm@eua.ericsson.se
Organization: Ellemtel Telecom Systems Labs, Stockholm, Sweden
Date: Fri, 16 Oct 1992 17:25:51 GMT

I have posted a description of the latest EasyDB release to
comp.newprod and eunet.newprod.

For further information, please contact Renee Sjostedt, Jaan Haabma or Per-Arne 
Gussander at Objective Systems SF AB on:

	phone: +46 8 703 45 30, fax: +46 8 750 80 56,
	E-mail: base-open-request@os.se


Product Summary

	EasyDB releases 3.1 product highlights are summarized in:

*	Multi-user system with network distributed storage - can be scaled down 
	to single-user and single-host configurations.

*	Strong modeling system (both graphical and textual). Dynamic schema 
	evolution.

*	Well integrated language bindings. Static or dynamic name resolution. 
	Multimedia support.

*	Safe and easy to use conflict handling throughout the system.

*	Support for Configuration Management.

*	Powerful distribution mechanism. Network topology independent.

*	Technology independent layers.

*	High performance. Short and long-lasting transactions.

Newsgroups: comp.object
From: hall@dec254.uucp (Phil Hall)
Subject: Re: OOP not GUT of programming?
Organization: Cincinnati-Milacron, Inc.
Date: Mon, 12 Oct 92 19:30:33 GMT


From the keyboard of st1lv@elroy.uh.edu (McLeod, Stephen):

> Hello,  back again with another question.

> OOP is gaining popularity right now and pretty soon I'm sure they will 
> be trying to use it to do everything but is OOD/P really *that* good?

> I have been talking to a lot of people about this lately and some had the 
> view that OOP was basically a good algorithm for handling the data base 
> handling aspect of a solution be it an OS, a Database, or a guided missile 
> program but that it was not appropriate for writing, say, a compiler, a 
> text editor and so on.

> What do you think?  I'd appreciate your views on this as I am floundering 
> around looking for a topic to write a paper on and 'the limits of the ood 
> paradigm' seems pretty good right now.

You might take a look at the following reference:

%A Peter Rechenburg
%T Programming Languages as Thought Models
%J Structured Programming
%V 11
%P 105-115
%I Springer International
%D 1990
%K programming languages, programming paradigms

He has rather interesting conclusions w/respect to OO and its place in
computer science.   Let me know what you think...

> Cheers...

> ---
> Stephen McLeod
> The Eternal? Student

-------------
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,comp.lang.smalltalk,comp.lang.eiffel
From: richieb@bony1.bony.com (Richard Bielak)
Subject: Re: OO Concurrency
Keywords: wait-by-necessity
Organization: multi-cellular
Date: Wed, 7 Oct 92 14:49:36 GMT

In article <1992Oct1.105430.428@dsg.cs.tcd.ie> cjmchale@dsg.cs.tcd.ie (Ciaran McHale) writes:

[...]

>>
>>You can divide features of a class into "querries" and "commands".
>>Querries only read the object's attributes and return some value.
>>Commands modify the object.
>
>Indeed, that is one way to handle it. But it has some limitations:
>
>	o The readers/writer (queries/commands as you call them) policy
>	  may be artifically constraining the potential for
          concurrency.

Since objects contain data and concurrent objects contain data shared
by many threads, so the concurrency *must* be constrained.

Because we discussing programming languages, it seems that we're
thinking of making code concurrent. But to have concurrent objects, we
also need to make data acccess concurrent - just like in a database.



>	o Most likely it would be the programmer's responsibility to
>	  take the pre-/post-conditions into account when writing the
>	  synchronisation code for the object. I think this gives
>	  programmers more than enough rope to hang themselves with.
>

By default all routines could be "readers" (querries). Additional
keyword be needed for routines that are "writers" (commands).


>Another possibility (as taken by Caromel) is for the language to
>disallow internal concurrency within objects (but to allow for
>concurrency between objects).
>

Right. This is even more restrictive. However, this type of
concurrency is easy to implement via a library, without having to
change the language. 

...richie



-- 
* Richie Bielak   (212)-815-3072   |                                          *
* Internet:       richieb@bony.com | Rule #1: Don't sweat the small stuff.    *
* Bang {uupsi,uunet}!bony1!richieb | Rule #2: It's all small stuff.           *
*    - Strictly my opinions -      |                                          *
Newsgroups: comp.object
From: maxtal@extro.ucc.su.OZ.AU (John MAX Skaller)
Subject: Re: Basis of OOP
Keywords: OOP,Mathematics
Organization: MAXTAL P/L C/- University Computing Centre, Sydney
Date: Sat, 17 Oct 1992 04:35:49 GMT

In article <1992Oct13.210801.20457@cis.ohio-state.edu> ogden@seal.cis.ohio-state.edu (William F Ogden) writes:
>In article <Bvvstz.FJv@world.std.com> rjk@world.std.com (robert j kolker) writes:
>   ...
>>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?
>
>Unfortunately, no single simple mathematical model will do. In essence,
>the objects in OOP can, in principle, come from any mathematical domain,
>so an adequate mathematical basis needs to include all of mathematics --
>including the higher order parts. 

	Have you perhaps confused the model for the system (OO) with
what the system models? For a given language there is definitiely
a mathematical model, it is embodied in the compiler/run-time system.
For a more generic OO there ought to be a correspondingly more abstract
mathematical model. This model may say something about there being
objects that have mutable states, perhaps. Whether the actual
objects happen to be mathematical objects or employee payroll records
is not relevant.

	Such a model would be nice to have because it would show
the inherent limitations of OO.

-- 
;----------------------------------------------------------------------
        JOHN (MAX) SKALLER,         maxtal@extro.ucc.su.oz.au
	Maxtal Pty Ltd, 6 MacKay St ASHFIELD, NSW 2131, AUSTRALIA
;--------------- SCIENTIFIC AND ENGINEERING SOFTWARE ------------------
Newsgroups: comp.object
From: mday@jukebox.lcs.mit.edu (Mark Day)
Subject: Re: comparing object-oriented platforms
Organization: MIT Laboratory for Computer Science
	<MDAY.92Oct11123541@jukebox.lcs.mit.edu>
	<1992Oct12.003503.26379@netcom.com>
Date: Tue, 13 Oct 1992 02:27:40 GMT

   objsys@netcom.com (Bob Hathaway) writes:
   > mday@jukebox.lcs.mit.edu (Mark Day) writes:
      objsys@netcom.com (Bob Hathaway) writes:

      [edited version deleted]

   >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.

   In the first place, you took out half of what I was responding to!!!
   Dirty pool, Day, where's Breuel's response???.  My reply referred to
   both referenced participants (perhaps you misunderstood this).  

Yes, I suppose I did misunderstand.  Although honestly, even when I
look at the whole exchange, I don't see much that has to do with Thomas
Breuel's original point.  I thought that Craig Chambers gave a
reasonable explanation of things and certainly didn't merit the label
of "gibberish".  I wasn't attempting to play "dirty pool", I was only
trying to edit out irrelevancies.  I'm sorry if I changed the meaning
of your contribution as a result.

   Notice the above
   claim that OO uses ad hoc polymorphism.  This is wrong by Strackey's
   definition, PERIOD.  If you divide the polymorphism world into two parts,
   ad hoc and parametric, OO inclusion polymorphism *is* a subset of parametric
   polymorphism.  In Smalltalk this is obvious and it continues from there.

I guess that maybe I have no idea what you mean by OO polymorphism.  I
understand what I mean by subtype polymorphism, I understand what I
mean by parametric polymorphism, I understand what Breuel's original
point was (although I think I disagree with him -- I'm still thinking
about a couple of messages he sent me), and I understand Chambers's
point.  You may well have a point, but I don't get it yet.  It's
certainly not "obvious".

My first impression is that you are actually refighting the
dynamic-versus-static-typing religious war using "OO" terminology, but
I'm not sure.

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.

--Mark Day

mday@lcs.mit.edu
Newsgroups: comp.object
From: matt@bacchus.esa.OZ.AU (Matthew Atterbury)
Subject: Re: Questions about OO analysis and design.
Organization: Expert Solutions Australia.
Date: Thu, 8 Oct 1992 07:08:12 GMT

In article <11215@platypus.uofs.uofs.edu> sgg2@owl.cs.uofs.edu (Sudhir G Gajre) writes:
> 
> 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.

    I don't see how you can be "following the Booch method" as OODwE
    does not really provide a method of design, more a method of
    documenting a design. IMO something like "Jackson, System
    Development" will tell you more about how to design than OODwE.

    I would say the books are complementary: JSD tells you very little
    about documenting a design but gets you thinking in the "right"
    way, and vice-versa for GB's book.
-- 
-------------------------------------------------------------------------------
Matt Atterbury [matt@bacchus.esa.oz.au]   Expert Solutions Australia, Melbourne
UUCP: ...!uunet!munnari!matt@bacchus.esa.oz.au            "klaatu barada nikto"
ARPA: ...!uunet!murtoa!bacchus.esa.oz.au!matt         "consider this a divorce"