La liberté d'imagination n'est pas une fuite dans l'irréel,
elle n'est pas une évasion, elle est audace, invention.
Overview - What is ST/X Smalltalk
ST/X Smalltalk is a complete implementation of the
Smalltalk language. Smalltalk/X is not based on the original ST-80 virtual
machine implementation and has been written from scratch.
However, the API, class libraries and language semantic are highly compatible
to ST-80 based Smalltalks, such as VisualWorks, Squeak and others.
Smalltalk/X consists of both an integrated environment for program
development AND a standalone Smalltalk compiler(1),
which generates true machine code, shared code libraries and binary executables without
a need for a so called "image". However, traditional image-based development
is also supported and typically used for program development.
The programming environment includes editors, browsers, compiler and debugger
and a large library of ready to use building blocks for application
The standalone compiler generates true machine code from Smalltalk source
files - and can be used in a batch environment for production/delivery.
- Language syntax and semantic compatible to the industry standard,
arbitrary precision arithmetic and automatic number conversion,
automatic memory management,
blocks (block closures),
and much more.
Additional (mostly backward compatible) extensions to the Smalltalk
end of line comments.
- A comprehensive threadsafe library of
and metaclass hierachy.
- Many user interface
widget classes usable as building blocks
for graphical applications.
These are fully (non-polling) event driven, multithreaded
parametrized view styles,
wide characters (unicode)
and national languages.
- Integrated programming environment
including browsers with sophisticated refactoring and code generation support,
GUI- and Menu builders, monitors and symbolic debugger for
efficient program development.
- The additional Scripting Engine
allows for command-line execution
of Smalltalk scripts. These script files can be generated by any other editor, or alternatively
by saving code from the IDE (file-out from the browser).
- Integrated JVM. A Java bytecode execution engine which is built
into the ST/X runtime system, and additional support classes
enable Java bytecode to be loaded and executed directly within ST/X.
Java and Smalltalk use the same object layout, reflection and
dynamic metaclass system, which allows for Java code to be written
and debugged in the "Smalltalk style".
- Debug once - run everywhere !
complete Source- and Byte-Code compatibility between
Unix, Mac-OSX and Windows versions
Write your application once, run it without change on
Windows-NT/XP/Vista, Linux, Alpha-OSF,
Solaris, HPUX, AIX, Silicon-Graphics IRIX and Apple Macintosh
- Many demo and 'how-to'
Online HTML documentation and
class documentation generator,
visualized by the ST/X HTML document viewer
or a standard web browser.
ST/X classes and methods are well documented,
including many code fragments for quick doIt evaluation.
- Very liberal licensing conditions
- Incremental compilation to internal
bytecodes for short turn around cycles during development.
Binary files containing bytecode are portable across different machine architectures.
- Dynamic (just-in-time) compilation from internal
bytecodes to machine code (2).
Except for the faster execution, this is transparent to the program or user.
A method's bytecode is automatically compiled to machine code when first executed.
- Batch compilation to real
machine code for production code,
enabling the creation of binary object modules,
class libraries or
even shared class libraries.
More optimizations and code analysis are performed by this (offline) compiler,
often resulting in faster code execution - even when compared to dynamic compiled
Although static compiled machine code leads to bigger executables,
the main advantage (beside faster execution) is the deterministic runtime
behavior, which cannot always be guaranteed, if bytecodes are compiled dynamically
at execution time.
In addition, big applications benefit from static compilation by the sharability of this
compiled code among multiple applications, if shared libraries and/or shared text segments
are supported by the operating system (which nowadays all systems do).
Applications can (and do) use a mix of precompiled machine code
classes and interpreted bytecode classes - this is transparent to the
program or programmer.
If supported by the operating system (3),
machine compiled modules can be dynamically added to and removed from the running system.
- Easy creation of
standalone executables and applications with or without graphical user interfaces.
This includes self-extracting installation code for Windows platforms
(Nullsoft self installing executables) and dmg-packages for Mac-OSX.
- Easy binding to C-language by allowing
inline c code
(even inline assembler by using asm statements)
or via the ffi (foreign function interface) callout mechanism to
dynamically loaded shared libraries (dll's).
Specifications for ffi calls are compatible in syntax to other
Smalltalk's library call specifications.
- Sophisticated window interface combining
event and process driven techniques.
ST/X supports multiple display devices - you can work with others in the
same object environment, or write applications which serve multiple screens.
Your application can even run on a display-less host,
serving multiple x-terminals or client applications via
- Additional protocol provided in the process, semaphore and processor classes,
for better thread synchronization.
ST/X's process handling includes additional mechanisms for
recovery (semaphore cleanup) in exceptional situations, which is required
in technical applications. The ST/X's process scheduler supports time slicing
and dynamic thread priorities. This allows for better response behavior in
multiwindow applications and allows progress of background processes even in
case of busy foreground processing.
- Modern generational garbage collector, with dynamic adjustable newSpace,
adaptive tenuring, both incremental and non-incremental collectors for the oldSpace,
both copying and non-copying compressors for the oldSpace.
- Object finalization via the WeakArray mechanism; in addition, a number of
other collection classes are available with weak references (WeakSet, WeakDictionary etc.)
- 64bit support on Windows, Linux and Mac-OSX systems.
- Both ANSI compliant class based exceptions and (VW-) backward compatible Signal-based
exceptions are supported.
In addition, process specific and global default exception handlers are avaliable,
to allow for non scoped, global exception handling.
- The byteCode interpreter and just-in-time compilers support multiple bytecode
sets, for total integration of different languages into a single unified system.
In the current release, this feature is used to support execution of compiled
- This requires a host platform specific c-compiler to be installed on the system.
For all unix platforms, these are free and typically already part of the installation (gcc).
For windows platforms, either the free borland command line tools (bcc55) or
a microsoft visual-C package have to be downloaded and installed.
Notice, that a C-compiler is not part of the ST/X's delivery, and must be purchased and
However, incremental compilation to bytecode
and internal just-in-time compilation to machine code is independent of any C-compiler,
and done transparently for all platforms by the Smalltalk/X runtime system itself,
without a need for a C-compiler to be installed.
- Dynamic compilation to machine code is not supported for all
architectures and CPU dependent. Currently, this feature has been implemented for
*86, sparc, rs6k, mc68k, mc88k, mips and alpha based systems;
A hppa code generator backends is being tested.
Notice, that older CPUs may not be supported anymore in newer releases.
Please refer to the download section of our website: www.exept.de or contact eXept
for further information.
Currently, this includes Linux-a.out, ELF based
(i.e. Linux and System5.4, Unixware, Solaris, SGI-IRIX and OSF-1), AIX3.2
Mac-OSX, and Windows-XP, NT, 95, 98, ME and Vista based operating systems.
On those systems, it is possible
to compile primitive C-code and to compile Smalltalk code down to machine code,
even from within the browser - without a need to leave the system for a relink.
It is of course possible, to access system and host specific functions and
Therefore, it is also possible to write architecture specific code if there is a need to.
But you have to be careful to not loose portability if you do so.
Some of the listed architectures may not be available at the time you read this.
This is not due to technical, but mainly for business reasons
(we simply cannot keep a big number of outdated machines in operation to generate
binaries of new versions).
Please contact exept if you require an up-to-date version of ST/X
for one of these "older" architectures.
We are willing to provide one for a service charge based on time & materials.
ST/X is a product of Claus Gittinger, Development & Consulting.
ST/X is maintained and further developed by Claus Gittinger and eXept Software AG.
A free version (even for commercial, but not for military use)
is available via FTP from www.exept.de.
Contact eXept for unlimited licences.
Copyright © 1986-2007 Claus Gittinger Development & Consulting
Copyright © 1996-2007 eXept Software AG
Doc $Revision: 1.52 $ $Date: 2019/08/26 22:06:29 $