🚀 go-pugleaf

Archive-name: prolog/resource-guide/part1
Last-Modified: Mon Nov 15 14:04:52 1993 by Mark Kantrowitz
Version: 1.13

;;; ****************************************************************
;;; Prolog Resource Guide ******************************************
;;; ****************************************************************
;;; prg_1.faq -- 42149 bytes

Contributions and corrections should be sent to Mark Kantrowitz
at mkant+prolog-guide@cs.cmu.edu. 

This guide lists a variety of resources for the Prolog community,
including books, magazines, ftp archives, and products. It is posted
once a month to the newsgroups comp.lang.prolog and comp.object.logic.

The original version of this guide (Version 0.6, Dec 11, 1991) was
compiled by Dag Wahlberg, Uppsala University, Sweden <dagwag@csd.uu.se>.
Other people who helped with the compilation include Chris Moss
<cdsm@doc.ic.ac.uk>, Mats Carlsson, SICS <matsc@sics.se>,
Michael A. Covington <mcovingt@ai.uga.edu>, Jocelyn Paine
<popx@vax.ox.ac.uk>, Per G. Bilse, PDC <pdev@pdc.dk>, David Cohen, BIM
Systems Inc <dc@bim.com>, Mark Korsloot <mark@logic.et.tudelft.nl>, and
David W. Talmage <talmage@luvthang.aquin.ori-cal.com>. 

Thanks also to Jamie Andrews <jamie@cs.sfu.ca>.

Suggestions and comments to:	mkant+prolog-guide@cs.cmu.edu

----------------------------------------------------------------
Table of Contents (Part 1):

  [1-0] Introduction
  [1-1] Sources of information about Prolog
  [1-2] FTP Archives and Other Resources
  [1-3] Prolog-related Mailing Lists
  [1-4] Books and Magazine Articles
  [1-5] The Prolog 1000 Database
  [1-6] X-Windows Interfaces
  [1-7] Is there a straight-forward way of compiling Prolog to C?
  [1-8] What is the Basic Andorra Model and AKL?

Prolog Implementations (Part 2):
  [2-1] Public Domain or Free Prolog Implementations
  [2-2] Commercial Prolog Implementations

