euroFORTH '98
Conference Abstracts

Session 1:
FORTH Philosophy and Standardisation

Context-Oriented Programming

M. L. Gassanenko

Context-oriented programming (COP) introduces one more notion to reason about the structure of software systems: a context (an environment) is a set of entities bound with a system of relations. This view is applicable where the object-oriented one is inadequate. Implementation of COP requires the same techniques as OOP: COP and OOP are different things assembled from the same components. COP allows things that OOP cannot do, for example, COP enables us to use late binding for elementary data that are not OOP objects.

Top-down thinking and top-down writing in DSSP

Sergey A. Sidorov

Top-down developing of algorithm is one of the main features of structured programming. But if we think top-down and write top-down on paper, we want to write our program files in the same manner. Dialogue supported by using of direct threaded code, special vocabulary organisation and compiler, which allows forward references to unknown words.

There are some control words for manipulating the vocabulary parts - sub-vocabularies and sections. We can open or shut sub-voc for searching, use only one sub-voc, clear sub-voc - delete useless words, and so on. Program debugging demands of replacing old copy of program code by new, and vocabulary structure allows it: re-solving of forward references is implemented in `forget' command and in compiler.

In not interactive target and especially embedded system, DSSP, compiler and vocabulary are not needed. Vocabulary can be simply deleted, and system without compiler and some large modules can be created by special tools.

This report give detail description of vocabulary, compilation algorithm and vocabulary commands.

ANS Forth: Standardising a Moving Language

Peter J. Knaggs

Developing a standard for a computer language has never been easy, especially for extendible languages. Everybody wants to see their "standard" addition included, without regard to anothers. The standardisation process is not the place to make recommendations for extensions to the language, but rather to consolidate existing practice.

Thus, I would like to suggest we adopt a three-stage process. In which additions and extensions to the language are accepted. The standardisation committee discusses them and they are either accepted for trial or rejected. Accepted suggestions are placed on an official notice board for developers to adopt and/or experiment with and comment on.

After a suitable period, no less than four years, the committee will take the trial suggestions (and comments) and consider them for inclusion in the standard. This will make the whole process simpler, as most of the argument will have occurred during the review period. Hence the standardisation process becomes what it should be, one of consolidating current practice.

Session 2:
Internationaliszation of programming in FORTH

Internationalising WIN32 – the final steps

Nick J. Nelson

In my 1995 and 1996 papers to this conference, I described most of the work necessary for creating multilingual applications in Windows NT, 95 and now 98. The remained one problem, which was how to deal with the components where text is an integral part of the language-specific version of Windows itself, i.e., the common dialog boxes, message boxes and property sheets. This paper briefly describes how to make these components multilingual. The examples are written in MPE ProForth for Windows.

Internal Representation to External View

Paul E. Bennett

In discussing how the internationalisation effort will affect the standards for Forth, in particular the ISO/IEC versions of the ANS standard, there is a high degree of concentration on the user view. The tendency for many programmers is to make the internal (machine view) a mirror of the user view. This can make the programmes very complex and difficult to adapt for an international audience.

This paper discusses the benefit of natural binary number representation for internal number manipulation. It also discusses conversion techniques, which properly scale the user representation. A concentration on Time, Date, Angles and Analogue Values will culminate in a small body of code examples.

Internationalisation – the user perspective

Stephen Pelc, Willem Botha, Nick Nelson, and Peter Knaggs

Internationalisation (or localisation) is becoming a major issue for several of MPE’s clients. These clients are of the opinion that the current ANS definitions of character related words are broken for multi-language use. In addition, in a world of 16 bit and multibyte character sets, the standard appears confused between characters and bytes.

Construction Computer Software (CCS) have 15 years experience of supporting multiple languages with Forth. Their software is used all over the world, and in languages for which Unicode support is not yet available. Coping with multibyte character sets must be included within an internationalisation system.

Micross Electronics have ported applications to run in Japanese and several European languages.

The word set presented here is based on a system that has been in use at CCS for many years.

Multiple Language Programs Made Easy

Howerd Oakford

A simple extension to the Forth compiler allows different language (English/Spanish/German) versions of the same program to be produced from identical source code. Word processor compatible translation files are used to allow translation of text messages by non-programmers.

Session 3:
Extensions: old and new words

PRELUDE Obejts and Methods with error checking

Klaus Schleisiek

state — Why it is Evil and How to Exorcise it

M. Anton Ertl

state-smart words provide a number of unpleasant surprises to their users. They are applied in two contexts, and they fail in both: 1) for providing an arbitrary combination of interpretation and compilation semantics; 2) for optimising with a special implementation of the compilation semantics. This paper discusses these issues and shows programmers and system implementers how to a void state-smart words. It also reports our experiences in converting the state-smart words in Gforth into a clean solution: little work and few problems.


Michael Milendorf

The CATCH and THROW exception handling mechanism (non-local or multilevel exit) is one of the most abstruse fundamental concepts to have been added to the Forth programming language as originally defined by C. Moore. At the same time the idea behind, and implementation of this mechanism is very elegant, and intrinsic to Forth. This mechanism is also easy to use if properly understood. This paper describes the history behind the discovery of CATCH and THROW, their implementation, syntax, semantics, and innovative methods to use them effectively in complex multi-layered Forth systems such as OpenFirmware.

PRELUDE and FINALE: Implicit context switching based on pre- and post-executed words

Manfred Mahlow

On the annual conference of the German Forth Association in 1997, I presented the "Prelude Concept", a simple but powerfull approach to early-bind methods to data. It´s simple enough to be applied to small microcontroller systems and powerfull enough to be useful for fat systems too. Since that time, the concept was used to implement extensions for context-oriented or object-oriented programming for several forth systems and based on that experience a more general concept of pre- and post-executed words evolved, that will be presented in this paper.

Session 4:
Virtual and concrete machines

Open Interpreter: Portability of Return Stack Manipulations

M. L. Gassanenko

To make the return stack manipulations portable, we introduce the notion of a stack machine with an open interpreter. The programming techniques, like implementation of new control structures via return stack manipulations, backtracking, and implementation techniques like keeping literals in the threaded code become portable across open interpreter Forths. The open interpreter approach may be used for distributed AI over a range of architectures.

Mite: a fast and flexible virtual machine

Reuben Thomas

Recent interest in virtual machines has been due mainly to the need to distribute executable content over the World Wide Web, where security and standardization are the key concerns. To fulfil the potential of distributed network computing virtual machines must be built into the OS kernel where speed and flexibility are of the essence. Mite is a virtual machine designed to allow optimising compilers to produce compact portable binaries which can be quickly translated at load-time into fast code. Its minimal core can be extended with support for language, machine or OS-specific features. Mite's design and current and planned implementation work are described, along with reasons why it should be of particular interest to Forth programmers.

DROM: Parallel Stack Core for Embedded Application

A. Tchepyjenko and K. Kazakevich

The DROM architecture is characterized by a high instruction level parallelism, the possibility to add specific peripheral modules and integration of dedicated application-specific execution units. It can be referred to a ML0 category on Koopman's classification. DROM improved Forth-like support. It can be used in different ASIC for embedded application.

Spiders & Forth

Jonathan Morrish

This paper describes the development of a small distributed system employing 8 pin microcontrollers (hence spiders) programmed in Forth.

The speed, low cost and ease of development of this system is described.

Session 5:
FORTH in the Battlefield

Certification of High Integrity Software

Paul E. Bennett and Malcolm Bugler

As software is employed in more and more applications for which Safety and/or security are major concerns, there is a growing demand by Notified and Regulatory Bodies that such software is certified for compliance with requirements, legislation, and standards. That certification can easily be applied to Forth source in a manner that will stand the scrutiny of close inspection and audit is to the benefit of the language. This paper describes the method of applying certification to Forth source code and describes some of the lessons learnt from its application to Forth software in a medical "life support" product.

A Grid Control in Forth

Nick J. Nelson

A grid control is the most common component required by Windows applications and which does not form part of the standard Windows API. In the past, I used the grid control from WinWidgets by Simple Software. This offered limited scope for customisation and is in any case no longer supported. There are numerous Active X grid controls available, but my preferred programming environment, MPE ProForth for Windows, together with its visual development tool, Guide, do not yet support Active X. I therefore decided to construct my own grid control DLL component, which is described in this paper. I hope to integrate this component into the Guide environment, and offer it as an accessory for future issues of ProForth.

MINOS-System Integration

Bernd Paysan

This paper presents the integration of MINOS—a toolkit for rapid application development of graphical user interfaces (GUI RAD) in Forth—into the system. Two main areas of interrest are data base query via SQL and integration of OpenGL. Other improvements of MINOS are also covered. This text blatantly contains parts that were already presented last time and on the last Forth Tagung in Moers.

A portable Forth optimising native code generator

Stephen Pelc

MPE has developed a native code generator and optimiser for Forth that has been ported to 386, H8/300H, 68xxx, and ARM targets. Considerable performance improvement over traditional subroutine threaded with inlining has been demonstrated. Code density is also improved.

The performance improvements will be shown in comparison with a range of Windows Forths.

[ Forth Research | euroFORTH | euroFORTH '98 ]