Though it is true, it does not explain why Smalltalk delights its users so quickly. Java or C# are also object oriented programming languages that have extensive class libraries and interactive programming languages and became the standard several years ago.
The Strengths of Smalltalk
The previously described characteristics of Smalltalk as a programming language and environment reveal some important strengths in practice that favour the usage of Smalltalk.
Smalltalk allows the simple and flexible modeling of concept hierarchies that follows the classic example of step-by-step refining from general to specific. With that, smalltalk virtually offers the prototypical modelling of business knowledge.
Smalltalk is a fully developed high performance scalable system that allows the "write once run everywhere" operation and it has been this way since the early 80s. The choice of available platforms depends on the provider and covers VisualWorks from Cincom on all up-to-date workstations from PC, Mac to the various Unix/Linux versions.
In the context of Smalltalk, eXtreme programming was developed and Smalltalk is certainly the most productive XP-development environment.
Smalltalk can show its strengths especially in an environment with very frequent changes. The integrated incremental development environment along with the flexibility that came from the reflexivity and the implicit typing allow the fast and constantly verifiable modification and rapid development cycles.
In the sum of all its characteristics that we briefly cited here, Smalltalk, specifically Cincom Smalltalk, is recommended for the development of complex and multi-layered systems that need to be continuously adapted to a rapidly evolving world.
The Smalltalk programming language is purely object oriented, reflexive and implicitly typed. That practically means that Smalltalk enables completely different programming compared to other OO languages derived from procedural languages such as C.
Purely object oriented means that every value and data structure is an object. In Smalltalk, we do not have the distinction between literal values such as numbers, characters or strings and objects which is done by C++ as well as its descendants, for example. The expression '23' creates an entity of the SmallInteger class that is derived from a brief hierarchy of the object class. This means that the number 23 understands every message that is defined in this hierarchy and new methods can also be implemented in the SmallInteger class. Similarly, arrays are not created by dedicated syntax but simply by creating a message to the array class, e.g. 'Array new: 4'. Pure object orientation avoids artificial distinctions between values and objects that is hard to motivate.
Reflexive means that Smalltalk is implemented in Smalltalk. The objects that define the Smalltalk language are described by the medium of the language. Therefore, classes and methods themselves are Smalltalk objects and do not simply merge with the translation of the class in the created program. This is why our example above, 'Array new: 4', becomes clearer. The array class itself is an object that can be adressed by its name and among other things a 'new:' method is implemented. The usage of Smalltalk objects to define Smalltalk systems allows the programmer to extend the language itself as well as the programming environment. This size cannot be achieved in other conventional environments.
An implicitly typed language has types -- these are the classes of the objects in Smalltalk -- but the assignment of the types to the objects is recorded in the whole runtime and doesn't need to be specified as type declaration to the programming time. Which is why it is typical of Smalltalk: the usage of an unknown message will not cause a program to crash. The reflexivity of Smalltalk makes it possible for such illegal situation to be recognized and dealt with in Smalltalk. It is even possible to resolve the error case by programming the missing method, thus allowing the 'crashed' program to run further. Here, we do not want to get into a heated argument about the pros and cons of type declaration. Smalltalk works best even without explicitly specified types.
However, the languange is not constrained by the reflexivity of Smalltalk. The class library and the development environment are also completely implemented in Smalltalk. Compiler, debugger and the browser system are Smalltalk programs and are usually present in the source codes. The browser is an integrated editor, source code analyzer and type declarations at the same time which has unsurpassed possibilities at the moment. The missing type declaration and reflexivity has an interesting consequence for the classic "edit, compile, debug" cycle: There is no incomplete class definition and classes and their methods can therefore be translated independently. To program in smalltalk means to incrementally build classes method by method. At any point in time, the partial classes can be used and tested. This allows the perfect opportunity for an "edit, compile, debug" cycle at a source code-level.