From: bruce@utafll.uta.edu (Bruce Samuelson)
Subject: here's propaganda for ParcPlace Smalltalk
Organization: University of Texas at Arlington
Date: Thu, 8 Oct 1992 23:16:33 GMT

I'm engaged in an internal debate within an organization to which I
belong.  The question is which language to use for writing in-house
applications.  I am writing them in Smalltalk.  Others are developing
an in-house language for writing our applications.  I came up with the
following list of Smalltalk capabilities with which our in-house
language must compete.  Perhaps the list would be useful for those of
you engaged in Smalltalk advocacy within your organization.  For you
who find this list wreaking of excessive praise, how about
contributing a list of Smalltalk weaknesses?  There are plenty.

Capabilities of ParcPlace Smalltalk (with optional PPS extensions) in 1992

powerful language       can write wide range of interactive applications
rich environment        includes around 400 classes and 8000 methods
commercial add-ons      1000's of classes, 10000's of methods are available
public domain add-ons   many extensions and applications available for free
extensible environment  the environment is designed to be easily extended
source code available   Smalltalk source code for all methods is included
commercially supported  we don't maintain or enhance Smalltalk; vendor does it
training available      universities and companies offer Smalltalk training
programmers available   there are programmers who know Smalltalk (a few 1000?)
literature available    there are books, articles, and journals on Smalltalk
in widespread use       probably the 2nd most popular OO language (C++ is 1st)
mature                  commercially available since mid 1980s
robust                  stable environment; remarkably few bugs
optimized               speed and memory management fine tuned over many years
productive              can build applications quickly out of existing classes
scalable                has been used on large projects with many programmers
high level              Smalltalk program averages 1/6 size of equiv. C pgm.(*)
clean syntax            one of the cleanest, simplest syntaxes of any language
object oriented         possibly the most pure object oriented language
elegant                 great leverage achieved from a few simple constructs
consistent              all work is done by sending messages to objects
integrated              all programming tools run in a single environment
portable wrt/ OS        supports Windows, Mac, Unix/X-Window; OS/2 soon
portable wrt/ color     has a platform independent color model
portable wrt/ imaging   has a platform independent imaging model
native look and feel    expected to support this soon while remaining portable
virtual machine         isolates Smalltalk code from native hardware and OS
interface to C          can call C from Smalltalk; can call Smalltalk from C
interface to databases  can communicate with relational and obj-oriented dbms
interface to processes  can communicate with external processes (DDE, sockets)
interface to DLLs       can link with Dynamic Link Libraries
interface to Smalltalk  can easily export/import/exchange Smalltalk code
source code browser     interactively view and cross reference source code
execution profiler      spot bottlenecks in space and time
inspectors              view and modify objects
debugger                symbolically debug running program inside environment
interactive UI builder  user interface builder simplifies programming(#)
incrementally compiled  quick edit, compile, run cycle
dynamically translated  cache of native machine code optimizes performance
automatic memory mngmnt efficient incremental garbage collector
graceful error handling exception handler simplifies error recovery
image based persistence save all work; resume where you left off next time
file based persistence  binary object storage system saves objects to files
polymorphic             simplify programming--one message, multiple meanings
dynamically bound       gain flexibility--bind messages to methods at run time
class encapsulation     classes encapsulate (data + interface + algorithms)
generic-specific        inheritance gives leverage in programming by refinement
part-whole              composite relations implemented by instance variables
abstract-concrete       concrete object instantiates abstract class template
peer-to-peer            objects communicate by sending messages
model-view-controller   semantic, visual, and interactive roles are separate
multitasking            has internal multitasking support (cooperative alas)
educational pricing     we qualify for the 90% discount off commercial prices

(*) Computerworld, Nov 7, 1988, page 98.
(#) Late October release?
-- 
**********************************************************
* Bruce Samuelson	Department of Linguistics	 *
* bruce@ling.uta.edu	University of Texas at Arlington *
**********************************************************
Newsgroups: comp.lang.smalltalk