HDTenEightyP/NetNews huggingface dataset:
From: santas@inf.ethz.ch (Philip)
Subject: Re: Object hidden state and side effects
Organization: Dept. Informatik, Swiss Federal Institute of Technology (ETH), Zurich, CH
Date: Wed, 23 Dec 1992 01:37:14 GMT


In article <BzMpwB.7y3@newsflash.concordia.ca> grogono@cs.concordia.ca (Peter Grogono) writes:
>bongalon@tcad05.intel.com (Ben Bongalon) writes:
>>
>>why would you want to consider "i" and "(i^5)" as equal but not
>>identical values? Do you consider "1" and "(3-2)" equal but not
>>identical also?  From a pragmatic point of view, the distinction
>>between the simplified and unsimplified forms of the expressions
>>seem questionable.
>
>It depends what you mean by "pragmatic". It is true that, when we are
>thinking informally, there is not much difference between "1" and
>"3-2". But there is a vast difference computationally. 

Quite agree. To reinforce this argument, the distinction is not only in 
terms of computational effort, but also in terms of consistency of operations.
Simplifications performed globaly, without any type information,
can lead to unexpected results:
consider the case:
   random() - random()
or to think of the example above:
  (random()+1) - random()
   
>Many
>languages, including Prolog, are formally defined as term languages.
>In a term language, "1" and "3-2" are different terms and are thererfore
>unequal. A Prolog interpreter needs a simplifier, which would not be
>part of a "formal" implementation, to turn one into the other.
>The consequence is that arithmetic predicates behave differently
>from other predicates, although implementations try to hide this as
>much as they can.

Unfortunately. One of the main reasons here is that term rewritting, and
pattern based systems use _global_ optimization techniques, and exclude 
type information from their algorithms (implmentation of numbers is the 
exception). This leads again to strange results, since one might expect 
that, from the overall behaviour of the system, 3-2 is different from 1.

Use of pure functions without predefined pattern matching, is the only 
available solution to this problem, as functional languages demonstrate.

Philip Santas

  "In an evolving universe those who stand still are really moving backwards"
--------------------------------------------------------------------------------
email: santas@inf.ethz.ch				 Philip Santas
Mail: Dept. Informatik			       Inst. of Scientific Computation
      ETH-Zentrum			  Swiss Federal Institute of Technology
      CH-8092 Zurich				       Zurich, Switzerland
      Switzerland
Phone: +41-1-2547478
      

Newsgroups: comp.object
From: jcrw@fmg.bt.co.uk (Jeremy Wilson)
Newsgroups: comp.object
Subject: Re: Need basic OO information
Date: 22 Dec 92 09:50:31 GMT
Organization: British Telecom
X-Newsreader: Tin 1.1 PL5

cgra@btma74.nohost.nodomain wrote:
: 
: Not an answer, but a me-too-please.
: 
: Yesterday evening I attended an "Introduction to Object-Oriented Analysis"
: provided by our training department.  The lecturer started by apologising
: for the lack of concrete examples in her presentation - she had been unable
: to find anything in the literature beyond the old schoolbook of examples of
: closed-curve/polygon/ellipse... and "a zebra is a horse, but black with white
: stripes" (plus you can't ride it, quipped I).

Well if you are looking for fully WORKED development case studies then 
 you may have a problem, and the trouble with ``real'' examples is that they
 are someone's commercial property; but you will find pretty realistic 
 examples  in most of the better  textbooks e.g. Grady Booch's 
  Object Oriented Design with Applications published 1990 by Benjamin/Cummings.

I think that this kind of criticism  is rife  but on the whole not 
 that justified. It is true that some academic papers use ``toy'' examples
 but if you are trying to illustrate a simple point it can cloud the issue 
 by introducing the complications  of the real world.  If, however, you
 are trying to sell OO or trying to teach OO, then failure to deal with 
 realistic examples is often seen as a cofession that OO is only fit for 
 academic games.

