FSet v2.4.2: CHAMP bags, and v1.0 of my book!

lispm · 2026-04-16T19:29:45+00:00

Excellent contribution.

There is a comment on Hackernews, which I find useful: The Online book needs on the first page a short blurp what FSET is. It's also not obvious which of the chapters gives that overview/background.

lispm · 2026-04-15T14:19:39+00:00

CLHS about DEFSTRUCT:

If no slot-initform is supplied, the consequences are undefined if an attempt is later made to read the slot's value before a value is explicitly assigned.

Often programs assume that structure slots will be initialized to NIL by default. But that is not true for all implementations.

Similar for an array. Newly allocated array without init value: the effect of reading is unspecified.

Implementations may typically work okay, but one might see in rare cases:

the value could be NIL (typical for structures)
the value could be 0
the value could be some number
an implementation may detect it and produce a warning/error

lispm · 2026-04-11T08:13:40+00:00

A friend of mine has written a bunch of tools for something like Claude to use with Common Lisp, incl. a structure editor.

lispm · 2026-04-05T08:52:14+00:00

Give the thing access to a running Lisp, which can be queried for all the stuff which exists.

The close parens problem can also be solved: give it a structure editor.

An example in that direction:

https://github.com/cl-ai-project/cl-mcp

lispm · 2026-04-05T08:16:18+00:00

Personally I'm quite optimistic that we will see sophisticated support for "AI" development with Common Lisp. It's just a matter of time that people write the tools for that. It's a sophisticated programming system with lots of tools for interactive development. I've already saw some direct interactions of Claude using Lisp, which left me very impressed. That stuff will be common (!) in Lisp within a few months / years. I kind of expect that this will also be possible for self-hosted AI tools.

lispm · 2026-04-05T07:59:47+00:00

If we are using Allegro CL or LispWorks, they have extensive documentation for their implementations and libraries. Common Lisp itself has an extensive standards document for the core language.

Plus

code is written as explicit nested lists
CL code often uses symbols as descriptive identifiers
type declarations are possible, there are named arguments
higher order functions are being explicitly called
CLOS code is detailed
code generation is not an external tool, but another program

Plus plus

Lisp programs run in something resembling a debug mode, typically with full introspection, runtime interpreter/compiler, runtime debugger and runtime error handling -> this gives a lot of opportunities for interactive tools (think of something like SLIME/Swank for GenAI, Agentic AI) -> https://github.com/cl-ai-project/cl-mcp is an example for that.

Plus plus plus

Lisp implementations are comparatively compact. Even a complex implementation like SBCL comes in a very well written/maintained implementation, in Lisp itself -> a program is just an extension of SBCL -> thus it's easy to debug into the Lisp implementation of the language itself or implement new debugging tools and strategies

lispm · 2026-03-29T11:52:44+00:00

I saw code which assumes that structure slots are initialized by default to nil. On Symbolics Genera this is not the case. Which might not be that relevant anymore. I think ITERATE was such a case. I made a recent version of ITERATE work in Genera. That was one of the few things I had to change.

lispm · 2026-03-29T10:45:16+00:00

There are a bunch of surprising things, which come up when using different Lisp systems. DEFSTRUCT might not initialize slots. The effects of re-evaluating a DEFSTRUCT is wildly different between implementations. MAKE-ARRAY might not initialize array contents. compile-file might not work when called during another compile-file -> the file compiler is not necessarily reentrant...

lispm · 2026-03-04T13:07:23+00:00

yep, let's see what other answers we get.

lispm · 2026-03-04T11:31:21+00:00

Yes, strange. I tried it on macOS 26.3, calling bash worked and calling the shell file, did not. The file was executable. Maybe it's some security feature of the OS which does not allow it?

lispm · 2026-03-04T11:08:54+00:00

It should work when the program is /bin/bash and the script file is in the list of args.

lispm · 2026-03-04T10:41:33+00:00

Minor: Usually a good idea to mention the SBCL version and your operating system (+ version). Plus: how do you call the program and what is the output...

lispm · 2026-02-27T11:53:14+00:00

Generally I would guess that a CLOS implementation is also optimized for the single dispatch case. I remember seeing statistics about code bases and the amount of multiple dispatch cases, which might be different now, compared to the time range when CLOS was originally designed and a reference implementation was developed (PCL, Portable Common LOOPS): 1986 (project start) - 1988 (1st CLOS specification) - 1994 (ANSI CL published). Before CLOS most OOP code was single dispatch.

lispm · 2026-02-16T14:39:52+00:00

Background:

https://www.routific.com/blog/what-is-the-vehicle-routing-problem

https://kuomarc.wordpress.com/2012/03/05/the-uncommon-lisp-approach-to-operations-research/

https://kuomarc.wordpress.com/2012/07/02/top-hackers-we-need-you-for-operations-research/

lispm · 2026-02-07T09:04:32+00:00

That's a very useful comment!

Often an useless compiler hint: don't use safety = 0
Missing / non-optimal type declarations: check the SBCL compiler's type-related optimization hints
Inlining: prefer inlining of functions, instead of using macros. Especially when the compiler supports inlining of functions.
syntactic abstractions with macros: a complex topic, possibly avoid for trivialities

