A few links

God Wrote in Lisp.

Lisp on Usenet.

My USENET posts of interest

1. Lisp Paradoxes
2. Macros
3. Forms, Lists, Trees, and Data Types
4. Variables
5. Passing arguments, modifying mutable objects
6. Miscellaneous
7. Object Oriented Programming
8. Improved DEFSTRUCT macro: run-time access to the fields
9. C-like pointers in Lisp
10. Various Macros and functions
11. Symbols
12. CLISP Specific Tricks
13. ECL Specific Tricks
14. Common Lisp, the Standard
15. Systems
16. Compilation
17. Fun & Miscellaneous
18. Why Lisp
19. Is Ruby a lisp?


• What I like in Lisp.

Lisp Paradoxes

• Lisp has not syntax. Lisp has no parentheses. Lisp as no lists.
• There is no list data type in lisp.
• Importance of syntactic exactitude.
• Lisp: don't worry about the syntax!
• Syntax doesn't matter; Smalltalk Block syntax reader macro.
• Syntax and grammar; Interpreting Syntax sections.
• Parenthesis-less s-exp editor.

Macros

• Macros receive their arguments unevaluated.
• Differences between macros and functions.
• Example macro - evaluation times.
• Backquote vs. macro -- When to use a macro?
• Macros are to make control structures.
• Building macros with functions.
• Using macros to generate different code from the same forms.
• Orthogonality between macros and backquote.
• Calling a macro at run-time.
• Calling a macro at run-time. Erratum.
• Gensym, make-symbol, intern, used in macro.
• Lisp the Programmable* Programming Language; TOOLEAN, TIF.
• Complex macros can just call functions.
• Exploring dynamic and lexical scopes, vs. evaluation times.
• Don't use a macro, analyze your problem first!
• Evaluation rules of Common Lisp; QUOTE vs. LIST.
• QUOTE: takes an argument and returns it without evaluating.
• Don't modify a literal list such as '(1 2 3).
• Macro with syntactic tree vs. Macro as source string.
• Alan Crowe's runable pseudo-code.

Forms, Lists, Trees, and Data Types

• Lists vs. forms.
• lists vs. abstract data types: remove-at; Common Lisp is a low level programming language!
• Lists vs. abstract data types: there's no list in lisp.
• Lists vs. abstract data types: various tree representations.
• Determining whether a given list is an executable form.
• Lists vs. abstract data types
• Various tree representations and WALK-TREE.
• Derecursivation of WALK-TREE.
• Code structure matching data structure.

Variables

• Local or Global, Lexical or Dynamic

Passing arguments, modifying mutable objects

