VAST is cross-platform at a source-code level, with
each platform's version tightly integrated for maximum performance
and user-interface conformance. Its tools are not quite as nice as
other versions of Smalltalk on the market but it can do what is necessary.
This development environment is slower than others, but holds up well
and is a great choice if interested in integrating with other IBM
products. It enjoys a robust community that actively grows third-party
support and offers effective development collaboration.
VAST does have a high cost with only one licensing
option, which is per seat which is why it is more ideally suited to
a corporate development environment. It is currently the de facto
standard for corporate Smalltalk development.
Dolphin is the de facto Smalltalk for the Windows
platform and for good reason. The development environment is incredibly
fast and exposes portions of the Win32 API directly. This is not required
for common development, but it does give access to features of the
Windows platform. Its class library is great, but not large. The Model
View Presenter (a derivate of the MVC pattern) framework is a nice
abstraction on top of the Windows message driven user-interface and
greatly leverages application development.
Dolphin integrates natively with the Windows user-
interface so applications can use the most up-to-date controls offered
by Microsoft and other parties. Dolphin has an intuitive packaging
system for importing and exporting code and third-party SCM products,
such as Source Tracking System from Gorisek (www.gorisek.com), which
supplies ENVY type functionality within Dolphin at an extremely reasonable
Dolphin includes the latest refactoring browser offered
by Refactory, Inc. The interfaces to Visual-Works and Dolphin are
nearly identical which is a great productivity enhancer since one
tends to do serious develop-ment in both products. It is reasonably
priced supplying an incredible Smalltalk in a compact and mature package.
Smalltalk MT, another Smalltalk developed specifically
for the Windows platform, is unique in that it is a compiled Smalltalk.
All other Smalltalks on the market are implemented on top of a Virtual
Machine and use Just in Time compilation for performance. MT, on the
other hand, compiles each method into native x86 op-codes for maximum
While MT is a true Smalltalk and benefits from many of its
features, I often have difficulty with the product. Stability is a
constant issue, due to it being compiled instead of interpreted. It
allows for direct memory manipulation and direct embedding of x86
assembly language in methods. MT promotes itself for game development
and has a DirectX class library built specifically for this task.
I have used it enough to feel it is designed for games and affords
performance directly comparable to Visual C++ compiled code. MT's
class library is very terse and does not abstract much beyond the
Win32 API. An MFC programmer will feel at home using Smalltalk MT.
MT is reasonably priced with excellent support. The user community
is small, but growing and because of its low price, I'd recommend
every Smalltalk programmer use MT for those performance sensitive
areas instead of writing them in C or C++.
GemStone/S is a multi-user, server based, Smalltalk.
The closest analogy is a cross between Oracle and a J2EE application
server such as WebLogic or WebSphere. However, this does not do it
justice because it is much simpler to use and many times more powerful.
Some consider GemStone/S an OODBMS or Object-Oriented Database Management
System and in the strictest sense, it is but it is also a very powerful
application server can handle transactions in the tens of thousands.
GemStone/S has an ample class library, but does not
support GUI development directly. In theory it is possible to host
web applications from it directly, but it does not support this functionality
at this time. Some developers in the community have looked into this,
which would make it a complete application server.
Using GemBuilder, a separate product that integrates
with VisualWorks or VisualAge for Smalltalk, it is easy and highly
productive to develop GemStone/S applications. It is costly, but worth
every penny for the right projects.
There are others, such as Squeak, GNU Smalltalk, and
SmallScript. The last, in particular, is still under development but
once developed will integrate directly with VisualStudio.NET and promises
to introduce the entire Microsoft developer community to Smalltalk
and its many benefits.
As one can see, Smalltalk deserves its name - the
language is concise yet powerful. While Java is looking forward to
its first decade, Smalltalk is well past its second. With age comes
a mature community, class libraries, and vendor support and for most
software projects this means programmer productivity. As the examples
in this article show, Smalltalk streamlines common programming tasks
by using a natural language approach and dynamic typing. These attributes,
combined with flexible development tools -- written in Smalltalk -
give programmers a powerful toolkit to tackle any problem, large or
Java isn't the only new game in town. The next time a
project requires an object-oriented langauge, consider a language
that started it all -- Smalltalk.
ReferencesIf you are still interested in learning more about
please visit Why Smalltalk (www.whysmalltalk.com)
or Worker Bee Solutions, Inc. (www.workerbee.com).
Jeff has been a programmer for over fifteen
years and a
consultant for the past seven. He currently lives
in Illinois where he herds Siamese cats - who love Smalltalk - and
runs his consultancy, Worker Bee Solutions. You can reach him at email@example.com.