smalltalk vs. Ada

smalltalk vs. Ada

[Rod Weston]

Still investigating OOP languages.  I'm quite impressed with Ada, from
what I've seen and read so far, but now want to turn my attention to
smalltalk.  Any ideas on how Ada and smalltalk compare?  Are there any
other OOP languages worth looking at?

Re: smalltalk vs. Ada

[Ed Falis]

Rod Weston wrote:

> Still investigating OOP languages.  I'm quite impressed with Ada, from
> what I've seen and read so far, but now want to turn my attention to
> smalltalk.  Any ideas on how Ada and smalltalk compare?  Are there any
> other OOP languages worth looking at?

They're birds of quite different feathers - and both worth familiarizing
yourself with.  Sticking just to OO, I'd also take a look at Eiffel.  For
scripting, Ruby.  And in functional languages, Haskell is worth a look,
too.

Language exploration can be a lifetime pasttime.

- Ed

Re: smalltalk vs. Ada

[Gary Scott]

Hi,

You can review OO Fortran here:

http://www.j3-fortran.org/Fortran-200x.html

Ed Falis wrote:
> 
> Rod Weston wrote:
> 
> > Still investigating OOP languages.  I'm quite impressed with Ada, from
> > what I've seen and read so far, but now want to turn my attention to
> > smalltalk.  Any ideas on how Ada and smalltalk compare?  Are there any
> > other OOP languages worth looking at?
> 
> They're birds of quite different feathers - and both worth familiarizing
> yourself with.  Sticking just to OO, I'd also take a look at Eiffel.  For
> scripting, Ruby.  And in functional languages, Haskell is worth a look,
> too.
> 
> Language exploration can be a lifetime pasttime.
> 
> - Ed


-- 

Gary Scott
mailto:scottg@flash.net

mailto:webmaster@fortranlib.com
http://www.fortranlib.com

Support the GNU Fortran G95 Project:  http://g95.sourceforge.net

Re: smalltalk vs. Ada

[Aron Felix Gurski]

Rod Weston wrote:
> Still investigating OOP languages.  I'm quite impressed with Ada, from
> what I've seen and read so far, but now want to turn my attention to
> smalltalk.  Any ideas on how Ada and smalltalk compare?  Are there any
> other OOP languages worth looking at?

You might consider looking at Modula-2. The ISO standard 10514 (parts 1, 2 and
3) added generics and object-oriented features to the original object-based
language.

-- 
        -- Aron

NB: To reply by e-mail, remove "spam-block." from my address.
- - - - - - - - - - -
"If you don't learn to laugh at your problems, then you will have nothing about
which to laugh when you are old."

        -- E.W. Howe

Re: smalltalk vs. Ada

[Jon S Anthony]

Rod Weston wrote:
> 
> Still investigating OOP languages.  I'm quite impressed with Ada, from
> what I've seen and read so far, but now want to turn my attention to
> smalltalk.  Any ideas on how Ada and smalltalk compare?  Are there any
> other OOP languages worth looking at?

Common Lisp and CLOS.  In terms of sophistication, industrial strength,
and unparalleled flexibility combined with high efficiency,nothing else
available really matches it.

BTW, I think both Ada and Smalltalk are worthy.

/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari

Re: smalltalk vs. Ada

[Marin David Condic]

AFAIK, Smalltalk pretty much restricts you to doing OOP even if that isn't
the best way to build a particular part of the system. Ada, OTOH, is more
"general purpose" and will let you design/implement with traditional
functional techniques (or pure spagetti-code ala "The Good Old Days" if you
like! :-) when necessary, yet still support all of the object creation you
may want.

There are practical concerns as well. You'd want to ask about the quality of
Ada & Smalltalk implementations, the target systems for which they are
available, tools, cost, etc. I've never done anything real with Smalltalk,
so I couldn't advise you on that aspect. I can say that Ada is available
from a number of sources with different qualities for each implementation,
so you have some choices available depending on your intended use. There are
a large number of target computers for which Ada can be had. There are also
a large number of tools available for working with Ada that are in general
pretty good. (Yes, I complain because they're not always everything I want
them to be, but in fairness, there really are a lot of things out there to
support Ada development.) I'd suspect that Smalltalk will be a bit more
obscure than Ada and (based on complaints heard here often) if you have a
hard time finding Ada programmers, you'll have an even harder time finding
Smalltalk programmers. If you need long-term future support, etc., Ada is
probably in a better position than Smalltalk.

Hope this helps.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com
Web:      http://www.mcondic.com/


"Rod Weston" <rod_weston@yahoo.com> wrote in message
news:f7ce0059.0106071420.2f38d37a@posting.google.com...
> Still investigating OOP languages.  I'm quite impressed with Ada, from
> what I've seen and read so far, but now want to turn my attention to
> smalltalk.  Any ideas on how Ada and smalltalk compare?  Are there any
> other OOP languages worth looking at?

Re: smalltalk vs. Ada

[Mark Lundquist]

"Rod Weston" <rod_weston@yahoo.com> wrote in message
news:f7ce0059.0106071420.2f38d37a@posting.google.com...

