Contents

Key Features

• Runtime
• Smalltalk
• Class Hierarchy
• Development Environment and Tools

Sample Executable sizes

Extra libraries

• Database access
• Sockets
• Communication
• Setup toolkit
• ActiveX

What Are the Key Features of Smalltalk MT?

• Smalltalk MT uses an optimizing compiler that generates truly compiled, efficient code. Still, code is compiled interactively, so that it appears like an interpreted system to the developer. True native compilation means optimal performance, even if code is executed for the first time.
• State-of-the-art memory management: Smalltalk MT uses an efficient multithreaded runtime model that uses extensively virtual memory management and exception handling. This translates into reduced memory consumption and increased performance.
• Smalltalk MT is fully multithreaded and all primitives are reentrant. Threads are very lightweight and share a common address space, which is consistent with the way threads are used on Win32. The system is scalable and can benefit from multiprocessor architectures.
• The minimum runtime image is very small (in the 100K range for a Windows application). This means that applications can be easily distributed. It enables an organization to package and deploy applications as independent executables rather than one large monolithic image, thus improving robustness and performance.
• Large programs scale even better: a moderately complex Smalltalk application will be smaller than its C or C++ counterpart. This is because Smalltalk reuses more code than other systems. For example, the entire development system takes only 800 K, of which less than 500 K is code.
• Native Unicode: the Unicode edition runs natively in Unicode, meaning that all API calls, literal strings and Windows messages use Unicode. The Unicode edition is compatible with ANSI editions at the source level, meaning that an application just needs recompilation to run in Unicode or ANSI.
• DLL support: new programming paradigms require modular components rather than monolithic applications. Smalltalk MT lets you write ActiveX components, shell extensions, Netscape plug-ins, ISAPI server extensions and so forth.
• Headless support: writing headless or non-GUI applications is easy, and the generated executables are very small. Console mode is also supported.

Back to Top

Runtime System

• Native PE (portable executable) format: this format ensures that the executable is handled efficiently by the operating system.
• Robust multithreaded implementation: Smalltalk MT is multithreaded from the ground up, with garbage collection running in a separate thread. A process can have any number of threads. This enables the development of scalable applications on Windows, and simplifies considerably the design and implementation of applications that use blocking I/O. There are no restrictions on sharing data between threads (other than application-specific synchronization issues). In addition, all Win32 synchronization mechanisms can be used, which enables a non-Smalltalk thread or process to synchronize with a Smalltalk thread. Starting with version 2.5, fibers and asynchronous procedure calls (APC) are also supported.
• Scalable: a threaded architecture is more responsive on mono-processor machines, and takes advantage of multi-processor architectures. Garbage collection occurs in a background thread.
• Native exception handling: Smalltalk MT implements Win32 exception handling. This lets you trap system exception as well as raise your own software exceptions.
• Ability to generate DLLs: Smalltalk MT lets you package applications as DLLs that expose standard API interfaces. Any C program can bind to such a DLL, either dynamically or statically, without particular rules or restrictions. Smalltalk MT DLLs are small in size and load very fast - you won't notice a difference with C++ code.
• Standard import section: Smalltalk MT uses an import section that is initialized by the OS loader. This design is the most efficient in terms of performance and lets you use SDK tools such as the BIND utility to further optimize your executable. Optionally, imported libraries can be declared as load-on-demand in a manner that is transparent to the application. Load-on-demand reduces the initial working set and is useful for components that may not be required at runtime.

Back to Top

Smalltalk

• Thread local variables: Smalltalk MT supports thread local variables, which are instantiated per thread, and visible from any code executed by the thread.
• Callback Blocks: Smalltalk blocks can be called by external non-Smalltalk code as well. To a C program, a block looks like a pointer to a function.
• Exports: Class methods can be exported, and instance methods can be called as C++ member functions (using the this pointer as the first parameter). Both WINAPI and cdecl calling conventions are supported.
• Inline API calls: Our API implementation lets you use external APIs just as would use them in C. This means that using an external DLL is both very easy and efficient.

Back to Top

Class Hierarchy

• Win32 common controls, property sheets (wizards), common dialogs
• MDI
• SplitPane (splitter windows)
• Efficient resizing implementation
• Memory Mapped Files
• Memory Mapped Object Files (map a collection of objects into the address space of the process)
• COM object support
• OLE automation, containers, ActiveX container support.

Back to Top

Development Environment and Tools

• Graphical, interactive, multithreaded debugger.
• Object inspectors, workspaces (text windows), class hierarchy browser.
• DLL link utilities.
• Project Browser that lets you organize your code into projects. A project is a collection of classes, methods, and pool dictionaries. A project may contain prerequisite projects and libraries (DLLs).
• Pool Dictionary Editor that manages pool dictionaries. It lets you view and edit constant values, and can save as and restore from a C include file.
• Method categories and timestamps. You can list methods and classes by their last-modified time and date.

• Image Comparison tool that lists differences between two images.

Back to Top

Sample Executable sizes

The table below lists the section sizes for different images. These values have been obtained with PEDump, a PE file dump utility.

(*) Development image with all extra libraries and samples loaded.
(**) Additional resources in stdev.dll, 293 kB.

The figures show that there is only a very moderate increase in code size.

Back to Top