home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #26 / NN_1992_26.iso / spool / comp / lang / function / 1336 < prev    next >
Encoding:
Text File  |  1992-11-07  |  8.7 KB  |  183 lines

  1. Newsgroups: comp.lang.functional
  2. Path: sparky!uunet!zaphod.mps.ohio-state.edu!sol.ctr.columbia.edu!ira.uka.de!math.fu-berlin.de!news.netmbx.de!Germany.EU.net!mcsun!sun4nl!wn1.sci.kun.nl!cs.kun.nl!ronny
  3. From: ronny@cs.kun.nl (Ron Wichers Schreur)
  4. Subject: Clean 0.8 Announcement
  5. Message-ID: <BxAF25.A3y@sci.kun.nl>
  6. Summary: Clean version 0.8 released
  7. Keywords: Clean, functional
  8. Sender: news@sci.kun.nl (NUnet News Owner)
  9. Organization: University of Nijmegen, The Netherlands
  10. Date: Fri, 6 Nov 1992 09:15:40 GMT
  11. Lines: 170
  12.  
  13.  
  14.  
  15.                        +-----------------------------+
  16.                        | The Concurrent Clean System |
  17.                        | --------------------------- |
  18.                        | Version 0.8.1, October 1992 |
  19.                        |                             |
  20.                        |     Research Institute      |
  21.                        |            for              |
  22.                        |     Declarative Systems     |
  23.                        |                             |
  24.                        |   University of Nijmegen    |
  25.                        |-----------------------------|
  26.                        |   E-mail: clean@cs.kun.nl   |
  27.                        +-----------------------------+
  28.  
  29.  
  30. The Concurrent Clean system is a programming environment for the functional
  31. language Concurrent Clean, developed at the University of Nijmegen, The
  32. Netherlands. The system is one of the fastest implementations of functional
  33. languages available at the moment. Its I/O libraries make it possible to do
  34. modern, yet purely functional I/O (including windows, menus, dialogs etc.) in
  35. Concurrent Clean. With the Concurrent Clean system it is possible to develop
  36. real-life applications in a purely functional language.
  37.  
  38. Since October 1992 version 0.8.1 of the Concurrent Clean System is available via
  39. anonymous FTP (ftp.cs.kun.nl (131.174.81.1) in the directory pub/Clean).
  40. There are versions of the system for the Apple Macintosh as well as for Sun3 and
  41. Sun4. This paper intends to describe exactly which parts of the Concurrent Clean
  42. system version 0.8 are available on each machine. For the Mac also the minimum
  43. configuration requirements are given. At the end the extensions and improvements
  44. that will be released in the near future will be summed up.
  45.  
  46. When you have any questions about Concurrent Clean and/or the Concurrent Clean
  47. system send us an e-mail (mail to clean@cs.kun.nl). Please send us your e-mail
  48. address when you take a copy of the Concurrent Clean system such that we can
  49. inform you about important changes and upgrades.
  50.  
  51. On special request our code generator for the Parsytec Supercluster transputer
  52. rack can be obtained. Mail us when you are interested.
  53.  
  54.  
  55. Concurrent Clean
  56. ----------------
  57.  
  58. Concurrent Clean is a lazy and purely functional programming language, based on
  59. graph rewriting. The most important features of Concurrent Clean are:
  60.  
  61. - It is a strongly typed language. The type system is based on the Milner/
  62.   Mycroft scheme, extended with unique types. It includes polymorphic types,
  63.   abstract types, algebraic types and synonym types, as well as basic types.
  64.  
  65. - It has a module structure with a facility to explicitly and implicitly import
  66.   definitions from other modules. There are libraries for basic operations on
  67.   objects of basic types (integers, reals, strings etc.).
  68.  
  69. - Modern input/output handling (including menus, windows, dialogs and mouse
  70.   handling) can be specified elegantly on a high level of abstraction. Thanks to
  71.   the unique types the I/O handling remains purely functional.
  72.  
  73. - With annotations the evaluation order can be influenced by the programmer.
  74.   Functions can be made (partially) eager instead of lazy.
  75.  
  76. - It is possible to split up the execution of a program in parts that are to be
  77.   evaluated interleaved or in parallel.
  78.  
  79.  
  80. Concurrent Clean on the Apple Macintosh
  81. ---------------------------------------
  82.  
  83. The Concurrent Clean System version 0.8 for the Macintosh runs on any Mac with
  84. system 6.0 or higher, including system 7. To be able to use the system properly
  85. at least 2 Mb of free memory is needed. When large applications are developed
  86. more memory might be necessary (up to 3 Mb). So, when you want to use the
  87. Concurrent Clean system under system 7 (which takes about 2 Mb), you need a Mac
  88. with at least 4 Mb and possibly 5 Mb of internal memory. The complete system
  89. (including documentation, interfaces and example programs) takes about 6 Mb of
  90. harddisk space. The system has been tested on Mac Plus, Mac LC, all kinds of Mac
  91. II's (from II to IIfx) and Quadra, under system 6 as well as system 7, with
  92. different versions of the Finder. We have also tested the system on an Atari
  93. computer from the ST line which was equipped with a Mac emulator (Spectre).
  94.  
  95. On the Apple Macintosh the Concurrent Clean system consists of the following
  96. parts:
  97.  
  98. - A complete program development environment, following the Mac's user interface
  99.   philosophy. This programming environment includes:
  100.  
  101.   - A text editor.
  102.   - A project manager that checks and controls the consistency of all files,
  103.     windows and options such that the compilation, code generation, linking,
  104.     launching and simulation of Clean programs can be invoked with one command.
  105.   - A compiler that translates Clean into (intermediate) PABC code.
  106.   - A code generator/linker that generates proper Mac applications.
  107.   - A PABC simulator/interpreter that makes it possible to simulate and trace
  108.     the parallel execution of a Concurrent Clean program.
  109.   - An on-line help facility that contains information about all aspects of the
  110.     Concurrent Clean system for the Macintosh. The on-line help file can be
  111.     printed. It can serve as a user's manual for the system.
  112.  
  113. - An I/O library that provides an interface with the Macintosh toolbox. This
  114.   library makes it possible to write interactive programs on a very high level
  115.   of abstraction, without losing the functional properties of the program. The
  116.   I/O interface library contains primitives to handle menus, dialogues, windows,
  117.   keyboard and mouse input and of course file I/O.
  118.  
  119. - An application (PABCstat) that can interpret the statistic files generated by
  120.   the PABC simulator during simulation of a parallel Concurrent Clean program.
  121.   With this application the execution can be traced and statistical information
  122.   (parallelism, communication) can be displayed graphically.
  123.   
  124. - A set of example programs, including some larger projects that show the
  125.   possibilities of Concurrent Clean's I/O interface.
  126.   
  127. - The Concurrent Clean version 0.8 language manual. This manual is distributed
  128.   in MS Word format. It contains a complete overview of the syntax and semantics
  129.   of the language Concurrent Clean and its predefined libraries.  
  130.  
  131.  
  132. Concurrent Clean on Sun 3 and Sun 4
  133. -----------------------------------
  134.  
  135. On the Sun's (both Sun3 and Sun4) no menu-driven, window-oriented programming
  136. environment is available. Furthermore, no I/O libraries (except for file I/O)
  137. are available yet. Lastly, no statistics application (for the post mortem trace
  138. of parallel simulations) has been implemented for the Sun.
  139. The Concurrent Clean system for Sun 3 & 4 consists of the following parts:
  140.  
  141. - A project manager that checks and controls the consistency of all files and
  142.   options such that the compilation, code generation and linking of Clean
  143.   programs can be invoked with one command.
  144.  
  145. - A compiler that translates Clean into (intermediate) PABC code.
  146.  
  147. - A code generator that produces MC68020 (Sun3) or Sparc (Sun4) assembly code.
  148.   This code can be assembled and linked by the standard Unix assembler/linker.
  149.   
  150. - A PABC simulator/interpreter that makes it possible to simulate and trace the
  151.   parallel execution of a Concurrent Clean program. The simulator/interpreter
  152.   has its own command-line interface.
  153.   
  154. - A set of small example programs.
  155.  
  156. - Documentation that contains information about the installation and use of the
  157.   Concurrent Clean system on Sun3/4. Manual pages for the make command are
  158.   included. The simulator/interpreter has its own on-line help facility.
  159.   
  160. - The Concurrent Clean version 0.8 language manual, both in Macintosh MS Word
  161.   format as well as in ASCII format.
  162.  
  163.  
  164. The near future
  165. ---------------
  166.  
  167. Before the end of 1992 we plan to release:
  168.  
  169. - An I/O interface with X Windows / Open Look for the Sun4. The Macintosh
  170.   version of the I/O interface will also be revised then, to become fully
  171.   compatible with the Open Look version.
  172.  
  173. - A Miranda (trademark of Research Software Ltd.) interface for both the Mac
  174.   and Sun versions. With this interface it will be possible to convert (simple)
  175.   Miranda scripts into Clean modules.
  176.  
  177. - An improved linker that generates smaller applications for Mac and Sun4.
  178.  
  179. Probably we will also release:
  180.  
  181. - A code generator/linker for the Macintosh that is capable of generating
  182.   applications that simulate parallel execution on a multi-processor machine.
  183.