Loving Common Lisp, or the Savvy Programmer's Secret Weapon

Cover Material, Copyright, and License

Preface

1. How To Read This Book?
2. Requests from the Author
3. Why Use Common Lisp?
4. Acknowledgments
5. Setting Up Your Common Lisp Development System and Quicklisp

Introduction

1. Why Did I Write this Book?
2. Free Software Tools for Common Lisp Programming
3. Making Book Examples Run Portably on Most Common Lisp Implementations
4. How is Lisp Different from Languages like Java and C++?
5. Advantages of Working in a Lisp Environment

Common Lisp Basics

1. Getting Started with SBCL
2. Making the repl Nicer using rlwrap
3. The Basics of Lisp Programming
4. Symbols
5. Operations on Lists
6. Using Arrays and Vectors
7. Using Strings
8. Using Hash Tables
9. Using Eval to Evaluate Lisp Forms
10. Using a Text Editor to Edit Lisp Source Files
11. Recovering from Errors
12. Garbage Collection
13. Loading your Working Environment Quickly
14. Functional Programming Concepts

Quicklisp

1. Using Quicklisp to Find Packages
2. Fixing Quicklisp Problems
3. Using Quicklisp to Configure Emacs and Slime

Defining Lisp Functions

1. Using Lambda Forms
2. Using Recursion
3. Closures
4. Using the Function eval

Defining Common Lisp Macros

1. Example Macro
2. Using the Splicing Operator
3. Using macroexpand-1

Using Common Lisp Loop Macros

1. dolist
2. dotimes
3. do
4. Using the loop Special Form to Iterate Over Vectors or Arrays

Common Lisp Package System

Input and Output

1. The Lisp read and read-line Functions
2. Lisp Printing Functions

Plotting Data

1. Implementing the Library
2. Packaging as a Quicklisp Project

Common Lisp Object System - CLOS

1. Example of Using a CLOS Class
2. Implementation of the HTMLstream Class
3. Using Defstruct or CLOS

Network Programming

1. An introduction to Drakma
2. An introduction to Hunchentoot
3. Complete REST Client Server Example Using JSON for Data Serialization
4. Network Programming Wrap Up

One Interface for Brave, Tavily, and Perplexity Web Search APIs

1. Two Kinds of Search API
2. The Shared Data Model
3. Source Code
4. Setting the API Keys
5. Running the Code
6. Interpreting the Results
7. Adding a Provider
8. Error Handling
9. Testing the Library
10. Wrap Up
11. Optional Practice Problems

Accessing Relational Databases

1. Database Wrap Up

Natural Language Processing

1. Loading and Running the NLP Library
2. Part of Speech Tagging
3. Categorizing Text
4. Detecting People’s Names and Place Names
5. Summarizing Text
6. Text Mining

Information Gathering Using DBPedia Lookup

1. Wrap Up

Web Scraping

1. Shared Utilities: utils.lisp
2. Extracting HTML Headers
3. Extracting Page Content as Plain Text
4. Converting a Web Page to Markdown
5. Wrap Up
6. Optional Practice Problems

Backpropagation Neural Networks

Hopfield Neural Networks

Anomaly Detection

1. What Is a Gaussian Distribution?
2. How the Detector Works
3. The Wisconsin Breast Cancer Dataset
4. Project Structure
5. Walking Through the Code
6. Running the Example
7. Using the API in Your Own Code
8. Understanding the Evaluation Metrics
9. Wrap Up

Semantic Web and Linked Data

1. Resource Description Framework (RDF) Data Model
2. Extending RDF with RDF Schema
3. The SPARQL Query Language
4. Case Study: Using SPARQL to Find Information about Board of Directors Members of Corporations and Organizations
5. Installing the Apache Jena Fuseki RDF Server
6. Common Lisp Client Examples for the Apache Jena Fuseki RDF Server

Implementing a Simple RDF Datastore and Partial SPARQL Support in Common Lisp