> Still investigating OOP languages.  I'm quite impressed with Ada, from
> what I've seen and read so far,

cool... :-)

> but now want to turn my attention to
> smalltalk.  Any ideas on how Ada and smalltalk compare?

OK, let's go!  I'll also throw in Java as an additional point of
comparison...

Smalltalk is a typeless language.  That doesn't mean there are no types or
that objects don't have types (that would be nonsense!); rather, it means
that the things in Smalltalk that correspond to what are called "names" in
Ada -- variables, method parameters, and method invocations -- are untyped.
That is, they denote objects whose types are unknown.  But since the only
thing you can do with an object is to "send it a message" -- that is, invoke
one of its methods -- the only error that can arise from an object having
the wrong type is when you try to invoke a method that does not exist for
the target object, and this is a run-time error.  Ada, by contrast, is a
quite strongly typed language.  Java also has strong static type checking.
But in both Smalltalk and Java, the only new types the programmer can create
are classes, where in Ada you can create new elementary types, array types,
etc.  And Ada's type system includes the powerful "subtype" mechanism which
is not found in any other mainstream language.

Smalltalk is also a "by-reference" language -- that is, a name denotes a
reference to an object, and the reference in turn designates or points to
the actual object.  There is no other way to access an object.  Ada is a
"by-value" language -- names denote objects themselves, and reference
semantics are explicit, i.e. a reference is an ordinary object, but of a
particular kind of type (an "access type" in Ada).  In languages with
by-reference semantics, the equality test really tests for *identity* of the
designated objects (since that's what equality of  two references means),
and assigment creates an alias, not a copy.  So things feel a lot different
in a by-reference language.  In Smalltalk, the reason for being a
by-reference language is deeply connected to typelessness.  If there is no
static typing, the implementation can't generate code to create an object as
a stack local, because if you don't know the type then you don't know the
size of the object.  So everything is allocated off the heap, and you just
pass around pointers to everything.  Java is also a by-reference language,
but for half-baked reasons.

Smalltalk (like Java) is a class-oriented language, i.e. everything is an
instance of a class.  Ada is not a class-oriented language.  Both Smalltalk
and Java are "pure class-oriented" -- they have a single-rooted class
hierarchy.  A practical implication is that although you might not like not
having generics, you can generally survive without them :-)

The classic Smalltalk (Smalltalk-80) doesn't have multiple inheritance,
although there are variants that do support MI.

Smalltalk, like Java, is meant to run on a virtual machine, and the compiler
compiles methods to bytecodes.  Ada is meant to be compilable to native
code, although of course it can also compile to bytecodes to run on a
virtual machine.

Smalltalk doesn't have a notion of "public vs. private members", because an
object's instance variables are visible only to the object's own methods,
i.e. all instance variables are "private".

Smalltalk, like Java, has a standard library that includes collection
classes.  Ada has no standard collection library.

Smalltalk has a programming environment including class browser, compiler,
debugger etc. that are all written in Smalltalk and run on the same virtual
machine as your program.  This is pretty important in a language where type
mismatches cause run-time errors :-).  When this happens, you are notified
by the fact that the debugger comes up in the context of the error, and
presto, you are debugging your code.  Also, you don't really compile a
"program" in Smalltalk as you compile individual methods as you write or
modify them.  Because of these factors, programming in Smalltalk has a real
incremental, dynamic, "rapid-prototyping" feel.

Ada has a hierarchial namespace.  In Smalltalk, the class namspace is flat.
There is a one-level "class category" attribute of classes, but this only
effects how the class is displayed in the class browser; it doesn't create a
namespace.  For instance, if I have a class Bone in category Body-Parts, I
cannot create a new class Bone in category Dog-Toys.

Ada is made for concurrent programming.  Smalltak has enought support to get
you by as long as you're not doing anything too complex.

Smalltalk was the system that brought together OOP, the mouse, and the WIMP
metaphor.  It brought class-oriented programming out into the daylight, and
class-oriented programming was the blunt instrument needed by the masses to
clobber into their brains an appreciation for the benefits of encapsulation,
inheritance, and dynamic polymorphism.  I guess it was probably worth the
brain damage.

I'm not a Smalltalk "believer", but I am a Smalltalk "fan", if that makes
any sense :-).  Although Ada is still my language of choice, I like
Smalltalk and I think it has a certain kind of coolness.  I learned
Smalltalk back in '87 -- before I learned Ada.

I'd suggest you try these languages out!  Download GNAT if you haven't
already, and start playing!  There are a lot of people on this NG who will
help you learn.  Same w/ Smalltalk; you can find an open source
implementation on www.squeak.org.

>  Are there any
> other OOP languages worth looking at?

Eiffel is probably worth looking at.  It's a pure class-oriented language
that supports multiple inheritance.  It embodies a philosophy called "design
by contract" that really seems like it belongs in Ada too, but nobody can
quite figure out where to make it fit.  Eiffel does not really have any
concept of interface and implementation being textually separated, so like
Java the methods are written in-line as part of the class definition.  I
much prefer the Ada approach where you have a specification and a body.
From what I've seen, Ada people seem to have a lot of respect for Eiffel as
a well-designed language, so I basically regard it positively even though
I've never actually used it :-).

