Lamber, my #LambdaCalculus -> Lisp compiler (https://github.com/aartaka/lamber) didn't handle big enough numbers (> 10-bit,) so I decided to implement some optimizations, reusing underlying #CommonLisp compiler to speed up and save space on numerics. It's not particularly reliable, because big LC numbers consume too much of the stack, but at least it's better than it used to be, almost reliably handling 12-bit numbers.

@rzeta0 since you have gone through introductions to quite a few different languages, including recently #commonLisp, I wonder if you might provide some comments and questions live in next week's #lispyGopherClimate where we'll have @ramin_hal9001, and treat the many different facets of the #lisp family (now and through history). I just think you might have something interesting to say.

#TIL (2) that Alexandria's mappend function is mostly unnecessary in #CommonLisp, because there's a standard mapcan that does roughly the same thing: mapping the function and joining the resulting lists. One downside might be that it uses nconc and not append, but it should be fine if you're mostly sticking with functional-ish style.

#TIL that #CommonLisp allows defining keyword arguments to be raw symbols and not keywords. So, theoretically, one can call a function like
(fn arg1 arg2 key1 kv1 key2 kv2)
instead of
(fn arg1 arg2 :key1 kv1 :key2 kv2)

Might make for some really undecipherable code, but a nice thing to have for e.g. user-facing commands.

Web developer KILLIAN.arts posted a review of Common Lisp: A Gentle Introduction to Symbolic Computation by David Touretzky. They read the book because:

"While I like web development, I have worried about specializing too much as a frameworker or a UI builder, missing out on more fundamental knowledge of computers and programming."

https://killianarts.online/en/articles/common-lisp-a-gentle-introduction-to-symbolic-computation

Answer: It's a cyclic number, to a point. But if you multiply it by 7, the answer is 999,999. There is both a mathematical connection (It starts with the repeating decimal in 1/7) and a connection to the Gurdjieff Work (used in formulating the Enneagram).

I thought it was interesting how it cycles, then 999,999 all of a sudden.

#lisp #commonlisp
https://infosec.exchange/deck/@ksaj/114233197996824014

#python
https://infosec.exchange/deck/@ksaj/114233177193135419

Wikipedia
https://en.wikipedia.org/wiki/142857

SpinPro™ was an expert system to design procedures for Beckman Instruments ultracentrifugation machines at biochemistry labs. Developed in Interlisp-D on Xerox 1108 workstations, SpinPro™ was deployed to IBM PC/XT computers as an application that ran under Golden Common Lisp by Gold Hill.

To learn more about SpinPro™ see this 1985 paper:

http://www.bitsavers.org/pdf/xerox/interlisp-d/newsletters/Masterscope_1-03_Aug85.pdf#page=2

Lisp Fun. A mathematical oddity.

Some numbers, when multiplied by consecutive numbers, produce a bit of a cycle. Try this code and notice that all the answers are permutations of the same number, 142857.

(defun cycle-142857 ()
"Prints the magical 142857 × 1..6 cycle."
(let ((n 142857))
(format t "~%Watch this cycle:~%")
(loop for i from 1 to 6 do
(format t "~d × ~d = ~d~%" n i (* n i)))))

When you've exhausted your fun running it, increment the number to see what 142857 * 7 gives you.

cl-po-parser is a Common Lisp package for parsing a GNU Gettext po file.

https://github.com/veer66/cl-po-parser

Joe Marshall on the granularity of Common Lisp packages and why he prefers coarse-grained packages.

https://funcall.blogspot.com/2025/03/the-obarray.html

https://archives.anonradio.net/202503260000_screwtape.mp3 #archive
#LispyGopherClimate #weekly #technology #podcast
- #climateCrisis #haiku by @kentpitman
- Kent vs billionaires' #welfare payments
https://netsettlement.blogspot.com/
- "Shark restaurant" a simple, original sanity test of 32B high performance #AI
https://codeberg.org/tfw/shark-restaurant-ai-sanity-test/src/branch/master/sanity-test.lisp
- My own #commonLisp #gamedev #programming trajectory, upsides and downsides.
- More short live-action #McCLIM video requests noted.
https://toobnix.org/w/qAnmJAKv1mhuwem7jJ1cJz
- More lisp history from @symbolics @rzeta0

Common Lisp Only. No Haskell (and no Canadians, either)

#lisp #commonlisp #haskell

https://newengland.com/travel/vermont/the-haskell-free-library-and-opera-house/

#programming #McCLIM #commonLisp #emacs #animating #graph #video.

https://toobnix.org/w/qAnmJAKv1mhuwem7jJ1cJz

Silent, two minutes thirty of just what me being at a computer is like. I write a closure that has an example graph tree in it, open the frame, hand-write a tree into the interactor the frame draws, start a background loop that randomly changes between graph frames.

The code demonstrates a way of asyncronously running animations in mcclim.
Source https://codeberg.org/tfw/lineage-tracing/src/branch/master/grapher.lisp

Comments, thoughts(, prayers)?

Graph animating Lisp McCLIM Emacs fiddling

https://toobnix.org/videos/watch/c727c72d-b3c9-49a1-b7c3-229ac7a1e491

Benben's audio engine (playback, FLAC reader/decoder, effect stack, resampling) is now all working in pure #CommonLisp, no bindings (well, except libao for the final output). Also working are a few other bits that I've ported over, like the configuration settings and metadata handling. Just FLAC files at the moment, but the others will follow very soon.

I haven't ported the UI yet, so it's just running in Emacs/Slime here with a very simple macro to init/deinit the audio output.

Performance is within just a few CPU percent of my existing Crystal version, and that should tighten up further.

#LinuxAudio

Sgolovin is experimenting with calling Rust functions and libraries from Common Lisp via FFI.

https://sgolovin.live/rust-inside-common-lisp

So, I've been taking another run at learning #CommonLisp. The last time I tried, I simply could not wrap my brain around macros. I'm reading the same book again, but this time am a more experienced programmer, and it all just clicked in my head.

I might actually end up enjoying #Lisp after all. I don't know if it'll dethrone #Haskell, but I'm starting to get why people like it.