Short:        Threaded Interpretive Language Environ. V2.1
Author:       mip@ida.liu.se (Mikael R.K. Patel)
Type:         dev/ade
Version:      2.1
Architecture: m68k-amigaos
Origin:       Amiga Development Environment, ftp.ninemoons.com:pub/ade

TILE Forth is a 32-bit implementation of the Forth-83 Standard written
in C. Thus allowing it to be easily moved between different computers
compared to traditional Forth implementations in assembly.

Most Forth implementations are done in assembly to be able to utilize
the underlying architecture as optimal as possible. TILE Forth goes
another direction. The main idea behind TILE Forth is to achieve a
portable forth implementation for workstations and medium size
computer systems so that new groups of programmers may be exposed to
the flavor of an extensible language such as Forth.

The implementation of TILE Forth is selected so that, in principle,
any C-level procedure may become available on the interactive and
incremental forth level. Other models of implementation of a threaded
interpreter in C are possible but these are not as flexible.

TILE Forth is organized as a set of modules to allow the kernel to be
used as a general threading engine for C. Environment dependencies
such as memory allocation, error handling and input/output have been
separated out of the kernel to increase flexibility. The forth
application is "just" an example of how to use the kernel.

Comparing forth implementations using the traditional benchmarks such
as the classical sieves calculation is difficult because of the
difference in speed between workstations and personal computers. The
Byte sieves benchmark is reported to typically run in 16 seconds on a
direct threaded forth implementation. This benchmark will run in 17
seconds in TILE forth (compiled with GNU CC and optimized) on a
SUN-3/60 and less than 9 seconds on a SUN SPARCstation 1. These times
are the total time for loading TILE forth, compiling and executing the
benchmark. Comparing to, for instance, other interpretive languages
such as Lisp, where one of the classical benchmarks is calculation of
the Fibonacci function, the performance increase is over a magnitude.

The kernel supports the Standard Forth-83 word set except for the
blocks file word set which are not used. The kernel is extended with
many of the concepts from modern programming languages. Here is a list
of some of the extensions; argument binding and local variables, queue
management, low level compiler words, string functions, floating point
numbers, exceptions and multi-tasking. The TILE Forth environment also
contains a set of reusable source files for high level multi-tasking,
data description and structuring modules, and a number of programming
tools.

To allow interactive and incremental program development TILE Forth
includes a programming environment as a mode in GNU Emacs. This
environ- ment helps with program structuring, documentation search,
and program development. Each vocabulary in the kernel and the source
library file is described by a manual, documentation and test file.
This style of programming is emphasized throughout the environment to
increase understanding and reusability of the library modules. During
compilation TILE Forth's io-package keeps track for which modules have
been loaded so that they are only loaded once even if included by
several modules.

Writing a Forth in C gives some possibilities that normally are not
available when performing the same task in assembly. TILE Forth has
been profiled using the available tools under Unix. This information
has been used to optimize the compiler so that it achieves a
compilation speed of over 200.000 lines per minute on my machine (a
disk-less SUN SPARCstation 1). Currently code is only saved in source
form and applications are typically "compile-and-go".

So far TILE Forth has been ported and tested at over forty locations
without any major problems except where C compilers do not allow sub-
routine pointers in data structures.