Search for [#] to get to topic number # quickly. In newsreaders which
support digests (such as rn), [CTRL]-G will page through the answers.


Recent Changes:
;;; 1.9:
;;; 20-JUL-93 mk    Updated IC-Prolog II entry and the PARLOG entry.
;;; 10-AUG-93 mk    Inserted [1-7] about compiling Prolog to C.
;;;
;;; 1.10:
;;; 24-AUG-93 mk    Corrected subscription info to EJFLP.
;;; 25-AUG-93 mk    Added entry on theorem-provers mailing list to [1-3].
;;;
;;; 1.11:
;;; 13-SEP-93 mk    Added entry on SLG to part 2.
;;;
;;; 1.12:
;;;  6-OCT-93 mk    Added entry on JB Prolog 2.1
;;; 12-OCT-93 mk    Added mention of Goedel mailing list to Goedel entry.
;;; 28-OCT-93 mk    Added entry on CHIP V4 to [2-2] Constraint Systems.
;;;
;;; 1.13:
;;; 15-NOV-93 mk    Updated ILOG Solver entry in part 2.
;;; 15-NOV-93 mk    Updated LP Bibs entry.
;;; 15-NOV-93 mk    Corrected email in SQL compiler entry.

----------------------------------------------------------------
Subject: [1-0] Introduction

This guide lists Prolog resources: archives, newsgroups, books,
magazines, compilers, interpreters and anything else you can think of
which has to do with the proliferation of Prolog. Also included is a
list of suppliers of products and a list of publishers. As Prolog has
a strong historical tradition in Europe, we've tried to ensure that
the information is relevant to all readers, including European and
North American. 

This guide is posted regularly to comp.lang.prolog and comp.object.logic. 
It may also be obtained by anonymous ftp from CMU:

   To obtain the file from CMU, connect by anonymous ftp to any CMU CS
   machine (e.g., ftp.cs.cmu.edu [128.2.206.173]), using username
   "anonymous" and password "name@host". The files prg_1.faq and prg_2.faq
   are located in the directory
       /afs/cs.cmu.edu/project/ai-repository/ai/pubs/faqs/prolog/
   [Note: You must cd to this directory in one atomic operation, as
   some of the superior directories on the path are protected from
   access by anonymous ftp.] If your site runs the Andrew File System,
   you can just cp the file directly without bothering with FTP.

The FAQ postings are also archived in the periodic posting archive on
rtfm.mit.edu [18.70.0.209]. Look in the anonymous ftp directory
/pub/usenet/news.answers/ in the subdirectory prolog/. If you do not
have anonymous ftp access, you can access the archive by mail server
as well.  Send an E-mail message to mail-server@rtfm.mit.edu
with "help" and "index" in the body on separate lines for more
information.

Disclaimer:

   We have taken great care in making the information in this document as
   accurate as possible. However we are not responsible for any problems
   which might occur from using information supplied in this guide.

----------------------------------------------------------------
Subject:  [1-1]  Sources of Information about Prolog

The newsgroups comp.lang.prolog, comp.object.logic, and (to a lesser
extent) comp.ai are a source of information and discussion about Prolog. 

A "Frequently Asked Questions" posting is posted to comp.lang.prolog
twice a month by Jamie Andrews <jamie@cs.sfu.ca>. The Prolog FAQ and this
Prolog Resource Guide are intended to complement one another.

The draft ISO standard for Prolog is available by anonymous ftp from
ai.uga.edu:/ai.prolog.standard [128.192.12.9]. An unofficial summary
of the draft ISO Prolog standard is available from
ai.uga.edu:/ai.prolog.standard/ as isoprolog.tex or isoprolog.ps.Z.
Send mail to Michael Covington <mcovingt@ai.uga.edu> for more information.

----------------------------------------------------------------
Subject: [1-2]  FTP Archives and Other Resources

The following are achives that contain Prolog-related material, such as
code, interpreters, articles, etc. Most of the archives are ftp sites.
They are listed by domain.name and [IP Address]. To access them and
download programs type at the prompt: 

	ftp <site name> (or IP address)
	login: "anonymous",
	password: your own return email address,
	cd <directory>, ls to see files, 
	set binary, 
	get <filename> to transfer file to your system
	stop with quit or exit

Deviations from this general scheme may occur but the above should
work in most cases.


Artificial Intelligence Programs:
   ai.uga.edu [128.192.12.9]

   Contains public domain Prologs, such as Open Prolog and ESL PD Prolog,
   all programs from the book by Covington, Nute, and Vellino, (see
   the section on Books below), PrEd (a small text editor for Prolog)
   and some technical reports with accompanying code. Maintained by
   Michael Covington, the University of Georgia, mcovingt@ai.uga.edu. 

ALE:	 
   ALE (Attribute Logic Engine), a public domain system written in
   Prolog, integrates phrase structure parsing and constraint logic
   programming with typed feature structures as terms.  Types are
   arranged in an inheritance hierarchy and specified for the features
   and value types for which they are appropriate.  Grammars may also
   interleave unification steps with logic program goal calls (as can be
   done in DCGs), thus allowing parsing to be interleaved with other
   system components.  While ALE was developed to handle HPSG grammars,
   it can also execute PATR-II grammars, DCG grammars, Prolog, Prolog-II,
   and LOGIN programs, etc. Grammars and programs are specified with a
   version of Rounds-Kasper Attribute Value Logic with macros and
   variables.  ALE supports lexical rules and empty categories for
   grammars, using a bottom-up, breadth-first dynamic chart parser.	ALE
   supports last call optimization, negation by failure and cuts in
   definite clauses, which may be used independently or integrated into
   grammars.	 The system is available free for research purposes, from
   Bob Carpenter <carp@lcl.cmu.edu>.

ALP-UK Library:
   The best Prolog library currently is the one collected by the ALP-UK
   group. It is available to members at 30 pounds sterling for a Sun
   cartridge or 2 pounds/IBM DOS disk. (non-members maybe, how much?) It
   contains MBs of Prolog systems (including SB Prolog), libraries
   (including the Edinburgh library), benchmarks, grammars, theorem provers,
   object and graphics systems etc. For more information, write to ALP-UK
   Library, Sanjay Raina, Librarian, Dept. of Computer Science, University
   of Bristol, University Walk, Bristol BS8 1TR, UK, call +44 0272 303030
   x3304, or send email to raina@compsci.bristol.ac.uk.

CASLOG
   CASLOG (Complexity Analysis System for LOGic) is an experimental
   semi-automatic complexity analysis system for logic programs. It can
   perform the worst-case analysis for complexity measures: argument size
   complexity, number of solutions complexity, and time complexity.

   CASLOG extends the techniques developed for analyzing imperative and
   functional languages to deal with nondeterminism and generation of
   multiple solutions via backtracking in logic languages. The analyses
   for different complexity measures are implemented in a unified
   framework and share several common features. First, the predicates in
   a program are processed in an order generated by a bottom-up
   topological sorting over the call graph of the program. Second, the
   complexity function for a predicate is derived from the complexity
   function of its clauses by using the information about the mutual
   exclusion relationships between its clauses. Third, the complexity
   function for a clause is inferred based on the data dependency
   relationships between its literals. Fourth, the complexity functions
   for recursive clauses are in the form of difference equations and are
   transformed into closed form functions using difference equation
   solving techniques. This unified framework can simplify proofs of
   correctness and the implementation of the algorithms.

   CASLOG is available by anonymous ftp from cs.arizona.edu:caslog/. This
   is an alpha distribution, and includes CASLOG version 1.0, a
   preliminary user manual, a paper on CASLOG, and a set of examples.
   For more information, contact Nai-Wei Lin <naiwei@cs.arizona.edu>.

Constraint Programming Paper Archive:
   Aarhus University, Denmark, has established an anonymous ftp archive
   for papers on "Constraint Programming" at ftp.daimi.aau.dk:pub/CLP/.
   For further information, contact Brian H. Mayoh <brian@daimi.aau.dk>.

Eden
   Eden is a Poplog-based AI microworld developed by Simon Perkins,
   Jocelyn Paine and Edmund Chattoe of the Oxford University Artificial
   Intelligence Society. It is intended to serve as a testbed for
   learning and planning programs. Programs written in Pop-11, Prolog,
   Lisp, and ML control a "bug" that lives in a 2-dimensional world. Any
   kind of algorithm may be used to control the bug, including genetic
   algorithms, neural nets, and rule-based systems. Eden consists of a
   grid of cells, each of which can contain objects such as keys, doors,
   boulders and quicksand. Bug's objective is to find and eat a piece of
   food which the simulator has placed somewhere within this grid. To do
   this, Bug must negotiate its way towards the food while dealing
   intelligently with obstacles. Eden's laws of physics allow Bug to take
   one of several different actions when it encounters an object. The
   simulator then works out the consequences of the chosen action on Bug
   and on Eden, and displays these graphically in a Ved window. Bug's
   perceptions are updated to reflect the new state of the world, and the
   cycle repeats. Eden is available by anonymous ftp from the Imperial
   College archive, src.doc.ic.ac.uk [146.169.2.1] in the directory
   computing/programming/languages/prolog/pd-software (a shortcut is
   packages/prolog-pd-software) as the file eden.tar.Z. Eden includes
   PopBeast, a simple Prolog bug which can read and parse simple
   commands, extract their meaning, plan how to satisfy these commands,
   and then carry out the plans.

   The Oxford University AI Society is running an international AI
   competition for Eden bugs. Send your source code to Jocelyn Paine
   <popx@vax.oxford.ac.uk> or Edmund Chattoe <econec@vax.oxford.ac.uk> by
   May 1, 1993, if you'd like to enter.

Logic Programming Bibliographies:
   duck.dfki.uni-sb.de [134.96.188.92]

   The BiBTeX bibliographies are available in /pub/lp-proceedings.
   The ftp server supports tar'ing on the fly, so if you type "get
   bibtex.tar" you will get a tar'ed version of the "bibtex" directory.

   BibTeX entries for the proceedings of the following conferences
   are included: SLP84-87,91, NACLP89-90, ILPS91, ICLP82,84,86-91,93,
      JICLP92, LP88, RTA89,93, PLILP90-92, ALPUK91, ICOT92, ALP90,92,
      CADE90,92, CTRS90,92, LICS86-91, UNIF89, EPIA89,91,93, TACS91,
      TAPSOFT93, EAIA90
   and the following journals: JLP85-93, JAR91,92, JSC91,92, IANDC82-92.

   The bibliography is mirrored by the Universidade Nova de Lisboa.
   In addition, the bibliography can be searched using either WAIS or
   GOPHER. To search the lp-proceedings using WAIS, use the
      lp-proceedings.src 
   wais source, available from the directory of servers. To search the
   lp-proceedings using GOPHER, point the client to gopher.fct.unl.pt,
   and follow the directories 
      "Research/Bibliography/Logic Programming Proceedings".
   Searching should be easier than retrieving the entire package every
   time you want to locate a particular article.

   Send comments and bug reports to rscheidhauer@dfki.uni-sb.de.

Machine Learning Algorithms Implemented in Prolog:
   In 1988 the Special Interest Group on Machine Learning of the German
   Society for Computer Science (GI e.V.) decided to establish a library
   of PROLOG implementations of Machine Learning algorithms. The library
   includes - amongst others - PROLOG implementations of Winston's arch, 
   Becker's AQ-PROLOG, Fisher's COBWEB, Brazdil's generation of 
   discriminations from derivation trees, Quinlan's ID3, inverse 
   resolution, and Mitchell's version spaces algorithm. The programs are 
   currently available via anonymous ftp-server from the GMD:

	ftp.gmd.de:/gmd/mlt/ML-Program-Library [129.26.8.90]

   Send additional PROLOG implementations of Machine Learning
   Algorithms, complaints about them and detected bugs or problems
   to Thomas Hoppe, <hoppet@cs.tu-berlin.de>. Send suggestions and
   complaints about the ftp library to Werner Emde, Gesellschaft
   fuer Mathematik und Datenverarbeitung, Bonn, <emde@gmdzi.gmd.de>. 

Natural Language Processing in Prolog:

   The Prolog and DCG programs from Pereira and Shieber's book, "Prolog
   and Natural Language Analysis", are available by anonymous ftp from
   das.harvard.edu:pub/shieber/pnla/. See the file README for the
   conditions under which the material is distributed. If you retrieve
   the files, please send an email message to the authors letting them
   know how you plan to use them. For further information, write to
   Fernando Pereira <pereira@research.att.com> or Stuart Shieber
   <shieber@das.harvard.edu>.

Object-Oriented Program in Prolog:

   OL(P), Object Layer for Prolog, is an object-oriented extension to
   Prolog.  It provides an object-oriented structuring and reuse
   mechanism for Prolog in a manner that preserves performance and
   semantics. The object-oriented layer is compiled into Prolog without
   introducing any side-effects.  OL(P) takes the view of objects as
   collections of predicates (called methods).  To Prolog, OL(P) 1.1 adds
   objects with methods, data encapsulation, instances, and multiple
   inheritance. Object methods can access Prolog predicates and vice
   versa. The OL(P) incremental compiler translates OL(P) programs to
   Prolog programs that don't need runtime interpretation (e.g., no
   search is needed for inheritance).  OL(P) 1.1 comes with prepared
   installation for SICStus Prolog and QUINTUS Prolog (both on UNIX),
   documentation, simple built-in project management, some libraries,
   and example programs. The source is included, so you can port OL(P)
   to different platforms, different Prolog systems, and different
   logic programming languages. OL(P) is available by anonymous ftp
   from parcftp.xerox.com:/ftp/pub/ol/ [13.1.64.94]. Written by Markus
   P.J. Fromherz <fromherz@parc.xerox.com>. 

