HDTenEightyP/NetNews huggingface dataset:
From: thinman@netcom.com (Technically Sweet)
Subject: Re: Visual programming
Organization: International Foundation for Internal Freedom
Date: Thu, 17 Dec 1992 18:45:08 GMT

js@montaigne.lif.icnet.uk (Jack Shirazi <js@biu.icnet.uk>) writes:

>I've seen a couple of visual programming environments, and used one
>that was implemented using Smalltalk, and I notice that they are
>really dataflow programs. Does anyone have any ideas about a way of
>visual programming which allows you to create and use objects
>interacting with each other.  I realize that the Smalltalk
>implementation has interacting objects uderlying it, but at the visual
>level you have data comming in, processed through some functions and
>output.  I know the question here is unclear, but I'm having trouble
>thinking up a visual program which is not a dataflow diagram.

The dataflow paradigm is naturally 2D or 3D, so it makes a good
visual interface.  You can have objects and messages flowing around
the screen instead of raw data.  Some dataflow paradigms have logical
assertions flowing around; each node rewrites its input assertions
and emits new output assertions.

There are several survey books of visual programming interfaces
out.  They tend to be hodgepodges of many different kinds of
programming.

-- 

Lance Norskog

Data is not information is not knowledge is not wisdom.
Newsgroups: comp.object
From: buck@siswat.hou.tx.us (Lester Buck)
Subject: Re: Object hidden state and side effects
Organization: Photon Graphics, Houston
Date: Fri, 18 Dec 1992 15:23:44 GMT

In article <BzF6uA.1u3@inews.Intel.COM> bongalon@tcad05.intel.com (Ben Bongalon) writes:
>
>I wrote:
>|> >Frankly I don't understand all the confusion about the distinction
>|> >between objects and values.  As i see it, an object may have
>internal states; 
>|> >more specifically, an object may contain other objects, which 
>|> >may in turn be composite (ie, contain other objects) or simple
>|> >(ie, just contains values).  But note that simple and composite
>|> >objects are merely concepts in our minds.  In order to apply them
>|> >to computer programming, we map these objects into variables.
>|> >
>
>Dave Griffith replied:
>|> The distinction between simple and compound is somewhat useful, but has
>|> very little to do with the value/object distinction.  

[Much extra deleted]

I got into this thread late, but just in case this definitive reference
has not been menitioned...

You two might want to read the following article:

Values and Objects in Programming Languages
B.J. MacLennan
SIGPLAN Notices, Vol 17, No. 12, Dec 1982, pp.70-79

reprinted in "Tutorial: Object-Oriented Computing, Volume 1: Concepts"
ed. Gerald E. Peterson, IEEE Computer Society Press, order number 821

The introduction section reads:

  The terms "value-oriented" and "object-oriented" are used to describe
  both programming languages and programming styles.  This paper attempts
  to elucidate the differences between values and objects and argues that
  their proper discrimination can be a valuable aid to conquering program
  complexity.  The first section shows that "values" amount to timeless
  abstractions for which concepts of updating, sharing and instantiation
  have no meaning.  The second section shows that "objects" exist in time
  and, hence, can be created, destroyed, copied, shared, and updated.  The
  third section argues that proper discrimination of these concepts in
  programming languages will clarify problems such as the role of state in
  functional programming.  The paper concludes by discussing the use of
  the value/object distinction as a tool for program organization.

-- 
A. Lester Buck   buck@siswat.hou.tx.us   ...!uhnix1!siswat!buck
Newsgroups: comp.object
From: hutz@cadsun.corp.mot.com (Suzana Hutz)
Subject: Tools For OO Development - Request Info
Organization: Motorola, Inc., Software Research and Development, Rolling Meadows, IL. 60008
Distribution: comp.object
Date: Wed, 16 Dec 92 21:26:05 GMT


I am trying to compile a comprehensive list of tools available for 
OO development.

Besides the name of the tool, vendor, and platform it runs,etc., I would like
to get some opinions on the tools from those that had used them.

I will post the answers I collect.

If there is already some list of tools, please let me know how to
get it.

Thank you in advance,

Suzana Hutz 
hutz@mot.com



---------------------------------------------------------------
Suzana Hutz              |  Motorola Inc. - Corporate Offices
hutz@mot.com             |  Software Research and Development
Ph:  (708) 576 2815      |  3701 Algonquin Rd. Suite 601
Fax: (708) 576 2025      |  Rolling Meadows, IL 60008
---------------------------------------------------------------







