Lisp (.lisp, .lsp)

Overview

Lisp (LISt Processing) is one of the oldest high-level programming languages, second only to Fortran. Created by John McCarthy in 1958, Lisp is known for its unique syntax based on symbolic expressions (s-expressions), powerful macro system, and fundamental role in artificial intelligence research. The language family includes numerous dialects, with Common Lisp and Scheme being the most prominent.

Technical Details

• File Extensions: .lisp, .lsp, .cl, .el, .scm
• MIME Type: text/x-lisp
• Category: Programming Language
• First Appeared: 1958
• Paradigm: Functional, procedural, object-oriented
• Platform: Cross-platform

Key Features

Homoiconicity

• Code and data share the same structure
• Programs can manipulate their own code
• Powerful metaprogramming capabilities
• Macros that transform code at compile time

Symbolic Computation

• Native support for symbolic expressions
• List processing as fundamental operation
• Dynamic typing system
• Garbage collection

Interactive Development

• Read-Eval-Print Loop (REPL)
• Incremental compilation
• Live coding and debugging
• Runtime code modification

Syntax Examples

Basic S-expressions

;; Basic arithmetic
(+ 2 3 4)  ; => 9
(* (+ 2 3) (- 8 3))  ; => 25

;; Function definition
(defun factorial (n)
  (if (<= n 1)
      1
      (* n (factorial (- n 1)))))

;; List operations
(setf my-list '(1 2 3 4 5))
(first my-list)  ; => 1
(rest my-list)   ; => (2 3 4 5)
(append my-list '(6 7))  ; => (1 2 3 4 5 6 7)

;; Higher-order functions
(mapcar #'1+ '(1 2 3 4))  ; => (2 3 4 5)
(reduce #'+ '(1 2 3 4 5))  ; => 15

;; Conditional expressions
(defun sign (x)
  (cond ((> x 0) 'positive)
        ((< x 0) 'negative)
        (t 'zero)))

Object-Oriented Programming (CLOS)

;; Class definition
(defclass person ()
  ((name :accessor person-name
         :initarg :name
         :initform "Unknown")
   (age  :accessor person-age
         :initarg :age
         :initform 0)))

;; Method definition
(defmethod greet ((p person))
  (format t "Hello, I'm ~A and I'm ~A years old.~%"
          (person-name p) (person-age p)))

;; Creating and using objects
(setf john (make-instance 'person :name "John" :age 30))
(greet john)

Macros

;; Simple macro definition
(defmacro when-not (condition &body body)
  `(when (not ,condition)
     ,@body))

;; Usage
(when-not (> 5 10)
  (print "5 is not greater than 10"))

;; Loop macro
(defmacro dotimes-collect (var count &body body)
  `(loop for ,var from 0 below ,count
         collect (progn ,@body)))

;; Usage
(dotimes-collect i 5
  (* i i))  ; => (0 1 4 9 16)

Language Dialects

Common Lisp

• ANSI standardized (1994)
• Object-oriented (CLOS)
• Comprehensive standard library
• Multiple implementations

Scheme

• Minimalist design philosophy
• Lexical scoping
• Tail call optimization
• Continuation support

Clojure

• JVM-based Lisp
• Emphasis on immutability
• Concurrent programming
• Java interoperability

Emacs Lisp

• Embedded in Emacs editor
• Text editing focus
• Buffer manipulation
• Editor customization

Development Tools

Common Lisp Implementations

• SBCL: Steel Bank Common Lisp
• CCL: Clozure Common Lisp
• CLISP: GNU CLISP
• ECL: Embeddable Common-Lisp

Development Environments

• SLIME: Superior Lisp Interaction Mode for Emacs
• Sly: Sylvester the Cat's Common Lisp IDE
• Portacle: Portable Common Lisp development environment
• LispWorks: Commercial Lisp IDE

Build Tools

• ASDF: Another System Definition Facility
• Quicklisp: Library manager
• Buildapp: Create executables
• cl-launch: Common Lisp script launcher

Libraries and Frameworks

Web Development

• Hunchentoot: Web server
• Caveman: Web framework
• Clack: Web application environment
• Lucerne: Web framework

Graphics and GUI

• McCLIM: Common Lisp Interface Manager
• CEPL: Complete Engine for Productive Lisp
• Sketch: Creative coding framework
• LTK: Lisp Tk interface

Utilities

• Alexandria: Utility library
• Split-sequence: Sequence utilities
• Bordeaux-threads: Threading portability
• CFFI: Foreign function interface

Common Use Cases

Artificial Intelligence

• Expert systems development
• Natural language processing
• Knowledge representation
• Symbolic reasoning

Research and Education

• Programming language research
• Algorithm prototyping
• Mathematical computation
• Academic projects

Domain-Specific Languages

• DSL implementation
• Configuration languages
• Rule-based systems
• Code generation

Rapid Prototyping

• Interactive development
• Exploratory programming
• Research prototypes
• Proof of concepts

File Structure

Basic Program Structure

;;;; package.lisp
(defpackage #:my-project
  (:use #:cl)
  (:export #:main-function
           #:utility-function))

;;;; my-project.lisp
(in-package #:my-project)

(defun utility-function (x y)
  "A utility function that adds two numbers."
  (+ x y))

(defun main-function ()
  "Main entry point of the program."
  (format t "Result: ~A~%" (utility-function 10 20)))

System Definition (ASDF)

;;;; my-project.asd
(defsystem #:my-project
  :description "A sample Lisp project"
  :author "Your Name"
  :license "MIT"
  :depends-on (#:alexandria #:split-sequence)
  :components ((:file "package")
               (:file "my-project" :depends-on ("package"))))

Advanced Features

Condition System

(define-condition my-error (error)
  ((message :initarg :message :reader error-message)))

(defun safe-divide (x y)
  (restart-case
      (if (zerop y)
          (error 'my-error :message "Division by zero")
          (/ x y))
    (use-value (value)
      :report "Supply a value to use instead"
      value)
    (use-zero ()
      :report "Use zero as the result"
      0)))

Closures and Lexical Scoping

(defun make-counter (&optional (start 0))
  (let ((count start))
    (lambda ()
      (incf count))))

(setf counter (make-counter 10))
(funcall counter)  ; => 11
(funcall counter)  ; => 12

Notable Applications

• AutoCAD: CAD software (originally AutoLISP)
• Emacs: Text editor and computing environment
• Grammarly: Natural language processing
• ITA Software: Airline reservation systems
• NASA: Various space mission software

Learning Resources

• "Practical Common Lisp" by Peter Seibel
• "On Lisp" by Paul Graham
• "Structure and Interpretation of Computer Programs" (SICP)
• "Land of Lisp" by Conrad Barski
• Common Lisp HyperSpec (official reference)

Lisp remains influential in computer science education and continues to inspire modern programming languages with its elegant approach to symbolic computation and metaprogramming.