🚀 go-pugleaf

                       +-----------------------------+
                       | The Concurrent Clean System |
                       | --------------------------- |
                       | Version 0.8.1, October 1992 |
                       |                             |
                       |     Research Institute      |
                       |            for              |
                       |     Declarative Systems     |
                       |                             |
                       |   University of Nijmegen    |
                       |-----------------------------|
                       |   E-mail: clean@cs.kun.nl   |
                       +-----------------------------+


The Concurrent Clean system is a programming environment for the functional
language Concurrent Clean, developed at the University of Nijmegen, The
Netherlands. The system is one of the fastest implementations of functional
languages available at the moment. Its I/O libraries make it possible to do
modern, yet purely functional I/O (including windows, menus, dialogs etc.) in
Concurrent Clean. With the Concurrent Clean system it is possible to develop
real-life applications in a purely functional language.

Since October 1992 version 0.8.1 of the Concurrent Clean System is available via
anonymous FTP (ftp.cs.kun.nl (131.174.81.1) in the directory pub/Clean).
There are versions of the system for the Apple Macintosh as well as for Sun3 and
Sun4. This paper intends to describe exactly which parts of the Concurrent Clean
system version 0.8 are available on each machine. For the Mac also the minimum
configuration requirements are given. At the end the extensions and improvements
that will be released in the near future will be summed up.

When you have any questions about Concurrent Clean and/or the Concurrent Clean
system send us an e-mail (mail to clean@cs.kun.nl). Please send us your e-mail
address when you take a copy of the Concurrent Clean system such that we can
inform you about important changes and upgrades.

On special request our code generator for the Parsytec Supercluster transputer
rack can be obtained. Mail us when you are interested.


Concurrent Clean
----------------

Concurrent Clean is a lazy and purely functional programming language, based on
graph rewriting. The most important features of Concurrent Clean are:

- It is a strongly typed language. The type system is based on the Milner/
  Mycroft scheme, extended with unique types. It includes polymorphic types,
  abstract types, algebraic types and synonym types, as well as basic types.

- It has a module structure with a facility to explicitly and implicitly import
  definitions from other modules. There are libraries for basic operations on
  objects of basic types (integers, reals, strings etc.).

- Modern input/output handling (including menus, windows, dialogs and mouse
  handling) can be specified elegantly on a high level of abstraction. Thanks to
  the unique types the I/O handling remains purely functional.

- With annotations the evaluation order can be influenced by the programmer.
  Functions can be made (partially) eager instead of lazy.

- It is possible to split up the execution of a program in parts that are to be
  evaluated interleaved or in parallel.


Concurrent Clean on the Apple Macintosh
---------------------------------------

The Concurrent Clean System version 0.8 for the Macintosh runs on any Mac with
system 6.0 or higher, including system 7. To be able to use the system properly
at least 2 Mb of free memory is needed. When large applications are developed
more memory might be necessary (up to 3 Mb). So, when you want to use the
Concurrent Clean system under system 7 (which takes about 2 Mb), you need a Mac
with at least 4 Mb and possibly 5 Mb of internal memory. The complete system
(including documentation, interfaces and example programs) takes about 6 Mb of
harddisk space. The system has been tested on Mac Plus, Mac LC, all kinds of Mac
II's (from II to IIfx) and Quadra, under system 6 as well as system 7, with
different versions of the Finder. We have also tested the system on an Atari
computer from the ST line which was equipped with a Mac emulator (Spectre).

On the Apple Macintosh the Concurrent Clean system consists of the following
parts:

- A complete program development environment, following the Mac's user interface
  philosophy. This programming environment includes:

  - A text editor.
  - A project manager that checks and controls the consistency of all files,
    windows and options such that the compilation, code generation, linking,
    launching and simulation of Clean programs can be invoked with one command.
  - A compiler that translates Clean into (intermediate) PABC code.
  - A code generator/linker that generates proper Mac applications.
  - A PABC simulator/interpreter that makes it possible to simulate and trace
    the parallel execution of a Concurrent Clean program.
  - An on-line help facility that contains information about all aspects of the
    Concurrent Clean system for the Macintosh. The on-line help file can be
    printed. It can serve as a user's manual for the system.

- An I/O library that provides an interface with the Macintosh toolbox. This
  library makes it possible to write interactive programs on a very high level
  of abstraction, without losing the functional properties of the program. The
  I/O interface library contains primitives to handle menus, dialogues, windows,
  keyboard and mouse input and of course file I/O.

- An application (PABCstat) that can interpret the statistic files generated by
  the PABC simulator during simulation of a parallel Concurrent Clean program.
  With this application the execution can be traced and statistical information
  (parallelism, communication) can be displayed graphically.
  
- A set of example programs, including some larger projects that show the
  possibilities of Concurrent Clean's I/O interface.
  
- The Concurrent Clean version 0.8 language manual. This manual is distributed
  in MS Word format. It contains a complete overview of the syntax and semantics
  of the language Concurrent Clean and its predefined libraries.  


Concurrent Clean on Sun 3 and Sun 4
-----------------------------------

On the Sun's (both Sun3 and Sun4) no menu-driven, window-oriented programming
environment is available. Furthermore, no I/O libraries (except for file I/O)
are available yet. Lastly, no statistics application (for the post mortem trace
of parallel simulations) has been implemented for the Sun.
The Concurrent Clean system for Sun 3 & 4 consists of the following parts:

- A project manager that checks and controls the consistency of all files and
  options such that the compilation, code generation and linking of Clean
  programs can be invoked with one command.

- A compiler that translates Clean into (intermediate) PABC code.

- A code generator that produces MC68020 (Sun3) or Sparc (Sun4) assembly code.
  This code can be assembled and linked by the standard Unix assembler/linker.
  
- A PABC simulator/interpreter that makes it possible to simulate and trace the
  parallel execution of a Concurrent Clean program. The simulator/interpreter
  has its own command-line interface.
  
- A set of small example programs.

- Documentation that contains information about the installation and use of the
  Concurrent Clean system on Sun3/4. Manual pages for the make command are
  included. The simulator/interpreter has its own on-line help facility.
  
- The Concurrent Clean version 0.8 language manual, both in Macintosh MS Word
  format as well as in ASCII format.


The near future
---------------

Before the end of 1992 we plan to release:

- An I/O interface with X Windows / Open Look for the Sun4. The Macintosh
  version of the I/O interface will also be revised then, to become fully
  compatible with the Open Look version.

- A Miranda (trademark of Research Software Ltd.) interface for both the Mac
  and Sun versions. With this interface it will be possible to convert (simple)
  Miranda scripts into Clean modules.

- An improved linker that generates smaller applications for Mac and Sun4.

Probably we will also release:

- A code generator/linker for the Macintosh that is capable of generating
  applications that simulate parallel execution on a multi-processor machine.