Newsgroups: comp.object
From: warren@cbnewsh.cb.att.com (warren.a.montgomery)
Subject: Re: Information about CALICO
Organization: AT&T
Date: Thu, 17 Dec 1992 14:48:39 GMT
Summary: Calico is available from the AT&T Software Solutions Group

Calico is available through the Software Solutions Group at AT&T
(1-800-462-8146 is the number I have for them).  They sell
software developed for internal use by units of AT&T that don't
generally sell and support software themselves.  Calico is a
language with C-like syntax and features, and Smalltalk-like
object model and semantics.  It has additional features aimed at
systems programming, including "real-time" garbage collection,
delegation based multiple inheritance, interfaces to external data
and procedures, and development tools for multi-user development.  
It comes with graphical and textual development environments and
libraries for building visual tools in addition to many object
types and collections.  Calico is described in an article in the
May 1991 issue of IEEE Software.

-- 

	Warren Montgomery
	att!iexist!warren
From: jeff@is.s.u-tokyo.ac.jp (Jeff McAffer)
Newsgroups: comp.object
Subject: Re: Object hidden state and side effects
Date: 14 Dec 92 11:22:17 GMT
    <1992Dec13.152136.16852@hasler.ascom.ch>
Reply-To: jeff@is.s.u-tokyo.ac.jp
Organization: University of Tokyo, tcejorP Project.

Jan Steinman (the roving poster) writes:

{ bunch of good stuff deleted }

 ! >This is
 ! >why the distinction between values and objects is of enormous
 ! >importance. Software objects are used to model real world objects
 ! >as well as real world values. Modeling objects with other objects
 ! >is far more straight-forward than modeling values with objects.
 ! >The field of numerical analysis is all about the difficulties
 ! >which arise when one is forced to use objects to represent values.

Can you give an example of a real world value which is concretely
definable and describable in the real world but not in a computer as
an object (or anything)?

 ! Huh? Let's replace "object" (a loaded term in this context) with "thing". Let's
 ! further agree that a fraction, or an integer, or the set of values "1", "2",
 ! and "3", or for that matter, the set of values endorsed by the Republican
 ! National Convention, are all "things". None of them *are* the set of binary
 ! patterns that represent them in a computer's memory, but must be represented or
 ! modelled since they are abstract. Some of them are modelled in hordware, some
 ! must be modeled in software.

It seems to me that people are confusing implementation with
behaviour.  What we are suffering from here is insufficient
specification.  People are all up in arms because they can't create
another False.  The problem is that they know there is a False!  A
properly specified system would simply spec Boolean and leave the rest
to the implementor.  Ditto for SmallInts.

You just know too much is all.  Hardware, software, OS, VM, mutable,
immutable?  Who knows?  If you care, you are doing something wrong!
It's not really your fault either.  The system forces you to know so
much because there is no decent spec.  Sit back sometime and take a
good hard look at how much implementation knowledge you are using in
your systems.  I think you will be surprised.  You can barely help it.
The methods and vars are just there, tempting you.

As for the difference (if any) between values and objects: value =
some 'thing' that does not change.  Right?  

Does that mean that the actual bits don't change?  So it is bit
identity that matters?  If so, your true and mine are different! (we
have different bits) This is appealing to existentialists for sure but
would make coding a nightmare.  Who's is right?  Can we decide?  Does
it matter?  Anyway, what is the "value" of true that pre-existed and
is being 'modelled' as an object/value in the computer?

If the bits can change and move, then I don't see the diff between
"value" and "object that does not change".  In short, why can't a
value be an object?  What does explicitly knowing/using the fact that
something does not change help us?

--
--
ato de, |m        -- Truth peels from the burning halls of words.
Newsgroups: comp.object
From: hasko@heeg.de (Hasko Heinecke)
Subject: Re: Object hidden state and side effects
Organization: Georg Heeg Objektorientierte Systeme, Dortmund, FRG
Date: Thu, 17 Dec 1992 16:02:21 GMT

In article <knight.724478279@cunews> knight@mrco.carleton.ca (Alan Knight) writes:
>In <Bz5ruB.5Mw@newsflash.concordia.ca> grogono@cs.concordia.ca (Peter Grogono) writes:
>
>>I completely agree with Chuck's analysis, but I would like to
>>add my 2 bits' worth.
>
>Are you sure that you agree with him?  I agree with everything you
>wrote, and I don't agree with Chuck, and I have a feeling agreement
>should be commutative.

