LinuxLinks.com
Newbies What Next ? News Forums Calendar

Search





News Sections
Home
General News (3987/0)
Reviews (636/0)
Press Releases (465/0)
Distributions (197/0)
Software (907/0)
Hardware (537/0)
Security (192/0)
Tutorials (356/0)
Off Topic (181/0)


User Functions
Username:

Password:

Don't have an account yet? Sign up as a New User


Events
There are no upcoming events




9 of the Best Free Lisp Books - Part 2

9 of the Best Free Lisp Books - Part 2

4. On Lisp

On Lisp
Website www.paulgraham.com/onlisp.html
Author Paul Graham
Format Postscript, PDF
Pages 432

On Lisp is a comprehensive study of advanced Lisp techniques, with bottom-up programming as the unifying theme. It is intended for anyone who wants to become a better Lisp programmer.

It gives the first complete description of macros and macro applications. The book also covers important subjects related to bottom-up programming, including functional programming, rapid prototyping, interactive development, and embedded languages. The final chapter takes a deeper look at object-oriented programming than previous Lisp books, showing the step-by-step construction of a working model of the Common Lisp Object System (CLOS).

Chapters cover:

  • The Extensible Language
  • Functions - explains how Lisp and Lisp programs are both built out of a single raw material: the function. Like any building material, its qualities influence both the kinds of things we build, and the way we build them
  • Functional Programming - describes the kind of construction methods which prevail in the Lisp world
  • Utility Functions - describes techniques for extending Lisp with new functions; how the ability to pass functions as arguments leads to greater possibilities for abstraction
  • Returning Functions - shows how to write functions which return other functions. Macros make the task of combining operators much easier
  • Functions as Representation
  • Macros - explains how macros work, gives techniques for writing and testing them, and looks at the issue of macro style
  • When to Use Macros - identifies when macros bring advantages
  • Variable Capture - Macros are vulnerable to a problem called variable capture. This chapter is about how to foresee and avoid them
  • Other Macro Pitfalls - discusses four more problems to avoid when defining macros: Number of Evaluations, Order of Evaluation, Non-functional Expanders, and Recursion
  • Classic Macros - shows how to define the most commonly used types of macros. They can be divided into three categories: macros which create context, macros for conditional and repeated evaluation, and another similarity between conditional and repeated evaluation
  • Generalized Variables - looks at the implications of setf, and then shows some examples of macros which can be built upon it
  • Computation at Compile-Time - describes a class of problems which could be solved by functions, but where macros are more efficient
  • Anaphoric Macros - shows that variable capture can also be used constructively
  • Macros Returning Functions - shows how to use macros to build abstractions which are equivalent to those defined in Chapter 5, but cleaner and more efficient
  • Macro-Defining Macros - presents three examples of macro-defining macros: one to define abbreviations, one to define access macros, and a third to define anaphoric macros
  • Read-Macros - discusses read-macros, which do their work at read-time
  • Destructuring - combines assignment with access: instead of giving a single variable as the first argument, we give a pattern of variables, which are each assigned the value occurring in the corresponding position in some structure
  • A Query Compiler - describes how to embed in Lisp a program to answer queries on a database
  • Continuations - looks at the use of continuations in Scheme, which has built-in support for them, and how to use macros to build continuations in Common Lisp programs
  • Multiple Processes - deals with a model of computation in which a computer runs not one single program, but a collection of independent processes
  • Nondeterminism - describes how macros can make Lisp handle another important class of details: the details of transforming a nondeterministic algorithm into a deterministic one
  • Parsing with ATNs - shows how to write a nondeterministic parser as an embedded language
  • Prolog - describes how to write Prolog as an embedded language
  • Object-Oriented Lisp - discusses object-oriented programming in Lisp. Common Lisp includes a set of operators for writing object-oriented programs. Collectively they are called the Common Lisp Object System, or CLOS

5. Performance and Evaluation of Lisp Systems

Performance and Evalution of Lisp Systems
Website www.dreamsongs.com/Books.html
Author Richard P. Gabriel
Format PDF
Pages 294

Performance and Evaluation of Lisp Systems focuses on what determines the performance of a Lisp implementation and how to measure it. It is the source of the so-called "Gabriel Benchmarks", which are still in use to benchmark Unix systems.