• Arguments are passed by value, but most values are references.
• Passing lists by reference.
• Call by value, difference between passing a number or a list.
• (SETF (CAR X) 'N)
• REMOVE and functional programming style.

Miscellaneous

• How to know if a string is mutable?
• Program-data identity; a byte-code interpreter sketch
• CL compiler bootstrapping.
• Ensuring that a compilation terminates (with a timer).
• Saving and loading compiled anonymous functions.
• What goes in source files? How to start a lisp program? How does lisp know which files it needs? Do packages provide a namespace?
• Installing software and libraries: cl-loaders
• EQL, EQUAL, EQUALP.
• Example of the use of #.
• Reading #.
• Reader macros #+, #- and *features*
• Reader trick: defining a "\" macro (actuall a macro named " ").
• Indentation; python code reader macro.
• Description of a fixed-length record file.
• Description of a fixed-length record file.
• Implementing a in-memory database with a hash-table.
• Parsing fixed-length records.
• Comparison Lisp and C executable sizes.
• Common-Lisp-POSIX on cliki
• Anonymouse function recursion -- Y combinator.
• F2CL example.
• Formatter function.
• Formatter function, bis.
• Editing at the REPL.

Object Oriented Programming

• Hiding data in a closure.
• OO: Equivalence between object and closure.
• OO: Closure Object Equivalence.
• OO: Public, Protected and Private CLOS slots.
• OO: Drawing conclusions, account and shapes; the name of a generic function must not be a natural language noun
• OO: Design by contract; SET is not a LIST, SET has a LIST
• Design Patterns are Lisp Macros
• Design Patterns: the Memento Design Pattern implemented as a Lisp Macro.

Improved DEFSTRUCT macro: run-time access to the fields

• E. Handelman's DEFSTRUCT*
• DEFSTRUCT* bookkeeping slots.
• DEFINE-WITH-STRUCTURE

C-like pointers in Lisp

• & and deref
• & and deref and more

Various Macros and functions

• How to write programming exercises without COND.
• decision-tree macro.
• Dynamic function bindings DFLET.
• Aliasing long operator names like MULTIPLE-VALUE-BIND.
• Generalized accessor ->.
• Generalized accessor -> with (setf ->).
• Analysis of median of three values.
• Analysis of median of three values. Erratum.
• RESET-CLUSER
• ACOND - Anaphoric COND
• INTEGER-FROM-USER Using *QUERY-IO* and CLEAR-INPUT.
• Merge sort
• XOR
• Your own REPL.
• Sliding window in a vector ; FIFO queue.
• Implementing a FIFO.
• File cursors.
• LITERAL-HASH-TABLE
• Printing readable hash tables.
• COPY-ARRAY
• Introspection - eval - XEV
• Three implementations of sets with bits.
• Three implementations of sets with bits. Erratum.
• Bitmaps.
• Style: Writting assembler lisp.
• FORTH sketch.
• Inline script #!
• English number string arithmetic.
• DRIBBLE and IBCL.
• IBCL.
• Package conducts.
• Making WRITE prefer "::" to ":".
• Unicode with CL:ALPHANUMERICP.
• Decoding UTF-8 URL-encoded strings.
• Partial functions (currying).
• COMPUTED-TAGBODY
• COMEFROM-TAGBODY
• COMEFROM-TAGBODY addendum
• Adding syntax to Common Lisp

Symbols

• Symbol vs. strings.
• Lisp keywords -- CL:LAMBDA
• Using symbols instead of constants. Parsing expressions.
• We cannot rename a symbol.
• We cannot rename a symbol, really.
• We still cannot rename a symbol.
• LISP 1.5 symbol representation -- Lisp-1 vs. Lisp-2.
• specialp -- detect a symbol is declared special.
• Global Special Variable / Local Special Variable
• Symbols, Special Symbols, Bindings.

CLISP Specific Tricks

• Recursive tesselation.
• clisp: drawing postscript to gv
• clisp: WITH-TIMEOUT
• clisp: save an executable Hello World.
• clisp: SCREEN & ECMA-048.
• clisp: terminal KEYBOARD.
• clisp: editing a function from the REPL with emacs.

ECL Specific Tricks

• Simple C program, example of building a CL expression and calling ecl to evaluate it.
• ecldemo.c, a simple example showing how to define C functions to be called from lisp.

Common Lisp, the Standard

• CL-USER polution.
• My own CL primitives thread...
• A CL:REQUIRE implementation.
• CLHS doesn't specify much; A displaced array implementation.
• LOOP keywords.
• LOOP keywords, another example.
• CL: FILE-POSITION is not defined on POSIX.
• CL: FILE-LENGTH is underspecified for POSIX.
• CL: FILE-LENGTH allows implementations working on strange file systems.
• CL: FILE-LENGTH: file attributes for COMMON-LISP-2010.
• CL: What is not written in CLHS about WRITE and PRINT-OBJECT.
• CL: Common Lisp Conditions -- unusable.
• CL: (read-from-string "#.(values) 42")
• CL: LOOP NEVER + THEREIS
• CL: PACKAGE-USE-LIST may return a newly consed list, or not.
• CL: Pathname hosts
• CL: REQUIRE and PROVIDE deprecated.
• CL: Arrays are CONSTANTP?!?!
• CL: missing a posix file truncate?
• CL: Specification of ADJOIN

Systems

• Symbols, Packages, Files, Modules, Systems
• RC Files.

Compilation

• Compiler, Interpreter, Bootstrapping,
• Abstract Syntax Tree vs. Concrete Syntax Tree
• A Toy Translator.
• Toy Language Byte Code Compiler.
• Compile to a simple VM
• Garbage Collection

Fun & Miscellaneous

• OpenStep memory management.
• IQ and statistics.
• Larry Clapp: Valentina: Soul in Sapphire.
• The little imps in the computer.
• The trials of the computer Imp.
• Pointers are not a fundamental data structure.

Why Lisp

• Why Lisp macros are cool, a Perl perspective.

Is Ruby a lisp?

• cons, car, cdr
• merge sort