Pleuk Grammar Development System:

   Pleuk is intended to be a shell for grammar development, in that many
   different grammatical formalisms can be embedded within it.
   Grammatical formalisms that currently work with Pleuk include CFG (a
   simple context-free grammar system), HPSG-PL (a system for developing
   HPSG-style grammars, produced at Simon Fraser University, Canada, by
   Fred Popowich, Sandi Kodric and Carl Vogel), Mike (a simple
   graph-based unification system, enhanced with additional operations
   for the treatment of free word order proposed by Mike Reape in various
   publications), SLE (a graph-based formalism enhanced with arbitrary
   relations in the manner of Johnson & Rosner and Doerre & Eisele.
   Delayed evaluation is used to compute infinite relations.  This system
   has been used for the development of several HPSG-style grammars) and
   Term (a term-based unification grammar system, originally developed
   for the support of Unification Categorial Grammar of Zeevat, Klein and
   Calder). Sample grammars are provided for all of these formalisms.
   Work continues apace on other formalisms, including Bob Carpenter's
   Ale system for typed feature structures, and Veronica Dahl's Static
   Discontinuity Grammars.

   Pleuk requires SICStus prolog version 2.1#6 or later, plus a variety
   of ancillary programs available free of charge from many FTP servers.
   Pleuk is available via anonymous FTP from the University of Georgia
   Artificial Intelligence FTP library, hostname
   ai.uga.edu:/ai.natural.language/ as the files pleuk.1.0.tar.Z,
   pleuk.PSmanuals.tar.Z, and pleuk.README.  Pleuk will also be available
   shortly from the Natural Language Software Registry, German Research
   Institute for Artificial Intelligence (DKFI), Saarbruecken.  For more
   information, send email to pleuk@cogsci.ed.ac.uk.

