The Common Lisp implementation of Medley Interlisp is closer to CLtL1 than ANSI but does support the condition system. The CONDITIONGRAPH tool shows the hierarchy graph of conditions.
The Common Lisp implementation of Medley Interlisp is closer to CLtL1 than ANSI but does support the condition system. The CONDITIONGRAPH tool shows the hierarchy graph of conditions.
Unfortunately the state of graphics programming frameworks in #commonlisp is not quite there yet, so it seems I'll be crawling back to #cpp and #openframeworks for my graphics needs.
Bits and pieces are there in the lisp ecosystem, but there's nothing at the moment that ties it all together in the way that oF or Processing does. In the future I might think of going down the Clojure/quill route, as it seems I should be able to leverage the full power of a lisp and all of Java/Processing.
Installing lisp for beginners.
https://screwlisp.small-web.org/fundamental/installing-lisp-etc/
So much computing is predicated on having this or a conscious alternative decision to it. Here is my attempt to help beginners get this far. What do you think?
> ANSI CL does not call for or need TCO as such.
My impression is that the ANSI committee didn't want to burden implementors by mandating tail call elimination (it is easier in Scheme), but don't take my word for it.
Besides, a stack overflow can be of great help to tackle endless loops, though that is a different story.
> DO exists because it is exactly like one common case of TCO.
Yes.
By the way, TCO as a TLA sounds like an OS/MVS thing...
@deech For the practicalities of working with #CommonLisp, the Common Lisp Cookbook is a good resource:
@ksaj @pkw @deech
oh, yeah, good book.
When I first went to read the art of the metaobject protocol and I got to where it says "if you are new to the common lisp object system, go read Sonya Keene's Object-oriented Programming in Common LISP: A Programmer's Guide to CLOS now then come back afterwards"
but I made the mistake of trying to read AMOP first (which I did not much understand or retain). #AMOP #bookstodon #commonLisp
#programming #workflow #GUI #mcclim #commonLisp #emacs #ecl #clisp #slime #leonardoCalculus #eepitch
https://screwlisp.small-web.org/lispgames/LCKR-object-oriented-simulation-simulation/
I have to say, I am really, really happy with how the flow into the thirty second GIF reflects my ideal computer useage.
Basically, I write a clim command that steers my leonardo system "like a person does" via emacs-server, visible in the background of the straightforward clim interactor GUI I generated in a couple lines.
#CommonLisp sturdy, industrial
#Scheme elegant, academic
#Emacs lisp the only actually useful lisp
#clojure if it weren't JVM-based... there's always one bad apple
#programming #gamedev #devlog #simulation #commonLisp #leonardoCalculus
https://screwlisp.small-web.org/lispgames/LCKR-a-simulation-backend-interface/
Really just a devlog! I slapped a #mcclim #gui onto my simulation so that I could click a button rather than type actions over and over again.
Then, I really just figured out that one simple-starting-arrangement idea I had doesn't work, because the only vertical move that gets triggered is from the lowest row of a tile to the highest row of the same tile.
Small "improvements".
Made some minor changes to MICRO COMMON LISP: better compatibility, pseudo-strings, more free nodes, etc.
http://t3x.org/mcl/index_d.html
#LISP #CommonLISP
#leonardoCalculus #Sandewall #programming #objectOriented #simulation #lisp #commonLisp
I feel like this article is one of those moments that is a monumental achievement for the writer themselves, but precedes adding glitzy picture making (which will eventually come too).
If you remember, I was recapitulating my somewhat failed #lispgamejam #gamedev . This time and in about half a week just now - I got the plant/insect/bird Breitenbergian Vehicle simulation workin'.
https://screwlisp.small-web.org/lispgames/LCKR-completing-the-simulation/
I got this fractal system switched over to the refactored/rewritten version of my Common Lisp library. For some reason, this is noticeably faster than in the original library (which has not always been the case).
Planning to write a post on #CommonLisp #REPL customization. Gathering state-of-the-art customizations. Remembered that I implemented native graphical debugger in #Nyxt once (immortalized in Ndebug https://github.com/atlas-engineer/ndebug). Went to check on the current state of Nyxt-native debugging.
And yes, native debugger was removed too, much like many other signature features. Which might be a reason to hold a grudge about my work being erased, I guess?
But I'm more saddened about this exemplary REPL hacking piece gone missing, really. I want to point at good examples of custom REPLs in my new post... and there aren't many anymore
Yay! Last-minute success! (only for left-to-right rendering, though)
It appears like I have the scaling working correctly and SDF fonts are rendering as expected. It's even working pretty nicely with the text sizing demo! It looks like I still have a bug with the text bounding box but, visually things are looking much better.
me relearning that #commonlisp's sort function is destructive: https://www.youtube.com/watch?v=kGnePGYgOoA
#hackThePlanet
#lispyGopherClimate #interview with 500 hats of @lambdacalculus
Their kofi: https://ko-fi.com/lambdacalculus
https://communitymedia.video/w/iEzEkc2SPuL5twaSnTEEq5 #archive
of #DOOM #redstaros #piratebox fame
Previewing their
#phreakNIC #technology #hacker
#HOPE #HOPE_16
talks!
Also #oldComputerChallenge happening RIGHT NOW https://screwlisp.small-web.org/occ/25/jul15.txt (I'm doing #xemacs emacs)
LambdaCalculus knows #emacs #lisp ...! And that's where it began then #commonLisp #CCL on the #macintosh
Here is some Common Lisp that definitely does not compete with Kap. It only runs in sbcl.
Try it. Marvel at its accuracy. Enjoy!
;; FACTORIAL-CALCULATOR.LISP
;; A straightforward OOP-based factorial calculator in Common Lisp.
;; Prompts for input, computes factorial, then exits cleanly.
(defpackage :factorial-calculator
(:use :cl)
(:export :main))
(in-package :factorial-calculator)
;;; Basic factorial function (simple recursion)
(defun factorial (n)
"Compute the factorial of N recursively."
(if (<= n 1)
1
(* n (factorial (1- n)))))
;;; Calculator class
(defclass factorial-calculator ()
((number :initarg :number :accessor calc-number
:documentation "The number to compute factorial of.")
(value :initform nil :accessor calc-value
:documentation "The computed factorial result.")))
(defmethod initialize ((calc factorial-calculator) n)
"Initialize calculator state."
(setf (calc-value calc) nil)
(format t ">>> Initialized calculator for ~A.~%" n))
(defmethod compute ((calc factorial-calculator))
"Compute and store the factorial in the calculator."
(let ((result (factorial (calc-number calc))))
(setf (calc-value calc) result)
(format t ">>> Computed factorial: ~A~%" result)))
;;; Main entry point
(defun main ()
"Prompt for input, compute factorial, and exit cleanly."
(format t "Please enter a non-negative integer: ")
(finish-output)
(let* ((input (read-line))
(n (parse-integer input :junk-allowed t)))
(if (or (null n) (< n 0))
(progn
(format t "Invalid input. Exiting.~%")
(sb-ext:quit :unix-status 1))
(let ((calc (make-instance 'factorial-calculator :number n)))
(initialize calc n)
(compute calc)
;; Display result
(format t "Result: ~A! = ~A~%" n (calc-value calc))
(format t ">>> Program complete. Exiting.~%")
(sb-ext:quit :unix-status 0)))))
;; To run:
;; sbcl --script factorial-calculator.lisp
;; or in REPL:
;; (load "factorial-calculator.lisp")
;; (in-package :factorial-calculator")
;; (main)
Ghost Ops use the language of ghosts. Common Lisp for starters. #CommonLisp #Lisp #DeadSwitch
http://tomsitcafe.com/2025/07/14/the-silent-operators-language-common-lisp-basics/
Got the final chip emulator ported to SatouSynth from YunoSynth: the YM2413 (aka VRC7). So now the two libraries have the same chips implemented, one in #CommonLisp, one in #CrystalLang. SatouSynth (the #lisp one) is just slightly ahead in terms of functionality since I didn't back-port VGM seeking into YunoSynth yet, but I will soon, probably in a day or two.
This also means #benben is now much closer to a v0.7.0 release. Just gotta fix up some unimplemented command line arguments, then finish the milestone for v0.7.0 (just one item left), then just do a thorough round of testing.
Testing will be a bit longer this time since the whole program was rewritten from scratch in Common Lisp, so I want to make sure everything is just right. I'll of course post new development AppImages as I go.
So my guess? Benben v0.7.0 will be out this fall.
#LinuxAudio