1. 1. RDF Triple Structure
2. 2. RDF Datastore
3. 3. Basic Datastore Operations
4. 4. Query Support
5. 5. SPARQL Query Structure
6. 6. SPARQL Query Parsing
7. 7. Query Execution
8. 8. Result Projection
9. 9. Main Query Execution
10. Conclusion
11. Optional Practice Problems

Automatically Generating Data for Knowledge Graphs

1. Implementation Notes
2. Generating RDF Data
3. Generating Data for the Neo4j Graph Database
4. Implementing the Top Level Application APIs
5. Implementing The Web Interface
6. Creating a Standalone Application Using SBCL
7. Augmenting RDF Triples in a Knowledge Graph Using DBPedia
8. KGCreator Wrap Up

Knowledge Graph Sampler for Creating Small Custom Knowledge Graphs

1. Project Definition
2. Overview of Architecture
3. Code

Knowledge Graph Navigator Common Library Implementation

1. Example Output
2. Project Configuration and Running the Application
3. Review of NLP Utilities Used in Application
4. Developing Low-Level SPARQL Utilities
5. Implementing the Caching Layer
6. Utilities in the Main Library File kgn-common.lisp
7. Wrap-up

Knowledge Graph Navigator Text-Based User Interface

1. Example Output
2. Text User Interface Implementation
3. Wrap-up

Knowledge Graph Navigator User Interface Using LispWorks CAPI

1. Project Configuration and Running the Application
2. Utilities to Colorize SPARQL and Generated Output
3. Main Implementation File kgn-capi-ui.lisp
4. User Interface Utilites File user-interface.lisp
5. User Interface CAPI Options Panes Definition File option-pane.lisp
6. Using LispWorks CAPI UI Toolkit
7. Wrap-up

Building a MicroGPT in Common Lisp

1. Introduction
2. Demystifying the Core Components
3. Conclusion
4. Complete Source Code Listing for microgpt.lisp
5. Wrap Up

One Library, Many LLM Providers: the litelm Library

1. The Provider Registry
2. Model Strings: “provider/model-name”
3. Finding the API Key
4. Headers and URLs: Small Pure Helpers
5. The Shared Send Path in completion
6. Embeddings Share the Same Path
7. Messages and Tools in Lisp Clothing
8. Streaming and Errors, Same Everywhere
9. Trying It Out
10. Adding a Provider or Swapping an Endpoint
11. litelm Chapter Wrap Up
12. Optional Practice Problems

Using Local LLMs With Ollama

1. Design Notes (Optional Material)
2. Implementation of Common Helper Code
3. Implementation of Generative AI Functionality
4. Implementation of Tool Use/Function Calling Generative AI Functionality
5. Using Built In Web Search Tool on Ollama Cloud
6. Ollama Chapter Wrap Up
7. Optional Practice Problems

Image Processing With Local Ollama Models

1. Design Notes for the Example code
2. Code to Process Images
3. Example Program Output
4. Optional Practice Problems

Knowledge Base Navigator: Building an AI-Powered Information System

1. Project Overview
2. Project Structure
3. Core Implementation
4. Running the Application
5. Key Takeaways
6. Dependencies
7. Environment Setup

Interfacing with External Programs: A Lightpanda Browser Client

1. The Problem: JavaScript-Rendered Web Content
2. Project Structure
3. Configuration
4. Running External Programs with UIOP
5. String Processing: Extracting Links
6. The Main API Function
7. Helper Functions
8. Usage Examples
9. Compatibility Package
10. Key Code Style Takeaways

Using a Local Document Embeddings Vector Database for Semantically Querying Your Own Data

1. Overview of Local Embeddings Vector Database to Enhance the Use of GPT3 APIs With Local Documents
2. Implementing a Local Vector Database for Document Embeddings
3. Using Local Embeddings Vector Database With OpenAI GPT APIs
4. Testing Local Embeddings Vector Database With OpenAI GPT APIs
5. Adding Chat History
6. Wrap Up for Using Local Embeddings Vector Database to Enhance the Use of GPT5 APIs With Local Documents
7. Optional Practice Problems