Prolog Repository:
   Established by Jocelyn Paine of Experimental Psychology, Oxford
   University in 1987. The current catalogue (January 1991) contains
   30 entries. For catalogue, queries and contributions contact POPX at: 
      popx%vax.ox.ac.uk@oxmail.ox.ac.uk (internet) or 
      popx@uk.ac.ox.vax (janet) 

   FTP access is available through the Imperial College archive at
      src.doc.ic.ac.uk  (146.169.2.1)
   in the directory
      computing/programming/languages/prolog/pd-software
   with a short-cut link of:
      packages/prolog-pd-software
   To access it, cd to either of the above directories via
   anonymous ftp. The file README gives a brief summary of the
   contents of the directory and CATALOGUE gives a (long!)
   description of each entry. Entries include the Logic Programming
   Tutor from Paine's book, the DEC-10 public-domain library, the
   Linger natural-language corrector, a simple object-oriented
   add-on for Prolog, graph utilities, among other things.

   Files in the archive are also available on MS-DOS floppies for a
   nominal fee to cover the cost of floppies, postage, and packing. 

Prolog to SQL Compiler:
   The Prolog to SQL Compiler translates database access requests,
   which consist of a projection term and a database goal, to the
   appropriate SQL query. The compiler is written in standard Edinburgh
   Prolog and has been ported to a number of Prologs. The code posted to
   comp.lang.prolog works in ECRC's SEPIA Prolog, but should be easily
   ported to other Prologs. A detailed tech report on the implementation
   is available by email from draxler@cis.uni-muenchen.de (include
   your full postal address). The compiler is copyright, but may be used
   free of charge for non-commercial purposes and redistributed provided
   the copyright notice is retained intact.

PSI:
   PSI is a handy system for the management and retrieval of your
   personal data, be it addresses, CD collections, or bibliographic
   references. It is intended for the non-commercial user. It may not be
   as full-fledged as some data-base systems, but has some features that
   you won't find in most commercial systems. Also, you may find it
   easier to set up and faster to use. PSI is useful for a broad range of
   data. Indexing with descriptors makes searching for the data you need
   fast, and the interface to other data-base formats (import and export)
   is quite powerful. PSI was written in LPA MacProlog and is a "genuine
   'double clickable' Mac application". PSI runs on all Macs with System
   6 or 7 in 1MB of main memory. As LPA MacProlog isn't yet 32-bit clean,
   PSI isn't either. Extensive documentation and some examples are
   included. PSI is available by anonymous ftp from
   sumex-aim.stanford.edu, directory info-mac/app, file psi-23.hqx. It
   was also available on a recent Nautilus CD-ROM and will be on the
   first Info-Mac CD-ROM.

SEL:

   SEL is a declarative set processing language. Its main features are
   subset and equational program clauses, pattern matching over sets,
   support for efficient iteration and point-wise/incremental computation
   over sets, the ability to define transitive closures through circular
   constraints, meta-programming and simple higher-order programming, and
   a modest user-interface including tracing. The language seems
   well-suited to a number of problems in graph theory, program analysis,
   and discrete mathematics. The SEL compiler is written in Quintus
   Prolog and the run-time system is written in C. It generates WAM-like
   code, extended to deal with set-matching, memoization, and the novel
   control structure of the language. SEL is available by anonymous FTP
   from ftp.cs.buffalo.edu:users/bharat/SEL2/.  The FTP release comes with a
   user manual, bibliography of papers (including .dvi files), several
   sample programs, and source code. For further information, write to
   Bharat Jayaraman <bharat@cs.buffalo.edu>.

