Having packages/modules be defined as single files is a fundamental programming language design error. #Python, but also #Erlang, #Scheme, the misguided package-inferred-system extension for #CommonLisp… Because no one wants a 10k lines file mixing dozens of concepts, you end up with a multitude of small packages for no good reason.
At least in Erlang you can just use whatever was loaded without manually importing every single module you need everywhere, but Python is as usual the worst.
This gives a very very #emacs -y experience in the browser: https://lisperator.net/blog/slip-a-lisp-system-in-your-browser/
> This is a #Lisp implementation (#CommonLisp wannabe, but oh well, we're still far from that) that runs in a #JavaScript VM.
Very much inspired by Common Lisp and Emacs/SLIME.
There's a "crazy clock demo" that runs in a canvas window.
Impressing.
#LispyGopherClimate #lisp #ai #peertube
https://communitymedia.video/w/7KpDL8dmSMN7zH6TxEgQbb
Resurrected Sandewall's #softwareIndividuals from 2014.
This episode is dedicated to general purpose interaction in the software individual / #CAISOR paradigm.
Next will be porting the dynamicwindows zetalisp zwei to McCLIM #commonlisp.
@prahou #unix_surrealism next #openbsd release art??
Also @pesco and @dougmerritt on IPE '84
co guest and join in on #lambdaMOO as always!
@pedromj seeing your iterative and recursive ones helped me see what I was /meant/ to do with series (which should be lazy and declarative):
``` #commonLisp #series
(defun better-fibs
(n &optional (x-1 0) (x-0 1))
(let* ((range (scan-range))
(fibonacci-series
(#M(lambda (n)
(declare (ignore n))
(psetq x-1 x-0
x-0 (+ x-1 x-0))
(values x-0))
range)))
(collect-nth n fibonacci-series)))
```
CL-USER> (better-fibs 4)
8
(Edit: (scan-range) on its own is just 𝗡)
@amoroso #clos #commonlisp #oop #lisp there was still a choice between various proposals then...
But the actual CLOS was not far away - the standard proposal was published in September 1988: https://dl.acm.org/toc/sigplan/1988/23/SI
Available above as a PDF. The final version was then published with the ANSI CL standard.
As installments of the ARTIFICIAL INTELLIGENCE column by Ernest Tello, in 1987 Dr. Dobb's Journal published a series of articles on OOP and object-oriented extensions for Common Lisp and Scheme. Back then CLOS was not yet on the radar but the Common Lisp extensions the articles covered already contained the main ideas of CLOS.
https://archive.org/details/1987-03-dr-dobbs-journal/page/126/mode/2up?view=theater
https://archive.org/details/1987-04-dr-dobbs-journal/page/146/mode/2up?view=theater
https://archive.org/details/1987-05-dr-dobbs-journal/page/132/mode/2up?view=theater
https://codeberg.org/tfw/pawn-75#headline-13
#Sandewall #SoftwareIndividuals
creating a knowledgebase, setting it as active, creating a file and
Minimally defining
- an entity that provides a #lisp function in the host #commonLisp
- an entity that provides a new CLE verb in the host #commonLisp
baby steps
I realized that I should have two #slime repls open, one running a Sandewallian software individual clisp-repl and one McCLIM running ecl-repl (or what have you) and things are getting weird.
This is because the software individual with a beliefbase about using McCLIM is /not/ the McCLIM lisp image itself, it is a separate lisp image that contains beliefs and actions for using McCLIM in another image. Which is trivial in #emacs with slime. #commonLisp #notThatCommonThoughTeeBeeAitch
@me I believe that I live in the Real World, though I cannot prove it. And I use #CommonLisp, for personal projects and for computational science.
@me You can find here 2 interviews of small teams using CL. One "secretly", one in a great open-source product:
"questions to Alex Nygren of Kina Knowledge, using Common Lisp extensively in their document processing stack"
https://lisp-journey.gitlab.io/blog/lisp-interview-kina/
"Arnold Noronha of Screenshotbot: from Facebook and Java to Common Lisp."
https://lisp-journey.gitlab.io/blog/lisp-interview-screenshotbot/
@me Personally, as a solo developer, I use CL more and more in my stack, ditching Python the more I can. I wrote about it: https://lisp-journey.gitlab.io/blog/running-my-4th-lisp-script-in-production/
Instead of extending a Python software I write independent modules in CL. It works well for standalone scripts too (read a DB, process data, send everything to a FTP, to a web service, by email…) It's such a joy.
On Discord, we see some are in big tech©, wrote their personal tool in CL and now it's part of the team's stack.
@me My partner writes theoretical physics simulations in #CommonLisp. He makes his graduate students learn lisp.
https://cosmos.phy.tufts.edu/~kdo/
Joe Marshall presents an insightful angle for thinking about Lisp parentheses and their benefits such as making refactoring easier.
https://funcall.blogspot.com/2025/04/lisp-programs-dont-have-parentheses.html
Joe Marshall on how he uses Lisp at work, with a practical (and quite impressive) example
The port of my music player #Benben to #CommonLisp continues... and as of tonight, the original S-Lang TUI interface is working! 
I even managed to fix a bug with the scrolling text fields and Japanese text.
The only C bindings going on here are: #libxmp (to play the .xm file), libao (final audio output), ZStandard (VGM decompression), and #S-Lang (TUI). The rest is pure Common Lisp, including the DSP effects and #VGM playback/chip emulation.
Normally you launch this from the command line (which is also working), but I did it with Emacs+Slime just to be fancy.
#LinuxAudio
@simendsjo @jackdaniel #XMPP has all those features, and there's a fairly big #Lisp / #Scheme / #CommonLisp channel there - https://xmpp.link/#lisp@conference.a3.pm?join
It might not have everything that #Discord does, but it's vastly better than #IRC. And there's a cost to using #proprietary and #centralized services, which people constantly forget about in chasing convenience and shiny features.
Here's a guide to help you get started.
https://contrapunctus.codeberg.page/the-quick-and-easy-guide-to-xmpp.html
Lisp sucks. Tell me what's wrong here:
(DEFVAR x 0) ; GLOBAL BADNESS STAYS
(DEFUN dO-StuFf (NUMBer)
(LET ((rEsUlT 1))
(DECLARE (SPECIAL X)) ; THIS IS LEGAL HERE
(SETQ X NUMBER)
(TAGBODY
StaRT
(IF (< X 1) (GO ENDz))
(SETQ rEsUlT (* rEsUlT X))
(SETQ x (- x 1)) ; NOTE: STILL USING GLOBAL x INSTEAD OF LOCAL X
(GO StARt)
ENDz)
(pRiNt (lIsT 'FACtoRiAl-oF NUMBER 'iS rEsUlT))))
(DEFUN nOW-dO-AlL ()
(LET ((I 0))
(LOOP
(WHEN (> i 5) (RETURN))
(Do-sTUFF i)
(SETQ i (+ i 1)))))
(nOW-dO-AlL)
Here's a new challenge for Lisp folks to figure out.
Why does this fail. And don't give the error message as the answer. WHY does this do what it does?
(defun who-am-i ()
(flet ((x () 'inner))
(labels ((x () (x))) ;;
(x))))
Is the third line calling inner or itself?
Okay you get one second hint: Yes, it overflows. Why?
That is the challenge.
