Overview - What is ST/X Smalltalk

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 writers.
The standalone compiler generates true machine code from Smalltalk source files - and can be used in a batch environment for production/delivery.

Features

• Language syntax and semantic compatible to the industry standard, including arbitrary precision arithmetic and automatic number conversion, exception handling, automatic memory management, threads, contexts, blocks (block closures), metaprogramming and much more.

• Additional (mostly backward compatible) extensions to the Smalltalk language include: private classes, multiple namespaces, method privacy and end of line comments.

• A comprehensive threadsafe library of basic classes, including collection classes, numeric classes, streams, lightweight processes, exception handling and metaclass hierachy.

• Many user interface widget classes usable as building blocks for graphical applications. These are fully (non-polling) event driven, multithreaded and support multiple displays, 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 (4). 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 (5).

• Many demo and 'how-to' example programs

• 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

Implementation highlights

• 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 machine code.

  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 TCP connections.

• 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 Java code.

(1)

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 installed separately.

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.

(2)

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.

(3)

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.

(4)

It is of course possible, to access system and host specific functions and API's. 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.

(5)

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.

Availablity

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