Of course, it's neither commutative, nor transitive. I'm not even
sure if it is reflexive. :-)

Hasko

-- 
+-------------------------------------------------------+
| Hasko Heinecke @ Georg Heeg Objektorientierte Systeme |
| I _never_ mean what I say - and nobody else does...   |
+-------------------------------------------------------+
From: pdc@dcs.ed.ac.uk (Paul Crowley)
Newsgroups: comp.object
Subject: Re: Object hidden state and side effects
Date: 16 Dec 92 14:04:14 GMT
Reply-To: pdc@dcs.ed.ac.uk (Paul Crowley)
Organization: Edinburgh University

Are people arguing that whichever set of integers or floats happen to
be supported by the hardware should be treated as a special case, or
that any immutable object should be?  If the former, I find this level
of hardware specificity in the name of language purity curious.  If the
latter, then to the extent that it's sensible to do you can do it in
Eiffel: use objects that support functions but not procedures.  It would
seem sensible, for example, to support bignums in this way.  I think the
Eiffel way of allowing functions to change internal state if they
promise not to change external behaviour is the right one; asking the
language to enforce guarantees would be very limiting.
  __                                _____
\/ o\ Paul Crowley pdc@dcs.ed.ac.uk \\ //
/\__/ "I'm the boy without a soul."  \X/
From: jeff@is.s.u-tokyo.ac.jp (Jeff McAffer)
Newsgroups: comp.object
Subject: Re: Object hidden state and side effects
Date: 16 Dec 92 06:52:43 GMT
    <1992Dec13.152136.16852@hasler.ascom.ch> 
    <1992Dec14.112222.13987@kei.is.s.u-tokyo.ac.jp> 
    <1992Dec15.014420.6604@midway.uchicago.edu>
Reply-To: jeff@is.s.u-tokyo.ac.jp
Organization: University of Tokyo, tcejorP Project.

In article <1992Dec15.014420.6604@midway.uchicago.edu> dave@alex.uchicago.edu (Dave Griffith) writes:

{ whole bunch of stuff about modelling deleted }

 |>If the bits can change and move, then I don't see the diff between
 |>"value" and "object that does not change".  In short, why can't a
 |>value be an object?  What does explicitly knowing/using the fact that
 |>something does not change help us?
 |
 |It _does_ allow a lot of optimization.  There are occasions where copy
 |semantics are cheaper than reference semantics.  But at a higher level, it 
 |seems to be necessary to allow safe programming.  We need to know that noone 
 |can subclass our Integer class so as to allow the old Fortranism of changing 
 |3 to 5.

I realize that it allows optimizations but to be honest, from a
programming/design point of view I don't want to know about the
implementation.  That is what we are fighting against.  Having to know
and explicitly use implementation detail.

I feel sort of like there is misunderstanding in this thread.  At some
point someone said that a value is not an object (or something like
that) and that it was bad to 'pretend' that it is.  Was that you?  Do
you agree with the statement?  If so why?

I am really at a loss here.  What exactly (in concrete real terms) do
you expect people to do differently when using true for example once
it is recognized as a value and not an object?

 |Whether the actual bits are changable is rather beside to point.  The idea
 |is that a values essential nature cannot change, whatever that means.  This
 |is usually easiest if the bits are unchanging, but that is not necessary.


If you want to have "essentially the same" objects great!  That's just
a differnt kind of object.  Perhaps your compiler can do something
special.  Great.  As a designer of large systems I don't want to know
about it.  They are just objects to which I can send messages, pass as
parameters...  They have a protocol... and allow only those operations
that are in line with their "essential sameness"

Are we talking about totally different things?

--
--
ato de, |m        -- Truth peels from the burning halls of words.
From: jb7m+@andrew.cmu.edu (Jon C. R. Bennett)
Newsgroups: comp.object
Subject: Re: Is Borland the leader in technology?
Date: 14 Dec 92 10:05:01 GMT
Article-I.D.: andrew.0f=CXhK00WD5Bi0v4w
 <henley.921130163220@wilbur.eng.auburn.edu> <5913@osc.COM> 
 	<henley.921209145115@wilbur.eng.auburn.edu> <Yf9te3C00WBEMfeqUe@andrew.cmu.edu>
	<1992Dec13.211623.14662@netcom.com>
Organization: Robotics Institute, Carnegie Mellon, Pittsburgh, PA



