From: Des.Kenny@bbs.actrix.gen.nz
Newsgroups: comp.object,comp.lang.smalltalk,comp.lang.eiffel
Subject: Re: comparing object-oriented platforms
Summary: Expansion of summary
Date: 28 Sep 92 02:40:59 GMT
Followup-To: comp.object, comp.lang.smalltalk,comp.lang.eiffel
Organization: Actrix Information Exchange

In article <-t!p#_a.nagle@netcom.com> nagle@netcom.com (John Nagle) writes:
> mwu@orion.oac.uci.edu (Matt Wu) writes:
> >I'm currently evaluating several object-oriented development platforms
> >and I was wondering if any of you would like to share your opinions on
> >platforms that you prefer or know about.  It'd be especially useful to hear
> >comparisons between different platforms (for instance, Eiffel v. Smalltalk).
> 
>       The language situation is roughly as follows:
> 
> 	Ada		Big, no inheritance, some tools expensive but do
> 			exist.  Many books on language available.  Many
> 			free libraries available.  DoD standard.
> 	C++		Big, multiple versions of language, unsafe.
> 			Tools widely available.  Many books available.
> 			Most popular choice.
> 	Modula-2	No classes or inheritance.  Many books.
> 			Many implementations.  Solid, but limited.
> 	Modula-3	Limited interest - one free compiler, one book.
> 			Adds classes to Modula-2.  Less used than
> 			Modula-2.  
> 	Eiffel		Limited interest - one or two compilers, one book.
> 			Less used than Smalltalk, C++, Ada, or Modula-2.
                        
                        Correction: two books:
                        "Object-Oriented Software Construction", B Meyer,
			Prentice Hall, 1988,
                        over 100,000 copies sold
                        Clearly NOT of limited interest!
			"Eiffel The Language", B Meyer, Prentice Hall, 1992
			This is the industry reference manual for version 3
			of Eiffel adopted by the international independent
			standards body for Eiffel as the basis for the
			standardisation of the Eiffel language.

                        Other languages are all still struggling even now 
			to keep up with Eiffel. None of them have yet
			reached the level of elegance, simplicity 
			and mental power of Eiffel and Eiffel is
			not standing still. ISE is working on version 3
			at the moment. SIG is working on a DOS version
			, with Windows coming soon. I have it on very
			good authority that there are other compilers
			in the works, I can't tell you who is developing
			them because my source is sworn to secrecy,
			and like a good honest source would not tell me.
			No doubt we will see them some time next year.

			ISE's  Eiffel came out in 1986 with
			multiple inheritance, repeated inheritance,
			genericity, including constrained genericity,
			static typing AND dynamic binding, polymorphism,
			 assertions
                       (method preconditions, method postconditions,
                        class invariants ) and the design of contracts 
			between client and supplier, a very object-oriented
			and neat approach to exception handling where in
			combination with assertions and contracts the error
			 is passed back exactly to its source, where the buck
			 stops : the client.
			
			 Assertions and the intelligent
			legal-like framework for assigning responsibility	
			make this language very safe and a pleasure to debug
			( if there can be pleasure in debugging) because you
			rarely have to debug! Assertions and the intelligent
			exception handling tell you exactly who did what to
			whom and who is responsible for fixing the problem.

			Run away error propagation is prevented by assertions
			and intelligent exception handling. There is also a
			retry capability where a delinquent client may restore
			the damage it has done and retry its request via a
			different pathway. But it is the clients job to clean
			up its own mess.
			
			 Of course, a supplier has to deal
			errors as a result of defaults in its side of the
			contract if a postcondition fails. But again the
			responsibility is clear and the error is localised.
			Used intelligently assertions and the Eiffel exception
			handling mechanism can save you days of grief compared
			to almost any other language on the market OO or
			otherwise.

			ISE Eiffel 3 is in the pipeline at the moment
		        The new development tools are a big advance forward.
			To the compiler has been added an interpreter which
			is integrated with the compiler. This environment
			is called EiffelBench.

			This has an enormous advantage because you can
			interpret some classes while leaving others 
			in compiled form. When you are dealing with a large
			number of classes you will have the significant
			advantage that you can experiment/prototype/maintain
			a small subset of the class network and gain a much
			faster turn around time than with a compiler alone.

			However, unlike Smalltalk, the interpreter like the
			compiler still provides full STATIC type checking for		
			each class that is interpreted. Smalltalk only checks
			types at run time. Which is a bit like the pilot of an
			aircraft checking, for the first time, to see if there
			is enough fuel when you are over a large ocean!
   			Some people might be happy with such an airline, not
			me!

			So you have the advantage of fast development,
			controlled change by limiting the span of interpretion
			versus compilation, AND static type checking.

        		There is aslo a new interface builder called
			EiffelBuild. Like Eiffelbench and the other
			tools it operates on OO principles. You decide
			what Context you are working in and then you add
			,via drag and drop style, Commands that are relevant
			in the Context. So you build up Modes that are able
			respond to events on the GUI. The approach is a 
			visual programming style. The interface generates 
			Eiffel code.

		        EiffelStore is going to provide interfaces to
			relational database systems : Oracle, Ingres,
			Informix and others.

			EiffelStore is also being interfaced to OO DBMS
			systems: Versant and O2 interfaces are in the
			pipeline.

			Currently there are about 2100 Eiffel licenses
			wordwide. These tend to be large companies or
			Universities. Over 400 Universities use Eiffel
			to teach the principles of OO. 
							
  			So Eiffel is not yet as widespread as C++
			but then how many people using a C++ compiler
			are really doing OO ? C++ compilers may be better for
			died in the wool C programmers who are scared to
			venture to far from the nice little C hole they have
			dug theselves. But C++ is a poor compromise at best.
			It is not real OO. Even authors who work at AT&T
			have documented, several times, how difficult it is
			to teach the best C programmers to use the OO 
			extensions of C++. OO thinking is very very different
			from procedural thinking. And it is just human nature
			to slip to the bad old ways.


			So when you see figure of enormous numbers of C++
			licenses. Think what this really means in OO terms
			rather that C terms.

			My advice is not to be a sheep. Sheep get slaughtered
			in the end. 

			Look at the various platforms and judge for yourself.
			Decide what you need that suits you. Don't go on the
			number of licenses!


> 	Smalltalk	Slow execution, good tools.  Multiple books
> 			available.  Clean language.  Good for experimental
> 			work.  Avoid pure-interpreted versions if speed
> 			at all important.
Newsgroups: comp.object