Newsgroups: comp.object,comp.lang.smalltalk,comp.lang.eiffel
Subject: Re: comparing object-oriented platforms
From: Des.Kenny@bbs.actrix.gen.nz
Date: Wed, 30 Sep 1992 03:11:00 GMT
Organization: Actrix Information Exchange
Summary: Are we talking about OO or not? 

In article <TMB.92Sep29101816@arolla.idiap.ch> tmb@idiap.ch writes:
> In article <1992Sep28.024059.25761@actrix.gen.nz> Des.Kenny@bbs.actrix.gen.nz writes:
> 
>                            But C++ is a poor compromise at best.
> 			   It is not real OO.
> 
> I'm really glad that C++ is a compromise between OO and non-OO
> facilities. If it weren't, it would be much less expressive and much
> less useful.
> 
  You need to make up your mind. Do you want to use the OO approach
  or not. If you do then in my opinion Eiffel is the most advanced
  OO language. 

  If you want to allow free state access style programming that is a different
  issue. The Eiffel approach is to separate these two paradigms.
  In traditional procedural style programming you have global states
  which are accesible from any module, a module can not protect itself
  from the incursions of other modules. 

  The OO approach is quite different. Each object/module is responsible
  for the access and management of its own state. No other object can
  get in and alter its states without permission. At least this is the case
  in Eiffel. It is not true in CLOS and it is only partially true in
  Smalltalk, you may be surprised to hear ( a subclass may access the 
  state of a parent class) and it is arbitray in C++.

  In C++ you have a confusion of these diametrically opposing state
  management philosophies. Some variables may be global while others
  may be protected by methods. This is not a clean state of affairs.

  It is a confusion of responsibility. The whole philosophy of OO
  is to place responsibility for each module's state in the hands 
  of the module itself. There is a new autonomy and independence
  given to modules. They can get on with their own job without
  worrying that other modules can come along and mess in their state
  of affairs. 

  So we are not just talking about minor syntax issues.
  This is a major change in th philosophy and politics of
  software modules. You may not like this. You may think that
  there are some areas of OO that are dubious, still under research
  etc. Which I may even agree with you in some specific cases.

  But the central policy of OO is tha assignment of responsibility
  of state management to each object/module and no other module should burgle
  its way in to change states by avoiding method interfaces.
  This is what OO is really all about. 

  In C++ in it is quite simple to violate this basic cornerstone of
  OO. In Eiffel it is totally impossible to violate it.


  The Eiffel approach is better. If you want to mix modules from
  these different paradigms, or other paradigms like logic programming
  or some other approach, then you call such modules from Eiffel.
  But they are treated as another world which this particular application has
  a need to communicate with.
 
  So you can call C from Eiffel ( and Eiffel from C ) for example.
  Such external modules are considered to be part of the implementation rather
  than the specification of an Eiffel class. You may chose to replace an
  external module with a new one,  a better algorithm for example. Such
  an implementation change has no impact on the specification/interface of a
  class at all. From a point of view of large scale systems such isolation
  from localised change is a major improvement in the stability of an
  industrial system. You can not guarantee such a robust evolution
  of change with C++ because it is not a 100% OO. There is global data,
  states can be altered by other modules without permission of the
  owner of the state. It is a philosophical and political confusion.
    

> 			   Look at the various platforms and judge for yourself.
> 			   Decide what you need that suits you. Don't go on the
> 			   number of licenses!
> 
> I did; Eiffel didn't suit me.
  
  I wonder if you are really following the OO philosophy at all.
  Maybe you don't agree with it. Maybe you think it will not work
  for your application. Perhaps, perhaps not.

  If you have some complaints with a particular implementation of Eiffel
  that is another issue. Some implementations are better than others in terms
  of the environment and the libraries.

  The implementations are improving all the time, providing better
  environments.

  If it is the language itself then I doubt if you are following
  the OO philosophy in reality. In which case no OO language
  will satisfy you.

  Are you perhaps using another paradigm such as logic programming
  or functional style programming? These two styles have not yet
  be reconciled with OO fully. Maybe they never will. We will see.
 
  Some people are trying to merge them with OO
  others say they should be treated as separate worlds and communicate
  with each other as required.  For example there are people claiming
  OO style Prologs. There are people attempting to merge some OO principles
  with the functional styles of languages like ML. It is very early
  days to see what will happen here. But I hope we are not going
  to get a confusion of opposing paradigms which I think is the case 
  with C++. It may be possible to achieve harmony. I think that
  Eiffels approach to treating the old freely accesible state styles
  like C, Fortran etc as other worlds does give us a reasonable
  harmony. C++ is not harmony it is discord.

  Regards
  --Des Kenny
    Objective Methods Ltd
    PO BOX 17356
    Wellington
    New Zealand
    Phone: 64 4 476 9499
    fax  : 64 4 476 9237
    email (Internet) : Des.Kenny@bbs.actrix.gen.nz

   
  





Newsgroups: comp.object