thinman@netcom.com (Technically Sweet) writes:
> "Jon C. R. Bennett" <jb7m+@andrew.cmu.edu> writes:
> >dont need chemicals to do computer science (unless you count caffine), but
> >in two courses the most that you can do is teach someone to be dangerous,
> >you cant teach them computer science. Look at it this way, if I took 2
> >chemical engineering courses, would you think I could do chemical
> >engineering? no, so why do you think 2 CS courses means that a Chemical
> >Engineer can do Computer Science?
> 
> Yes, everyone with a Computer Science (TM) degree is automatically
> a Computer Scientist (TM even more).  We all push back the frontiers
> of Computer Science (oh forget it) and publish papers.  Yup!
> 
> With two semesters of Lisp or Smalltalk, you can teach a Chemical 
> Engineer (TM) to write a chemical factory simulation, and use it 
> to find problems.  With two semesters of Fortran, she can also learn 
> how to find prime numbers!

its interesting, i agree with the point that you are trying to make in
your first paragraph, i do not in fact belive that just because someone
has a CS degree that they can do computer science, but if you think that
is true why is it that you then belive that with 2 courses any Chemical
Engineer (TM) can do computer science?????????


jon
Newsgroups: comp.object
From: dvandrei@desperado.lerc.nasa.gov (Don Van Drei)
Subject: Object Request Broker 
Reply-To: dvandrei@desperado
Organization: NASA LEWIS RESEARCH CENTER
Date: Fri, 11 Dec 1992 19:02:51 GMT

	Where can I find information on the Object Management Group(OMG)
Object Request Broker?
-- 

-----------------------------------------------------
Donald Van Drei            NASA Lewis Research Center
dvandrei@desperado.lerc.nasa.gov       (216) 433-9089 
-----------------------------------------------------
Newsgroups: comp.object
From: henley@eng.auburn.edu (James Paul Henley)
Subject: Re: Is Borland the leader in technology?
Organization: Auburn University Engineering
Date: Tue, 15 Dec 1992 20:09:52 GMT

In article <0f=CXhK00WD5Bi0v4w@andrew.cmu.edu> jb7m+@andrew.cmu.edu (Jon C. R. Bennett) writes:
>
>
>its interesting, i agree with the point that you are trying to make in
>your first paragraph, i do not in fact belive that just because someone
>has a CS degree that they can do computer science, but if you think that
>is true why is it that you then belive that with 2 courses any Chemical
>Engineer (TM) can do computer science?????????
>
>
>jon


The field of Computer Science has mushroomed, just like the field of 
Chemical Engineering.  Writing software in any one field no longer
requires one to be a computer scientist, and in fact a lot of computer
science no longer requires one to truly be a computer scientist.  

What is computer science?   It is just as difficult to answer the question
what is chemical engineering?  Some chemical engineers know more about certain
aspects of computers than the typical computer scientist, and some computer
scientists may know more about certain aspects of chemical engineering than
the typical chemical engineer.  In fact, I can name a computer scientist who
definitely knows more about certain aspects of chemical engineering than the
typical chemical engineer.     So let's drop all the pretentious bullshit
and try to do something constructive.  The reason I am on this newgroup is
because I *know* that there are some areas in which a computer scientist
can help me out.  But since I'm not a computer scientist, all you do is tell me
how much I don't know about computer science.  If I thought I knew everything
about computer science I wouldn't be here in the first place, I'd be writing
a book.


Dr. James P. Henley Jr.
Department of Chemical Engineering
Auburn University
From: dmarer@td2cad.intel.com (Dennis Marer)
Newsgroups: comp.object
Subject: Implementation of multiple inheritance?
Keywords: multiple inheritance
Date: 17 Dec 92 00:26:13 GMT
Organization: Intel Corporation, Santa Clara, CA USA

Howdy,

	I've been working with OOP for a while, and only recently thought
about needs for multiple inheritance (from a discussion in this newsgroup,
I think), and I was wondering how something like that would be implemented
in an efficient manner.

	I'm most familiar with C++, so I'll use that for examples...say my
C++ compiler sees the following code:

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

class parent {
public:
    virtual int foo();
    int data;
};


class otherParent {
public:
    int moreData;
};


class child : public parent,public otherParent {
public:
    virtual int foo();
    int evenMoreData;
};

void main() {
    parent *p;
    otherParent *op;
    child c;

p = &c;

p->foo();				// How does the compiler reference
printf("Data: %d\n",p->data);		//  these methods and attributes?

op = &c;
printf("More data: %d\n",op->moreData);
}

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

	If multiple inheritance didn't exist, the offset of an attribute such
