Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!uunet!mcsun!hp4nl!media01!pkr
From: pkr@media01.UUCP (Peter Kriens)
Newsgroups: comp.object
Subject: The essence of objects...
Keywords: oops objects co2 objective c
Message-ID: <1280@media01.UUCP>
Date: 10 Jul 90 08:10:13 GMT
Organization: Mediasystemen, Netherlands
Lines: 64

The essence of objects...

4 years ago we met the object oriented paradigm by
using Smalltalk. The shock was lessened by the fact that
parts ideas behind object oriented "thinking" were already 
in use by our previous software developments. Many times we felt
like "coming-home". Finally a way of thinking that matched
our own experiences. 

These years of using Smalltalk and later CO2 (something
like objective C) teached us many different things. We
made many mistakes and we have learned more. But we
still feel very strongly about the advantages.

But I still have problems explaining oops to people who
have no prior experience. When I start talking about
inheritance, dynamic binding they start to gaze and
we both feel lost. Why is it so difficult to explain
something which is so advantageous to use and which feels 
so right? How do I explain the essence of objects?

When I think about it further it seems that I have never 
really seen a description about oops that touches the
nucleus. There is a lot of talk about reuse, encapsulation,
dynamic binding versus static binding, multiple 
inheritance versus single inheritance and many more 
"symptoms". But they seem to be the tools and not the 
essence.

There is one element I feel very strong that it is
close to the nucleus of oops. My problem is that I find 
it very hard to make myself clear. I would like to try
it here and maybe some people can help to come to a
better formulation, or prove me wrong.

	The essence of oops is to specify 
	a functionality only once.

Let me try to make myself clear. If I design a hashing
collection I would like to write the locate function
in such way that it will work for all types of objects. If
I design a dragging routine I would like it to work on
all objects that could have a visual representation.

If this is the essence of oops, then I feel that we should
focus on the specification of that functionality. How can
we find those "functions" that fit in a world where they
are only described once. 

It seems that those functions need to be very "narrow" to
allow infinite combinations. It seems almost like we
need some sort of normalisation technique to find those
functions. How could case tools help us here?

Oops seem to give me exactly this behaviour. The inheritance
allows me to reuse specifications higher up in the
hierarchy and polymorphism gives me the handle to
specify a hash functions which is defined in the class
itself.

I would really like to start a discussion about this
subject. So please post back any comments.

Peter Kriens