[More Lisp semantics]
Modern #Lisp systems distinguish between several different types of string-like-things:
1. symbols
2. strings
3. keywords
By convention we typically use symbols as handles on things bound in the environment, keywords as handles on things bound in maps (hash tables), and […]
Common Lisp Tamagotchi development log.
The core mechanics work. Phew. What a relief.
I am wondering what the best approach to the mini games will be. I think I will keep it simple. Every function for the mini games will have a similar structure, which would look like this:
1. Some prompt
2 […]
discussion happening on the sbcl-devel mailing list about implementing goroutines (fibers+scheduler).
Based on this talk by Kartik Singh: https://www.youtube.com/watch?v=S2nVKfYJykw
Discussion can be followed on the archive: sourceforge.net/p/sbcl/mailman/message/5...
#commonLisp
Common Lisp Tamagotchi development log.
starting to actually lay down some code now...
#lisp #commonlisp #functionalprogramming
[More Lisp semantics]
Also, in #CommonLisp, `=` with one arg returns `t`, but `=` with no args errors. `eq` with one arg errors.
In #Scheme both `=` and `eq?` return `t` for either one or zero args.
Again, I feel Scheme has this right. Do you concur?
[More Lisp semantics]
In #CommonLisp, `=` takes arbitrary numbers of args, but `eq` takes exactly two.
In #Scheme `=` takes arbitrary numbers of args, and `eq?` also takes arbitrary numbers of args.
In #Logo, `equalp` takes exactly two args, and I don't think there's an equivalent of `eq` […]
Common Lisp Tamagotchi development log.
I think I have it.
Most pet ... 'metrics' (forgive me) will increase over time. This will act like a 'high score'.
Perhaps hunger and exhaustion will increase per 'turn' from the user, kinda like fuel for some device. The idea will be, the more you […]
[Lisp semantics of nth]
SBCL #CommonLisp
(nth 2 '(1 2 3 4 5 6))
3
#Clojure
(nth '(1 2 3 4 5 6) 2)
3
#Scheme
(list-ref '(1 2 3 4 5 6) 2)
;Value: 3
So, they differ on the name of the function and the order of the arguments, but they all agree on zero-indexing the first element of a list.
This […]
just found out there was a commit to sbcl recently "co-authored by" an LLM
github.com/sbcl/sbcl/commit/66e8662...
#CommonLisp
A minimal GPT training and inference engine in a single file, with a custom autograd. This is a Common Lisp re-implementation of @karpathy.bsky.social's microgpt that I wrote for learning reasons.
github.com/gicrisf/micr...
#lisp #commonlisp #python #ai #ml #gpt
I just completed all 12 days of Advent of Code 2025! #AdventOfCode adventofcode.com
#CommonLisp github.com/brewski82/ad...
“Learn Lisp the Hard Way,” 2nd draft, last updated in 2022.
https://llthw.common-lisp.dev
#lisp #commonLisp
I just completed "Reactor" - Day 11 - Advent of Code 2025 #AdventOfCode adventofcode.com/2025/day/11
#CommonLisp github.com/brewski82/ad...
![The idea is pretty simple:
We write code, and sometimes we repeat ourselves there. So why not write code that abstracts over this repetition?
That is what _Macros_ are.
# C Macros
The lowest sophistication level (and the worst to work with) is something like C preprocessor macros. There, you do the easiest thing possible: A string replacement over the full following program text, irrespective of anything else.
So a Macro in C has this type signature:
```haskell
CMacro :: String -> String
```
---
```c title=simple.c
#define LALA "hohohoho"
char laugh[] = LALA
```
->
```c title=simple.c
char laugh[] = "hohohoho"
```
A standard C Macro usage looks like this:
```c title=min.c
#define min(X, Y) ((X) < (Y) ? (X) : (Y))
x = min(a, b); → x = ((a) < (b) ? (a) : (b));
y = min(1, 2); → y = ((1) < (2) ? (1) : (2));
z = min(a + 28, *p); → z = ((a + 28) < (*p) ? (a + 28) : (*p));
```
But since this is just doing straight string replacement, anything can happen (There's just no rules whatsoever for the expansion, so you can have unbalanced parentheses and other weird stuff).
They're still powerful, and you probably want to use them in C, but we can do better.
# Lisp Macros
Lisp Macros do better: They're not doing string replacement, but operate on the _syntax tree_.
```haskell
LispMacro :: Syntax -> Syntax
```
The also have a second pretty helpful property: They use _the same syntax as the base language_.
So their type is actually this:
```haskell
LispMacro :: LispSyntax -> LispSyntax
```
This is what they look like:
```lisp
> (defmacro the-macro (a b)
`(+ ,a (* ,b 3)))
> (the-macro 4 5) ;; => 19
```
This makes them way more generally useful (for example)
But they, too, have a problem: They're not _hygienic_.
That is, they're introducing variables into their target program that could be referenced both from the inside and outside.
This possibly couples the macro source code to the location it's being used in, which, if you squint, is the one unambigiously bad (default) feature in programming languages (again): Dynamic Scoping
There's an easy fix for this, however: gensym
But this makes for a relatively bad default, and we shouldn't rely on programmers knowing all the ways in which they could fuck up, and then having the mental workload left to fix them.
<Draft>
# Scheme Macros
Scheme was the first language that didn't have the problem of accidental scope leaking. They introduced _hygienic macros_.
# Racket Macros
Racket escalates this completely, and has facilities to define whole new languages.
</Draft>
# Notes
- I've skipped procedural macros#Procedural_macros) (never heard of them before)
- Damn, are those AI Memos badly scanned sometimes: https://dspace.mit.edu/bitstream/handle/1721.1/6111/AIM-057.pdf?sequence=2&isAllowed=y](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:fzyhtjbjqeoj2pmjajl5ehou/bafkreihcqnlk5min237iswmxu4ysvavtzbuhnt44xzmhgxybnn74gwqqxu)
The idea is pretty simple: We write code, and sometimes we repeat ourselves there. So why not write code that abstracts over this repetition? That is what _Macros_ are. # C Macros The lowest sophistication level (and the worst to work with) is something like C preprocessor macros. There, you do the easiest thing possible: A string replacement over the full following program text, irrespective of anything else. So a Macro in C has this type signature: ```haskell CMacro :: String -> String ``` --- ```c title=simple.c #define LALA "hohohoho" char laugh[] = LALA ``` -> ```c title=simple.c char laugh[] = "hohohoho" ``` A standard C Macro usage looks like this: ```c title=min.c #define min(X, Y) ((X) < (Y) ? (X) : (Y)) x = min(a, b); → x = ((a) < (b) ? (a) : (b)); y = min(1, 2); → y = ((1) < (2) ? (1) : (2)); z = min(a + 28, *p); → z = ((a + 28) < (*p) ? (a + 28) : (*p)); ``` But since this is just doing straight string replacement, anything can happen (There's just no rules whatsoever for the expansion, so you can have unbalanced parentheses and other weird stuff). They're still powerful, and you probably want to use them in C, but we can do better. # Lisp Macros Lisp Macros do better: They're not doing string replacement, but operate on the _syntax tree_. ```haskell LispMacro :: Syntax -> Syntax ``` The also have a second pretty helpful property: They use _the same syntax as the base language_. So their type is actually this: ```haskell LispMacro :: LispSyntax -> LispSyntax ``` This is what they look like: ```lisp > (defmacro the-macro (a b) `(+ ,a (* ,b 3))) > (the-macro 4 5) ;; => 19 ``` This makes them way more generally useful (for example) But they, too, have a problem: They're not _hygienic_. That is, they're introducing variables into their target program that could be referenced both from the inside and outside. This possibly couples the macro source code to the location it's being used in, which, if you squint, is the one unambigiously bad (default) feature in programming languages (again): Dynamic Scoping There's an easy fix for this, however: gensym But this makes for a relatively bad default, and we shouldn't rely on programmers knowing all the ways in which they could fuck up, and then having the mental workload left to fix them. <Draft> # Scheme Macros Scheme was the first language that didn't have the problem of accidental scope leaking. They introduced _hygienic macros_. # Racket Macros Racket escalates this completely, and has facilities to define whole new languages. </Draft> # Notes - I've skipped procedural macros#Procedural_macros) (never heard of them before) - Damn, are those AI Memos badly scanned sometimes: https://dspace.mit.edu/bitstream/handle/1721.1/6111/AIM-057.pdf?sequence=2&isAllowed=y
Inspired by my TypeScript macro finding yesterday, I started a note about Macros :)
#Lisp #Racket #Emacs #Clojure #DSLs #CommonLisp #Rust
I've completed "Factory" - Day 10 - Advent of Code 2025 #AdventOfCode adventofcode.com/2025/day/10
#CommonLisp github.com/brewski82/ad...
I've completed "Movie Theater" - Day 9 - Advent of Code 2025 #AdventOfCode #CommonLisp
adventofcode.com/2025/day/9
github.com/brewski82/ad...
ILsee is a Common Lisp GUI tool for viewing Interlisp source files.
journal.paoloamoroso.com/an-interlisp...
#interlisp #CommonLisp #lisp #McCLIM
I just completed all 12 days of Advent of Code 2025!
#AdventOfCode #commonlisp #common_lisp adventofcode.com
github.com/argentcorvid...
well, I guess i did it. I had no idea how to do part 2 of day 10, so I translated the dijkstra approach from the reddit thread from python.
Screenshot of a portion of the black and white desktop of a 1980s graphical workstation environment. The desktop has a grey background pattern and one window with a white background and a title bar with white text on a black background. The window is a Lisp REPL where the following expressions are evaluated, output printed, and values returned: 2/5_ (SETQ STACK '()) NIL 2/6_ (PUSH STACK 1) (1) 2/7_ (PUSH STACK 2) (2 1) 2/8_ (PUSH STACK 3) (3 2 1) 2/9_ (PUSH STACK 4) (4 3 2 1) 2/10_ (PUSH STACK 5) (5 4 3 2 1) 2/11_ (POP STACK) 5 2/12_ (POP STACK) 4 2/13_ STACK (3 2 1)
In Interlisp PUSH and POP manipulate stacks represented as lists and work like the corresponding Common Lisp macros, but PUSH swaps the order of the arguments.
interlisp.org/documentatio...
#interlisp #CommonLisp #lisp
I've completed "Playground" - Day 8 - Advent of Code 2025
#AdventOfCode #CommonLisp
adventofcode.com/2025/day/8
github.com/brewski82/ad...
I've completed "Laboratories" - Day 7 - Advent of Code 2025 #AdventOfCode adventofcode.com/2025/day/7
github.com/brewski82/ad...
#CommonLisp
Is anyone maintaining Portacle today, or interested in keeping it alive?
Even minimal maintenance or guidance would help many users, especially on Windows.
#CommonLisp #Portacle
github.com/portacle/por...
This is a nice read by @svw which trues to compare the speed of dot product calculation in Python, R and #CommonLisp.
I was surprised why `sum(a*b)` is slower than looping through the elements and calculate the dor product in base R 🤔 […]
hellos everyones i am zoë trout i like these thingies and #math #maths #lisp #commonlisp #sbcl #seqfan #oeis #lambdamoo #lambda #calculus #mathypeopleswhonevercommentonparityexceptingcollatzobvsetc #emacs #fsf #gnu #number #theory #numbertheory #ethics #sex #primes #frozen and i apparently bluesky!.
once again asking which libraries you feel are missing in the common lisp ecosystem
#commonLisp
so roswell uses the quicklisp dist by default, right?
https://github.com/atgreen/icl is installable via roswell, but fails because a dependency, cl-version-string is not in the default dist (it is on ultralisp).
#CommonLisp
I just completed "Playground" - Day 8 - Advent of Code 2025 with Common Lisp!
Not the most efficient at 16 seconds for part 2, but it gets it done.
adventofcode.com/2025/day/8
github.com/argentcorvid...
#commonlisp #common_lisp #AdventOfCode
I just completed "Laboratories" - Day 7 - Advent of Code 2025 with #commonlisp! #common_lisp #AdventOfCode adventofcode.com/2025/day/7
github.com/argentcorvid...
Ryan Burnside is doing Advent of Code 2025 in Common Lisp on Medley Interlisp.
www.linkedin.com/feed/update/...
#AdventOfCode #interlisp #CommonLisp
