---

Content of the Book

• Preface: Introductory notes from the author.
• To the Reader: A specific address to the person learning from the book.

I THE BASICS

• Getting Started: Covers the initial setup and basic interaction with the LISP environment.
• Numbers: Discusses numeric data types (integers, floats) and their representation in LISP.
• Lists: Introduces the fundamental LISP data structure, the list, and basic operations.
• Arithmetic: Explains how to perform mathematical operations using LISP’s prefix notation.
• Strings and Characters: Covers the creation, manipulation, and use of text data.
• Symbols: Details the unique LISP concept of symbols, used for variables and identifiers.
• Packages: Explains how LISP manages namespaces to organize symbols and avoid conflicts.
• Basic List Processing: Introduces common functions and techniques for manipulating lists.
• The Special Form quote: Explains the essential quote form used to treat code as data and prevent evaluation.

II PROGRAMMING IN PURE LISP

• Defining Your Own Functions: How to create new functions using defun.
• Defining Functions in Packages: Organizing custom functions within specific namespaces (packages).
• Saving for Another Day: Techniques for saving source code to files and loading it into the LISP environment.
• Predicate Functions: Using functions that return a boolean value (t or nil) to test conditions.
• Conditional Expressions: Controlling program flow using if and cond structures.
• Recursion: The fundamental concept of defining functions that call themselves to solve problems.
• Recursion on Lists, Part 1—Analysis: Applying recursion to deconstruct and analyze list structures.
• Recursion on Lists, Part 2—Synthesis: Using recursion to build or transform lists.
• Recursion on Trees: Extending recursive techniques to handle nested lists and tree-like data structures.
• The Evaluator: Understanding the internal LISP evaluator (eval) and the Read-Eval-Print Loop (REPL).
• Functions with Arbitrary Numbers of Arguments: Defining functions that accept optional, rest (&rest), or keyword (&key) arguments.
• Mapping Functions: Using higher-order functions like mapcar to apply an operation to each element of a list.
• The Applicator: Using apply and funcall to invoke functions dynamically.
• Macros: Introducing LISP’s powerful macro system (defmacro) for meta-programming and creating new syntax.

III PROGRAMMING IN IMPERATIVE LISP

• Assignment: Introducing state and changing the value of variables using setq.
• Scope and Extent: Understanding lexical vs. dynamic variable scope and variable lifetime.
• Sequences: Working with generalized sequence data types, including lists and arrays (vectors).
• Local Variables: Creating temporary, block-scoped variables using let and let*.
• Iteration: Using iterative constructs like do, dolist, and the loop macro as alternatives to recursion.
• Input/Output: Reading data from and writing data to streams, including the console and files.
• Destructive List Manipulation: Modifying list structures in-place (e.g., rplaca, nconc) for performance.
• Property Lists: Using symbols as dictionaries by attaching key-value pairs to them.
• Hash Tables: Creating and using efficient, general-purpose key-value data structures.

IV OBJECT-ORIENTED PROGRAMMING

• Methods: Defining generic functions and methods, a key feature of the LISP object system.
• Classes: Creating classes, defining slots (fields), and using inheritance with the Common Lisp Object System (CLOS).

V APPENDICES

• Solutions to Selected Exercises: Answers and explanations for practice problems in the book.
• COMMON LISP Reference Manual: A detailed reference guide to the language’s functions, macros, and features.
  • Organization
  • System-Dependent Operations
  • Control Functions
  • Utility Functions
  • Input/Output
  • CLOS
  • Arrays
  • Boolean Operators
  • Character Predicates
  • File Operators
  • Functions
  • Hash Tables
  • Lists and Conses
  • Numbers
  • Objects
  • Packages
  • Sequences
  • Strings
  • Symbols

Book Description

Common Lisp: An Interactive Approach by Stuart C. Shapiro is more than just another programming book. It’s like having a friendly tutor guiding you through the quirks and wonders of Common Lisp, one of the most fascinating languages out there. The book takes a hands-on approach, encouraging you to experiment, try out code, and yeseven make mistakes (because that’s how we learn, right?). If you’ve ever felt intimidated by functional programming or thought Lisp was just for academics, this book will change your mind in no time.

Book Overview

This book doesn’t drown you in jargon or theory. Instead, it invites you into the world of Common Lisp through practical exercises and interactive examples. Stuart C. Shapiro’s writing style is approachable and even a bit witty at timesso you won’t find yourself nodding off after a few pages! Each chapter builds on the last, so you’ll go from zero to writing real code before you know it. The focus is on understanding how things work under the hood while still having fun along the way.

Why Read This Book

Let’s be honestlearning a new language can feel overwhelming. But with Common Lisp: An Interactive Approach, it’s actually enjoyable! The interactive format means you’re not just reading; you’re doing. You’ll get your hands dirty with code right from the start. Plus, if you’re someone who likes to understand why things work (not just how), this book has your back. It explains concepts clearly and gives plenty of real-world examples. And hey, even if you’ve never touched Lisp before, that’s totally fineyou’ll pick it up faster than you think.

Who This Book Is For

This book is perfect for beginners who want to dive into programming with something unique like Common Lisp. Are you a student curious about functional programming? Maybe a hobbyist looking for a challenge? Or perhaps a seasoned coder wanting to broaden your horizons? You’ll find value here! Even if your only experience with parentheses is in math class, don’t worryShapiro makes sure you never feel lost. It’s also great for anyone who learns best by doing rather than just reading theory.

What You Will Learn

• The basics of Common Lisp syntax and structure (yes, those famous parentheses!)
• How to write interactive programs that actually do cool stuff
• Key concepts like recursion, data structures, and higher-order functions explained simply
• Troubleshooting tipsbecause let’s face it, bugs happen!
• The art of thinking differently about code (Lisp really does change your perspective)
• How to experiment safely and learn from your own code in real time
• A gentle intro to more advanced topics without getting overwhelmed

Report Broken Link

File Copyright Claim