Smalltalk MT

Last Updated (Friday, 15 August 2008 19:04)

|

Written by Administrator

|

Sunday, 23 March 2008 17:14

FAQs - Commercial Smalltalk Environments

More ...

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.

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 NT, 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.

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.

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.

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.

Socket Library

The Socket library gives you multithreaded access to Windows sockets. The associated example demonstrates different operating modes:

• Blocking calls in separate threads.
• WSA (asynchronous calls).

ODBC Interface

The ODBC library lets you access databases via an ODBC driver. It currently implements ODBC level 1 & 2 and major level 3 functionality.

Communication Library

COMMLIB implements communications via a FileStream subclass, CommStream. The communication API uses the File interface. Writing communication software is therefore relatively straightforward.

The Simple Terminal sample demonstrates the use of communication devices, device configuration, and multithreading issues. The program opens the following threads:
the main thread manages the user interface.

• A background thread reads incoming data and raises an event whenever data is ready or an error occurred.
• The user can send a text file. In this case, a background thread transmits the data and raises an event when the operation completes or an error occurs.
• Any character entered by the user is directly sent to the device.

In addition, the program can also spawn a thread that waits on comm events and displays the events in the status bar.

---

< Prev		Next >