as 'data' or 'moreData' from the start of the object's instance record would
be the same regardless of what ancestor object type is actually realized.

	Seeing that multiple inheritance DOES exist, what would be the best
method of dealing with it?  For example, how does the compiler know where to
find 'data' from the pointer 'p' which may or may not be pointing to an object
which has multiple ancestors?

	Thanx for any help you can give!

				Dennis
				dmarer@td2cad.intel.com

-- Not speaking for Intel
Newsgroups: comp.object
From: hasko@heeg.de (Hasko Heinecke)
Subject: Re: Object hidden state and side effects
Organization: Georg Heeg Objektorientierte Systeme, Dortmund, FRG
Date: Tue, 15 Dec 1992 14:32:43 GMT

In article <1992Dec14.175402.1889@crd.ge.com> eaker@ukulele.crd.ge.com (Chuck Eaker) writes:
>In article <1992Dec13.152136.16852@hasler.ascom.ch>, steinman@hslrswi.hasler.ascom.ch (Jan Steinman - Bytesmiths, 3946) writes:
>|> Oh, sorry for the misunderstanding. Will all C++ compilers that store the
>|> value "3/4" in binary form *please* refrain from doing so? Instead, they
>|> are to immediately begin using the *real* "3/4" that has been around a long
>|> time.
>
>The point is that computers cannot use "the *real* 3/4."

You wanted philosophy, so here it is: What *is* the real 3/4. What would
Immanuel Kant say?

>My point is that the hardware things are models or representations, not
>the values themselves.

What effects does this have on problem solving. I mean, other than the
notion that there is more than one binary represenation for any one
value?

>Integer values are abstractions. So are family values. The values of
>good, ok, and bad are all abstractions, immutable and eternal.  Their
>representations should reflect these attributes.
>
>If marriages are represented with objects and the values of good and
>bad are applied to them according to a GOP or any other scheme, make
>sure that any instance of marriage can be created, destroyed, or
>modified, and that the value good is represented by a single object
>which cannot be created, destroyed, or modified.
>
>There is a fundamental difference between a data type and an object
>class that most languages fail to capture. All the representations of
>values represented by a data type are created (specified, etc.) when the
>data type is defined. This is not true of the instances of an object
>class. We know, in some sense, all the integers and all the colors.
>We do not know all the marriages.

Oh no! Who told you the value "good" is eternal and immutable? I'm
almost sure that the very two of us have completly different
specifications of "good", and they are changing though time.

What do you mean by saying "We know in some sense [...]?" Why don't
we know all the marriages? Please elaborate.

Hasko

-- 
+-------------------------------------------------------+
| Hasko Heinecke @ Georg Heeg Objektorientierte Systeme |
| I _never_ mean what I say - and nobody else does...   |
+-------------------------------------------------------+
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, 17 Dec 1992 02:14:51 GMT

In <1992Dec17.001046.27321@crd.ge.com> eaker@ukulele.crd.ge.com (Chuck Eaker) writes:

>the domain of imaginary numbers. If we implement this domain as
>instances of a class that we create on the fly as needed, we could
>well have multiple instances of the same imaginary number around. 
>Thus, it is possible to confuse tests for identity with tests for
>equality.  But ordinary people don't think of this as being
>possible with imaginary numbers because two imaginary numbers are
>identical iff they are equal.

Strangely enough, I think the two sides may be beginning to understand
each other. It is true that if you use identity tests instead of
equality, that it is possible to distinguish multiple instances of
classes where this doesn't make very good intuitive sense.

However, what does identity mean for a value. If you tell a
mathematician that two imaginary numbers are identical iff they are
equal she will probably ask you what identity means?

>Very good object-oriented developers do understand all of this. 
>They are very careful to build value domain classes so that invalid
>operations can't be performed on them (provided people use them as
>advertised).

It's not that difficult. Just don't provide operations that modify the
object.  If people can use them in a non-advertised way your
encapsulation facilities are lacking.

> But in my experience, many of the really nasty
>problems with complex object-oriented systems have been the result
>of not being able to completely maintain and cover up the "big
>lie": that an ordinary class mechanism is being used to implement a
>value domain which means that certain kinds of inappropriate
>operations can, and were, performed on values. (I suspect that
>the big lie may be behind most memory leaks.)

The only inappropriate operation I've seen so far is identity versus
equality tests. I've never had to deal with a memory leak, so I
wouldn't know whether this kind of thing causes them or not.

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