I feel that a certain amount of simplication in tutorial work is justified.
  To take an example from mathematics,  generally speaking  when teaching 
 linear equations I always used to start off by dealing with 2 or 3 
  unknowns and whole numbers ( and preferably whole number solutions).
 But real industrial examples could include hundreds of unknowns 
 and floating point arithmetic.

I agree though that the ``zoological taxonomy'' examples can seem rather 
 silly.,

+---------------------------------+----------------------------------------+
! Jeremy Wilson			  !	email: jcrw@fmg.bt.co.uk           !
! Room 3-07                       !     Telephone: 0473-227822             !  
! BT Development and Procurement  !     International: +44 473-227822      !
! Bibb Way			  !     Facsimile: 0473-210182             !
! IPSWICH                         !     International: +44 473-210182      !
! Suffolk  IP1 2EQ                !     Telex: 987705                      !
! United Kingdom                  !     International: +51 987705          !
!  				  !     				   !
+---------------------------------+----------------------------------------+
Newsgroups: comp.object
From: santas@inf.ethz.ch (Philip)
Subject: Re: Object hidden state and side effects
Organization: Dept. Informatik, Swiss Federal Institute of Technology (ETH), Zurich, CH
Date: Wed, 23 Dec 1992 01:15:57 GMT


In article <1992Dec21.151326.21426@midway.uchicago.edu> dave@alex.uchicago.edu (Dave Griffith) writes:
>
>You're using assignment a lot differently then I have been.  When I think
>of assignment, I just mean binding values/objects to names.  There is no
>creation of new objects involved.  (Call this reference assignment.)

Example 1:

a := "asd"
b := "qwe"

We have creation of new objects here. The strings
"asd" and "qwe"  were _not_ preexisting.

Example 2:

c := "asd"

Do you use the same "asd" as before?
(as far as I remember, you imposed _not_ to)

>Values, as I have been using the term, are immutable, and thus copying may
>be used as a possible optimization.  

Usually _not_-copying is an optimization.
If something is _definitely _immutable_, why should one need to _copy_ it?

>                                     The actual semantics of assignment is
>still just binding values to names.  Variables aren't modified. Objects are
>modified, variables just get rebound, which results in the object containing
>them (if any) being modified.

This is very confusing.
In the examples above, which are the objects, which are the values
and which are the variables?
(for help, add the operation: 
   c.appendToSelf: "f"
 and please, explain what happens during this operation, while
 distinguising between objects/variables/values)

Philip Santas

  "In an evolving universe those who stand still are really moving backwards"
--------------------------------------------------------------------------------
email: santas@inf.ethz.ch				 Philip Santas
Mail: Dept. Informatik			       Inst. of Scientific Computation
      ETH-Zentrum			  Swiss Federal Institute of Technology
      CH-8092 Zurich				       Zurich, Switzerland
      Switzerland
Phone: +41-1-2547478
      

Newsgroups: comp.object
From: rontelta@fwi.uva.nl (Richard Ronteltap (I87))
Subject: Re: Object-Oriented DataBase
Organization: FWI, University of Amsterdam
Date: Sat, 2 Jan 1993 10:34:21 GMT

drew@netcom.com (drew) writes:

>I've emailed John directly, but in case any other readers are interested,
>Objectivity/DB runs on the SGI platforms.  It's the leading ODBMS in
>installed runtimes in use in production, 

Not to forget, the most used DB by parents with yodeling Jewish-Russian
grandmothers...

If you must advertise here, at least tell us some features!

A happy start of the New Year,
Bye,
Richard
From: cgra@btma74.nohost.nodomain
Newsgroups: comp.object
Subject: Re: Need basic OO information
Date: 21 Dec 92 08:44:34 GMT
Reply-To: cgra@btma74.nohost.nodomain ()


