home *** CD-ROM | disk | FTP | other *** search
/ RISC DISC 2 / RISC_DISC_2.iso / pd_share / program / language / scm / FAQs / SCMFAQ1 next >
Encoding:
Text File  |  1994-08-06  |  47.9 KB  |  1,002 lines
  1. Newsgroups: comp.lang.scheme,comp.lang.lisp,news.answers,comp.answers
  2. Path: bloom-beacon.mit.edu!grapevine.lcs.mit.edu!olivea!charnel.ecst.csuchico.edu!yeshua.marcam.com!MathWorks.Com!news2.near.net!das-news.harvard.edu!honeydew.srv.cs.cmu.edu!mkant
  3. From: mkant+@cs.cmu.edu (Mark Kantrowitz)
  4. Subject: FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]
  5. Message-ID: <SCHEME_1_774082827@CS.CMU.EDU>
  6. Followup-To: poster
  7. Sender: news@cs.cmu.edu (Usenet News System)
  8. Supersedes: <SCHEME_1_771490829@CS.CMU.EDU>
  9. Nntp-Posting-Host: glinda.oz.cs.cmu.edu
  10. Reply-To: lisp-faq@think.com
  11. Organization: School of Computer Science, Carnegie Mellon
  12. Date: Wed, 13 Jul 1994 07:06:45 GMT
  13. Approved: news-answers-request@MIT.Edu
  14. Expires: Wed, 24 Aug 1994 07:00:27 GMT
  15. Lines: 984
  16. Xref: bloom-beacon.mit.edu comp.lang.scheme:4208 comp.lang.lisp:5288 news.answers:22378 comp.answers:6266
  17.  
  18. Archive-name: scheme-faq/part1
  19. Last-Modified: Fri May 27 12:16:49 1994 by Mark Kantrowitz
  20. Version: 1.14
  21.  
  22. ;;; ****************************************************************
  23. ;;; Answers to Frequently Asked Questions about Scheme *************
  24. ;;; ****************************************************************
  25. ;;; Written by Mark Kantrowitz and Barry Margolin
  26. ;;; scheme_1.faq -- 48890 bytes
  27.  
  28. This post contains part 1 of the Scheme FAQ.
  29.  
  30. If you think of questions that are appropriate for this FAQ, or would
  31. like to improve an answer, please send email to us at lisp-faq@think.com.
  32.  
  33. Note that the lisp-faq mailing list is for discussion of the content
  34. of the FAQ posting only.  It is not the place to ask questions about Scheme;
  35. use either the scheme@ai.mit.edu mailing list, the comp.lang.scheme
  36. newsgroup or the Scheme Digest (scheme@mc.lcs.mit.edu) for that. If a
  37. question appears frequently in one of those forums, it will get added
  38. to the FAQ list. 
  39.  
  40. *** Copyright:
  41.  
  42. Copyright (c) 1993-94 by Mark Kantrowitz and Barry Margolin. 
  43. All rights reserved. 
  44.  
  45. This FAQ may be freely redistributed in its entirety without
  46. modification provided that this copyright notice is not removed.  It
  47. may not be sold for profit or incorporated in commercial documents
  48. (e.g., published for sale on CD-ROM, floppy disks, books, magazines,
  49. or other print form) without the prior written permission of the
  50. copyright holder.  Permission is expressly granted for this document
  51. to be made available for file transfer from installations offering
  52. unrestricted anonymous file transfer on the Internet.
  53.  
  54. This article is provided AS IS without any express or implied warranty.
  55.  
  56. *** Topics Covered:
  57.  
  58. Topics Covered (Part 1):
  59.   [1-0]   What is the purpose of this newsgroup?
  60.   [1-2]   What is the difference between Scheme and Common Lisp?
  61.   [1-3]   Scheme books, introductions, documentation, periodicals,
  62.           journals, and conference proceedings. 
  63.   [1-4]   Where can I learn about implementing Scheme interpreters and 
  64.           compilers?
  65.   [1-7]   Standards for Scheme -- What are R4RS and IEEE P1178?
  66.   [1-8]   How do I do object-oriented programming in Scheme?
  67.   [1-9]   Repositories of Scheme Software
  68.   [1-10]  Publicly Redistributable Scheme Software
  69.   [1-11]  Formatting code in LaTeX (WEB and other literate programming tools)
  70.   [1-12]  Where can I get an implementation of Prolog in Scheme?
  71.   [1-13]  What does SICP, SCOOPS, R4RS, CAR, CDR, ... mean?
  72.   [1-14]  Why is there no EVAL in Scheme?
  73.   [1-15]  World-Wide Web (WWW) Resources
  74.   [1-16]  Why is Scheme called 'Scheme'?
  75.  
  76. Topics Covered (Part 2):
  77.   [2-1]   Free Scheme implementations.
  78.   [2-2]   Commercial Scheme implementations.
  79.   [2-3]   What Scheme-related discussion groups and mailing lists exist?
  80.  
  81. Search for \[#\] to get to question number # quickly.
  82.  
  83. *** Recent Changes:
  84.  
  85. ;;; 1.13:
  86. ;;; 15-APR-94 mk    Replaced cs.indiana.edu with ftp.cs.indiana.edu 
  87. ;;; 12-MAY-94 mk    Added entry on libscheme to [2-1].
  88. ;;; 12-MAY-94 mk    SIOD v3.0 now available.
  89. ;;; 12-MAY-94 mk    Added entry on Andrew Wright's Soft Scheme type system.
  90. ;;;
  91. ;;; 1.14:
  92. ;;; 27-MAY-94 mk    Added ChezSybase to [1-10].
  93. ;;; 12-JUN-94 mk    New version of STk.
  94. ;;;
  95. ;;; 1.15
  96. ;;; 15-JUN-94 mk    Moved STk to the free Scheme implementations list.
  97. ;;; 15-JUN-94 mk    Alphabetized the free scheme implementations.
  98. ;;; 15-JUN-94 mk    Alphabetized the commercial Scheme implementations.
  99. ;;;  7-JUL-94 mk    Changed "http://martigny..." to "http://www-swiss..." in
  100. ;;;                 [1-15], per Jonathan Rees.
  101. ;;;  8-JUL-94 mk    Updated PC-Scheme entry; added Ibuki PC-Scheme entry.
  102. ;;;  8-JUL-94 mk    Added HTML version of R4RS.
  103.  
  104.  
  105. *** Introduction:
  106.  
  107. Certain questions and topics come up frequently in the various network
  108. discussion groups devoted to and related to Scheme.  This file/article is
  109. an attempt to gather these questions and their answers into a convenient
  110. reference for Scheme programmers.  It (or a reference to it) is posted
  111. periodically.  The hope is that this will cut down on the user time and
  112. network bandwidth used to post, read and respond to the same questions
  113. over and over, as well as providing education by answering questions
  114. some readers may not even have thought to ask.
  115.  
  116. This is not a Scheme tutorial, nor is it an exhaustive list of all Scheme
  117. intricacies.  Scheme is a very powerful and expressive language, but with
  118. that power comes many complexities.  This list attempts to address the
  119. ones that average Scheme programmers are likely to encounter.  If you are
  120. new to Scheme, see the answer to the question "How can I learn
  121. Scheme?" [1-3].
  122.  
  123. The latest version of this file is available via anonymous FTP from CMU
  124. and Thinking Machines: 
  125.  
  126.    To obtain the files from CMU, connect by anonymous FTP to 
  127.       ftp.cs.cmu.edu:/user/ai/pubs/faqs/scheme/  [128.2.206.173]
  128.    using username "anonymous" and password "name@host" (substitute your
  129.    email address) or via AFS in the Andrew File System directory
  130.       /afs/cs.cmu.edu/project/ai-repository/ai/pubs/faqs/scheme/
  131.    and get the files scheme_1.faq and scheme_2.faq.
  132.  
  133.    To obtain the files from Thinking Machines, connect by anonymous FTP to
  134.       ftp.think.com:/public/think/lisp/
  135.    The file scheme-faq.text containse the latest version of the Scheme
  136.    FAQ. In addition, specific versions of the FAQ are available as
  137.    scheme-faq-<version>.text. 
  138.  
  139. You can also obtain a copy of the FAQ by sending a message to
  140. ai+query@cs.cmu.edu with 
  141.    Send Scheme FAQ
  142. in the message body.
  143.  
  144. An automatically generated HTML version of the Scheme FAQ is accessible by
  145. WWW as part of the AI-related FAQs Mosaic page. The URL for this
  146. resource is
  147.    http://www.cs.cmu.edu:8001/Web/Groups/AI/html/faqs/top.html
  148. The direct URL for the Lisp FAQ is
  149.    http://www.cs.cmu.edu:8001/Web/Groups/AI/html/faqs/lang/scheme/top.html
  150.  
  151. We've tried to minimize the overlap with the FAQ postings to the
  152. comp.lang.lisp, comp.lang.clos and comp.ai newsgroups, so if you don't
  153. find what you're looking for here, we suggest you try the FAQs for
  154. those newsgroups. These FAQs should be available by anonymous ftp from
  155.    rtfm.mit.edu:/pub/usenet/news.answers/ [18.181.0.24]
  156. in the lisp-faq/, ai-faq/ and scheme-faq/ subdirectories or by email.
  157. For instructions on email retrieval, send a mail message to
  158. mail-server@rtfm.mit.edu with "help" and "index" on separate lines in
  159. the body of the message.
  160.  
  161. If you need to cite the FAQ for some reason, use the following format:
  162.    Mark Kantrowitz and Barry Margolin, "Answers to Frequently Asked
  163.    Questions about Scheme", comp.lang.scheme, <month>, <year>,
  164.    ftp.cs.cmu.edu:/user/ai/pubs/faqs/scheme/scheme_?.faq, lisp-faq@think.com.
  165.  
  166. ----------------------------------------------------------------
  167. Subject: [1-0] What is the purpose of this newsgroup?
  168.  
  169. The newsgroup comp.lang.scheme exists for general discussion of
  170. topics related to the programming language Scheme. For example, possible
  171. topics can include (but are not necessarily limited to):
  172.    announcements of Scheme books and products
  173.    discussion of programs and utilities written in Scheme
  174.    discussion of portability issues
  175.    questions about possible bugs in Scheme implementations
  176.    problems porting an implementation to some architecture
  177. Postings should be of general interest to the Scheme community. See also
  178. question [2-3].
  179.  
  180. Questions about Common Lisp should be directed to the newsgroup
  181. comp.lang.lisp.  Discussion of object oriented programming in Lisp to
  182. the newsgroup comp.lang.clos. Discussion of functional programming
  183. language issues in general should be directed to the newsgroup
  184. comp.lang.functional.  Discussion of AI programs implemented in Scheme
  185. should sometimes be cross-posted to the newsgroup comp.ai.
  186.  
  187. ----------------------------------------------------------------
  188. Subject: [1-2] What is the difference between Scheme and Common Lisp?
  189.  
  190. Scheme is a dialect of Lisp that stresses conceptual elegance and
  191. simplicity. It is specified in R4RS and IEEE standard P1178. (See
  192. question [1-7] for details on standards for Scheme.) Scheme is much
  193. smaller than Common Lisp; the specification is about 50 pages,
  194. compared to Common Lisp's 1300 page draft standard. (See the Lisp FAQ
  195. for details on standards for Common Lisp.) Advocates of Scheme often
  196. find it amusing that the entire Scheme standard is shorter than the
  197. index to Guy Steele's "Common Lisp: the Language, 2nd Edition".
  198.  
  199. Scheme is often used in computer science curricula and programming
  200. language research, due to its ability to represent many programming
  201. abstractions with its simple primitives. Common Lisp is often used for
  202. real world programming because of its large library of utility
  203. functions, a standard object-oriented programming facility (CLOS), and
  204. a sophisticated condition handling system.
  205.  
  206. See question [1-8] for information about object-oriented programming
  207. in Scheme. 
  208.  
  209. In Common Lisp, a simple program would look something like the
  210. following:
  211.  
  212.    (defun fact (n)
  213.      (if (< n 2)
  214.          1
  215.          (* n (fact (1- n)))))
  216.  
  217. In Scheme, the equivalent program would like like this:
  218.  
  219.    (define fact
  220.      (lambda (n)
  221.        (if (< n 2)
  222.            1
  223.          (* n (fact (- n 1))))))
  224.  
  225. Experienced Lisp programmers might write this program as follows in order
  226. to allow it to run in constant space:
  227.  
  228.    (defun fact (n)
  229.      (labels ((tail-recursive-fact (counter accumulator)
  230.                 (if (> counter n)
  231.                     accumulator
  232.                     (tail-recursive-fact (1+ counter)
  233.                                          (* counter accumulator)))))
  234.        (tail-recursive-fact 1 1)))
  235.  
  236. Whereas in Scheme the same computation could be written as follows:
  237.  
  238.    (define fact
  239.      (lambda (n)
  240.        (letrec ((tail-recursive-fact
  241.                  (lambda (counter accumulator)
  242.                    (if (> counter n)
  243.                        accumulator
  244.                      (tail-recursive-fact (+ counter 1)
  245.                                           (* counter accumulator))))))
  246.                (tail-recursive-fact 1 1))))
  247.  
  248. or perhaps (using IEEE named LETs):
  249.  
  250.    (define fact
  251.      (lambda (n)
  252.        (let loop ((counter n)
  253.                   (accumulator 1))
  254.             (if (< counter 2)
  255.                 accumulator
  256.               (loop (- counter 1)
  257.                     (* accumulator counter))))))
  258.  
  259. Some Schemes allow one to use the syntax (define (fact n) ...) instead
  260. of (define fact (lambda (n) ...)).
  261.  
  262. ----------------------------------------------------------------
  263. Subject: [1-3] Scheme books, introductions, documentation, periodicals, 
  264.                journals, and conference proceedings.
  265.  
  266. Introductions to Scheme:
  267.  
  268.    The following four books from MIT Press are listed in order of
  269.    increasing difficulty. The first is good for the complete novice,
  270.    the second for students with little or no previous exposure to programming,
  271.    and the third and fourth for more advanced students. The third and
  272.    fourth may also be used to learn a variety of powerful programming
  273.    language concepts. One of these books will suit your needs.
  274.  
  275.    1. Daniel P. Friedman and M. Felleisen.
  276.       "The Little LISPer"
  277.       MIT Press (Cambridge, MA), 3rd printing, 1989. ISBN 0-262-56038-0.
  278.       Science Research Associates (Chicago), 3rd ed, 1989. 206 pages.
  279.  
  280.       Good for a quick introduction. Uses Scheme instead of Common Lisp.
  281.       (The book uses a dialect of Scheme with footnotes about translating to
  282.       Scheme or Common Lisp. The footnotes won't allow a non-expert to use
  283.       Common Lisp for the advanced chapters because of the complexity.)
  284.  
  285.    2. Brian Harvey and Matthew Wright
  286.       "Simply Scheme: Introducing Computer Science"
  287.       MIT Press, Cambridge, MA, 1994. 583 pages. 
  288.       ISBN 0-262-08226-8. $49.95.
  289.  
  290.       This book is ideal for students with little or no previous exposure to
  291.       programming. The book is designed to be used before SICP (the authors
  292.       call it a SICP "prequel"), and makes Scheme fun by sheltering the
  293.       students from potentially confusing technical details. Unlike Pascal
  294.       or C, the emphasis is on ideas, not obscure matters of syntax and
  295.       arbitrary rules of style.  High schools who have shied away from using
  296.       Scheme because they found SICP to be too challenging should consider
  297.       using this book instead.
  298.  
  299.       The text gradually and gently introduces students to some of the key
  300.       concepts of programming in Scheme. It starts off with functions and
  301.       function composition and continues with the notion of functions as
  302.       data (first-class functions) and programs that write programs
  303.       (higher-order functions).  Since the complexity of the language is
  304.       hidden, students can get involved in some of the more interesting and
  305.       fun aspects of the language earlier than in other texts.  Then the
  306.       book progresses through the more complicated concepts of lambda,
  307.       recursion, data abstraction and procedural abstraction, and concludes
  308.       with sequential techniques, but with careful attention to topics
  309.       students often find difficult.  There are five chapters on recursion
  310.       alone! There's also a pitfalls section at the end of most chapters to
  311.       help students recognize and avoid common errors.
  312.  
  313.       The book uses several programs as examples, including a tic-tac-toe
  314.       program, a pattern matcher, a miniature spreadsheet, and a simple
  315.       database program.  Source code for the programs is available by
  316.       anonymous ftp from anarres.cs.berkeley.edu:/pub/scheme/, or for $10 on
  317.       IBM or Macintosh diskettes from the publisher.
  318.  
  319.    3. Harold Abelson and Gerald Jay Sussman, with Julie Sussman.
  320.       "Structure and Interpretation of Computer Programs"
  321.       MIT Press (Cambridge, MA) and McGraw-Hill (New York), 1985.
  322.       542 pages. ISBN 0-262-01077-1, $55. The teacher's manual, which is
  323.       also available from MIT Press (ISBN 0-262-51046-4 $20), does NOT
  324.       contain solutions to the exercises, but does contain hints on
  325.       teaching with the book. 
  326.  
  327.       Starts off introductory, but rapidly gets into powerful
  328.       Lisp-particular constructs, such as using closures and engines,
  329.       building interpreters, compilers and object-oriented systems.  Often
  330.       referred to by its acronym, SICP, which is pronounced "Sick-Pee". This
  331.       is the classical text for teaching program design using Scheme,
  332.       and everybody should read it at least once. MIT problem sets are
  333.       available from the repositories, and materials from Gustavus
  334.       Adolphus College are available from ftp.gac.edu:/pub/SICP/. 
  335.  
  336.    4. George Springer and Daniel P. Friedman
  337.       "Scheme and the Art of Programming" 
  338.       MIT Press and McGraw Hill, 1990, 596 pages.
  339.       ISBN 0-262-19288-8, $50.
  340.  
  341.       Introduces basic concepts of programming in Scheme. Also deals with
  342.       object oriented programming, co-routining, continuations.  Gives
  343.       numerous examples. Has more of an emphasis on teaching Scheme than
  344.       SICP, and can be seen as an alternative to SICP.  Source code from the
  345.       chapters is available from 
  346.           ftp.cs.indiana.edu:/pub/scheme-repository/lit/sap/
  347.  
  348. Older Introductions to Scheme:
  349.  
  350.    1. Smith, Jerry D.
  351.       "Introduction to Scheme"
  352.        Prentice Hall (Englewood Cliffs, NJ), 1988, 324 pages.
  353.            Focuses on PC Scheme.
  354.  
  355.    2. Michael Eisenberg 
  356.       "Programming in Scheme"
  357.       Scientific Press (Redwood City, CA), 1988. 304 pages.
  358.  
  359.    3. Two articles in BYTE Magazine, February 1988, by Abelson and
  360.       Sussman, and Clinger.
  361.  
  362. Online Introductions to Scheme:
  363.  
  364.    1. The Ken Dickey article, "The Scheme Programming Language", in
  365.       COMPUTER LANGUAGES magazine, June 1992, is available from the
  366.       Scheme Repository at 
  367.           ftp.cs.indiana.edu:/pub/scheme-repository/txt/intro.txt
  368.       The Revised^4 Report on the Algorithmic Language Scheme is also 
  369.       available from the Scheme Repository.
  370.  
  371.    2. The Info files from the MIT Scheme implementation.
  372.  
  373.    3. "Introductory Scheme" by Joseph W. Lavinus and James D. Arthur,
  374.        <lavinus@virginia.edu>. Available from the Lisp Utilities
  375.        Repository as ftp.cs.cmu.edu:/user/ai/lang/scheme/doc/intro/ 
  376.        as schemedoc.tar.gz.
  377.  
  378. Scheme and Artificial Intelligence:
  379.  
  380.    1. Wolfgang Kreutzer and Bruce McKenzie
  381.       "Programming for Artificial Intelligence: 
  382.        Methods, Tools and Applications"
  383.       Addison-Wesley (Reading, MA), 1990. 682 pages. 
  384.       ISBN 0-201-41621-2.
  385.            Discusses Scheme, Prolog, and Smalltalk, gives an overview of
  386.            the history and philosophy of AI, surveys three major
  387.            programming paradigms (procedural, declarative, and
  388.            object-oriented), and metaphors to AI programming.
  389.            Source code from the chapters is available from 
  390.               ftp.cs.indiana.edu:/pub/scheme-repository/lit/
  391.            as aibook.tar.Z. Some of the programs will only run under MacScheme.
  392.  
  393. General Scheme reference books include:
  394.  
  395.    1. K. Dybvig
  396.       "The Scheme programming language"
  397.       Prentice Hall, 1987.
  398.          Good reference for Scheme.
  399.  
  400. Scheme-related periodicals include:
  401.         
  402.    1. LISP Pointers.
  403.       Published by ACM SIGPLAN six times a year. Volume 1, Number 1
  404.       was April-May 1987. 
  405.       Subscriptions: ACM Members $12; ACM Student Members $7; Non-ACM
  406.       members $25. Mail checks payable to the ACM to ACM Inc., PO Box
  407.       12115, Church Street Station, New York, NY 10249.
  408.  
  409.    2. LISP and Symbolic Computation, Kluwer Academic Press. Volume 1
  410.       was published in 1989. (jlz@lucid.com is the editor).  ISSN 0892-4635.
  411.       Subscriptions: Institutions $169; Individuals $80. Add $8 for
  412.       air mail. Kluwer Academic Publishers, PO Box 322, 3300 AH Dordrecht, 
  413.       The Netherlands, or Kluwer Academic Publishers, PO Box 358, Accord
  414.       Station, Hingham, MA 02018-0358. 
  415.  
  416.    3. Proceedings of the biannual ACM Lisp and Functional Programming
  417.       Conference. (First one was in 1980.)
  418.  
  419.    4. Proceedings of the annual Lisp Users and Vendors Conference.
  420.  
  421. See also the Scheme Bibliography from the Scheme Repository
  422. (ftp.cs.indiana.edu:/pub/scheme-repository/) for additional readings.
  423. A large number of technical reports on Scheme are now available in the
  424. text section (ftp.cs.indiana.edu:/pub/scheme-repository/txt/).
  425.  
  426. ----------------------------------------------------------------
  427. Subject: [1-4] Where can I learn about implementing Scheme interpreters  
  428.                and compilers?
  429.  
  430. There is no single book that is really comprehensive, so you will have
  431. to combine reading the sources to the various free implementations
  432. (e.g., Gambit [Feeley] and S48 [Rees]) with bits and pieces of tech
  433. reports and various books.
  434.  
  435. Books about Scheme implementation include:
  436.  
  437.    1. John Allen
  438.       "Anatomy of Lisp"
  439.       McGraw-Hill, 1978. 446 pages. ISBN 0-07-001115-X
  440.  
  441.    2. Samuel Kamin
  442.       "Programming Languages, An Interpreter-Based Approach"
  443.       Addison-Wesley, Reading, Mass., 1990. ISBN 0-201-06824-9
  444.            Includes sources to several interpreters for Lisp-like
  445.            languages, and a pointer to sources via anonymous ftp.
  446.  
  447.    3. Sharam Hekmatpour
  448.       "Lisp: A Portable Implementation"
  449.       Prentice Hall, 1985. ISBN 0-13-537490-X.
  450.            Describes a portable implementation of a small dynamic
  451.            Lisp interpreter (including C source code). 
  452.  
  453.    4. Peter Henderson
  454.       "Functional Programming: Application and Implementation"
  455.       Prentice-Hall (Englewood Cliffs, NJ), 1980. 355 pages.
  456.  
  457.    5. Peter M. Kogge
  458.       "The Architecture of Symbolic Computers"
  459.       McGraw-Hill, 1991. ISBN 0-07-035596-7.
  460.            Includes sections on memory management, the SECD and
  461.            Warren Abstract Machines, and overviews of the various
  462.            Lisp Machine architectures.
  463.    
  464.    6. Daniel P. Friedman, Mitchell Wand, and Christopher T. Haynes
  465.       "Essentials of Programming Languages"
  466.       MIT Press, 1992, 536 pages. ISBN 0-262-06145-7, $55.
  467.            Teaches fundamental concepts of programming language
  468.            design by using small interpreters as examples. Covers
  469.            most of the features of Scheme. Includes a discussion
  470.            of parameter passing techniques, object oriented languages,
  471.            and techniques for transforming interpreters to allow
  472.            their implementation in terms of any low-level language.
  473.            Also discusses scanners, parsers, and the derivation of
  474.            a compiler and virtual machine from an interpreter.
  475.            Source files available by anonymous ftp from 
  476.               ftp.cs.indiana.edu:/pub/eopl/ (129.79.254.191) or from the
  477.            Scheme Repository.
  478.  
  479.    7. Peter Lee, editor, "Topics in Advanced Language Implementation",
  480.       The MIT Press, Cambridge, Mass., 1991.
  481.            Articles relevant to the implementation of functional
  482.            programming languages.
  483.  
  484.    8. Also see the proceedings of the biannual ACM Lisp and Functional
  485.       Programming conferences, the implementation notes for CMU Common Lisp,
  486.       Peter Norvig's book ("Paradigms of AI Programming: Case Studies
  487.       in Common Lisp", Morgan Kaufmann, 1992. 946 pages. ISBN
  488.       1-55860-191-0), and SICP (Abelson & Sussman). 
  489.  
  490. Technical reports and journal articles about Scheme implementation include:
  491.  
  492.    Mitchell Wand and Daniel P. Friedman, "Compiling Lambda Expressions
  493.    Using Continuations and Factorizations", Journal of Computer Languages
  494.    3(1978), 241-263.
  495.  
  496.    Guy Lewis Steele Jr., "Rabbit: A Compiler for Scheme", MIT AI Memo
  497.    474, Massachusetts Institute of Technology, Cambridge, MA, May 1978.
  498.  
  499.    Guy Lewis Steele Jr., "Compiler Optimization Based on Viewing LAMBDA
  500.    as RENAME + GOTO", in "Artificial Intelligence: An MIT Perspective",
  501.    Patrick Henry Winston and Richard Henry Brown (eds.), MIT Press,
  502.    Cambridge, MA, 1980.
  503.  
  504.    Jonathan A. Rees and Norman I. Adams, "T: A Dialect of Lisp or,
  505.    LAMBDA: The Ultimate Software Tool", Conference Record of the 1982 ACM
  506.    Symposium on Lisp and Functional Programming, 1982, 114-122.
  507.  
  508.    R. Kent Dybvig, "C-Scheme", Computer Science Department Technical
  509.    Report #149 (MS Thesis), Indiana University, Bloomington, IA, 1983.
  510.  
  511.    William Clinger, "The Scheme 311 compiler: An Exercise in Denotational
  512.    Semantics", Conference Record of the 1984 ACM Symposium on Lisp and
  513.    Functional Programming, 1984, 356-364.
  514.  
  515.    Guillermo J. Rozas, "Liar, an Algol-like Compiler for Scheme", S.B.
  516.    Thesis, Department of Electrical Engineering and Computer Science,
  517.    Massachusetts Institute of Technology, January 1984.
  518.  
  519.    David H. Bartley and John C. Jensen, "The Implementation of PC
  520.    Scheme", Proceedings of the 1986 ACM Conference on Lisp and Functional
  521.    Programming, 1986, 86-93.
  522.  
  523.    David Kranz, Richard Kelsey, Jonathan A. Rees, Paul Hudak, James
  524.    Philbin and Norman I. Adams, "Orbit: An Optimizing Compiler for
  525.    Scheme", Proceedings of the SIGPLAN Notices '86 Symposium on Compiler
  526.    Construction, June 1986, 219-233.  Published as SIGPLAN Notices 21(7),
  527.    July 1986.
  528.  
  529.    Marc Feeley, "Deux Approches a' L'implantation du Language Scheme",
  530.    M.Sc. Thesis, De'partement d'Informatique et de Recherche
  531.    Ope'rationelle, University of Montreal, May 1986.
  532.  
  533.    R. Kent Dybvig, "Three Implementation Models for Scheme", Department
  534.    of Computer Science Technical Report #87-011 (Ph.D. Dissertation),
  535.    University of North Carolina at Chapel Hill, Chapel Hill, North
  536.    Carolina, April 1987.
  537.  
  538.    William D. Clinger, Anne H. Hartheimer and Eric M. Ost,
  539.    "Implementation Strategies for Continuations", Conference Record of
  540.    the 1988 ACM Conference on Lisp and Functional Programming, August
  541.    1988, 124-131.
  542.  
  543.    David Kranz, "Orbit: An Optimizing Compiler for Scheme", Computer
  544.    Science Technical report #632 (Ph.D. Dissertation), Yale University,
  545.    1988.
  546.  
  547.    Joel F. Bartlett, "SCHEME->C a Portable Scheme-to-C Compiler",
  548.    Research Report 89/1, Dec. Western Research Laboratory, Palo Alto, CA,
  549.    January 1989.
  550.  
  551.    Marc Feeley and James S. Miller, "A Parallel Virtual Machine for
  552.    Efficient Scheme Compilation", Proceedings of the 1990 ACM Conference
  553.    on Lisp and Functional Programming, Nice, France, June 1990.
  554.  
  555.    Chris Hanson, "Efficient Stack Allocation for Tail-Recursive
  556.    Languages", Proceedings of the 1990 ACM Conference on Lisp and
  557.    Functional Programming, Nice, France, June 1990.
  558.  
  559.    Robert Hieb, R. Kent Dybvig and Carl Bruggeman, "Representing Control
  560.    in the Presence of First-Class Continuations", Proceedings of the
  561.    SIGPLAN Notices '90 Conference on Programming Language Design and
  562.    Implementation, White Plains, New York, June 1990, 66-77.
  563.  
  564.    Guillermo Rozas, "Taming the Y Operator", Proceedings of the 1992 ACM
  565.    Conference on Lisp and Functional Programming, San Francisco, CA,
  566.    June 1992, 226-234.
  567.  
  568.    Dan Teodosiu, "HARE: An Optimizing Portable Compiler for Scheme", ACM
  569.    Sigplan Notices 26(1), January 1991.
  570.  
  571. ----------------------------------------------------------------
  572. Subject: [1-7] Standards for Scheme -- What are R4RS and IEEE P1178?
  573.  
  574. R4RS is the Revised^4 Report on the Algorithmic Language Scheme,
  575. edited by W. Clinger and J. Rees. It appeared in ACM Lisp Pointers IV,
  576. July-September 1991, and also as MIT AI Memo 848b. It serves as a kind
  577. of standard for the language. It can be obtained by anonymous ftp at
  578. the two Scheme Repositories, altdorf.ai.mit.edu and ftp.cs.indiana.edu.
  579. A HTML version is available as
  580.    ftp://altdorf.ai.mit.edu/archive/scm/HTML/r4rs_toc.html
  581.  
  582. IEEE P1178 is IEEE Standard 1178-1990, "IEEE Standard for the Scheme
  583. Programming Language", published by IEEE in 1991. ISBN 1-55937-125-0.
  584. It is now also an ANSI standard. It may be ordered from IEEE by
  585. calling 1-800-678-IEEE or 908-981-1393 or writing IEEE Service
  586. Center, 445 Hoes Lane, P.O. Box 1331, Piscataway, NJ 08855-1331, 
  587. and using order number SH14209 ($28 for IEEE members, $40 others).
  588.  
  589. ----------------------------------------------------------------
  590. Subject: [1-8] How do I do object-oriented programming in Scheme?
  591.  
  592. Some Scheme implementations (for example, MacScheme, Feel, Oaklisp, XScheme,
  593. and PC-Scheme) include built-in object-oriented extensions.  
  594.  
  595. SCOOPS (Scheme Object Oriented Programming System) is an object system
  596. for Scheme written by Amitabh Srivastava/Texas Instruments with 
  597. re-writes by Steve Sherin <sherin@linc.cis.upenn.edu>. [Email to this
  598. address bounced 7/7/93.] This package needs first-class environments.
  599. It is available from the Scheme Repository as
  600. /pub/scheme-repository/scm/scoops.sha. 
  601.  
  602. MEROON is a package written in Scheme to provide the basic facilities
  603. of an object-oriented programming style through three macros:
  604. define-class, define-generic, and define-method. MEROON offers simple
  605. inheritance, reflective metaclasses and simple dispatching generic
  606. functions with support for multimethods. MEROON also offers indexed
  607. fields subsuming Scheme vectors without inheritance restrictions.
  608. Meroon runs in Scheme->C, PC-Scheme, Chez Scheme, Elk, Bigloo, SCM
  609. with SLIB, and MacGambit. MEROON sources and documentation may be
  610. found in the Scheme Repository as
  611.    ftp.cs.indiana.edu:/pub/scheme-repository/new/meroon.*.tar.Z
  612. and also from
  613.    ftp.inria.fr:/pub/INRIA/icsla/Programs/MeroonV3*.tar.gz [128.93.1.26]
  614. The file meroonet*.tar.gz is a toy version of meroon. For more
  615. information, contact Christian Queinnec <queinnec@polytechnnique.fr>
  616. or <Christian.Queinnec@inria.fr>.
  617.  
  618. YASOS (Yet Another Scheme Object System) is fairly functional in style
  619. and uses delegation.  The implementation includes multiple inheritance
  620. and "send to super" and is much smaller than class-based OO systems.
  621. See Ken Dickey, "Scheming with Objects", AI Expert 7(10):24-33,
  622. October 1992. A copy of the article and YASOS code is available from
  623. the Scheme Repository in pub/scheme-repository/txt/swob.txt. YASOS is also
  624. included as part of SLIB. For further information, contact Ken Dickey
  625. <kend@newton.apple.com>.
  626.  
  627. Tiny CLOS is a Scheme implementation of a `kernelized' CLOS, with a
  628. metaobject protocol. The implementation is even simpler than the
  629. simple CLOS found in `The Art of the Metaobject Protocol,' weighing in
  630. at around 850 lines of code, including (some) comments and
  631. documentation. Tiny CLOS is available by anonymous ftp from
  632. parcftp.xerox.com:/pub/mops/. Tiny CLOS runs in MIT Scheme 11.74 and
  633. should run with only minor modifications in other Schemes as well. If
  634. you want to be added to the mops@parc.xerox.com mailing list
  635. (technical questions and discussion only), send mail to Gregor Kiczales
  636. <gregor@parc.xerox.com>.
  637.  
  638. ----------------------------------------------------------------
  639. Subject: [1-9] Repositories of Scheme Software
  640.  
  641. There are several repositories of publicly redistributable and
  642. public domain Scheme code. 
  643.  
  644.    The Scheme Repository contains a Scheme bibliography, copies of the
  645.    R4RS report, IEEE P1178 specification and other papers, sample Scheme
  646.    code for a variety of purposes, several utilities, and some
  647.    implementations. The Scheme code includes code for calendar
  648.    calculations, Earley parser, FORMAT for Scheme, a scheme version of
  649.    the Gabriel benchmarks, Marc Feeley's minimal object support for
  650.    Scheme, a Scheme pretty-printer, a Prolog interpreter written in
  651.    Scheme, a random number generator in Scheme, an implementation of
  652.    SCOOPS, code from Abelson and Sussman's SICP book, Aubrey Jaffer's
  653.    IEEE/R4RS compliance test, an implementation of matrices, a Scheme
  654.    implementation of the Common Lisp FORMAT function, a Scheme front
  655.    end to Adobe Illustrator PostScript, and a LALR(1) parser (ZEBU).
  656.    The repository was established by Ozan S. Yigit and is currently
  657.    maintained by David Eby and John Zuckerman. Send administrative
  658.    requests to
  659.       scheme-repository-request@cs.indiana.edu
  660.    The repository is accessible by anonymous ftp at 
  661.       ftp.cs.indiana.edu:/pub/scheme-repository/   [129.79.254.191]
  662.    The repository is mirrored in INRIA, courtesy of Christian Queinnec
  663.    [Ecole Polytechnique and INRIA-Rocquencourt], ftp.inria.fr:/lang/Scheme/
  664.    and also faui80.informatik.uni-erlangen.de:/pub/scheme/yorku
  665.  
  666.    Scheme Implementations may also be found at altdorf.ai.mit.edu:/archive/ 
  667.    The R4RS report is available in altdorf.ai.mit.edu:/archive/scheme-reports/
  668.    or as MIT AI Memo 848b (email publications@ai.mit.edu for more information).
  669.    The altdorf archive includes SCOOPS, CL2Scheme, extend-syntax,
  670.    btree, Gabriel benchmarks, FORMAT for Scheme, etc.
  671.  
  672.    The GI (German Computer Science Society) Scheme Archive contains a
  673.    variety of scheme programs, utilities, code from theses, and other
  674.    materials. It also mirrors the Scheme Repository.  It is
  675.    accessible by anonymous ftp to faui80.informatik.uni-erlangen.de
  676.    (login as 'ftp', giving your email address as the password).
  677.       pub/scheme/gi                # GI Scheme Archive
  678.       pub/scheme/yorku             # Internet Scheme Repository
  679.    Direct questions to scheme@faui80.informatik.uni-erlangen.de.
  680.    The GI Scheme Archive is supported by the German Computer Society Special
  681.    Interest Group on AI programming and sponsored by the Bavarian AI Center
  682.    FORWISS -- Research Institute for Knowledge Based Systems.
  683.  
  684. ----------------------------------------------------------------
  685. Subject: [1-10] Publicly Redistributable Scheme Software
  686.  
  687.    SLIB (Standard Scheme Library) is a portable scheme library that
  688.    provides compatibility and utility functions for many of the
  689.    standard scheme implementations, including Chez, ELK 2.1, GAMBIT,
  690.    MITScheme, scheme->C, Scheme48, T3.1, VSCM and Scm4e. It is available by
  691.    anonymous ftp from 
  692.        altdorf.ai.mit.edu:/archive/scm/slib2a1.tar.gz
  693.        prep.ai.mit.edu:/pub/gnu/jacal/slib2a1.tar.gz
  694.        ftp.cs.indiana.edu:/pub/scheme-repository/new/slib2a1.tar.gz
  695.    Now includes a FAQ file.
  696.  
  697.    TEST.SCM is an IEEE and R4RS conformance test suite.  It is available
  698.    from 
  699.       altdorf.ai.mit.edu:/archive/scm/test.scm
  700.       prep.ai.mit.edu:/pub/gnu/jacal/test.scm
  701.       ftp.cs.indiana.edu:/pub/scheme-repository/new/test.scm
  702.  
  703.    PSD (Portable Scheme Debugger) is available by anonymous ftp
  704.    from Tampere University of Technology, Finland,
  705.       ftp.cs.tut.fi:/pub/src/languages/schemes/psd-1.1.tar.Z
  706.    With PSD, you can run a Scheme program in an Emacs buffer, set
  707.    breakpoints, single step evaluation and access and modify the
  708.    program's variables. It works by instrumenting the original source
  709.    code, so it should run with any R4RS compliant Scheme. It has been
  710.    tested with SCM and Elk 1.5, but should work with other Schemes with a
  711.    minimal amount of porting, if at all. Includes documentation and
  712.    user's manual. Written by Pertti Kellom\"aki, pk@cs.tut.fi
  713.    The Lisp Pointers article describing PSD (Lisp Pointers VI(1):15-23,
  714.    January-March 1993) is available as 
  715.       http://www.cs.tut.fi/staff/pk/scheme/psd/article/article.html
  716.  
  717.    SCLINT is a lint-like program for Scheme. It checks for consistency of
  718.    indentation, syntax of special forms, and the number of arguments to
  719.    primitive and most user-defined procedures. This is not a full
  720.    implementation, but rather a quick hack. It is used in teaching
  721.    programming at the Tampere University of Technology. It is available
  722.    by anonymous ftp from 
  723.       ftp.cs.tut.fi:/pub/src/languages/schemes/sclint-0.9.tar.Z.
  724.    For further information, write to Pertti Kellom\"aki <pk@cs.tut.fi>.
  725.  
  726.    A bibliography of work in functional programming can be obtained by 
  727.    anonymous ftp from tamdhu.dcs.st-andrews.ac.uk:/pub/staple/pubs.txt
  728.    (138.251.192.40). It uses a refer-like format with %T for title, %A
  729.    for authors %I for a unique index entry %S for source (possibly a
  730.    reference to another index) %K for keywords and %C for comments.
  731.    Compiled by Tony Davie, <ajtd@honey.st-and.ac.uk>. [Email bounced, 7/7/93.]
  732.  
  733.    Scheme Utilities -- brokaw.lcs.mit.edu:/pub/scmutils.tar  18.30.0.33
  734.    [This collection seems to no longer be located on brokaw -- does
  735.    anybody know the current location?]
  736.  
  737.    A collection of Scheme implementations of data structures and
  738.    algorithms is available by anonymous ftp from 
  739.       ftp.cs.tut.fi:/pub/src/languages/schemes/
  740.    as the file scheme-algorithms.tar. For more information, contact
  741.    Pertti Kellom\"aki <pk@cs.tut.fi>. 
  742.  
  743.    6.001. The User's Manual, example code, and problem sets from MIT's
  744.    course "Structure and Interpretation of Computer Programs" are 
  745.    available by anonymous ftp from martigny.ai.mit.edu:/archive/6.001/
  746.    [18.43.0.152].
  747.  
  748.    Steele's Constraint System. Chris Hanson's implementation of Steele's
  749.    constraint system is available for anonymous ftp from
  750.       martigny.ai.mit.edu:/archive/cph/constraint.tar [18.43.0.152]
  751.       ftp.cs.indiana.edu:/pub/scheme-repository/new/constraint.tar.Z
  752.    A compressed version is also stored there. The software is source code
  753.    for MIT Scheme. It should run in release 7.1.3. Most of the MIT Scheme
  754.    dependencies could be eliminated, but it also uses the following
  755.    procedures which aren't in standard Scheme: error, bkpt, macros,
  756.    dynamic binding, and string output ports. The code corresponds pretty
  757.    closely to Guy Steele's PhD thesis implementation, which you can
  758.    obtain in printed form from the MIT AI Lab publications office as
  759.    AI-TR-595 for $15.00 (email publications@ai.mit.edu for more
  760.    information). For more information, send email to Chris Hanson
  761.    <cph@martigny.ai.mit.edu>.
  762.  
  763.    JACAL is a symbolic mathematics system for the simplification and
  764.    manipulation of equations and single and multiple valued algebraic
  765.    expressions constructed of numbers, variables, radicals, and algebraic
  766.    functions, differential, and holonomic functions. In addition, vectors
  767.    and matrices of the above objects are included.  JACAL is written in
  768.    Scheme and requires SLIB. JACAL source is available via anonymous FTP
  769.    from
  770.       altdorf.ai.mit.edu:/archive/scm/jacal1a4.tar.Z,
  771.       prep.ai.mit.edu:/pub/gnu/jacal/jacal1a4.tar.Z, and
  772.       ftp.cs.indiana.edu:/pub/scheme-repository/new/jacal1a4.tar.Z
  773.    Contact jaffer@altdorf.ai.mit.edu for more information.
  774.   
  775.    Zebu 0.9 is an LALR(1) parser generator for Scheme written by 
  776.    William M. Wells III. It lives in the Scheme Repository 
  777.       ftp.cs.indiana.edu:/pub/scheme-repository/scm/
  778.    and works with PC-Scheme from TI and MIT C-Scheme 6.2 (but not with
  779.    anything after 7.0). 
  780.  
  781.    Thomas is a compiler for the Dylan programming language.  The Thomas
  782.    system is written in Scheme and runs under MIT's CScheme, DEC's
  783.    Scheme->C, and Marc Feeley's Gambit.  It can run on a wide range of
  784.    machines including the Macintosh, PC compatibles, Vax, MIPS, Alpha,
  785.    and 680x0.  Thomas generates IEEE compatible Scheme code.  Thomas is
  786.    available to the public by anonymous ftp at
  787.       crl.dec.com:/pub/DEC/Thomas
  788.       gatekeeper.pa.dec.com:/pub/DEC/Thomas
  789.       altdorf.ai.mit.edu:/archive/Thomas
  790.    For more information on Thomas and Dylan, see part 4 of the Lisp FAQ.
  791.  
  792.    MATCH is a pattern matching macro package for Scheme.  Pattern
  793.    matching allows complicated control decisions based on data structure
  794.    to be expressed in a concise manner. This document describes several
  795.    pattern matching macros for Scheme, and an associated mechanism for
  796.    defining new forms of structured data. This macro package works with
  797.    any Scheme that supports defmacro (which is obtainable by loading
  798.    SLIB), such as Chez Scheme (release 4 or greater). MATCH is available
  799.    by anonymous ftp from titan.cs.rice.edu:/public/wright/match.tar.Z
  800.    [128.42.1.30] and includes the macro source code and documentation. A
  801.    copy should be available from the Scheme Repository shortly.  For
  802.    further information, write to Andrew Wright, <wright@cs.rice.edu>.
  803.  
  804.    Soft Scheme provides the benefits of static typing for dynamically
  805.    typed Scheme.  Like a static type checker, a soft type checker infers
  806.    types for variables and expressions.  But rather than reject programs
  807.    containing untypable fragments, a soft type checker inserts explicit
  808.    run-time checks to transform untypable programs to typable form.
  809.    These run-time checks indicate potential program errors, enabling
  810.    programmers to detect errors prior to program execution.  Soft type
  811.    checking minimizes the number of run-time checks in the compiled code,
  812.    enabling dynamically typed languages to attain the efficiency of
  813.    statically typed languages like ML. Soft Scheme is available by
  814.    anonymous ftp from
  815.       titan.cs.rice.edu:public/wright/softscheme.tar.Z [128.42.1.30]
  816.    For more information, write to Andrew Wright <wright@cs.rice.edu>.
  817.  
  818.    ChezSybase is a Chez Scheme interface to the Sybase database.
  819.    It uses the Chez Scheme foreign function interface to provide a
  820.    high-level Scheme interface to the Sybase db-lib (the API to the
  821.    Sybase database). Most of the db-lib calls and datatypes are
  822.    supported, with the possible exception of spotty support for text and
  823.    image data, and there is no analog to the datetime datatype. It is
  824.    available by anonymous ftp from
  825.       ftp.cs.cmu.edu:/user/ai/lang/scheme/code/io/chez_syb/
  826.    For more information, write to Karl O. Pinc <kop@acm.org>.
  827.  
  828. ----------------------------------------------------------------
  829. Subject: [1-11] Formatting code in LaTeX
  830.  
  831. SLaTeX is a R4RS-compliant Scheme program that allows you to write
  832. program code "as is" in your LaTeX or TeX source.  It is particularly
  833. geared to the programming languages Scheme and Common Lisp, and has
  834. been tested in Chez Scheme, Common Lisp, MIT C Scheme, Elk, Scheme->C,
  835. SCM and UMB Scheme on Unix; and MIT C Scheme and SCM on MSDOS.  The
  836. formatting of the code includes assigning appropriate fonts to the
  837. various tokens in the code (keywords, variables, constants, data), at
  838. the same time retaining the proper indentation when going to the
  839. non-monospace (non-typewriter) provided by TeX.  SLaTeX comes with two
  840. databases that recognize the standard keywords/variables/constants of
  841. Scheme and Common Lisp respectively.  These can be modified by the
  842. user using easy TeX commands.  In addition, the user can inform SLaTeX
  843. to typeset arbitrary identifiers as specially suited TeX expressions
  844. (i.e., beyond just fonting them).  The code-typesetting program SLaTeX
  845. is available by anonymous ftp from 
  846.    cs.rice.edu:/public/dorai/slatex.tar.Z
  847. Send bug reports to dorai@cs.rice.edu.
  848.  
  849. SchemeWEB provides simple support for literate programming in Lisp.
  850. SchemeWEB version 2.0 is a Unix filter that allows you to generate
  851. both Lisp and LaTeX code from one source file.  The generated LaTeX
  852. code formats Lisp programs in typewriter font obeying the spacing in
  853. the source file.  Comments can include arbitrary LaTeX commands.
  854. SchemeWEB was originally developed for the Scheme dialect of Lisp, but
  855. it can easily be used with most other dialects.  Version 2.0 is
  856. available in the Scheme Repository as
  857.    ftp.cs.indiana.edu:/pub/scheme-repository/new/schemeweb.sh
  858. or in the Comprehensive TeX Archive Network (CTAN) in the directory
  859.    ftp.shsu.edu:/tex-archive/web/schemeweb 
  860.  
  861. The Literate Programming FAQ lists a number of alternatives, both
  862. language-independent and Scheme-specific. The Literate Programming FAQ
  863. is posted once a quarter to the comp.literate.programming newsgroup
  864. and is available by anonymous ftp from rtfm.mit.edu. A copy may also be
  865. requested by sending an email message to fileserv@shsu.edu
  866.    sendme litprog.faq
  867. in the body of the message.
  868.  
  869. ----------------------------------------------------------------
  870. Subject: [1-12] Where can I get an implementation of Prolog in Scheme?
  871.  
  872.    Prolog in Scheme is a collection of macros that expand syntax for
  873.    clauses, elations, and so on. It is written in Scheme and has support
  874.    for delayed goals and interval arithmetic. It is known to run in Chez
  875.    Scheme and in Elk, and is intended to be portable to other Scheme
  876.    implementations. It relies on continuations, and so is not easily
  877.    ported to Common Lisp. Available from the University of Calgary by
  878.    anonymous ftp from
  879.       ftp.cpsc.ucalgary.ca:/pub/prolog1.2/prolog12.tar.Z
  880.    Questions and comments may be addressed to Alan Dewar
  881.    <dewar@cpsc.ucalgary.ca> or John Cleary <jcleary@waikato.ac.nz>.
  882.  
  883.    Schelog is an embedding of Prolog in Scheme. It represents Prolog
  884.    goals as procedures in Scheme, and includes macros to simulate a
  885.    Prolog-style syntax for clauses, relations and queries.  The embedding
  886.    permits the user to combine Prolog and Scheme code freely, in the same
  887.    s-expression, if desired.  Documentation and examples are included.
  888.    Schelog should run in any R4RS Scheme, has been tested in SCM and Chez
  889.    Scheme, and will run in any Scheme implementation that supports SLIB (see
  890.    entry in [1-10] above).  Schelog (version 2) is available by anonymous
  891.    ftp from titan.cs.rice.edu:/public/dorai/schelog2.tar.Z.  Its use of
  892.    higher-order continuations is probably a major obstacle to porting it
  893.    to Common Lisp.  For more information, please contact the author Dorai
  894.    Sitaram <dorai@cs.rice.edu>.
  895.  
  896. ----------------------------------------------------------------
  897. Subject: [1-13]  What does SICP, SCOOPS, R4RS, CAR, CDR, ... mean?
  898.  
  899. Glossary of acronyms:
  900.    CAR             Originally meant "Contents of Address portion of Register",
  901.                    which is what CAR actually did on the IBM 704.
  902.    CDR             Originally meant "Contents of Decrement portion of 
  903.                    Register", which is what CDR actually did
  904.                    on the IBM 704. Pronounced "Cudder".
  905.    ANSI            American National Standards Institute
  906.    SICP            Abelson and Sussman's book "Structure and
  907.                    Interpretation of Computer Programs".
  908.    EOPL            Essentials of Programming Languages 
  909.    SCOOPS          An experimental object-oriented programming
  910.                    language for Scheme.
  911.    R3RS            Revised^3 Report on the Algorithmic Language Scheme.
  912.    R4RS            Revised^4 Report on the Algorithmic Language Scheme.
  913.  
  914. ----------------------------------------------------------------
  915. Subject: [1-14] Why is there no EVAL in Scheme?
  916.  
  917. The answer to this question is based on information provided by 
  918. Guillermo J. Rozas and Aubrey Jaffer.
  919.  
  920. There are three major positions in the Scheme community regarding EVAL:
  921.  
  922.    1. No EVAL: EVAL is antithetical to a Pascal-like (compiler based,
  923.       externally statically linked) implementation for Scheme, such as
  924.       some people have or wish to see. 
  925.  
  926.    2. Single Argument: There is a single distinguished top-level
  927.       environment, and EVAL always evaluates its argument there. 
  928.       (This is the approach taken in Common Lisp, where EVAL evaluates
  929.       its argument in the current dynamic environment and in a null
  930.       lexical environment.) 
  931.  
  932.    3. Two Arguments: There are multiple environments in which
  933.       the user might want to evaluate expressions, so EVAL should take
  934.       two arguments, the second being an environment.  In particular,
  935.       in some systems with first-class environments, there is no
  936.       a-priori single distinguished top-level environment, and
  937.       defaulting the environment does not fit those dialects well.
  938.  
  939. Not every dialect of Scheme has EVAL. Most do, but some with different
  940. names and arguments. Jaffer's SLIB package uses LOAD as defined in
  941. R4RS to define EVAL for those implementations that don't support EVAL
  942. (e.g., by writing the code out to a file and then loading it).
  943. Rozas's compromise proposal for EVAL was accepted for R5RS, but it is
  944. unclear whether there will ever be a R5RS.
  945.  
  946. ----------------------------------------------------------------
  947. Subject: [1-15] World-Wide Web (WWW) Resources
  948.  
  949. The World Wide Web (WWW) is a hypermedia document that spans the
  950. Internet.  It uses the http (HyperText Transfer Protocol) for the
  951. light-weight exchange of files over the Internet.  NCSA Mosaic is a
  952. World Wide Web browser developed at the National Center for
  953. Supercomputing Applications (NCSA). 
  954.  
  955. Mosaic's popularity derives, in part, from its ability to communicate
  956. using more traditional Internet protocols like FTP, Gopher, WAIS, and
  957. NNTP, in addition to http. Mosaic can display text, hypertext links,
  958. and inlined graphics directly. When Mosaic encounters a file type it
  959. can't handle internally, such as Postscript documents, mpeg movies,
  960. sound files, and JPEG images, it uses an external viewer (or player)
  961. like Ghostscript to handle the file. Mosaic also includes facilities
  962. for exploring the Internet. In other words, Mosaic is an multimedia
  963. interface to the Internet.
  964.  
  965. The hypertext documents viewed with Mosaic are written in HTML
  966. (HyperText Markup Language), which is a subset of SGML (Standard
  967. Generalized Markup Language).  All that is needed is just a few more
  968. improvements, such as the ability to format tables and mathematics,
  969. and a WYSIWYG editor, for HTML to greatly facilitate electronic
  970. journals and other publications.
  971.  
  972. NCSA Mosaic for the X Window System is available by anonymous ftp from  
  973.    ftp.ncsa.uiuc.edu:/Mosaic/
  974. as source code and binaries for Sun, SGI, IBM RS/6000, DEC Alpha OSF/1, DEC
  975. Ultrix, and HP-UX. Questions about NCSA Mosaic should be directed to 
  976. mosaic-x@ncsa.uiuc.edu (X-Windows version), mosaic-mac@ncsa.uiuc.edu
  977. (Macintosh), and mosaic-win@ncsa.uiuc.edu (Microsoft Windows).
  978.  
  979. A simple HTML version of the Scheme FAQ (this FAQ) is available as
  980.    http://www.cs.cmu.edu:8001/Web/Groups/AI/html/faqs/lang/scheme/top.html
  981.  
  982. The Scheme home page at MIT is
  983.     http://www-swiss.ai.mit.edu/scheme-home.html
  984. It includes a nifty little form that lets you execute small examples
  985. of Scheme code.
  986.  
  987. The Scheme Undergound web page is
  988.     http://www.ai.mit.edu/projects/su/su.html
  989.  
  990. ----------------------------------------------------------------
  991. Subject: [1-16] Why is Scheme called 'Scheme'?
  992.  
  993. According to Steele and Gabriel's "The Evolution of Lisp" paper,
  994. Scheme was originally called Schemer, in the tradition of the AI
  995. languages Planner and Conniver. But the ITS operating system had a
  996. 6-character limitation of file names, so the names were shortened to
  997. PLNR, CNVR, and SCHEME. Eventually the truncated name Scheme stuck.
  998.  
  999. ----------------------------------------------------------------
  1000. ;;; *EOF*
  1001.  
  1002.