----------------------------------------------------------------
Subject: [1-3]  Mailing Lists

Prolog and Logic Programming:
   prolog@sushi.stanford.edu (general)
   prolog-hackers@sushi.stanford.edu (nitty gritty)

   All requests to be added to or deleted from this list, problems,
   questions, etc., should be sent to prolog-request@sushi.stanford.edu

   [The host sushi.stanford.edu no longer exists, as of 11/24/92.
    Does anybody know the new location of the mailing lists?]

Lambda Prolog:
   lprolog@cis.upenn.edu

   To subscribe, send mail to lprolog-request@cis.upenn.edu.

Electronic Journal of Functional and Logic Programming (EJFLP)

   EJFLP is a refereed journal that will be distributed for free via e-mail.
   The aim of EJFLP is to create a new medium for research investigating the
   integration of the functional, logic and constraint programming paradigms.

   For instructions on submitting a paper, send an empty mail message with 
      Subject: Help
   to: 
      submissions@ls5.informatik.uni-dortmund.de. 
   You will receive an acknowledgment of your submission within a few hours.

   To subscribe to the journal, send an empty mail message to the following
   address:
       subscriptions@ls5.informatik.uni-dortmund.de
   You will receive an acknowledgment of your subscription within a few days. 

   If there are any problems with the mail-server, send mail to
   ejflp.op@ls5.informatik.uni-dortmund.de. 

   The editorial board is: Rita Loogen (RWTH Aachen), Herbert Kuchen (RWTH
   Aachen), Michael Hanus (MPI-Saarbruecken), Manuel MT Chakravarty (TU
   Berlin), Martin Koehler (Imperial College London), Yike Guo (Imperial
   College London), Mario Rodriguez-Artalejo (Univ. Madrid), Andy Krall
   (TU Wien), Andy Mueck (LMU Muenchen), Tetsuo Ida (Univ. Tsukuba,
   Japan), Hendrik C.R. Lock (IBM Heidelberg), Andreas Hallmann (Univ.
   Dortmund), Peter Padawitz (Univ. Dortmund), Christoph Brzoska (Univ.
   Karlsruhe).

PDC-L:
   PDC-L@hearn.bitnet is a discussion list for PDC Prolog users.

Theorem Provers:
   theorem-provers@ai.mit.edu

   This (unmoderated) list is intended for announcements of interest to
   people interested in automated theorem proving.

   To subscribe, send your email address to theorem-provers-request@ai.mit.edu.

----------------------------------------------------------------
Subject: [1-4] Books and Magazine Articles

A BiBTeX bibliography of Logic Programming Conferences is available by
anonymous ftp from duck.dfki.uni-sb.de. See [1-2] above.

A partially annotated bibliography of work on integrating
object-oriented and logic programming is available by anonymous ftp
from menaik.cs.ualberta.ca:pub/oolog/ in PostScript and BibTeX
formats. Written by Vladimir Alexiev <vladimir@cs.ualberta.ca>.