Have fun!  Hope this helps...

Mark Lundquist

Re: smalltalk vs. Ada

[Wes Groleau]

> pass around pointers to everything.  Java is also a by-reference language,
> but for half-baked reasons.

In fact, it's "pure-OO, everything's an object claim" is itself only
half-baked.
The programmer before doing anything with any name has to know whether it's
an object or a primitive, since they have different semantics.  A violation
of "information hiding" in the sense that you can do almost nothing with
"employeeNumber" without knowing something about it's implementation.

> Smalltalk (like Java) is a class-oriented language, i.e. everything is an
> instance of a class.  Ada is not a class-oriented language.  Both Smalltalk
> and Java are "pure class-oriented" -- they have a single-rooted class

Again, not really pure.


> Ada has a hierarchial namespace.  In Smalltalk, the class namspace is flat.

Java has a sort of hierarchical namespace, but--here we go again--it's tied
to a particular implementation: a hierarchical directory structure.

-- 
Wes Groleau
http://freepages.rootsweb.com/~wgroleau

Re: smalltalk vs. Ada

[Chris Campbell]

> > pass around pointers to everything.  Java is also a by-reference language,
> > but for half-baked reasons.
>
> In fact, it's "pure-OO, everything's an object claim" is itself only
> half-baked.

Maybe take a look at Self which going by the documentation is a pure OO language
from Sun that presumably was discontinued by Sun when they developed Java.  As
far as i can tell there is a JVM based compiler called JSelf and a few
Linux/Unix compilers.  Also there is agora and omega that are both described as
OO, but i'm not sure about the availability of compilers for those languages.
Self, Omega and Agora are prototype based OO languages which are different from
class based languages, and this might be worth investigating if you're used to
the standard (class based) OO.



Chris Campbell

Re: smalltalk vs. Ada

[Gerhard Häring]

On Fri, 08 Jun 2001 17:01:25 -0500, Wes Groleau wrote:
>> Ada has a hierarchial namespace.  In Smalltalk, the class namspace is flat.
>
>Java has a sort of hierarchical namespace, but--here we go again--it's tied
>to a particular implementation: a hierarchical directory structure.

No, it's not (the Java language specification doesn't specify this at all).
This may be an implementation restriction of many of the more popular Java
compilers (most, not all; IIRC IBM's VisualAge only works on a repository, no
files or directories)

For the runtime, this restriction does not exist at all. In fact, you can
implement any custom class loader by extending the abstract class
java.lang.ClassLoader. Typical examples are loading classes from the network
(applets) or from a database.

Gerhard
-- 
mail:   gerhard <at> bigfoot <dot> de       registered Linux user #64239
web:    http://highqualdev.com              public key at homepage
public key fingerprint: DEC1 1D02 5743 1159 CD20  A4B6 7B22 6575 86AB 43C0
reduce(lambda x,y:x+y,map(lambda x:chr(ord(x)^42),tuple('zS^BED\nX_FOY\x0b')))

You will be a winner today.  Pick a fight with a four-year-old.

Re: smalltalk vs. Ada

[Ed Falis]

Mark Lundquist wrote:

> Eiffel is probably worth looking at.  It's a pure class-oriented language
> that supports multiple inheritance.  It embodies a philosophy called "design
> by contract" that really seems like it belongs in Ada too, but nobody can
> quite figure out where to make it fit.  Eiffel does not really have any
> concept of interface and implementation being textually separated, so like
> Java the methods are written in-line as part of the class definition.  I
> much prefer the Ada approach where you have a specification and a body.
> From what I've seen, Ada people seem to have a lot of respect for Eiffel as
> a well-designed language, so I basically regard it positively even though
> I've never actually used it :-).
>

I have.  It's a pleasure - much less "plumbing" to do OOP compared to Ada, if
that's what you want to do.  The MI facilities work really well (unlike C++),
the syntax is clean like Ada, and DbC is very useful (though pragma Assert in
Ada gets you most of the way there).  It's much weaker in terms of portability
of code between compilers than Ada is.  And it's not quite there yet for
concurrency, or IMO real-time and systems programming.  Garbage collection also
removes a lot of plumbing for general kinds of applications.  If you can't
tell, Ada and Eiffel are my favorite languages.

- Ed

Re: smalltalk vs. Ada

[Pascal Obry]

Ed Falis <efalis@mediaone.net> writes:

> I have.  It's a pleasure - much less "plumbing" to do OOP compared to Ada, if
> that's what you want to do.  The MI facilities work really well (unlike C++),
> the syntax is clean like Ada, and DbC is very useful (though pragma Assert in
> Ada gets you most of the way there).  It's much weaker in terms of portability
> of code between compilers than Ada is.  And it's not quite there yet for
> concurrency, or IMO real-time and systems programming.  Garbage collection also
> removes a lot of plumbing for general kinds of applications.  If you can't
> tell, Ada and Eiffel are my favorite languages.

I second that. And for me too Ada and Eiffel are my favorite languages.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--|
--| "The best way to travel is by means of imagination"