[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Implementors of Scheme: Please read!

I have just completed an interpreter for R3 Scheme, as part of a
thesis project, with which I am fulfilling the requirements for
the degree of "Engineer in Computer Science" from ETH, the Swiss
Federal Institute of Technology in Zurich.  ETH's Engineer's degree
is similar to a U.S. Master's degree in Computer Science.

My interpreter is written in the programming language Oberon and is
designed to run on the Ceres workstation under the Oberon Operating

The Ceres workstation, Oberon operating system and the Oberon
language (the successor to Modula-2) were all developed here at ETH
by Professor Niklaus Wirth, who also oversees my thesis.  The Ceres
line of computers is based on NS32000 series microprocessors.
Oberon is similar to Modula-2, but offers the concept of "type
  [N. Wirth, "Type Extensions", ACM TOPLAS V10 N2 Apr88, pp204-214]
  [N. Wirth, "The Programming Language Oberon", Software, Practice
              and Experience, V18 N7 Jul88, pp671-690]

The main goal of my thesis was less to develop an efficient
implementation of Scheme than to evaluate different strategies for
implementing a functional language **in a Modula-like-language and
without using any machine-specific tricks**.  There is very little
experience with functional language programming at ETH, being the
original source of languages such as Pascal and Modula.

The result of my programming project is an interpreter entirely
written in Oberon (which by the way does not offer a GOTO, so the
program needs a very ugly dispatch function), which should be
easily portable to any other machine on which a compiler for either
Oberon or Modula is available.  (Actually, I implemented Scheme
three times, using different approaches.)

As part of my thesis, I would like to include a small survey about
existing Scheme **interpreter** implementations on microprocessors
and would like to ask you to send me a short reply to the following
questions.  (I do realize, that most implementations of Scheme are
compilers that either generate native code or some kind of interpre-
ted intermediate code, but these are not really comparable to my
work, which is a true interpreter and does not process instructions 
prior to execution (apart from lexical conversion).  Please only
answer if you can comment on an existing **interpreter**.


 1.1.  Name of Project/Program
 1.2.  Based On  or  New Work
 1.3.  Implementation Language
 1.4.  Destination Processor / Word Length
 1.5.  Are any parts of the program coded in assembly language?
 1.6.  Amount of memory available to the interpreter for data storage
 1.7.  Garbage collection strategy used
 1.8.  Source Code / Object Size (lines/bytes) of Scheme Interpreter

 2.1. Time to execute (fib 20) with body of fib defined as
      (cond ((< n 2) n) (else (+ (fib (- n 2)) (fib (- n 1)))))
 2.2. Time to execute (fib 20) using IF instead of COND
 2.3. Time to execute (tak 18 12 6) with (tak x y z) defined as
      (cond ((<= x y) z)
            (else (tak (tak (- x 1) y z)
                       (tak (- y 1) z x)
                       (tak (- z 1) x y))))

Also, if you have any Scheme programs that I could use for testing my
interpreter, I would also be grateful if you could send them to me.

Thank you very much.  I greatly appreciate your help.

Michael Franz
  mfranz@ifi.ethz.ch   and   mfranz@rzeth.ethz.ch

P.S.:  I have been trying to get a copy of R. Kent Dybvigs Ph.D.
dissertation (unfortunately, I only saw the reference to it way after
I had started on my own set of implementation models), but no library
that I have access to seems to have it.  If anyone could make a copy
and send it to me, please notify me by E-mail; I will send you a my
complete postal address and a check to cover copying and postage.
Please send me a mail before you copy anything, because there may be
more than one person who can help me with this one (who knows, even R.K.D.