Loglan 82, A micro-manual of the programming language - Basic constructs and facilities

1) Introduction

LOGLAN-82 is a universal programming language designed at the Institute of Informatics, University of Warsaw. Its syntax is patterned upon Pascal's. Its rich semantics includes the classical constructs and facilities offered by the Algol-family programming languages as well as more modern facilities, such as concurrency and exception handling.

The basic constructs and facilities of the LOGLAN-82 programming language include:

• A convenient set of structured statements,
• Modularity (with the possibility of module nesting and extending),
• Classes (as a generalization of records) which enable to define complex structured types, data structures, packages, etc.,
• Adjustable arrays whose bounds are determined at run-time in such a way that multidimensional arrays may be of various shapes, e.g. triangular, k-diagonal, streaked, etc.,
• Coroutines and semi-coroutines,
• Prefixing - the facility borrowed from Simula-67, substantially generalized in LOGLAN-82 - which enables to build up hierarchies of types and data structures, problem-oriented languages, etc.,
• Formal types treated as a method of module parametrization,
• Module protection and encapsulation techniques,
• Programmed deallocator - a tool for efficient and secure garbage collection, which allows the user to implement the optimal strategy of storage management,
• Exception handling which provides facilities for dealing with run-time errors and other exceptional situations raised by the user,
• Concurrency easily adaptable to any operating system kernel and allowing parallel programming in a natural and efficient way.

The language covers system programming, data processing, and numerical computations. Its constructs represent the state-of-art and are efficiently implementable. Large systems consisting of many cooperating modules are easily decomposed and assembled, due to the class concept and prefixing.

LOGLAN-82 constructs and facilities have appeared and evolved simultaneously with the experiments on the first pilot compiler (implemented on Mera-400 Polish minicomputer). The research on LOGLAN-82 implementation engendered with new algorithms for static semantics, context analysis, code generation, data structures for storage management etc.

The LOGLAN-82 compiler provides a keen analysis of syntactic and semantic errors at compilation as well as at run time. The object code is very efficient with respect to time and space. The completeness of error checking guarantees full security and ease of program debugging.