The following books are regarded as popular and widely used. Also
included are some books about WAM. This is not intended to be a complete
Prolog bibliography.

   Ait-Kaci, Hassan, "Warren's Abstract Machine: A Tutorial Reconstruction",
   MIT Press, Cambridge, MA. 1991.
   ISBN: 0-262-51058-8 (paper), 0-262-01123-9 (cloth).

   Bratko, Ivan, "Programming in Prolog for Artificial Intelligence", 
   2nd Edition, Addison-Wesley, 1990 

   Campbell, J.A. (ed):	 "Implementations of Prolog", John Wiley, 1984

   Clocksin, W.F. and Mellish, C.S: "Programming in Prolog", 3rd Ed.
   Springer Verlag, 1987, $29. (Basic Introduction).

   Conlon, Tom: "Programming in Parlog". Addison-Wesley, 1989, 
   ISBN 0-201-17450-2.

   Covington, Michael A.; Nute, D.; and Vellino, A. "Prolog
   Programming in Depth", Scott, Foresman & Co., 1987. ISBN 0-521-40984-5

   Deville, Yves: "Logic Programming, Systematic Program Development",
   International Series in Logic Programming, Addison-Wesley, 1990, 338 pages.
   ISBN 0-201-17576-2. 
 
   Gregory, Steve: "Parallel Logic Programming in Parlog: The Language
   and Its Implementation", Addison-Wesley, 1987, ISBN 0-201-19241-1.

   Hogger, C.J.: "Introduction to Logic Programming", Academic Press 1984

   O'Keefe, Richard A.:	 "The Craft of PROLOG", MIT Press, 1990, 
   ISBN 0-262-15039-5.

   Kluzniak and Szpakowicz: "Prolog for Programmers", Academic Press 1985

   Kowalski, R.A.: "Logic for Problem Solving", New York 1979, Elsevier Publ.

   Le, Tu Van,  "Techniques of Prolog programming, with implementation
   of logical negation and quantified goals", John Wiley, New York, 1993.
   ISBN: 0-471-57175-X (American edition), 0-471-59970-O (International
   edition).  LnProlog, a Prolog interpreter that supports negative
   finding queries and quantified queries is available together with
   the book. 

   LLoyd, John: "Foundations of Logic Programming", 2nd Edition,
   Springer-Verlag, 1988. (Intro to logic programming theory.)

   David Maier and David S. Warren: "Computing with Logic: Logic
   Programming with Prolog", Benjamin Cummings, Menlo Park, CA, 1989.

   Dennis Merritt: "Building Expert Systems in Prolog", Springer-Verlag 1989.
   Explains how to build various expert system shells in Prolog, including
   forward/backward chaining, FOOPS, rete-network, frames and more. Includes
   complete source code listings. (Source code from the book is also
   sold on disk by Amziod.)

   Dennis Merritt: "Adventure in Prolog", Springer-Verlag, 1990. 
   Teaches Prolog by leading the reader through the construction of an
   adventure game. The exercises lead the reader through three other
   programs:  an intelligent database, an expert system and an order-entry
   program.  While most texts teach Prolog with fragments of interesting code,
   this book takes a more pragmatic (as opposed to theoretical approach) and
   shows the reader how to assemble complete Prolog programs.

   Nilsson, Ulf and Maluszynski, Jan, "Logic, Programming and Prolog",
   John Wiley & Sons, 1990, ISBN 0-471-92625-6.

   Peter Ross, "Advanced Prolog: Techniques and Examples",
   Addison-Wesley, 1989, ISBN 0-201-17527-4.

   Sterling, Leon (ed): "The Practice of Prolog", MIT Press, 1990
   ISBN 0-262-19301-9

   Sterling, Leon, Shapiro, Ehud: "The Art of Prolog: Advanced Programming
   Techniques", MIT Press, 1986 ISBN 0-262-19250-0

   Tick, E.: "Parallel Logic Programming". MIT Press, 1991

   David H. D. Warren: "An Abstract Prolog Instruction Set", Technical Note
   No 309, SRI International, Menlo Park, CA, 1983.

   David H. D. Warren, "Logic Programming and Compiler Writing," in
   Software-Practice and Experience 10(2), 1980.

   Wolfram, D.A., "The Clausal Theory of Types", Cambridge Tracts in 
   Theoretical Computer Science {\bf 21}, Cambridge University Press,
   1993.

   Subrata Kumar DAS, "Deductive Databases and Logic Programming",
   Addison-Wesley Publishing Company, July 1992, 448 pages. 
   ISBN 0-201-56897-7. 

Magazine Articles:

   BYTE Magazine, August 1987. 5 introductory articles on Prolog.

   Uwe Schreiweis: Beredte Logik, Konzepte der 'KI-Sprache" Prolog,
   (Eloquent Logic, Concepts of the AI language Prolog), iX Magazine,
   October 1992, pages 84-90.

   Uwe Schreiweis: Basis der Fuenf, Die Sprache Prolog in der Public
   Domain, (Base of the Five, Prolog in the Public Domain), iX Magazine,
   October 1992, pages 92-94.

   Uwe Schreiweis: Fuenfte Generation, Kommerzielle Prolog-Systeme,
   (Fifth Generation, Commercial Prolog Systems), iX Magazine, October
   1992, pages 96-102.

   Klaus Bothe: Weniger Raum, Speicherplatzbezogener Prolog-Benchmark,
   (Less Space, A Space Oriented Prolog Benchmark), iX Magazine, October
   1992, pages 106-7.

Magazines Related to Prolog:

   Logic Programming Newsletter (4 issues/yr)
   Included with membership in the Association for Logic Programming 
   ($20 regular, $10 students). For membership information, write to
   Cheryl Anderson (ALP), DoC-ICSTM, 180 Queens Gate, London SW7 2BZ,
   UK, phone +44-71-589-5111 x5011, fax +44-71-589-1552, or send email
   to alp@doc.ic.ac.uk. Contributions are welcome and should be sent
   to Andrew Davidson <ad@cs.mu.oz.au>. 

   AI Communications (4 issues/yr)
   "The European Journal on Artificial Intelligence"  ISSN 0921-7126,
   European Coordinating Committee for Artificial Intelligence.

   AI Expert (issued monthly) ISSN 0888-3785, Miller Freeman Publishers
   See a copy of the magazine for list of BBS's in NA. On CompuServe: GO
   AIEXPERT. Regularly reviews Prolog interpreters and compilers.

   Expert Systems (issued Feb, May, Aug and Nov) ISSN 0266-4720,
   Learned Information (Europe) Ltd. Subscription: GBP 85 or USD 110

   IEEE Expert (issued bimonthly) ISSN 0885-9000, IEEE Computer Society

   The Journal of Logic Programming (issued bimonthly), (North-Holland),
   Elsevier Publishing Company, ISSN 0743-1066

   New Generation Computing, Springer-Verlag. (LOTS of Prolog in it.)

----------------------------------------------------------------
Subject: [1-5]  The Prolog 1000 Database

The Prolog 1000 is a database of real Prolog applications being
assembled in conjunction with the Association for Logic Programming
(ALP) and PVG. The aim is to demonstrate how Prolog is being used in
the real world and it already contains over 500 programs with well
over 2 million lines of code. The database is available for research
use in SGML format from the Imperial College archive
   src.doc.ic.ac.uk:packages/prolog-progs-db/prolog1000.v1.gz
