LinuxLinks.com
Newbies What Next ? News Forums Calendar

Search





News Sections
Home
General News (3973/0)
Reviews (628/0)
Press Releases (464/0)
Distributions (187/0)
Software (878/0)
Hardware (522/0)
Security (192/0)
Tutorials (345/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
All Group Tests

Top Free Software
5 Office Suites
7 Document Processors
6 Lean Desktops
6 Desktop Search
9 Project Management
9 Groupware Apps
14 File Managers
10 Databases
21 Backup Tools
21 DVD Tools
21 Window Managers
21 Productivity Tools
9 Terminal Emulators
21 Financial Tools
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
11 Remote Display Apps
42 Best Games
42 More Games
21 More Games
21 Notable Games (1)
21 Notable Games (2)
21 Notable Games (3)
8 ASCII Games
9 Educational Games
42 Audio Apps
42 Video Apps
6 Screencasting Apps
80 Security Apps
9 System Monitoring
6 Family History Apps
11 PDF Tools
6 Music Servers
6 Collection Managers
7 Calculator Apps
8 Geometry Apps
Free Console Apps
14 Multimedia
Programming
8 Compilers
9 IDEs
9 Debuggers
7 Revision Control Apps
6 Doc Generators
'Free' Proprietary
21 Closed-Source Apps
Top Commercial Apps
42 Games
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

All Group Tests

Other Articles
Migrating from Windows
Back up your data
Distribution Guide
Distro Portal Pages
20 Free Linux Books
Running Linux Under Windows


Older Stories
Saturday 08/02
  • The Best Lightweight Graphical Email Clients (0)

  • Sunday 07/20
  • Excellent Free Distraction-Free Tools for Writers (0)
  • Pick of the Bunch: Console Internet Applications (0)
  • Mobile Phone Management Made Easy (0)

  • Saturday 06/28
  • Easy File Comparisons With These Great Free Diff Tools (0)
  • 9 ASCII Games You'll Want to Play Again and Again (0)

  • Friday 06/13
  • 12 Remarkable Free Shell Scripting Books (0)

  • Saturday 06/07
  • Open Source LDAP Solutions (0)

  • Monday 06/02
  • Delightful ASCII Art Tools (0)

  • Saturday 05/31
  • Best Tools for Network Inventory Management (0)


  • Vote

    What do you find MOST attractive about Open Source software?

    Amount of customization
    Security
    Freedom provided
    Speed of development
    Quality
    Multiple versions
    Cost
    Potential to contribute
    Ability to modify code
    Results
    4847 votes | 2 comments

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