Instructor's Guide
intro,
paradigms,
comparison,
design,
prototypes,
architectures,
summary,
Q/A,
literature
When choosing a particular programming language
as a vehicle for program development a number
of factors play a role, among which are the availability
of a class library, the existence of a good programming
environment, and, naturally,
the characteristics of the language itself.
Class libraries
An important criterion when selecting a language
may be the availability of sufficient class library support.
A general class library, and preferably libraries
suitable for the application domain one is working in,
may drastically reduce development time.
Another important benefit of using (well-tested)
class libraries is an improvement of the reliability of the
application.
Smalltalk (that is Smalltalk-80 of ParcPlace Systems)
comes with a large collection of general purpose and graphics
programming classes, that are identical for both MS-DOS and
Unix platforms.
Also Eiffel
comes with a standard collection of well-documented
libraries containing common data structures, container
classes and classes for graphics programming.
For both Smalltalk and Eiffel, the accompanying classes
may almost be considered to be part of the language
definition, in the sense that they provide a
standard means to solve particular problems.
In contrast, for C++ there is almost no standard
library support (except for IO stream classes).
Even worse, the various C++ compiler vendors
disagree considerably in what functionality the standard
class libraries of C++ must offer.
Fortunately, however, there is an increasingly large
number of third party libraries (commercially and non-commercially)
available.
The burden of choosing the appropriate libraries
is, however, placed on the shoulders of a user
or a company,
which has the advantage that a more optimal
solution may be obtained
than possible within the confines of standard libraries.
Java, on the other hand, offers an overwhelming amount
of APIs, including a Reflection API, for meta programming,
APIs for networking, communication, and APIs for multimedia
and 3D.
Perhaps the greatest benefit of Java is the effort put into
the standardization of these APIs.
Programming environments
Another selection criterion in choosing a language is
the existence of a good programming environment.
What constitutes a good programming environment
is not as simple as it may seem,
since that depends to a large extent upon the experience
and preferences of the user.
For example, with respect to operating systems,
many novice users favor a graphical interface as
originally offered by the Apple Macintosh computers,
while experienced users often feel constrained
by the limitations imposed by such systems.
In contrast, experienced users may delight in the
terseness and flexibility of the command-based
Unix operating system, which leads
to outright bewilderment with many novice users.
Of the object-oriented programming languages
we consider,
Smalltalk definitely offers the most comprehensive
programming environment (including editors, browsers and
debuggers).
Eiffel comes with a number of
additional tools (such as a graphical browser, and a
program documentation tool) to support program
development (and maintenance).
In contrast, C++ usually comes with nothing at all.
However, increasingly many tools (including browsers
and debuggers) have become available.
For Java there are a number of IDEs (Integrated Development Environments)
available, most of which run only on the PC platform.
Language characteristics
Despite the commonality between Smalltalk, Eiffel, C++ and Java
(which may be characterized by saying that they all support
data abstraction, inheritance, polymorphism
and dynamic binding), these languages widely
disagree on a number of other properties,
such as those listed in slide [5-characteristics].
Language characteristics
- uniformity of data structures
- documentation value
- reliability
- inheritance mechanisms
- efficiency
- memory management
- language complexity
slide: Language characteristics
These characteristics were used in [BPS89] to compare
Smalltalk, Eiffel and C++ with the language Oberon,
which offers what may be called a minimal (typed)
object-oriented language.
We will, however,
limit our discussion here to Smalltalk, Eiffel, C++, and,
additionally, Java.