Agentic RAG Using the Gemini LLM APIs

1. Overview of the Agentic RAG Architecture
2. Project Structure
3. Computing Embeddings With the Gemini API
4. In-Memory Vector Store
5. The Multi-Agent Pipeline
6. Top-Level API and Demo
7. Running the Example
8. Offline Tests
9. Wrap Up for Agentic RAG
10. Optional Practice Problems

Prompt Engineering for Large Language Models

1. Two Types of LLMS
2. Prompt Examples
3. Prompt Engineering Wrapup

Client Library for the Google Gemini LLM APIs

1. Relationship to the litelm library
2. Example Use
3. Using Google’s “Grounding Search”
4. Using Google’s “Grounding Search” With Citations
5. Mixing Local Tools with Google Platform Tools Using the Interactions APIs.
6. Optional Practice Problems

AutoContext: Prepare Effective Prompts with Context for LLM Queries

1. Implementing the BM25 Algorithm
2. Implementing Vectorization of Text and Semantic Similarity
3. Implementation of Main Program
4. Example Generated Prompt with Context
5. Wrap Up For Generating Prompts with Contexts
6. Optional Practice Problems

AI-Powered Text Adventure Game

1. Architecture
2. The System Prompt
3. The Game Code
4. The Ollama Chat Function
5. Running the Game
6. Example Session
7. What Makes This Work
8. Customizing the Adventure
9. Wrap Up
10. Optional Practice Problems

Symbolic Mathematics in Common Lisp

1. The Data Layer
2. Symbolic Differentiation
3. Symbolic Integration
4. Wrap Up
5. Optional Practice Problems

WebKit Applications - macOS Only

1. Architecture Overview
2. Prerequisites and Building
3. Project Structure
4. The C Shim
5. CFFI Bindings
6. The Bridge: JS <—> Lisp Communication
7. High-Level API
8. Example 1: Hello World
9. Example 2: Counter App with Bridge
10. Example 3: Markdown File Viewer
11. API Reference Summary
12. Key Takeaways
13. Optional Practice Problems

A Persistent LLM Cache with SQLite

1. The System Definition
2. The Class and the Schema
3. Adding an Entry
4. Escaping LIKE Metacharacters
5. Looking Up Entries
6. Housekeeping
7. Testing the Library
8. Key Takeaways
9. Optional Practice Problems

A Daily-Use Gemini REPL with Search Grounding and Persistent Cache

1. Two Ways to Reach Gemini
2. How It Works
3. Prerequisites
4. Project Structure
5. The Main Application
6. Running the Tool
7. Example Session
8. REPL Command Reference
9. Key Takeaways

Building an AI Coding Assistant for Common Lisp

1. Architecture
2. Project Structure
3. File-System Tools
4. The Agent Core
5. Installation
6. Usage Examples
7. Example Session
8. Key Takeaways
9. Wrap Up
10. Optional Practice Problems

Hacking the SBCL REPL

1. Shell Access via a Reader Macro
2. AI Coding Agent Integration

Building a Neural-Symbolic Knowledge Graph Engine in Common Lisp

1. Two ways to know things
2. What we will build
3. The package
4. Unification: matching by structure
5. The triplestore and its durable log
6. A natural query syntax with reader macros
7. The query engine
8. Self-contained JSON
9. The neural fallback layer
10. The interactive REPL
11. The optional REST server
12. Command-line entry point and builds
13. Running NSK
14. Interpreting the results
15. Testing the engine
16. Wrap up
17. Optional practice problems

Overview of Probability

1. The result that surprises everyone
2. Fact, prediction, or wishful thinking?
3. Bayes in one line
4. The library
5. Frequentists vs. Bayesians
6. The frequentist check
7. The vocabulary you need
8. Practice problems
9. Wrap up

Book Wrapup