In article <1377@se.alcbel.be>, I wrote:
|>
|>
|>Not an answer, but a me-too-please.
|>
|>Yesterday evening I attended an "Introduction to Object-Oriented Analysis"
|>provided by our training department.  The lecturer started by apologising
|>for the lack of concrete examples in her presentation...

and then signed off as ``cgra@se.alcbel.br''. That should have been
`cgra@se.alcbel.be'' - my apologies to anyone who was confused by this.
                ^^
Apolgies too to the postmaster in Sao~ Paulo  %^>

Must find the time to make a proper .sig file.

Yet more season's greetings,

Chris
Newsgroups: comp.object
From: dave@alex.uchicago.edu (Dave Griffith)
Subject: Re: Object hidden state and side effects
Organization: University of Chicago
Date: Mon, 21 Dec 1992 15:13:26 GMT

In article <knight.724948496@cunews> knight@mrco.carleton.ca (Alan Knight) writes:
>In <knight.724904387@cunews> knight@mrco.carleton.ca (Alan Knight) writes:
>
>>In <1992Dec20.162050.14652@midway.uchicago.edu> dave@alex.uchicago.edu (Dave Griffith) writes:
>
>>>>Normal storage (or mutable values): State can be modified, but there
>>>>is no identity operation. e.g. storage allocated on the stack in
>>>>traditional languages. 
>
>>>'Splain me, boss.  I'm feeling dumber than usual.
>
>Let me try that again more concisely, having rested my brain cells.
>
>Consider objects which are mutable but for which assignment is really
>copying. An identity operation for such objects is meaningless because
>no two can ever be identical. However, any individual object can be
>modified. 
>This is the normal case for data not represented by pointers in
>traditional languages. 
>

You're using assignment a lot differently then I have been.  When I think
of assignment, I just mean binding values/objects to names.  There is no
creation of new objects involved.  (Call this reference assignment.)
Values, as I have been using the term, are immutable, and thus copying may
be used as a possible optimization.  The actual semantics of assignment is
still just binding values to names.  Variables aren't modified. Objects are
modified, variables just get rebound, which results in the object containing
them (if any) being modified.



-- 
Dave Griffith, Information Resources, University of Chicago,
Department of Surgery                       dave@alex.bsd.uchicago.edu
A man's best friend is his dogma.
Newsgroups: comp.object
From: santas@inf.ethz.ch (Philip)
Subject: Re: Object hidden state and side effects
Organization: Dept. Informatik, Swiss Federal Institute of Technology (ETH), Zurich, CH
Date: Wed, 23 Dec 1992 00:42:59 GMT


In article <1992Dec20.162050.14652@midway.uchicago.edu> dave@alex.uchicago.edu (Dave Griffith) writes:
>knight@mrco.carleton.ca (Alan Knight) writes:
>>
>>Immutable objects: Have no operations which modify state, but have an
>>identity operation. e.g. non-mutable strings
>
>Might be useful, although the need for an identity operation for non-mutable
>strings escapes me.

Usually you want this in order to minimize the storage requirements
of your system. If two equal strings as stored in the same address,
then you spend the half memory for storing them; as bonus, the equality
operation for strings becomes _fast_, and an interpreter which 
uses a plethora of symbols, becomes faster. Some widely used systems 
exploit this technique since the last decade...

Philip Santas

  "In an evolving universe those who stand still are really moving backwards"
--------------------------------------------------------------------------------
email: santas@inf.ethz.ch				 Philip Santas
Mail: Dept. Informatik			       Inst. of Scientific Computation
      ETH-Zentrum			  Swiss Federal Institute of Technology
      CH-8092 Zurich				       Zurich, Switzerland
      Switzerland
Phone: +41-1-2547478
      

Newsgroups: comp.object
From: humm@cs.uow.edu.au (Bernhard G Humm)
Subject: type-specific synchronization specification for transactions
Organization: Dept of Computer Science, Wollongong University, Australia
Date: Tue, 22 Dec 1992 00:35:07 GMT

The Clouds and TABS/Camelot distributed object-oriented operating systems 
both allow for type-specific synchronization specification for transactions. 
Does anyone know references to papers that describe those facilities in 
Clouds, TABS/Camelot or any other object-oriented distributed system?

__________________________________________________________
Bernhard G. Humm   <humm@cs.uow.edu.au>
Telecommunications Software Research Centre
Department of Computer Science, University of Wollongong
Wollongong, NSW, Australia
__________________________________________________________

Newsgroups: comp.object
From: knight@mrco.carleton.ca (Alan Knight)
Subject: Re: Object hidden state and side effects
Reply-To: knight@mrco.carleton.ca (Alan Knight)
Organization: Carleton University
Date: Thu, 24 Dec 1992 01:18:18 GMT

In <BzMnKp.B4J@inews.Intel.COM> bongalon@tcad05.intel.com (Ben Bongalon) writes:
>In article <knight.724800099@cunews>, knight@mrco.carleton.ca (Alan
>Knight) writes:
>|> This seems like an excellent example of what I was talking about. You
>|> apparently do not disintguish between identity and equality for
>|> complex numbers.  If my representation of complex numbers was, for
>|> example, strings, then "1+2i" and "1+2(i^5)" are not in any normal
>|> sense identical, but they are equal.

>my question is:

>why would you want to consider "i" and "(i^5)" as equal but not
>identical values? Do you consider "1" and "(3-2)" equal but not 
>identical also?  From a pragmatic point of view, the distinction
>between the simplified and unsimplified forms of the expressions 
>seem questionable.

If I have non-normalized instances then they are clearly distinct. If
only during the process of normalization, I must consider them as
such, and they must be stored in different places, i.e. not identical.
For the sake of efficiency, I may also wish not to represent all
complex numbers by a pointer.

Frankly, I shouldn't care if complex numbers are identical or not. I
don't think identity is a useful operation for them.

>|> If I, as a user, type in these two expressions on the keyboard, I
>|> would expect to get separate instances of complex numbers (i.e.
>|> multiple copies) of equal values.

>Why? Unless there is a specific need for distinction, I as a user
>would be more interested in the simplified form (ie, the semantic
>definition) of an expression rather.  I don't want to distinguish 
>the _infinite_ number of ways that a value can be represented in.

Perhaps you do, perhaps you don't. If you were writing a symbolic
algebra system, you probably would.  You still wouldn't want to
distinguish them by identity, though. 
-- 
 Alan Knight  knight@mrco.carleton.ca  +1 613 788 2600x1027 
 Dept. of Mechanical and Aerospace Engineering              
 Carleton University, Ottawa, Ontario, Canada, K1S 5B6      

Newsgroups: comp.object
From: meulenbe@perlis.mcs.gvsu.edu (Joel Meulenberg)
Subject: ObServer/ENCORE Object Server (Help)
Organization: Grand Valley State University, Allendale MI
Date: Mon, 28 Dec 1992 17:43:27 GMT

I'm looking for information pertaining to the "ObServer/ENCORE" Object Server 
developed at Brown University.  Based upon the dates on the source which I
FTP'ed from wilma.cs.brown.edu, it looks as if development stopped sometime
near the end of 1990.  Does anyone know if further work has been done on
"ObServer" since then?  Also, if you have any experience with ObServer/ENCORE
that you could share, I would really appreciate hearing from you.  Please
direct responses to the email address listed below.
--
Joel Meulenberg     meulenbe@perlis.mcs.gvsu.edu
Newsgroups: comp.object
From: grogono@cs.concordia.ca (Peter Grogono)
Subject: Re: Equality
Organization: Computer Science, Concordia University, Montreal, Quebec
Date: Tue, 22 Dec 1992 18:07:55 GMT

In article <1992Dec21.184405.2215@midway.uchicago.edu> dave@alex.uchicago.edu (Dave Griffith) writes:
> .......
>1) Equality should be reflexive.  
>	I thought this was obvious, but IEEE754 may provide a counterexample.
>
>2) Equality should be symettric.
>3) Equality should be transitive.
>4) Substitution of equals for equals should give equals.
>5) If two objects are equal at one point in program execution, they should be
>     equal at all points. 
>6) Assignment should respect equality.   (Assuming no side-effects, after 
>   executing x:=a; it should be true that x=a.
>7) If your parameter passing model is based on assignment, 6) should hold 
>   mutatis mutandi.
>8) If two objects are equal, they should be behaviourally indistinguishable. 
>   The converse need not hold, but often will.
>9) Two sets A,B are equal iff  for_all(x:A)there_exists(y:B) such y=x, and
>   vice versa.
>
>Given mutable objects, identity was the only practical definition I found
>which would  support all of the above.  However, identity is not a practical 
>equality definition for all objects we wish to program with (vis, integers). 
>In these cases, if immutability holds, users may be able to define equality
>in ways which satisfy the above, and there are good reasons to let them try. 

I do not see how "identity" supports #9. In principle, A=B, where A and
B are sets, should mean that A and B have the same members, even if the
representations of A and B are distinct in memory and may be different
data structures. I do not see how an equality test of this kind can be
built-in to a language, and this was my reason for saying that equality
must be user-defined in general.

Peter
Newsgroups: comp.object
From: knight@mrco.carleton.ca (Alan Knight)
Subject: Re: Object hidden state and side effects
Reply-To: knight@mrco.carleton.ca (Alan Knight)
Organization: Carleton University
Date: Wed, 23 Dec 1992 20:15:42 GMT

In <1992Dec21.165539.20916@kei.is.s.u-tokyo.ac.jp> jeff@is.s.u-tokyo.ac.jp (Jeff McAffer) writes:

>In article <knight.724801566@cunews> knight@mrco.carleton.ca (Alan Knight) writes:

> >>In article <1992Dec17.163916.25512@kei.is.s.u-tokyo.ac.jp> jeff@is.s.u-tokyo.ac.jp writes:
> >>"Everything is an object", even such IMHO obvious non-objects like control
> >>structures.  Of course you can map everything to objects, I just see few 
> >>good reasons to do so.  

>Yikes!  Either I've found some particularly good drugs or I didn't say
>that.  Wonder which?

>In article <knight.724801566@cunews> knight@mrco.carleton.ca (Alan Knight) writes:

> >I wish I were writing C++ code to interface Fortran and Cobol.

>Personally, I think I was misquoted.  How 'bout you Alan? :-)

>--
>--
>ato de, |m        -- Santa or Satan?  Think about it.


OK, OK, I haven't been paying as much attention as I should to the
attributions in these posts that reference a couple of dozen others.
Maybe it's just me being careless, or maybe nn has a problem. Either
way, I apologize to those I have misattributed. I'll try to be more
careful.

That first quote should, I believe, be attributed to Mr. Griffith. I
don't know who that second one was, but it certainly wasn't me. 

-- 
 Alan Knight  knight@mrco.carleton.ca  +1 613 788 2600x1027 
 Dept. of Mechanical and Aerospace Engineering              
 Carleton University, Ottawa, Ontario, Canada, K1S 5B6      

Newsgroups: comp.object
From: dave@alex.uchicago.edu (Dave Griffith)
Subject: Re: Object hidden state and side effects
Organization: University of Chicago
Date: Tue, 22 Dec 1992 18:20:29 GMT

In article <BzMqx4.Bn9@inews.Intel.COM> bongalon@tcad05.intel.com (Ben Bongalon) writes:
>
>
>Amen  :-)
>
>Ben Bongalon
>Intel Corporation

Fan post! My first fan post!

It almost makes up for the deafening silence on my equality post!


-- 
Dave Griffith, Information Resources, University of Chicago,
Department of Surgery                       dave@alex.bsd.uchicago.edu
A man's best friend is his dogma.
Newsgroups: comp.object
From: feustel@netcom.com (David Feustel)
Subject: Re: Public domain Eiffel-3 front-end available
Reply-To: feustel@netcom.com (David Feustel)
Organization: DAFCO: OS/2 Software Support & Consulting
Date: Fri, 25 Dec 1992 00:16:43 GMT
Keywords: Eiffel, question, comment

Is anyone thinking about porting Eiffel to OS/2 version 2 (32-bit)?
-- 
Dave Feustel N9MYI <feustel@netcom.com>
[Doesn't the ISE Eiffel compiler actually turn it into C?  I'd think that
porting it to OS/2 should be straightforward. -John]
-- 
Send compilers articles to compilers@iecc.cambridge.ma.us or
{ima | spdcc | world}!iecc!compilers.  Meta-mail to compilers-request.
Newsgroups: comp.lang.eiffel
From: cflatter@nrao.edu (Chris Flatters)
Subject: Eiffel for 386BSD
Reply-To: cflatter@nrao.edu
Organization: NRAO
Date: Mon, 4 Jan 1993 00:32:14 GMT

I'm just wondering if ISE or SIG Computing would be willing to produce a
cut-price Eiffel package for 386BSD.  386BSD is Bill Jolitz' freely distributable
implementation of BSD Unix for Intel 80386-based PC/AT clones (I suspect that
porting ISE Eiffel 2.3 would require little more than a recompile).

I think I would be willing to pay in the range of $300-$400 (or less, of
course) for a full Eiffel development system on my home machine and I think
that there is a chance that others would too.  Any takers?

	Chris Flatters
	cflatter@nrao.edu
From: bertrand@eiffel.com (Bertrand Meyer)
Newsgroups: comp.lang.eiffel
Subject: Re: ISE 3.0 Compiler
Date: 2 Jan 93 02:09:52 GMT
Organization: Interactive Software Engineering, Santa Barbara CA

From <mod.725126439@cs.man.ac.uk> by
mod@cs.man.ac.uk (Mike O'Docherty (Teaching Company Associate)):

> Does anybody have any hard information about the
> release date of ISE's Eiffel 3.0 compiler, or details
> of any available beta-test version?

The version is indeed undergoing beta testing at the moment.
It is still too early to announce a firm date for release.
-- 
-- Bertrand Meyer
ISE, Santa Barbara
bertrand@eiffel.com
Newsgroups: comp.lang.eiffel
From: Des.Kenny@bbs.actrix.gen.nz
Subject: Re: Eiffel Description
Organization: Actrix Information Exchange
Date: Thu, 24 Dec 1992 21:27:33 GMT
Keywords: Eiffel, Introduction 

In article <MATTHEW.92Dec23145958@eeyore.ntl02.decnet.nokia.fi> matthew@ntl02.decnet.nokia.fi (Matthew Faupel) writes:
> In article <1992Dec19.143052.21438@mic.ucla.edu> iwelch@agsm.ucla.edu (Ivo Welch) writes:
> 
> IW: Is there a 2-10 page description of Eiffel features?  I'd like to switch to
> IW: a safer language than C++, and a number of  people mentioned Eiffel. I have
> IW: no idea of what features it has.
> 
> I have a 14 page leaflet from Interactive Software Engineering Inc (the
> original designers of Eiffel) called "Eiffel: An introduction".  This may be
> what you're after.  The document has a number: TR-EI-3/GI and I would guess
> that it is available directly from ISE at:
> 
> Interactive Software Engineering Inc.
> 270 Storke Road, Suite 7,
> Goleta, CA 93117
> USA
> 
> Phone: +1 805 685 1006  Fax: +1 805 685 6869.
> 
> N.B. This information is directly from the leaflet which was published in
> 1989 and so may well be out of date.  Would somebody kindly post a
> correction if this is wrong...
  
  The most recent introduction to Eiffel is in the book
  "Eiffel the Language", Prentice Hall, 1992.


--Des Kenny