Skip to main content
main-content

Über dieses Buch

Here is a presentation of LISP which is both practical and theoretical. For the practical, the syntax of the language, the programming styles, and the semantics of computation are carefully developed. For the theoretical, the algebra of interpreters, the lambda calculus as a foundation for LISP, and the algebraic significance of LISP's approach to artificial intelligence are discussed. As the title suggests, the book reaches beyond the technical side of LISP to present colorful applications, historical comments and quotations, computational philosophy, consequences of LISP's exceptional power, and much more. The material has been designed to appeal to a variety of readers, from the bright freshman to the practicing professional, and from computer scientists and mathematicians to chemists, engineers, and philosophers.

Inhaltsverzeichnis

Frontmatter

1. A First Look at LISP

Abstract
This chapter begins with a sketch of the origins of LISP. The second part of the chapter introduces the most basic and important features of the language. This includes LISP data, LISP terms, and examples of typical LISP-listener responses to the terms.
W. Richard Stark

2. Elementary Programming

Abstract
This chapter shows how the essential features of LISP are used in programming. The first section presents the ideas involved in straightforward (i.e., no loops) computation. Section 2.2 shows how recursive computations are programmed using COND, IF, and DEFUN. In Section 2.3, programs are developed and stored in files which are external with respect to the listener. Search functions are introduced and their importance is explained in Section 2.4. Methods for improving efficiency through the use of extra variables and functions are described in 2.5. Association lists and their application in an English-to-Inuit translator are presented in Section 2.6. Section 2.7 discusses fixed-point computation. Section 2.8 gives additional details on simple input and output functions and the use of streams.
W. Richard Stark

3. Deeper into Essential Structure

Abstract
In this chapter, we will take a deeper and more careful look at the remaining issues that are fundamental to LISP. The topics include the representation of data; details on EQ, EQUAL, SETF, as well as more familiar functions; the abstract syntax of LISP; examples of self-processing; and approaches to variable binding and scope determination.
W. Richard Stark

4. Computational Philosophy

Abstract
The essentials of LISP that we have developed so far support some interesting and important computational philosophy. At this point, a little philosophy—like a smile on a friend’s face—is an appropriate interruption to the serious study of LISP programming. The objective of this chapter is to introduce some theoretical aspects of functional programming and computing. This will consist of a bit of classical recursion theory, pure LISP, types of recursion, and the folklore of fixed-point computation.
W. Richard Stark

5. LISP Functions for Powerful Programming

Abstract
This chapter introduces major topics not developed in chapters 1 or 3. The first section covers the basics of debugging. The second presents applicative operators (APPLY, FUNCALL, MAPCAR, and MAPLIST) and their programming style. Section three deals with macros—functions which perform syntactic preprocessing on unevaluated arguments. Four discusses structures and vectors—objects not described in 3.1. As an application, structures are used to represent chemical atoms and fragments of molecules which are linked into desired molecules by a macro called BOND. In section five, function closures are explained. Finally, the last section introduces functions which surgically reconfigure pointers in data structures.
W. Richard Stark

6. Interpreters: From Algebra to LISP

Abstract
The interpretive style of computing is founded in abstract algebra and applied in implementations of computer languages from BASIC to LISP and PROLOG. This chapter begins with the abstract algebra of the subject, continues with interpreters for LISP, and concludes by mentioning the LISP compiler.
W. Richard Stark

7. Mathematical Foundations for LISP

Abstract
This chapter presents a highly simplified look at the lambda calculus—an algebraic formalization of computation. As our presentation proceeds, we will compare it to LISP. Now, LISP is not really an implementation of the lambda calculus, but it has inherited (deliberately and otherwise) some of its most important features. The comparison will throw some light on the issue of LISP’s relation to the lambda calculus.
W. Richard Stark

8. Automatic Reasoning, Algebraic Intelligence

Abstract
What is really happening when a machine does something that seems to be intelligent? If it recognizes a spoken word, proves a theorem, plays a good chess game, or solves a problem in calculus, then does it have some idea of what is going on? Of course not. Machine intelligence is fundamentally different from human intelligence. It is an illusion based on algebraic links between syntax and semantics. The semantics of a language represents meaning in terms of an object world. When a machine’s behavior seems intelligent, it is because it is semantically appropriate. However, the machine is simply a symbol shuffler—its abilities are limited to syntactic processing. Algebraic systems which provide strong formal connections between their semantics and their syntax make it possible for a symbol shuffling machine to appear to understand what it is doing.
W. Richard Stark

9. Bibliography

Without Abstract
W. Richard Stark

10. Answers to Selected Exercises

Without Abstract
W. Richard Stark

Backmatter

Weitere Informationen