Re: Smalltalk and Ada

["Nick Roberts" <nickroberts@adaos.worldonline.co.uk>]

I suspect you won't find any existing comparisons between Ada and Smalltalk.

One interesting observation I have made is the way in which devotees of both
languages consider their language (Ada or Smalltalk) to be especially suited
to 'software engineering'.

Of course, I suspect different people have different ideas of what 'software
engineering' means.

To some it seems to be about constructing software which operates in close
connection with hardware; I guess hardware engineers culturally like to
supplant hardware engineering concepts onto software. Ada's areas of
application tend to be very much here (more as a result of the history of
the language rather than its features).

To others, especially Smalltalk people I think, it is purely about the
construction of software, but constructing it in ways which have analogies
to good engineering principles (e.g. overspecification of a structural
member's strength, as compared to redundancy and robustness techniques in a
program). Smalltalk has had some remarkable successes in the building of
large, complicated applications quickly (i.e. economically) yet with an
unusually high level of quality (for that kind of software).

Smalltalk is a great language for building (high-level) application software
fast. You can start building ideas straight away: you make a list of
entities in the application domain, and then make a class or object for each
one; add suitable methods, and test them out, interactively; add interface
components; add database and/or filing components; connect stuff up, and lo!
you've got the beginnings of a solution. Because Smalltalk is strong on
things like default behaviour, incremental refinement, and closeness of
correspondence between the software model and the real-world model, you tend
to be able to push forward rapidly, without having to keep going back and
changing your design, or lots of implementational details. Smalltalk has a
small syntax, and always has an 'object browser', so it can be easy to
learn.

However, Smalltalk has some serious disadvantages. Compilation is one. Some
Smalltalks can compile to native code, but oh so slowly. Too slow to be a
part of the development cycle. It is therefore useless for most low-level
programming. Even then, the native code produced will never be as good as
that produced by a program reasonably well written in a 'traditional'
compiling language (like Ada). Another disadvantage is the fact that
Smalltalk makes the assumption that the target is the host, and that this
must be powerful enough to support Smalltalk's typically huge memory
requirements and a full GUI.

Ada has a lot of hidden strengths. It's a very practical language. It has
all the (important) advantages of 'traditional' compiled languages (COBOL,
Fortran, Algol, C, Pascal, Modula, C++, etc.), but with solutions to (or
improvements on) most of the major practical shortcomings of these
languages. Nevertheless, Ada is able to live pretty directly in traditional
language environments, and can target embedded and 'tiny' environments. It
can interface directly with object code produced by compilers of other
languages. It is excellent at the low level, and adequate at the high level;
this mix can be very potent in some circumstances. Ada has a fair few
oddities and subtleties of use; it may be quite quickly learnt, but is less
quickly mastered. The best mitigation for this is that Ada compilers catch a
great many mistakes (that would be caught only dynamically or not at all by
other languages).

Smalltalk is all-pervasively object-oriented (it was the language that
invented the concept). Ada 95 provides object-oriented programming
facilities, but these are (almost) additional to the core language, and can
generally be ignored if not required. One interesting comparison between
Smalltalk and Ada is that they both support only single-inheritance (a
class/object can only have one parent class).

The one really big -- stark, even -- difference between Smalltalk and Ada is
in standardisation: you will find that every different Smalltalk product is
highly incompatible with nearly every other one; you will find that very
nearly every Ada implementation is very highly compatible with all the
others.

You will find useful information on Ada at:

http://www.adapower.com

I think you will find some useful information about Smalltalk at:

http://www.dnsmith.com/SmallFAQ/SmallFaq.html

and:

http://www.smalltalk.org.au/index.html

as well as, of course, the Usenet news group:

comp.lang.smalltalk

Hope this gives you a little food for thought!

--
Best of luck,
Nick Roberts