Chapters cover:

  • Introduction
  • The Implementation:
    • MacLisp - one of the first Lisps written on the PDP-10
    • MIT CADR - The CADR is the MIT Lisp machine; it is quite similar to the Symbolics LM-2. Both machines run a dialect of Lisp called ZetaLisp, which is a direct outgrowth of the MIT Lisp Machine Lisp
    • Symbolics - an intellectual descendent of the CADR and the LM-2 but has more hardware support for Lisp
    • LMI Lambda - the Lambda is a 32-bit microprogrammed processor with up to 64K 64-bit words of virtual control store and a 200 nanosecond microcycle time
    • S-1 Lisp - runs on the S-1 Mark IIA computer, which is a supercomputer-class complex instruction set computer. S-1 Lisp is almost entirely written in Lisp
    • Franz Lisp - written at the University of California at Berkeley by Richard Fateman and his students. It was originally intended to be a Lisp that was suitable for running a version of MACSYMA on a Vax
    • NIL - New Implementation of Lisp, one of the main influences on the design of Common Lisp
    • Spice Lisp - an implementation of Common Lisp written mostly in Common Lisp and partly in microcode
    • Vax Common Lisp - the first Common Lisp implemented on stock hardware
    • Portable Standard Lisp - a ĎLISP in LISPí that has been in development at the University of Utah since 1980 and at Hewlitt-Packard since 1982
    • Xerox D-Machine
  • The Benchmarks:
    • Tak - a variant of the Takeuchi function that Ikuo Takeuchi of Japan used as a simple benchmark
    • Stak - a variant of TAK; it uses special binding to pass arguments rather than the normal argument-passing mechanism
    • Ctak - a variant of TAK that uses CATCH and THROW to return values rather than the function-return mechanism
    • Takl - very much like TAK, but it does not perform any explicit arithmetic
    • Takr - a function that was defined to thwart the effectiveness of cache memories. TAKR comprises 100 copies of TAK, each with a different name
    • Boyer - a rewrite-rulebased simplifier combined with a very dumb tautology-checker, which has a three-place IF as the basic logical connective
    • Browse - it is essentially a theorem-proving benchmark
    • Destructive - benchmarks the 'destructive' (hence the name) list utilities. It does this by constructing a tree that is a list of lists and then destructively modifying its elements. This manipulation proceeds by means of a fairly elaborate iterative control structure
    • Traverse - tries to measure the performance that can be expected from the abstract data structure systems provided by the various Lisp dialects
    • Derivative - performs a simple symbolic derivative in which the data representation is the usual S-expression representation for functions
    • Data-Driven Derivative - exactly like DERIV except that functions taking derivatives of specific operators are located on the property list of the operator rather than buried in a piece of code
    • Another Data-Driven Derivative - a variant of DDERIV. It optimizes FUNCALL by using a FUNCALL-like function that assumes it is being handed compiled code
    • Division by 2 - this benchmark that divides by 2 using lists of n NILís
    • FFT - a FFT benchmark tests a variety of floating point operations including array references
    • Puzzle - solves a search problem that is a block-packing puzzle invented by John Conway
    • Triangle - similar in many respects to the Puzzle benchmark, but it does not use any two-dimensional arrays. Therefore it provides a differentiator between one-dimensional and two-dimensional array references
    • File Print - measures the performance of file output. The program checks to see whether there is a file with a certain name (there should not be). Then it creates and opens a new file with that name, prints a test pattern into that file, and then closes it
    • File Read - tests file input. It reads the file produced by FPRINT
    • Terminal Print - tests terminal output
    • Polynomial Manipulation - computes powers of particular polynomials
    • Conclusions

Performance and Evalution of Lisp Systems is released under the Creative Commons License.

6.†Common Lisp the Language, 2nd Edition

Common Lisp the Language, 2nd Edition

Website www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html
Author Guy L. Steele, Thinking Machines, Inc.
Format HTML, PostScript, DVI, LaTeX
Pages 1029

Common Lisp the Language is intended to be a language specification rather than an implementation specification (although implementation notes are scattered throughout the text).