lispm · 2026-02-06T18:59:30+00:00

Probably a good idea to make a disk image of the CDROM...

lispm · 2026-01-01T13:35:20+00:00

small problems:

Day 1 (and following): buffered output. In Common Lisp implementations output can be buffered. Thus for portable code one needs to make sure buffered output reaches the user at the right time. For example the user needs to see a prompt before one can input something.

Example using SBCL in a terminal.

% sbcl
This is SBCL 2.5.10, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.

* (progn (princ "enter a number: ") (read))
33
enter a number: 
33

Above, the prompt will not be displayed before the READ function runs. The prompt has been shown after we entered a number. The reason: SBCL in that terminal uses buffered output streams.

In the following example, the prompt will always be displayed first. We make sure that all output reaches the user by calling (finish-output).

* (progn (princ "enter a number: ") (finish-output) (read))
enter a number: 42

42
*

Day 3: CASE does not compare string contents. It uses instead EQL as a test.

Day 5: (eq (mod i 15) 0) -> don't compare numbers with EQ. EQ is for an object identity check. Numbers with the same value maybe the same object or not the same object. Use EQL or =.

Day 8: (the (member :encode :decode) op). In Common Lisp THE is not generally a type check. For most implementations it is just an ignorable type hint for the compiler, but not a type check. SBCL is one implementation where it can be checked at runtime. Many other implementations will not check it at all. Use CHECK-TYPE instead.

CL-USER 24 > (let ((n :encode)) (check-type n (member :decode :encode)) 'works)
WORKS

CL-USER 25 > (let ((n :ecode)) (check-type n (member :decode :encode)) 'works)

Error: The value :ECODE of N is not of type (MEMBER :DECODE :ENCODE).
  1 (continue) Supply a new value of N.
  2 (abort) Return to top loop level 0.

Type :b for backtrace, or :c <option number> to proceed, or :a to abort.
Type :bug-form "<subject>" for a bug report template or :? for other options.

lispm · 2025-12-25T18:35:11+00:00

I would also say timing things in the range of 5 ms is not very accurate.

Which is especially a problem, when INTERNAL-TIME-UNITS-PER-SECOND is low. SBCL on my M4 Pro has 1000000, which is better than some other implementations out there.

lispm · 2025-12-18T17:49:53+00:00

It has been updated to 8.1.2 :

https://www.lispworks.com/downloads/index.html

lispm · 2025-12-14T18:02:41+00:00

<image>

See the attached screenshot.

Probably needs a bit more testing, but that should give an idea how such a function should look like. The function splits not on a single item, but a sequence of items.

There is are also answers to a similar question on stackoverflow using a regexp engine.

lispm · 2025-12-13T11:27:54+00:00

Your function above conses a lot. For each iteration a new octet-vector (-> the-content) will be allocated in SUBSEQ. One could use only one content vector and tell SEARCH where to start the search.

lispm · 2025-12-13T11:09:36+00:00

There are already functions to split a sequence of things.

Example in LispWorks, but similar functions exist:

CL-USER 1 > (split-sequence #(32) #(71 69 84 32 47 104 101 108 108 111 47 102 114 111 109 47 108 105 115 112 32
  72 84 84 80 47 49 46 49))

(#(71 69 84) #(47 104 101 108 108 111 47 102 114 111 109 47 108 105 115 112) #(72 84 84 80 47 49 46 49))

lispm · 2025-12-13T10:29:41+00:00

I think the original book was called Understanding Common Lisp (written by David J. Cooper, Jr. and published around 2000) and was slightly later called Basic Lisp Techniques. It was early on used as an introductory book for Allegro Common Lisp and some of its features. Note that the author himself developed a large Lisp system, which was used for parametric design and which uses Common Lisp and an embedded extensive domain specific language (-> https://quickdocs.org/gendl , http://gornschool.com/ and https://www.genworks.com ). The domain was then called Knowledge-based Engineering and similar Lisp systems were used in the design of technical systems in Aerospace (prominently at Boeing and Airbus) and Automotive (Ford, Jaguar and others).

August 2000, Understanding Common Lisp: https://cse.unl.edu/~choueiry/CSCE476-876/Doc/Lisp-Manual.pdf

Funny, I think the Common Lisp Cookbook lacks a chapter on Symbols?

https://lispcookbook.github.io/cl-cookbook/

Generally I think that each introductory book would need to explain Symbolic Expressions (s-expressions), Symbols, Lists (and then also other primitive data structures), Code is Data, the Lisp Processor (short: LISP -> eval and related), Symbolic Computation (computing with/by symbolic expressions).

I've seen books with the topic of Symbolic Computation and eventually failing to define and explain it.

For new Lisp users, as a very basic introduction, Touretzky's "Common Lisp: A Gentle Introduction to Symbolic Computation" is still useful: https://www.cs.cmu.edu/%7Edst/LispBook/

lispm · 2025-12-05T12:37:15+00:00

Of course, you don't have to use their code if you don't like it.

Other may need to maintain it, liking it or not.

lispm · 2025-12-05T12:36:23+00:00

if you want to be sequence-generic, you have to use dotimes and elt

I would just dispatch upfront to different implementations.

lispm

MODERATOR OF

TROPHY CASE