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

Publication announcement of new AI programming book


Paradigms of Artificial Intelligence Programming: Case Studies in
Common Lisp

Peter Norvig (University of California, Berkeley)

Published Oct. 1991; ISBN 1-55860-191-0; 946 pages; paper; $39.95
Book/Software Package: $54.95 (specify Macintosh, DOS 3.5", OR DOS
5.25" disk; software also available via anonymous ftp)

"In simple, easily digestible steps, [Norvig] takes the reader from
classic problem solvers such as GPS to state-of-the-art
applications like unification grammars...This book is a joy to
read, and should be anyone's first choice for a hands-on AI
course."--David S. Touretzky (Carnegie Mellon University)

"Paradigms of AI Programming is a thorough, modern treatment of AI
programming techniques which describes both the pleasures and
pitfalls of writing in Common Lisp.  I hope it becomes the standard
text for the teaching of undergraduate AI courses."--James Hendler
(University of Maryland)

"This book will become one of the classics.  It goes further than
any other text currently available for teaching advanced Lisp
coding techniques and giving the reader a perspective on AI
programming.  This is definitely the best text I have seen...I
think this book will be a classic for Common Lisp as Abelson and
Sussman's is for Scheme."--David D. Loeffler (MCC)

"[This is] a book that I can recommend to experienced software
developers that they will use and enjoy...The honesty and matter-
of-fact style will appeal to those who have "seen it all" in
software development..."--Mary Boelk (Johnson Controls)

Paradigms of AI Programming is the first text to teach advanced
Common Lisp techniques in the context of building major AI systems. 
By reconstructing authentic, complex AI programs using state-of-
the-art Common Lisp, the book teaches students and professionals
how to build and debug robust practical programs, while
demonstrating superior programming style and important AI concepts. 
The author strongly emphasizes the practical, performance issues
of writing real working programs of significant size, including
chapters on troubleshooting and efficiency.  Also included is a
discussion of the fundamentals of object-oriented programming and
a description of the main CLOS functions.  This volume is an
excellent text for a course on AI programming, a useful supplement
for general AI courses and an indispensable reference for the
professional programmer.

Table of Contents:

Part I: Introduction to Common Lisp
This review is intentionally brief to leave more room in the book
for  presenting actual AI programs.  For some readers, another text
or reference book may be needed to clarify some of the features of
the language.  The author recommends several Lisp texts as

Chapter 1 Introduction to Lisp

Chapter 2 A Simple Lisp Program

Chapter 3 Overview of Lisp

Part II: Early AI Programs
This Part reconstructs four fundamental AI programs that use rule-
based pattern matching techniques.  Starts with relatively simple
versions of the programs, improves them and moves on to more
complex versions, enabling the reader to gradually acquire
increasingly advanced programming skills.

Chapter 4 GPS: The General Problem Solver
Presents GPS, the General Problem Solver--the implementation
follows the STRIPS approach.  Demonstrates problem solving, rule-
based systems, and search.

Chapter 5 Eliza: Dialog with a machine
Describes Eliza, a program that mimics human dialogue and uses
pattern matchine techniques.  

Chapter 6 Building Software Tools
Abstracts the techniques used in \GPS\ and \Eliza\ by turning them
into general, flexible tools that can be incorporated in other

Chapter 7 STUDENT: Solving Algebra Word Problems
Covers \Student, a program that solves high-school level algebra
word problems.  Shows a more powerful example of pattern matching
and rules to solve two problems: translating English into
mathematical equations, and solving the equations

Chapter 8 Symbolic Mathematics: A Simplification Program 
Develops a subset of the \Macsyma\ program for doing symbolic
algebra, including differential and integral calculus.  An analysis
of the simple rule-based version presented here will lead to the
more advanced version of Chapter 15.

Part III Tools and Techniques
Part III detours from AI to present some general tools for more
efficient programming.  Readers who master the material in this
part should be considered advanced \Lisp\ programmers.

Chapter 9 Efficiency Issues
Gives an overview of crucial efficiency issues that every
programmer should know including caching, indexing, compiling, and
delaying computation.

Chapter 10 Low Level Efficiency Issues
Covers efficiency issues such as using declarations, avoiding
garbage generation, and choosing the right data structure. Provides
the programmmer with a model of the relative costs of Lisp

Chapter 11 Logic Programming
Describes the three key ideas of Logic Programming: unification,
backtracking, and a uniform data base.  Shows how each technique
can be used separately, and how they can be brought together to
build a Prolog interpreter.

Chapter 12 Compiling Logic Programs
Developes a compiler for \Prolog\, which is 20 to 200 times faster
than the interpreter.

Chapter 13 Object Oriented Programming
Includes a discussion of the fundamentals of object-oriented
programming, a description of the main CLOS functions and an
example of the use of CLOS to implement an extensible searching

Chapter 14 Knowledge Representation and Reasoning
Explores the advantages and limitations of both logic-oriented and
object-oriented programming, and develops a knowledge
representation formalism using the techniques introduced in Part

Part IV Advanced AI Programs

Chapter 15 Symbolic Mathmatics with Canonical Forms
Techniques discussed in Part III are used to develop a much more
efficient implementation of \Macsyma: it uses the idea of a
canonical form to replace the very general rewrite rule approach
with a series of more specific functions.

Chapter 16 Expert Systems
The Emycin expert system shell is reconstructed, with emphasis on
the basic backward-chaining inference engine, the treatment of
certain factors, and having the system provide explanations of its
reasoning.  An example diagnosis program using the original Mycin
medical knowledge is demonstrated.

Chapter 17 Line-Diagram Labeling by Constraint Satisfaction Covers
the Waltz line-labelling algorithm for polyhedra (using Huffman-
Clowes labels).  Uses constraint propagation to solve the line-
labeling problem for polyhedra with trihedral angles.

Chapter 18 Search and the Game of Othello
Presents a program that plays an excellent game of Othello.  The
technique used, alpha-beta searching, is appropriate to a wide
variety of two-person games.  Covers advanced techniques such as
killer moves, iterative deepening and forward pruning.

A Natural language parser is developed over the next three
chapters: one as an introduction, one for Definite Clause Grammars,
and one for a fairly comprehensive grammar of English.

Chapter 19 Introduction to Natural Language
Covers context free grammar, top-down and bottom-up parsing, chart
parsing, semantic interpretation and preferences.

Chapter 20 Unification Grammars
Extends the linguistic coverage of chapter 19 and introduces logic
grammars, using the \Prolog\ compiler developed in chapter 12.

Chapter 21 A Grammar of English
Comprehensive grammar of English using the logic grammar formalism. 
The problems of going from a simple idea to a realistic,
comprehensive program are discussed.

Part V The Rest of Lisp
Includes material that is important for any serious \Lisp\

Chapter 22 Scheme: An Umcommon Lisp
Developes a simple \Scheme\ interpreter, then a properly tail-
recursive interpreter, and an interpreter that explicitly
manipulates continuations and supports call/cc.

Chapter 23 Compiling Lisp
Presents a s \Scheme\ compiler that generates instructions for a
hypothetical stack-based computer.  Both global and peephole
optimization techniques are demonstrated.

Chapter 24 ANSI Common Lisp
Presents the features that are unique to ANSI Common Lisp. This
includes the loop macro, series, error handling, and pretty
printing. The use of sequences and the package facility is also

Chapter 25 Troubleshooting
A comprehensive guide to troubleshooting and debugging \Lisp\

lists over 200 sources.  

Includes a general index and one for \Lisp\ functions.  In
addition, there is a directory of publicly available \Lisp\


Over 250 exercises are provided, many with solutions.

Morgan Kaufmann Publishers, Inc

Ordering Information:

     Shipping: In the U.S. and Canada, please add $3.50 for the   
  first book and $2.50 for each additional for surface shipping;  
   for surface shipments to all other areas, please add $6.50 for 
    the first book and $3.50 for each additional book.  Air     
shipment available outside North America for $35.00 on the     
first book, and $25.00 on each additional book.  

     American Express, Master Card, Visa and personal checks drawn 
    on US banks are accepted.

     Department NV
     2929 Campus Drive, Suite 260
     San Mateo, CA 94403
     Phone: (800) 745-7323 (in North America)
          (415) 578-9928
     Fax: (415) 578-0672
     email: morgan@unix.sri.com

This book is available locally from Morgan Kaufmann distributors in
the following territories.  PLEASE NOTE THAT PRICES AND SHIPPING

Countries Served:

Australia/New Zealand:
Telephone:  02-550-3855
Fax:  02-550-3860

Telephone/fax:  (03) 3205-4651

P.R.C./Taiwan/Hong Kong
Telephone:  413-5322
Fax:  413-7049

Telephone: (0273) 207-259
Fax:  (0273) 205-612