If you have or know about a program that might qualify for inclusion,
send an email message to Al Roth (alroth@cix.compulink.co.uk) for an
electronic entry form which only takes a few minutes to complete. Or
write to Prolog 1000, PO Box 137, Blackpool, Lancashire, FY2 0XY,
U.K., Fax: +44 253 53811 Telephone: +44 253 58081. (Floppy disks for
PC or Mac in text form are also welcome, and paper entries may also be
sent). Queries may also be addressed to: Chris Moss
(cdsm@doc.ic.ac.uk), Leon Sterling (leon@alpha.ces.cwru.edu).
----------------------------------------------------------------
Subject: [1-6] X-Windows Interfaces

PI:
   PI is an interface between Prolog applications and the X Window System
   that aims to be independent from the Prolog engine, provided that it
   has a Quintus-style foreign function interface (such as SICStus, YAP).
   It is mostly written in Prolog and is divided in two libraries: (1)
   Edipo, a low-level interface to the Xlib functions, and (2) Ytoolkit,
   a high-level user interface toolkit that allows you to create and
   manage graphical objects, define new classes of objects, and handle
   user interaction. PI is available by anonymous ftp from
   ftp.ncc.up.pt:/pub/prolog/pi_1.2.tar.gz and includes documentation
   and some demos. Also see ytoolkit.tar.Z. PI has been tested in
   Quintus Prolog 3.1.1 and SICStus 2.1 #8. Send questions, comments,
   and bug reports to Ze' Paulo Leal, Universidade de Porto, Portugal,
   <zp@ncc.up.pt>. 

XWIP: 
   export.lcs.mit.edu:/contrib/xwip.tar.Z 
   ftp.uu.net:X/contrib/xwip.tar.Z

   XWIP is an X Windows interface for PROLOG.

XPCE:

   XPCE is an object-oriented X-window interface toolkit for symbolic
   programming languages (Prolog and Lisp), offering a high level of
   abstraction for communication with X11, Unix processes, Unix
   networking facilities (sockets) and Unix files. XPCE's built-in
   classes (about 150) are mostly written in C.  The XPCE/Prolog
   interface allows the user to create and manipulate instances of these
   classes.  The user can also create new XPCE classes from Prolog.
   XPCE's window related classes provide various styles of menus,
   primitive graphical objects, compound graphical objects and Emacs
   oriented programmable text manipulation windows. The distribution
   contains several demo programs, including a diagram drawing tool
   (PceDraw), an animation demo, an Epoch-like editor, a graphical
   interface to Unix ispell, and an online hyper-text manual for XPCE
   itself.  A demo version of XPCE/SWI-Prolog for Linux may be obtained
   by anonymous ftp from swi.psy.uva.nl:pub/xpce/linux/ [145.18.114.17].
   The non-demo versions (for SWI-Prolog, SICStus Prolog, Lucid Common
   Lisp and LispWorks) require filling out a license and paying a fee
   (see the file pub/xpce/INFO).  To be added to the mailing list
   xpce@swi.psy.uva.nl send mail to xpce-request@swi.psu.uva.nl. Send
   bugs to xpce-bugs@swi.psy.uva.nl. [Mail to xpce-request bounced, 7/8/93.]

----------------------------------------------------------------
Subject: [1-7] Is there a straight-forward way of compiling Prolog to C?

Two methods of compiling Prolog to C have been reported in the
literature:
   -  WAM-based approaches
   -  Continuation-based approaches

The WAM-based approach compiles Prolog programs into a sequence of C
function or macro calls to WAM instructions. A brief description of
this method and some results are given in the paper:

   Michael R. Levy and R. Nigel Horspool, "Translating Prolog to C: a
   WAM-based Approach", in Proceedings of the Second Compulog Network
   Area Meeting on Programming Languages, and the Workshop on Logic
   Languages in Pisa, May 1993. (Available by anonymous ftp from 
   csr.uvic.ca:/pub/mlevy/.)

A "quick-and-dirty" method is to implement the WAM functions as described
in Ait-Kaci's tutorial, to label each call with a C case label, and then throw
a giant switch(P) statement around the entire sequence of calls, where P
is the WAM program counter.  On return from any instruction that modifies
P, a "goto Start" must be inserted. (This method was posted by Rob
Scott, <rbs@aisb.ed.ac.uk>, based on the JANUS papers by Saraswat.)

This strategy will work, but does not allow you to modularize your
prolog program. Predicates in prolog seem to generate 8 to 15 WAM
instructions per clause, so (assuming very roughly a clause per
line)you might expect your 1,000 line program to expand to a switch
statement containing up to 15,000 lines. Some C compilers can't handle
such a big switch statement.

Levy and Horspool solve this problem by compiling each Prolog
predicate to a seperate C function. A dispatch loop mechanism is used
to call the C functions. C switch statements are used only inside the
functions.  A predicate that calls another predicate sets P to contain
the address of the C function that implements the called predicate,
(and sets another register called W in their scheme) and then returns
to the dispatcher instead of calling the predicate. This bypasses the
C run-time stack.  This lets one exploit WAM optimizations (like LCO)
and yet retain the ability to create many modules. Their system
performs well when compared with byte-code compilers, but translated
code runs slower than code produced by native code compilers.  On the
other hand, it outputs portable ANSI C that can run on any machine
with a C compiler.