It defines a set of standard language concepts and constructs that may be used for communication of data structures and algorithms in the Common Lisp dialect.

Chapters cover:

  • Data Types
  • Scope and Extent
  • Type Specifiers
  • Program Structure
  • Predicates
  • Control Structure
  • Macros
  • Declarations
  • Symbols
  • Packages
  • Numbers
  • Characters
  • Sequences
  • Lists
  • Hash Tables
  • Arrays
  • Strings
  • Structures
  • The Evaluator
  • Streams
  • Input/Output
  • File System Interface
  • Errors
  • Pretty Printing
  • CLOS, the Common Lisp Object System, with new features to support function overloading and object-oriented programming, plus complete technical specifications
  • Loops, a powerful control structure for multiple variables
  • Conditions, a generalization of the error signaling mechaniss
  • Series and generators
  • Plus other subjects not part of the ANSI standards but of interest to professional programmers

Next Section: 9 of the Best Free Lisp Books - Part 3

This article is divided into three parts:

Part 1, Part 2, Part 3

Bookmark and Share


Last Updated Sunday, August 31 2014 @ 03:53 AM EDT


We have written a range of guides highlighting excellent free books for popular programming languages. Check out the following guides: C, C++, C#, Java, JavaScript, CoffeeScript, HTML, Python, Ruby, Perl, Haskell, PHP, Lisp, R, Prolog, Scala, Scheme, Forth, SQL, Node.js (new), Fortran (new), Erlang (new), Pascal (new), and Ada (new).


Group Tests
100 Essential Apps
All Group Tests


Top Free Software
5 Office Suites
3 Lean Desktops
7 Document Processors
4 Distraction Free Tools
9 Project Management
4 Business Solutions
9 Groupware Apps
14 File Managers
10 Databases
21 Backup Tools
21 Productivity Tools
5 Note Taking Apps
9 Terminal Emulators
21 Financial Tools
5 Bitcoin Clients
21 Text Editors
21 Video Emulators
21 Home Emulators
42 Graphics Apps
6 CAD Apps
42 Scientific Apps
10 Web Browsers
42 Email Apps
12 Instant Messaging
10 IRC Clients
7 Twitter Clients
12 News Aggregators
11 VoIP Apps
42 Best Games
9 Steam Games
42 Audio Apps
5 Music Streaming
42 Video Apps
5 YouTube Tools
80 Security Apps
9 System Monitoring
8 Geometry Apps
Free Console Apps
14 Multimedia
4 Audio Grabbers
9 Internet Apps
3 HTTP Clients
5 File Managers
Programming
8 Compilers
9 IDEs
9 Debuggers
7 Revision Control Apps
6 Doc Generators
Free Web Software
21 Web CMS
14 Wiki Engines
8 Blog Apps
6 eCommerce Apps
5 Human Resource Apps
10 ERP
10 CRM
6 Data Warehouse Apps
8 Business Intelligence
6 Point-of-Sale

Other Articles
Migrating from Windows
Back up your data
20 Free Linux Books
24 Beginner Books
12 Shell Scripting Books


Older Stories
Monday 03/09
  • Raspberry Pi 2: Raspbian (ARMv6) v Linaro (ARMv7) (0)

  • Friday 03/06
  • Raspberry Pi 2 review (0)

  • Sunday 02/22
  • Chess in a Few Bytes (0)
  • Learn the Art of Computer Programming With These Great Free Beginner Books (2)
  • CD Audio Grabbers (0)

  • Monday 01/19
  • fitlet is a tiny fanless PC full of openness (0)

  • Sunday 01/18
  • MintBox Mini gives Linux users a pocket-sized PC (0)
  • 6 Invaluable Assembly Books (0)

  • Wednesday 01/14
  • Why Mac users donít switch to Linux (0)
  • MIPS Creator CI20 review (0)


  • Vote

    What Linux distribution do you run on your main computer?

    Debian
    Fedora
    Mint
    Slackware
    openSuSE
    Arch
    Ubuntu
    Redhat
    Mageia
    CentOS
    FreeBSD
    Results
    667 votes | 3 comments

    Built with GeekLog and phpBB
    Comments to the webmaster are welcome
    Copyright 2009 LinuxLinks.com - All rights reserved