Special features

A reliable partnerMany companies and technologies have come and gone in the past 15 years. We continue to base our developments on Smalltalk and are confident that no other product can compete with this technology.

Whoever has written a graphical application some 15 years ago in C/C++, would have had a maintenance nightmare during that time. Adapting to new compilers and language standards would have taken a lot of effort. Not to mention the graphic support. Xlib, Xt, Motif, Qt, Win3, WinXP etc. all require different APIs and some even different program structure.

In contrast to that, many of our customers have smalltalk applications still in use, which were written 15 years ago. These are still running without a single change and with almost zero cost in code maintenance.

Java or C# ? That is the question for many today. On the Java side, you get less support from Microsoft. If you go the C#-way, you are locked in to a monopolist for a long time. Also, Java and C# developers are again fighting against incompatibilities. The same old story is told by those who had to move from AWT to Swing or the eclipse toolkit, or to a new language version. During all that time, Smalltalk meant and still means liberty and standing on a stable platform. Feel at home in both worlds - without having to change a single line of code.

One of the highest goals for eXept Software AG is backward compatibility to protect the investment of our customers.


Tried and tested in practical applicationsSmalltalk/X is applied successfully in many projects – including critical ones. These include factory controls and systems for process visualization, trading platforms for shares, logistics and controls for a package dispatch system, management systems for a mobile network operations cryptographic keys, a system for the analysis and storage of log files, automatic test systems for large telecom systems, web services, and many more.

Many of these are run 24/7 in continuous operation with minimum downtimes. Maintenance and upgrades are performed on-the-fly in the running system, which means that the application does not have to be interrupted.

If you recently made a phone call in Europe, used coal for heating, had water treated, received a parcel via mail, or dealt in shares online, it is highly likely that Smalltalk/X played a significant role somewhere in the process.


Syntactic and semantic compatibility with the industry standard

• Exception handling with continuable execution after handling (proceedable exceptions).
• Memory management with automatic release of memory space that is no longer in use (garbage collection).
• Processes (threads) with priority-controlled preemptive scheduler.
• Non-blocking GUI / non-blocking API access.
• Complete meta model with classes, meta classes, methods, etc.
• Real contexts and blocks (block closures).
• Integer and rational arithmetic of arbitrary precision, with automatic conversion of numeric data types
• Open – all Smalltalk components are available in source code and can be adapted to specific requirements.

A powerful virtual machine (VM) and support system

• Incremental compilation to byte code for short development cycles. Binary files containing byte code are portable across different machines and will therefore run on any processor architecture.
• The byte code is converted to real machine code as required. This is transparent to the program and done on a per-method basis. This technique is called dynamic or "just-in-time" translation ("JITTER").
• An additional standalone compiler generates efficient machine code and allows classes to be compiled into real machine code. This permits the generation of shared libraries (dlls) and executable programs without image files. Production can be preformed in a shell environment, i.e. libraries and applications can be automatically generated using make-files or batch statements. Applications can be delivered without source code or decompilable byte code.
• If supported by the operating system, these libraries can be dynamically incorporated into and removed from the system - by the user or by program control while the system is running.
• Bytecode and machine code methods can be mixed within an application or even within a single class. This is transparent to the program and the programmer.
• Inline C-code: C-code can be directly embedded in Smalltalk methods, and global, instance, class and method variables can be accessed from C. This allows time-critical operations to be optimized, and also means that existing C-libraries can be linked easily to Smalltalk.
• Optionally, external functions can also be called via FFI. The call is specified by a compatible compiler pragma.
  
• Generational memory management with automatic garbage collection (garbage collection featuring “generation scavenging” algorithm). Memory that is no longer in use is automatically detected in the background; this does not generally cause any noticeable pauses in the system. Memory is automatically requested and released from the operating system.
• Name spaces to avoid name conflicts in bigger projects.

A flexible and robust class library

• Process management is done in timeslicing mode, which can be turned off.
• Optional dynamic process priorities (i.e. background processes are guaranteed a timeslice, even when foreground activities might otherwise block the system).
• The class library has been specifically reworked to ensure interruptibility and multitasking (for example, appropriate locks have been integrated in the dependency management, access to windows, transcript etc.).
• GUI components are completely event-driven. No polling or explicit programmed control-flow passing.
• A dedicated thread is assigned to each window so that any possible blocks (or program errors) only affect the window in question. The GUI components are linked internally by the “dependency” mechanism (= “observer pattern”).
• Standalone applications can be generated without a graphic user interface (“headless” operation, e.g. in server applications).
• Support for multiple screens (“multi-headed” operation). This facilitates the creation of multi-user applications (without complicated inter-process communication or file access locks).
• Under Unix, multiple X-windows can be opened and operated on different machines. Under Windows, in addition to the local screen, X-windows can be operated on other screens (e.g. Unix machines, X-terminals or other Windows machines with an X-server).
• The “look and feel” of the GUI components (widgets) is controlled by parameterized viewstyles. These can be modified or enhanced by the user, allowing him to match the appearance of the application to existing applications (e.g. corporate identity colors). Standard style-sheets are provided to allow the appearance of ST/X applications to be adapted to motif, kde, Windows, irix and various other environments.
  
• National language versions are supported by the class library. Language-dependent texts are managed in external text files. Additional language versions can also be added at a later date (by editing these files). No recompilation or any change to the program is required.
• Unicode is supported in all 8, 16 and 32-bit character sets. Under windows, the Unicode API-Calls (-W-Calls) are supported and used.
  
• The library contains XML parsers/generators, server and client implementations of SOAP, HTTP, FTP, Telnet, NFS, JSON and other Internet protocols.
• Builtin Webservices for HTTP, SOAP, FTP and others. This simplifies the integration of your application into the existing infrastructure. The configuration can be done via an easy to use graphical dialog.
  

Powerful development environment

• Integrated programming environment with file and class browsers. Additional monitors for process and memory monitoring and a symbolic debugger support effective and low-cost software development.
• Changes can be applied to the program while it is running, which makes for very short turnaround times (since it is not necessary to shut down the program, recompile and restart it).
• Optional dynamische Prozessprioritäten (background processes get their timeslice even if a higher priority foreground activity would block the system).
• Integrated GUI builder. This facilitates the development of graphical user interfaces, menus and tables via drag & drop. As well as a large selection of existing GUI components, users can also easily integrate their own, user-defined widgets.
• Integrated version management (connection to CVS). This facilitates version management, thereby supporting team-based software development.
• Integrated web server. It can be operated in stand-alone master mode or under a master server (e.g. Apache with FastCGI connection). It supports conventional file access, Embedded Smalltalk (STT), Smalltalk services, CGI and SOAP. A preconfigured Swiki is also supplied, which is ready for use immediately.
• Online documentation as hypertext (HTML). This can be viewed in an ST/X-integrated HTML viewer (or another HTML browser).
• A class documentation generator creates online HTML documentation for the ST/X class library and the user classes by extracting the relevant information from the source code.
• Well-documented classes and methods. The source code for all classes is supplied.
• Numerous demo and example programs. As well as demonstrating particular concepts or features of individual classes, these can also serve as a starting point for the development of new applications.