Other approaches to translating to C use continuations. The idea here
is to translate every Prolog predicate to a C function that has
an additional argument, namely a continuation function. If the function
fails, it simply returns, but if it succeeds, it executes the continuation.
When the function regains control from the continuation, it can then try
to generate a new solution. Here are two references
that describe systems built using continuations:

   J. L. Weiner and S. Ramakrishnan, "A Piggy-Back Compiler for Prolog",
   in Proceedings of SIGPLAN T88 Conference on Programming Language
   Design and Implementation, Atlanta, Georgia, 1988, pages 288-296.

   J. L. Boyd and G. M. Karam, "Prolog in C", Carleton University,
   Ottawa, 1988. 

Oliver Ridoux <Olivier.Ridoux@irisa.fr> reports that a
continuation-based approach works well when used to compile
LambdaProlog. His scheme translates every predicate into a function
that uses and modifies the success and failure continuations, with
recursion in the predicate becoming iteration in the continuation
passing mechanism. Inside the function one uses whichever intermediate
machine one fancies. Clauses within the function can be either the
branches of a switch statement or simply labelled when using a C
system that can store labels. This approach can still generate
monstrous C programs that blow up the C compiler, but the C programs
aren't as large as those generated by a one module to a function
scheme. Approaches that replace recursion in a predicate with
recursion in a function tend to overload the C stack and lead to
sloppy memory management.  Two technical reports describing Ridoux's
approach are available by anonymous ftp from ftp.irisa.fr in pm/*.ps.Z
and mailv06/*.ps.Z.

Michael Covington <mcovingt@ai.uga.edu> points out that a very simple
approach is to write a Prolog interpreter in C, then store the Prolog
program in that program's data! This will, of course, execute slowly.
One might imagine all sorts of other schemes. For example, a query
could be treated as a stack of "suspensions" (with the left-most goal
on top).  The top suspension is executed by selecting the appropriate
clause (possibly using indexing), and then, if necessary, pushing new
suspensions on the stack (the body of the clause whose head unified
with the current suspension).

Another question to ask is this: Is there any reason why you should want to
convert Prolog to C at all? George Saab of Quintus Corp. pointed out that,
with Quintus Prolog, you can create a standard .o file from a Prolog file,
which can then be linked with your other .o files to create an executable.
What's more, your Prolog code can be called from C code and vice versa.

On ther hand, the advantage of distributing "Prolog objects" as C rather than
.o files is portability.

M. Gaspari  and G. Attardi describe an approach to translating Prolog to C
based on the provision of a common runtime architecture. This is
described in 

   G. Attardi and M. Gaspari, "Multilanguage Interoperability", in
   Proceedings of The 3rd International Symposium, PLILP 91, 
   Springer Verlag, LNCS #528, 1991.

[Note: Thanks to Michael Levy, Department of Computer Science,
University of Victoria, <mlevy@csr.uvic.ca>, for writing this section.]

----------------------------------------------------------------
Subject: [1-8] What is the Basic Andorra Model and AKL?

The Basic Andorra Model is a way to execute definite clause programs
that allows dependent and-parallelism to be exploited transparently.
It also supports nice programming techniques for search programs.  The
idea is to first reduce all goals that match at most one clause.  When
no such goal exists, any goal (e.g., the left-most) may be chosen.
The BAM was proposed by David H. D. Warren, and his group at Bristol
has developed an AND-OR parallel implementation called Andorra-I,
which also supports full Prolog.  See, for example, 

   Seif Haridi and Per Brand, "Andorra Prolog, an integration of Prolog
   and committed choice languages", in Proceedings of the FGCS 1988,
   ICOT, Tokyo, 1988.

   Vitor Santos Costa, David H. D. Warren, and Rong Yang, "Two papers on
   the Andorra-I engine and preprocessor", in Proceedings of the 8th
   ICLP. MIT Press, 1991.

   Steve Gregory and Rong Yang, "Parallel Constraint Solving in
   Andorra-I", in Proceedings of FGCS'92. ICOT, Tokyo, 1992.

AKL (Andorra Kernel Language) is a concurrent constraint programming
language that supports both Prolog-style programming and committed
choice programming.  Its control of don't-know nondeterminism is based
on the Andorra model, which has been generalised to also deal with
nondeterminism encapsulated in guards and aggregates (such as bagof)
in a concurrent setting. See, for example,

   Sverker Janson and Seif Haridi, "Programming Paradigms of the Andorra
   Kernel Language", in Proceedings of ILPS'91. MIT Press, 1991.

   Torkel Franzen, "Logical Aspects of the Andorra Kernel Language", SICS
   Research Report R91:12, Swedish Institute of Computer Science, 1991.

   Torkel Franzen, Seif Haridi, and Sverker Janson, "An Overview of the
   Andorra Kernel Language", In LNAI (LNCS) 596, Springer-Verlag, 1992.

   Sverker Janson, Johan Montelius, and Seif Haridi, "Ports for Objects
   in Concurrent Logic Programs", in Research Directions in Concurrent
   Object-Oriented Programming, MIT Press, 1993 (forthcoming).

The above papers on AKL are available by anonymous ftp from sics.se in
/pub/ccp/papers. An (as yet non-released) prototype implementation of
AKL is available for research purposes (contact sverker@sics.se).

----------------------------------------------------------------
;;; *EOF*