|Which one gets invoked ("dispatch") is decided at run-time,
|in contrast to many other languages with "overloading".
"An Introduction to the Common Lisp Object System"
- Gregor Kiczales, Jim des Rivi|?res, and Daniel G. Bobrow?
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Mon, 29 Jun 2026 17:37:24 -0700, Paul Rubin wrote:
If garbage collection is so good, why donrCOt OS kernels use it?
You are probably using a shitty OS.
postscript is a complicated language in my mind, especially when
compared to C.
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Mon, 29 Jun 2026 07:33:05 -0000 (UTC), tfb wrote:
Lawrence D-|Oliveiro <ldo@nz.invalid> wrote:
If a GC is not finding long-dead objects to reclaim, then what
exactly is it doing? IsnrCOt that exactly what the rCLgarbagerCY is,
that it is supposed to rCLcollectrCY?
Like I said: you do not understand, at all, how a copying GC works.
ThatrCOs what we call a rCLpassive-aggressiverCY response: trying to
imply IrCOm wrong, but not specifically enough so that I can call you
up on it.
Where did you study psychology; I mean social worker class.
tfb <tfb@work.it.out> writes:
Lawrence D-|Oliveiro <ldo@nz.invalid> wrote:
Have they come up with any excuses as to why OS kernels donrCOt use
garbage collection?
Here is why: they're written either in C or in languages which must be
memory & call compatible with C. It is essentially impossible to implement >> a garbage collector in C. There is a famous counterexample: the Boehm GC. >> It would probably be possible to use that in an OS kernel written in C but >> I expect it would be very hard to retrofit it to an existing kernel. It's >> also (because C) not a copying collector.
Introduction to GC:
The GC package contains the Boehm-Demers-Weiser conservative garbage collector, which can be used as a garbage collecting replacement for the
C malloc function or C++ new operator. It allows you to allocate memory basically as you normally would, without explicitly deallocating memory
that is no longer useful. The collector automatically recycles memory
when it determines that it can no longer be otherwise accessed. The
collector is also used by a number of programming language
implementations that either use C as intermediate code, want to
facilitate easier interoperation with C libraries, or just prefer the
simple collector interface. Alternatively, the garbage collector may be
used as a leak detector for C or C++ programs, though that is not its
primary goal.
this is what guile uses and GCC can use.
C was a deeply appropriate language to write an OS for the PDP-11. At
every point since then there's been the choice of continuing to use C and
either a port of that OS or an implementation of a compatible OS or of
implementing a new, incompatible, OS. For at least 30 years there's really >> only been one answer to that question. And so, today, by a series of
perfectly reasonable choices, we've ended up with a vast OS implemented in >> a language which is now deeply inappropriate.
let me guess assembler is not your programming language of choice.
henceforth C.
Sadly we've also ended up with programmers who think the machines they
program for are giant PDP-11s, and as a result machines which spend a huge >> amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
tfb <tfb@work.it.out> writes:
Lawrence D-|Oliveiro <ldo@nz.invalid> wrote:
Have they come up with any excuses as to why OS kernels donrCOt use
garbage collection?
Here is why: they're written either in C or in languages which must be
memory & call compatible with C. It is essentially impossible to implement >> a garbage collector in C.
... There is a famous counterexample: the Boehm GC.
It would probably be possible to use that in an OS kernel written in C but >> I expect it would be very hard to retrofit it to an existing kernel. It's >> also (because C) not a copying collector.
On 10 Jul 2026 10:17:33 GMT, Stefan Ram wrote:
|Which one gets invoked ("dispatch") is decided at run-time,
|in contrast to many other languages with "overloading".
"An Introduction to the Common Lisp Object System"
- Gregor Kiczales, Jim des Rivi|?res, and Daniel G. Bobrow?
Maybe that doesnrCOt mean what you think it means. Remember, theyrCOre
using rCLdispatchrCY specifically for a language without infix operators. >Smalltalk was doing dynamic operator overloading before Common Lisp
was even thought of.
Of course you meant "for C." Many collectors are/were written "in C."
Sadly we've also ended up with programmers who think the machines
they program for are giant PDP-11s, and as a result machines which
spend a huge amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
The tragedy is not using Common Lisp for everything.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
[...]
Sadly we've also ended up with programmers who think the machines
they program for are giant PDP-11s, and as a result machines which
spend a huge amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct. My little
experience with Common Lisp is that it allows me to write the equivalent
fast code that I'd write in C, where speed matters. In other words, I
seem to gain nothing (other than more work) by writing typical
applications in C.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct.
On Fri, 31 Jul 2026 12:21:51 -0300, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct.
What a dumb idea. Common Lisp is full of legacy baggage to cater to proprietary pre-POSIX OSes which are now extinct.
Python can offer basic facilities like these in its standard library: <https://docs.python.org/3/library/subprocess.html> <https://docs.python.org/3/library/select.html>; where are the Common
Lisp equivalents?
On Wed, 29 Jul 2026 16:26:56 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Mon, 29 Jun 2026 17:37:24 -0700, Paul Rubin wrote:
If garbage collection is so good, why donrCOt OS kernels use it?
You are probably using a shitty OS.
So where is there a rCLnon-shitty OSrCY that uses garbage collection in
its kernel? Does the one *you* use have garbage collection in its
kernel?
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
[...]
Sadly we've also ended up with programmers who think the machines
they program for are giant PDP-11s, and as a result machines which
spend a huge amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct. My little
experience with Common Lisp is that it allows me to write the equivalent
fast code that I'd write in C, where speed matters. In other words, I
seem to gain nothing (other than more work) by writing typical
applications in C.
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Wed, 29 Jul 2026 16:26:56 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Mon, 29 Jun 2026 17:37:24 -0700, Paul Rubin wrote:
If garbage collection is so good, why donrCOt OS kernels use it?
You are probably using a shitty OS.
So where is there a rCLnon-shitty OSrCY that uses garbage collection in
its kernel? Does the one *you* use have garbage collection in its
kernel?
It depends on how the kernel is compiled.
Anton Antimo <anton@safunu.org> writes:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
[...]
Sadly we've also ended up with programmers who think the machines
they program for are giant PDP-11s, and as a result machines which
spend a huge amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct. My little
experience with Common Lisp is that it allows me to write the equivalent
fast code that I'd write in C, where speed matters. In other words, I
seem to gain nothing (other than more work) by writing typical
applications in C.
Wait until you read LISP:Lisp In Small Pieces. it's published in france.
PYTHON IS THE ONLY TRUE SOLUTION PYTHON HAS BEEN THE BEST THE ONLY
LANGUAGE FOR CENTURIES REFERENCE COUNTING WILL NOT CORRUPT YOUR PRECIOUS BODILY FLUIDS GARBAGE COLLECTION IS THE WORK OF SATAN PYTHON IS THE
STANDARD REFERENCE COUNTING MAKES THE BIRDS SING AND THE GRASS GREEN
GARBAGE COLLECTORS ARE CONTINUALLY TRAWLING THROUGH DEAD DATA LISP IS OBSOLETE EVIL NOBODY USES LISP USE PYTHON LIKE ME USE PYTHON REFERENCE
PYTHON LISP SLOW FAST PYTHON BEST YES PYTHON GARBAGE BAD PYTHON OBSOLETE
It is 2042.
Fade.
Well, that was only a leg-pull. Here is another paragraph of that
slop, to provide some balance.
Enterprise backend raA Java or C#
On Sat, 1 Aug 2026 07:49:41 -0400, Paul wrote:
Well, that was only a leg-pull. Here is another paragraph of that
slop, to provide some balance.
Enterprise backend raA Java or C#
This <https://www.infoworld.com/article/4091447/spring-ai-tutorial-get-started-with-spring-ai.html>
is supposed to be an example of how you do AI programming in Java.
Is anybody still mystified why normal people would rather use Python
instead?
[... Python, Rust ...]
Hello everyone!
I want to learn Common Lisp, but I don't really know what resources to
use.
What did you all use to learn? Is that even relevant? Is this newsgroup active?
Thanks for everyone in advice
For learning the basics about the language I highly recommend the
book "Practical Common Lisp" by Peter Seibel.
Also it does help to have a background in Emacs Lisp ...
For learning the basics about the language I highly recommend the book "Practical Common Lisp" by Peter Seibel.... Also it does help to have
a background in Emacs Lisp
On Mon, 29 Jun 2026 17:37:24 -0700, Paul Rubin wrote:
Python's inventors insist that it's not a Lisp, but we Lispers can
see that it's just a weird Lisp implementation with some surface
syntax added.
Lisp doesnrCOt have operator overloading.
On Sun, 5 Jul 2026 01:49:41 -0000 (UTC), I wrote:
On Mon, 29 Jun 2026 17:37:24 -0700, Paul Rubin wrote:
Python's inventors insist that it's not a Lisp, but we Lispers can
see that it's just a weird Lisp implementation with some surface
syntax added.
Lisp doesnrCOt have operator overloading.
Also: Python doesnrCOt need the whole multiple-value-return Heath-Robinsonesque mechanism. It has something simpler: destructuring assignment.
|------------------------------------------------------------------------------|
|" Ar an c||igi|| l|i de m|! I||il, scr|!obh Lawrence DrCOOliveiro: |
| |
| > On Sun, 05 Jul 2026 22:14:32 +0100, Aidan Kehoe wrote: |
| > |
| > > Ar an nao|| l|i is fiche de m|! Meitheamh, scr|!obh tfb: |
| > > |
| > >> steve g <Sgonedes1977@gmail.com> wrote: |
| > >>> |
| > >>> Does any program actually free or return memory to the kernel |
| > >>> before it exits? |
| > >>> |
| > >> Absolutely. LispWorks even has a function to do just this. |
| > > |
| > > Why, with a modern OS? For the sake of leak-tracking? |
| > |
| > rCLModernrCY OSes support multitasking. That means there are going to be |
| > other processes running and doing useful things in their way, not just |
| > yours. |
| > |
| > Giving up memory yourCOre not using is just part of acting like a |
| > well-behaved resident of the userland ecosystem. Because, at least on |
| > Linux, being too much of a memory hog is liable to awaken the Dreaded |
| > OOM Killer. |
| > |
| > And you do not want that. |
| |
|I broadly agree with that; my question above was from a misinterpretation of: |
| |
| > >>> Does any program actually free or return memory to the kernel |
| > >>> before it exits? |
| > >>> |
| > >> Absolutely. LispWorks even has a function to do just this. |
| |
|I took the question to mean rCLright before it exits,rCY which would be a waste of|
|time." |
|------------------------------------------------------------------------------|
arsa Aodh|in mac Eochadha.
N|! c||is n|iire sin!
Is mise le meas,
Niocl|is|in Caile|in Glost|-ir
(S. HTTP://Gloucester.Insomnia247.NL/ fuer Kontaktdaten!)
George Neuner <gneuner2@comcast.net> wrote:
Of course you meant "for C." Many collectors are/were written "in C."
Yes, and specifically 'for large existing C programs which you are not >willing to completely reengineer'. At any point since it started running
on machines where a GC would be a practical proposition[*], the Unix kernel >was such a program.
There is more, I think: the Sapir-Whorf hypothesis is at least partly true >for programming languages: the language determines what its programmers can >(easily) think. You obviously could write GC-friendly C programs, but C >programmers exposed to large existing C programs probably would find them
so alien they probably wouldn't actually write them. You really need a new >language (which, in turn, would influence how people think, but in
different ways).
And let's leave out compatibility questions: 'you mean to port my device >driver I have to ...?'
All of this means that, once you've got large C programs and a culture
around them you can't just drop in GC.
[*] Yes, I do not claim GC is suitable for all machines. I've written >programs for the 1802.
On Wed, 29 Jul 2026 16:08:10 -0400, steve g wrote:
Specific substantive response still lacking.
On 01/08/2026 6:46 AM, Lawrence DrCOOliveiro wrote:
On Fri, 31 Jul 2026 12:21:51 -0300, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:What a dumb idea. Common Lisp is full of legacy baggage to cater to
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct.
proprietary pre-POSIX OSes which are now extinct.
As always, you start off by mouthing your own ignorance.
* OpenVMS is both sold and ported to the x86. https://vmssoftware.com/
* OS/2 is being sold and supported, under a new brand name.
https://www.arcanoae.com/
Flecks of foam and blood land on the keyboard. No birds sing; what once
was grass is now dust and ash.
Still he types, faster and faster now, singing and chanting.
From the computer in the shack a cable runs. The camera follows it, to its end: copper cores poking through charred insulation.
Fade.
On Fri, 31 Jul 2026 23:52:27 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Wed, 29 Jul 2026 16:26:56 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Mon, 29 Jun 2026 17:37:24 -0700, Paul Rubin wrote:
If garbage collection is so good, why donrCOt OS kernels use it?
You are probably using a shitty OS.
So where is there a rCLnon-shitty OSrCY that uses garbage collection in
its kernel? Does the one *you* use have garbage collection in its
kernel?
It depends on how the kernel is compiled.
What a load of nonsense. There is no OS kernel you have access to,
that uses garbage collection for internal memory management. Just
admit it instead of trying to bullshit.
On 01/08/2026 11:59 AM, steve g wrote:
Anton Antimo <anton@safunu.org> writes:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:Wait until you read LISP:Lisp In Small Pieces. it's published in france.
[...]
Sadly we've also ended up with programmers who think the machines
they program for are giant PDP-11s, and as a result machines which >>>>>> spend a huge amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct. My little
experience with Common Lisp is that it allows me to write the equivalent >>> fast code that I'd write in C, where speed matters. In other words, I
seem to gain nothing (other than more work) by writing typical
applications in C.
I read the French edition. /Principes d'Implantation de Scheme et
Lisp/, and it's now available as ebook on Amazon. I recommend it,
it's a really fun book. I believe it's the /second edition/, and
may have a little bit different content than the English one, which
I haven't read.
Do you read French?
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
There is no OS kernel you have access to, that uses garbage
collection for internal memory management. Just admit it instead of
trying to bullshit.
well thanks. as Microsoft's Singularity apparently uses a GC.
tfb <tfb@work.it.out> wrote:
Waldek Hebisch <antispam@fricas.org> wrote:
Consider:
(defun c_args_as_string (arguments)
(cond
((null arguments) "")
(t (let ((res (c_type_as_string (nth 1 (car arguments)))))
(dolist (el (rest arguments))
(setf res (concatenate 'string res ", "
(c_type_as_string (nth 1 el)))))
res)))
)
I do not say it is great code, but I find it easier to handle than
more traditional Lisp style.
OK, that's just weird. Everything is fine and you've got lots of close
parens at the ends of lines in the standard way, but then something breaks >> and you have the final close paren on its own at the left margin. I can't >> even begin to understand what motivates that.
If you look at rational factors: I need to see where given piece of
code ends. In bigger function with multiple blocks inside I would
put some parentheses in separate lines to signal ends of blocks.
There is also issue of seeing what is changed. Code frequently
gets added at end of existing functions. Separate "end"
parenthesis means that in such case old lines are unchanged and
only new lines get added. Version with parentheses at end of
line needs to move closing parentheses from old line to new
one.
I trying to be conservative with putting end parentheses on
separate lines. One, doing this on too many constructs would
add too many extra lines. Second, putting such parentheses
in too many places would limit their value, they would be no
longer good cue. Third, really small pieces of code are
managable without extra cues, it is bigger pieces when it
matters. Fourh, I want to limit dissatisfaction of Lispers
used to traditional style in case they need to work on code
that I write.
But the same question: if you wrote it in Python, would you leave an extra >> little blank line for that weird closing paren?
"no trailing white space".
On Tue, 04 Aug 2026 22:47:33 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
There is no OS kernel you have access to, that uses garbage
collection for internal memory management. Just admit it instead of
trying to bullshit.
well thanks. as Microsoft's Singularity apparently uses a GC.
Try using past tense. ItrCOs a dead project. Wonder why?
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Tue, 04 Aug 2026 22:47:33 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
There is no OS kernel you have access to, that uses garbage
collection for internal memory management. Just admit it instead
of trying to bullshit.
well thanks. as Microsoft's Singularity apparently uses a GC.
Try using past tense. ItrCOs a dead project. Wonder why?
No, I do not wonder about microsoft or why their stuff fails.
On Tue, 04 Aug 2026 22:47:33 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
There is no OS kernel you have access to, that uses garbage
collection for internal memory management. Just admit it instead of
trying to bullshit.
well thanks. as Microsoft's Singularity apparently uses a GC.
Try using past tense. ItrCOs a dead project. Wonder why?
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 01/08/2026 11:59 AM, steve g wrote:
Anton Antimo <anton@safunu.org> writes:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:Wait until you read LISP:Lisp In Small Pieces. it's published in france. >>>
[...]
Sadly we've also ended up with programmers who think the machines >>>>>>> they program for are giant PDP-11s, and as a result machines which >>>>>>> spend a huge amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct. My little
experience with Common Lisp is that it allows me to write the equivalent >>>> fast code that I'd write in C, where speed matters. In other words, I >>>> seem to gain nothing (other than more work) by writing typical
applications in C.
I read the French edition. /Principes d'Implantation de Scheme et
Lisp/, and it's now available as ebook on Amazon. I recommend it,
it's a really fun book. I believe it's the /second edition/, and
may have a little bit different content than the English one, which
I haven't read.
Do you read French?
No I do not read french; just the algorithms. It is a fantastic book. I
can also apparently read german algorithms but the comments and the docstrings can be difficult.
In C the situation is complicated even beyond simply not being able to
find pointers because the standard explicitly permits idioms and code optimizations that can obscure what pointers are there.
On 31/07/2026 11:21 PM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
[...]
Sadly we've also ended up with programmers who think the machines
they program for are giant PDP-11s, and as a result machines which
spend a huge amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct. My little
experience with Common Lisp is that it allows me to write the equivalent
fast code that I'd write in C, where speed matters. In other words, I
seem to gain nothing (other than more work) by writing typical
applications in C.
The fun is in writing atypical applications, and then finding yourself looking at the disassembly in SBCL.
Personally, I love writing in C, even though it's more verbose.
That said, and to be mildly on-topic in comp.lang.lisp, have
* /The Common Lisp Condition System/, and
* /Programming Algorithms in Lisp/
been mentioned before as resources for learning common lisp?
These two books look lovely in my programming shelf, next to
* /Common Lisp Recipes/, and
* /Practical Common Lisp/,
which must have been mentioned. They're interspersed with
* /Low Level Programming/,
* /String Algorithms in C/, and
* /The Joys of Hashing/,
which come in handy when you want to implement your own Common
Lisp system.
Enjoy!
George Neuner <gneuner2@comcast.net> wrote:
In C the situation is complicated even beyond simply not being able to
find pointers because the standard explicitly permits idioms and code
optimizations that can obscure what pointers are there.
I wonder how the Symbolics C compiler dealt with all this horror? That's
not a rhetorical question: if anyone knows, I'd be interested, because it must have been painful.
On 05/08/2026 10:54 AM, Lawrence DrCOOliveiro wrote:
On Tue, 04 Aug 2026 22:47:33 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
There is no OS kernel you have access to, that uses garbage
collection for internal memory management. Just admit it instead of
trying to bullshit.
well thanks. as Microsoft's Singularity apparently uses a GC.
Try using past tense. ItrCOs a dead project. Wonder why?
Now, now, Lawrence, you're totally misunderstanding the situation.-a As always.-a Garbage collection is /not bad/.
To be fair, a big part of my struggle is the thick layer of Racket
on top of POSIX. For instance, try to locate the equivalent
select-call on it. It's so hard to recognize exactly how your Racket
maps to the lower level. I understand that may a strong point of
Racket's design, but it certainly hits my weakness.
Let Over Lambda
Doug Hoyte, 2008
ISBN 978-1-4357-1275-1
This book is about macros, that is programs that write programs.
Macros are what make lisp the greatest programming language in the
world. When used properly, macros enable amazing feats of
abstraction, programmer productivity, and code efficiency and
security that are unheard of elsewhere. Macros let you do things
you simply cannot do in other languages.
If garbage collection is so good, why donrCOt high-performance operating system kernels use it? Why do they prefer reference-counting instead?
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
Given this is posted to comp.lang.c, itrCOs always worth mentioning
these are not macros in the style of #define, but they work at the AST
level. Which is really the only sensible way to implement a workable
macro system.
And no longer unique to Lisp.
antispam@fricas.org (Waldek Hebisch) writes:
tfb <tfb@work.it.out> wrote:
Waldek Hebisch <antispam@fricas.org> wrote:
Consider:
(defun c_args_as_string (arguments)
(cond
((null arguments) "")
(t (let ((res (c_type_as_string (nth 1 (car arguments)))))
(dolist (el (rest arguments))
(setf res (concatenate 'string res ", "
(c_type_as_string (nth 1 el)))))
res)))
)
I do not say it is great code, but I find it easier to handle than
more traditional Lisp style.
OK, that's just weird. Everything is fine and you've got lots of close
parens at the ends of lines in the standard way, but then something breaks >>> and you have the final close paren on its own at the left margin. I can't >>> even begin to understand what motivates that.
If you look at rational factors: I need to see where given piece of
code ends. In bigger function with multiple blocks inside I would
put some parentheses in separate lines to signal ends of blocks.
There is also issue of seeing what is changed. Code frequently
gets added at end of existing functions. Separate "end"
parenthesis means that in such case old lines are unchanged and
only new lines get added. Version with parentheses at end of
line needs to move closing parentheses from old line to new
one.
Hear Hear!
IMHO python looks like pascal. Pascal is a great language but
do not mess up the begin/end statements! The semicolons should be
standard. I have the same issue with GO. This is starting to remind me
of sendmail.cf :)
I trying to be conservative with putting end parentheses on
separate lines. One, doing this on too many constructs would
add too many extra lines. Second, putting such parentheses
in too many places would limit their value, they would be no
longer good cue. Third, really small pieces of code are
managable without extra cues, it is bigger pieces when it
matters. Fourh, I want to limit dissatisfaction of Lispers
used to traditional style in case they need to work on code
that I write.
But the same question: if you wrote it in Python, would you leave an extra >>> little blank line for that weird closing paren?
[ ... ]--- Synchronet 3.22a-Linux NewsLink 1.2
"no trailing white space".
Hear hear!
On 05/08/2026 23:48, Lawrence DrCOOliveiro wrote:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
Given this is posted to comp.lang.c, itrCOs always worth mentioning
these are not macros in the style of #define, but they work at the AST
level. Which is really the only sensible way to implement a workable
macro system.
And no longer unique to Lisp.
Given that this is entirely about Lisp (or at least it has absoltuely nothing to do with C), it should be posted only in comp.lang.list - not comp.lang.c.-a It would be very nice if the absurd level of pointless cross-postings we have seen recently were to stop.-a It is fine to have occasional cross-postings and "outside influence" in a newsgroup, but a
few trolls have taken to cross-posting meaningless ramblings to all
sorts of groups.-a I would ask all reasonable participants in Usenet
threads to check the newsgroup lists on their posts, and trim them where
it makes sense (or simply not to respond to the worst trolls).
As for macros in programming languages, AST macros are /not/ the only "sensible" way to have macros.-a They are a very different thing from text-based macros as supported by the C pre-processor.-a The two types of macro have their advantages and disadvantages, and can be used for
different purposes.-a The mistake is not in having one or the other, but
in calling them both "macros".-a It is reasonable to note, however, that
AST macros must be part of the language while text-based macros can be provided by a generic external tool (like m4).
On 05/08/2026 23:48, Lawrence DrCOOliveiro wrote:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
Given this is posted to comp.lang.c, itrCOs always worth mentioning
these are not macros in the style of #define, but they work at the AST
level. Which is really the only sensible way to implement a workable
macro system.
And no longer unique to Lisp.
Given that this is entirely about Lisp (or at least it has absoltuely
nothing to do with C), it should be posted only in comp.lang.list -
not comp.lang.c. It would be very nice if the absurd level of
pointless cross-postings we have seen recently were to stop. It is
fine to have occasional cross-postings and "outside influence" in a newsgroup, but a few trolls have taken to cross-posting meaningless
ramblings to all sorts of groups. I would ask all reasonable
participants in Usenet threads to check the newsgroup lists on their
posts, and trim them where it makes sense (or simply not to respond to
the worst trolls).
As for macros in programming languages, AST macros are /not/ the only "sensible" way to have macros. They are a very different thing from text-based macros as supported by the C pre-processor. The two types
of macro have their advantages and disadvantages, and can be used for different purposes. The mistake is not in having one or the other,
but in calling them both "macros". It is reasonable to note, however,
that AST macros must be part of the language while text-based macros
can be provided by a generic external tool (like m4).
On Tue, 04 Aug 2026 23:11:08 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Tue, 04 Aug 2026 22:47:33 -0400, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
There is no OS kernel you have access to, that uses garbage
collection for internal memory management. Just admit it instead
of trying to bullshit.
well thanks. as Microsoft's Singularity apparently uses a GC.
Try using past tense. ItrCOs a dead project. Wonder why?
No, I do not wonder about microsoft or why their stuff fails.
Funny, you were just talking about it. Suddenly backpedalling when you realize itrCOs actually destroying rather than strengthening your
argument?
Now is there some particular book you feel is worth my time in German?
For either studying some C or Lisp arcana? Preferably not some basics,
as those are already covered in English.
George Neuner <gneuner2@comcast.net> wrote:
In C the situation is complicated even beyond simply not being able to
find pointers because the standard explicitly permits idioms and code
optimizations that can obscure what pointers are there.
I wonder how the Symbolics C compiler dealt with all this horror? That's
not a rhetorical question: if anyone knows, I'd be interested, because it must have been painful.
As for macros in programming languages, AST macros are /not/ the only >"sensible" way to have macros.
... They are a very different thing from
text-based macros as supported by the C pre-processor. The two types of >macro have their advantages and disadvantages, and can be used for
different purposes. The mistake is not in having one or the other, but
in calling them both "macros".
... It is reasonable to note, however, that--- Synchronet 3.22a-Linux NewsLink 1.2
AST macros must be part of the language while text-based macros can be >provided by a generic external tool (like m4).
Let me try to contribute with
Let Over Lambda
Doug Hoyte, 2008
ISBN 978-1-4357-1275-1
On Thu, 6 Aug 2026 09:05:38 +0200, David Brown
<david.brown@hesbynett.no> wrote:
As for macros in programming languages, AST macros are /not/ the only >>"sensible" way to have macros.
Depends on your definition of "sensible". <grin>
Do you think that reader macros are sensible?
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Wed, 29 Jul 2026 16:08:10 -0400, steve g wrote:
Specific substantive response still lacking.
I am actually nor familiar with this. thank you for mentioning it! I
will certainly discuss this with a friend whois Dr Psychology. This will
be a great discussion. seriously I think I can use this to impress him
:)
If garbage collection is so good, why donrCOt high-performance operating system kernels use it? Why do they prefer reference-counting instead?
On 05/08/2026 10:22 AM, steve g wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
On Wed, 29 Jul 2026 16:08:10 -0400, steve g wrote:
Specific substantive response still lacking.
I am actually nor familiar with this. thank you for mentioning it! I
will certainly discuss this with a friend whois Dr Psychology. This will
be a great discussion. seriously I think I can use this to impress him
:)
I'm starting to think Lawrence has a list of words on a piece of paper,
and uses dice to select them for his replies on Usenet. Nothing he says
ever makes sense.
I mean, at least he could do would be to run an L.L.M. and generate the
words for him. It's less work, and doesn't require throwing all these
dice.
I'm starting to think Lawrence has a list of words on a piece of paper,
and uses dice to select them for his replies on Usenet. Nothing he says
ever makes sense.
I mean, at least he could do would be to run an L.L.M. and generate the
words for him. It's less work, and doesn't require throwing all these
dice.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
Now is there some particular book you feel is worth my time in German?
For either studying some C or Lisp arcana? Preferably not some basics,
as those are already covered in English.
my answer would be using ITU (international morse code) and looking at American (or military) CW (continious wave). Many people claim they have learned both from just listening to it on the radio.
Unfortunately radio is all but dead. This is a good thing; less "traffic police".
As to english books I do have an excellent book one of my teachers gave
me. it contains all the funky rules of american enhlish. I am not at
"home" right now so I look it up and I can't remeber the name. She said
just read and re-scim this book before writing papers in college. This
is bothering me now...
I personally think that you need to practice the language to understand
it.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
I'm starting to think Lawrence has a list of words on a piece of paper,
and uses dice to select them for his replies on Usenet. Nothing he says
ever makes sense.
I mean, at least he could do would be to run an L.L.M. and generate the
words for him. It's less work, and doesn't require throwing all these
dice.
I think he (it?) may well *be* an LLM. In particular he (it?) has, at
least twice, done this weird looping thing, asking the same question which has already been answered. That looks like something losing context.
If it wasn't for the fact that usenet is moribund, an obvious way of acquiring training data for LLMs would be to set up troll bots and then use all the human responses to them as training data. Perhaps it's bit as moribund as I thought and someone is in fact doing this.
George Neuner <gneuner2@comcast.net> wrote:
On Thu, 6 Aug 2026 09:05:38 +0200, David Brown
<david.brown@hesbynett.no> wrote:
As for macros in programming languages, AST macros are /not/ the only >>>"sensible" way to have macros.
Depends on your definition of "sensible". <grin>
Do you think that reader macros are sensible?
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 31/07/2026 11:21 PM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
[...]
Sadly we've also ended up with programmers who think the machines
they program for are giant PDP-11s, and as a result machines which >>>>>> spend a huge amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct. My little
experience with Common Lisp is that it allows me to write the equivalent >>> fast code that I'd write in C, where speed matters. In other words, I
seem to gain nothing (other than more work) by writing typical
applications in C.
The fun is in writing atypical applications, and then finding yourself
looking at the disassembly in SBCL.
I actually do that every now and then just to learn a bit more about assembly, something I find so cool about SBCL (and lacking in other close-to-the-language tools).
Speaking of which, I decided to try Common Lisp about 2 years ago,
having struggled to deal with Racket for over ten years, nevertheless considering Racket the most elegant Lisp around ever since its birth.
And, boy, did I never look back.
(*) A critique of Racket
To be fair, a big part of my struggle is the thick layer of Racket on
top of POSIX. For instance, try to locate the equivalent select-call on
it. It's so hard to recognize exactly how your Racket maps to the lower level. I understand that may a strong point of Racket's design, but it certainly hits my weakness.
How about the macro system? So perfect, yet so annoying. One thing I
love about Common Lisp is precisely macro's (lack of) hygiene. I'm
totally fine with complete guarantee. Anaphoric macros are so useful.
(No idea how to implement them in Racket---impossible?)
Personally, I love writing in C, even though it's more verbose.
That said, and to be mildly on-topic in comp.lang.lisp, have
* /The Common Lisp Condition System/, and
* /Programming Algorithms in Lisp/
been mentioned before as resources for learning common lisp?
These two books look lovely in my programming shelf, next to
* /Common Lisp Recipes/, and
* /Practical Common Lisp/,
which must have been mentioned. They're interspersed with
* /Low Level Programming/,
* /String Algorithms in C/, and
* /The Joys of Hashing/,
which come in handy when you want to implement your own Common
Lisp system.
Enjoy!
Enjoyed a lot! Thanks so much for sharing very useful references.
Let me try to contribute with
Let Over Lambda
Doug Hoyte, 2008
ISBN 978-1-4357-1275-1
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
To be fair, a big part of my struggle is the thick layer of Racket
on top of POSIX. For instance, try to locate the equivalent
select-call on it. It's so hard to recognize exactly how your Racket
maps to the lower level. I understand that may a strong point of
Racket's design, but it certainly hits my weakness.
Sounds very Java-like. Though perhaps not as irritating as Java.
Compare Python <https://docs.python.org/3/library/select.html> --
thatrCOs less than 10 pages (i.e. number of times I have to hit
Page-Down in the browser) of docs.
Let Over Lambda
Doug Hoyte, 2008
ISBN 978-1-4357-1275-1
This book is about macros, that is programs that write programs.
Macros are what make lisp the greatest programming language in the
world. When used properly, macros enable amazing feats of
abstraction, programmer productivity, and code efficiency and
security that are unheard of elsewhere. Macros let you do things
you simply cannot do in other languages.
Given this is posted to comp.lang.c, itrCOs always worth mentioning
these are not macros in the style of #define, but they work at the AST
level. Which is really the only sensible way to implement a workable
macro system.
And no longer unique to Lisp.
I've found the Common Lisp macro system annoying enough that I rarely
use it. I'm OK with functions most of the time, and CLOS the rest of
the time. And only resort to macros when I can't do anything else in
the situation.
(*) A critique of Racket
To be fair, a big part of my struggle is the thick layer of Racket on
top of POSIX. For instance, try to locate the equivalent select-call on
it. It's so hard to recognize exactly how your Racket maps to the lower >level. I understand that may a strong point of Racket's design, but it >certainly hits my weakness.
How about the macro system? So perfect, yet so annoying. One thing I
love about Common Lisp is precisely macro's (lack of) hygiene. I'm
totally fine with complete guarantee. Anaphoric macros are so useful.
(No idea how to implement them in Racket---impossible?)
I've found the Common Lisp macro system annoying enough that I rarely
use it. I'm OK with functions most of the time, and CLOS the rest of
the time. And only resort to macros when I can't do anything else in
the situation.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
I've found the Common Lisp macro system annoying enough that I rarely
use it. I'm OK with functions most of the time, and CLOS the rest of
the time. And only resort to macros when I can't do anything else in
the situation.
It is so weird that people use a language whose defining feature is the incremental construction of languages and then say they don't use that feature. I mean, I'm aware people do that, but it's just so fucking weird.
Ar an naoi|| l|i de m|! L||nasa, scr|!obh tfb:
> Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
> >
> > I've found the Common Lisp macro system annoying enough that I rarely
> > use it. I'm OK with functions most of the time, and CLOS the rest of
> > the time. And only resort to macros when I can't do anything else in
> > the situation.
>
> It is so weird that people use a language whose defining feature is the
> incremental construction of languages and then say they don't use that
> feature. I mean, I'm aware people do that, but it's just so fucking weird.
I donrCOt find macros annoying, but I will use macrolet much more than defmacro.
Usually no point making a utility macro available in the run-time namespace. (This is XEmacs Lisp, so reader macros not available.)
Common Lisp is big and thererCOs plenty worth using in the rest of the language.
Common Lisp is big and thererCOs plenty worth using in the rest of the language.
On Sun, 09 Aug 2026 11:50:07 +0100, Aidan Kehoe wrote:
Common Lisp is big and thererCOs plenty worth using in the rest of the
language.
It leaves out too many things we take for granted in this era of
pretty much universal POSIX availability.
Where are the Common Lisp equivalents of these?
<https://docs.python.org/3/library/subprocess.html> <https://docs.python.org/3/library/threading.html> <https://docs.python.org/3/library/select.html>
On 06/08/2026 6:00 AM, Lawrence DrCOOliveiro wrote:
If garbage collection is so good, why donrCOt high-performance operating
system kernels use it? Why do they prefer reference-counting instead?
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
I think he (it?) may well *be* an LLM.
I try to keep in shape by reading books in languages I'm not using. Or converse with people about programming languages I don't use anymore,
such as Pascal.
I've managed to keep my French more or less intact, but could use a
brush up on Danish, and of course German as I said. I'm sure I'll
find something to inspire me to keep practicing German. After all,
I'm struggling to read Asterisk and Obelisk in Latin.
Best wishes, and happy language studies in comp.lang.lisp!
Do you think that reader macros are sensible?
I've not implemented them in TXR Lisp. It's not that they are
"insensible" or any other epithet.
They have a disruptive effect in the ecosystem.
It is so weird that people use a language whose defining feature is the incremental construction of languages and then say they don't use that feature. I mean, I'm aware people do that, but it's just so fucking weird.
I've never really gotten the hang of when I need to use (gensym) and
and when I don't. If I ever reach those heights of Common Lisp arcana,
I may change my mind and use macros all the time.
Chances are, I won't. I have this feeling that macros should be used as
a last resort, and not as the first /weapon of choice/ when coding Comm-
on Lisp.
Common Lisp is big and thererCOs plenty worth using in the rest of the
language.
Indeed, and QuickLisp makes it bigger. It's perhaps the major reason I
find myself faster at coding certain tasks in Common Lisp than most
other programming languages. Though packages of various types are now commonplace in other common programming languages.
Perhaps the major beauty of the Common Lisp social culture, is the disc- ipline of keeping interfaces stable. As far as I've heard, the /Python-
ic/ interfaces are always in flux, perhaps because their Python is ever writhing? It didn't help when they ditched the syntax of Python 2.7.
Many people whose code got obsolete decided never to use that language
again. And with good reason.
Of course, cultures change, but Common Lisp is eternal. I'm sure we can still code all of our websites with Hunchentoot without ever having the
need to learn something new, several hundred years from now.
Happy coding in Common Lisp!--- Synchronet 3.22a-Linux NewsLink 1.2
To be fair, you need to understand that Racket is multi-platform,
needs to run on Windows, and Windows [for the most part] does not
implement POSIX functions.
Do you think that reader macros are sensible?I've not implemented them in TXR Lisp. It's not that they are
"insensible" or any other epithet.
They have a disruptive effect in the ecosystem.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
I've found the Common Lisp macro system annoying enough that I rarely
use it. I'm OK with functions most of the time, and CLOS the rest of
the time. And only resort to macros when I can't do anything else in
the situation.
It is so weird that people use a language whose defining feature is the incremental construction of languages and then say they don't use that feature. I mean, I'm aware people do that, but it's just so fucking weird.
The question I have is "what argument"?
On Wed, 5 Aug 2026 22:00:45 -0000 (UTC), Lawrence DrCOOliveiro wrote:
If garbage collection is so good, why donrCOt high-performance
operating system kernels use it? Why do they prefer
reference-counting instead?
to be a high performance kernel you should not need to do garbage
collection.
GC is for user space, not kernel space. Kernel developers are
usually very good programmers.
Reader macros have been proposed/requested for ELisp several times, but
we've managed to resist the temptation so far.
It is so weird that people use a language whose defining feature is
the incremental construction of languages and then say they don't use
that feature. I mean, I'm aware people do that, but it's just so
fucking weird.
I admit I'm not sure why the select system call seems to be missing from
this selection of networking functions, so I'm impelled to ask, what is
is that you use select for, in Python?
On 06/08/2026 12:13 AM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 31/07/2026 11:21 PM, Anton Antimo wrote:I actually do that every now and then just to learn a bit more about
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
[...]
Sadly we've also ended up with programmers who think the machines >>>>>>> they program for are giant PDP-11s, and as a result machines which >>>>>>> spend a huge amount of effort pretending to be giant PDP-11s.
It's all a tragedy.
The tragedy is not using Common Lisp for everything.
I loved this bit and I have a feeling you're correct. My little
experience with Common Lisp is that it allows me to write the equivalent >>>> fast code that I'd write in C, where speed matters. In other words, I >>>> seem to gain nothing (other than more work) by writing typical
applications in C.
The fun is in writing atypical applications, and then finding yourself
looking at the disassembly in SBCL.
assembly, something I find so cool about SBCL (and lacking in other
close-to-the-language tools).
Speaking of which, I decided to try Common Lisp about 2 years ago,
having struggled to deal with Racket for over ten years, nevertheless
considering Racket the most elegant Lisp around ever since its birth.
And, boy, did I never look back.
(*) A critique of Racket
To be fair, a big part of my struggle is the thick layer of Racket on
top of POSIX. For instance, try to locate the equivalent select-call on
it. It's so hard to recognize exactly how your Racket maps to the lower
level. I understand that may a strong point of Racket's design, but it
certainly hits my weakness.
How about the macro system? So perfect, yet so annoying. One thing I
love about Common Lisp is precisely macro's (lack of) hygiene. I'm
totally fine with complete guarantee. Anaphoric macros are so useful.
(No idea how to implement them in Racket---impossible?)
I've found the Common Lisp macro system annoying enough that I rarely
use it. I'm OK with functions most of the time, and CLOS the rest of
the time. And only resort to macros when I can't do anything else in
the situation.
George Neuner <gneuner2@comcast.net> wrote:
In C the situation is complicated even beyond simply not being able to
find pointers because the standard explicitly permits idioms and code
optimizations that can obscure what pointers are there.
I wonder how the Symbolics C compiler dealt with all this horror? That's
not a rhetorical question: if anyone knows, I'd be interested, because it must have been painful.
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo <anton@safunu.org>
wrote:
(*) A critique of Racket
To be fair, a big part of my struggle is the thick layer of Racket on
top of POSIX. For instance, try to locate the equivalent select-call
on it. It's so hard to recognize exactly how your Racket maps to the
lower level. I understand that may a strong point of Racket's design,
but it certainly hits my weakness.
To be fair, you need to understand that Racket is multi-platform,
needs to run on Windows, and Windows [for the most part] does not
implement POSIX functions.
Racket's network [and filesystem, and ... ] implementation tries to
abstract over equivalent behaviors on all the target platforms.
How about the macro system? So perfect, yet so annoying. One thing I
love about Common Lisp is precisely macro's (lack of) hygiene. I'm
totally fine with complete guarantee. Anaphoric macros are so useful.
(No idea how to implement them in Racket---impossible?)
Racket has its roots in Scheme. Scheme is defined in terms of source
/text/ rather than the compiler's AST. So there is no real equivalent
of Lisp's AST macros.
That said, Racket does support Lisp-like unhygienic macros with 'define-macro'. Apologies for the ridiculous length of the URL.
https://docs.racket-lang.org/compatibility/defmacro.html#%28form._%28%28lib._compatibility%2Fdefmacro..rkt%29._define-macro%29%29
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
I admit I'm not sure why the select system call seems to be missing from
this selection of networking functions, so I'm impelled to ask, what is
is that you use select for, in Python?
Select is used to listening to a bunch of file descriptors
simultaneously and unblocking as soon as data becomes available on one
or more of the fd's. These days it's somewhat superseded by epoll or >io_uring or a few other alternatives.
I actually don't see any of these in the sbcl manual, though maybe I
didn't look hard enough. I'd expect to see it in the streams or
concurrency modules. You could use threads and mailboxes instead, but
that's often overkill, especially with posix threads.
On 06/08/2026 6:00 AM, Lawrence DrCOOliveiro wrote:
If garbage collection is so good, why donrCOt high-performance operating >>> system kernels use it? Why do they prefer reference-counting instead?
to be a high performance kernel you should not need to do garbage
collection. GC is for user space, not kernel space. Kernel developers
are usually very good programmers.
On 07/08/2026 7:36 AM, steve g wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
Now is there some particular book you feel is worth my time in German?
For either studying some C or Lisp arcana?-a Preferably not some basics, >>> as those are already covered in English.
my answer would be using ITU (international morse code) and looking at
American (or military) CW (continious wave). Many people claim they have
learned both from just listening to it on the radio.
Unfortunately radio is all but dead. This is a good thing; less "traffic
police".
As to english books I do have an excellent book one of my teachers gave
me. it contains all the funky rules of american enhlish. I am not at
"home" right now so I look it up and I can't remeber the name. She said
just read and re-scim this book before writing papers in college. This
is bothering me now...
I personally think that you need to practice the language to understand
it.
I try to keep in shape by reading books in languages I'm not using.-a Or converse with people about programming languages I don't use anymore,
such as Pascal.
I've managed to keep my French more or less intact, but could use a
brush up on Danish, and of course German as I said.-a I'm sure I'll
find something to inspire me to keep practicing German.-a After all,
I'm struggling to read Asterisk and Obelisk in Latin.
Best wishes, and happy language studies in comp.lang.lisp!
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
I admit I'm not sure why the select system call seems to be missing from
this selection of networking functions, so I'm impelled to ask, what is
is that you use select for, in Python?
Select is used to listening to a bunch of file descriptors
simultaneously and unblocking as soon as data becomes available on one
or more of the fd's. These days it's somewhat superseded by epoll or io_uring or a few other alternatives.
I actually don't see any of these in the sbcl manual, though maybe I
didn't look hard enough. I'd expect to see it in the streams or
concurrency modules. You could use threads and mailboxes instead, but
that's often overkill, especially with posix threads.
I see a mention of:
*Recursive Event Loop*: SBCL provides a recursive event loop
(serve-event) for doing non-blocking IO on multiple streams without
using threads.
But I don't see anything more about that in the manual. There's a
reddit thread saying it's poorly supported:
https://old.reddit.com/r/Common_Lisp/comments/kdk6mq/how_to_use_serveevent_from_sbcl/
Anyway that is basically what select is for.
On 06/08/2026 5:48 AM, Lawrence DrCOOliveiro wrote:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
To be fair, a big part of my struggle is the thick layer of RacketSounds very Java-like. Though perhaps not as irritating as Java.
on top of POSIX. For instance, try to locate the equivalent
select-call on it. It's so hard to recognize exactly how your Racket
maps to the lower level. I understand that may a strong point of
Racket's design, but it certainly hits my weakness.
Compare Python <https://docs.python.org/3/library/select.html> --
thatrCOs less than 10 pages (i.e. number of times I have to hit
Page-Down in the browser) of docs.
I admit I'm not sure why the select system call seems to be missing from
this selection of networking functions, [...]
For select (called unix-fast-select in SBCL), see sb-unix.
I think in terms of POSIX---likely because I started there.
On Thu, 06 Aug 2026 19:25:26 -0400, steve g wrote:
The question I have is "what argument"?
Since you mentioned MicrosoftrCOs Singularity, letrCOs look in a bit
more detail at it, shall we?
It was some kind of OS rCLresearch projectrCY. rCLLetrCOs build yet another microkernelrCY, they thought. As if that wasnrCOt a bad enough idea, they also thought rCLletrCOs include garbage collection in the kernelrCY. Perhaps two sufficiently bad ideas, mashed together sufficiently thoroughly,
will add up to something good?
So what came out of that research project? Nothing, that I can see. It
was abandoned, and then disappeared without leaving any trace on the
world of computer science.
Can you find some published papers on it?
Do they say anything more than rCLthis is not something that should be
tried againrCY?
Because if you go to the website, the link to the downloadable
software disappears off into the ether.
Feel free to prove me wrong. But somehow I donrCOt think you would know
where to start.
Of course, you could always regurgitate some AI slop, if you think it
will help ...
On Sun, 09 Aug 2026 18:42:29 -0400, steve g wrote:
On Wed, 5 Aug 2026 22:00:45 -0000 (UTC), Lawrence DrCOOliveiro wrote:
If garbage collection is so good, why donrCOt high-performance
operating system kernels use it? Why do they prefer
reference-counting instead?
to be a high performance kernel you should not need to do garbage
collection.
But isnrCOt that supposed to be better than reference-counting? Offering higher performance or something?
GC is for user space, not kernel space. Kernel developers are
usually very good programmers.
Do different laws of physics apply in kernel space or something?
And/or is that an admission that garbage collection is not for rCLvery
good programmersrCY?
And by the way some of my complains can also be exactly applied to
Common Lisp. For instance, I think Common Lisp doesn't have the
semantics of POSIX's read(2). I suppose there are libraries out there
that might go lower level (than Common Lisp's) and then give you an abstraction that mimics read(2), but that's beside the point.
On Sun, 09 Aug 2026 18:42:29 -0400, steve g wrote:
[...] GC is for user space, not kernel space. Kernel developers are usually very good programmers.
Do different laws of physics apply in kernel space or something?
And/or is that an admission that garbage collection is not for rCLvery
good programmersrCY?
Ar an deichi|| l|i de m|! L||nasa, scr|!obh Lawrence DrCOOliveiro:
On Sun, 09 Aug 2026 18:42:29 -0400, steve g wrote:
[...] GC is for user space, not kernel space. Kernel developers are usually very good programmers.
Do different laws of physics apply in kernel space or something?
And/or is that an admission that garbage collection is not for rCLvery good programmersrCY?
Let me digress for a moment:
Within medicine, my day job, [...]
This would require essentially assembler written with the quality of
the Apollo code, without an operating system. (IrCOm sure everyone
reading this accepts that good assembler, if it has no bugs, is going
to make better use of the hardware than their language of choice.)
The trade-off is that the resulting software is slower than the above
ideal, and, e.g. that my Windows install decides that it is going to
update whether I like it or not and the Cygwin terminal that I had
open, in the middle of debugging something, with a command history
that I would ideally like to have kept, evaporates.
On Mon, 10 Aug 2026 17:41:30 -0300, Anton Antimo wrote:
For select (called unix-fast-select in SBCL), see sb-unix.
select(2) is considered an archaic way of doing things these days,
because of its ABI limitations. The modern way is poll() ><https://manpages.debian.org/poll(2)> (POSIX) or even epoll() ><https://manpages.debian.org/epoll(7)> (Linux-specific).
tfb <tfb@work.it.out> writes:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
I think he (it?) may well *be* an LLM.
I was asked a psychiatrist what an LLM is. Large Language Model makes no >sense. What is behind this LLM, neural nets? I was thkng that semantic
nets. How do I go about writing an LLM, no I do not want to use one; I
want to write one (list is comp.lang.lisp afterall).
George Neuner <gneuner2@comcast.net> writes:
To be fair, you need to understand that Racket is multi-platform,
needs to run on Windows, and Windows [for the most part] does not
implement POSIX functions.
Can you use CYGwin? it is a bit ugly but it is POSIX. Microsoft should
be able to introduce a POSIX level (xyz) rather easily; they just don't
do that. It's like the Xterminal.
dunno, I cannot use windows 11; it needs a credit card. God bless the--- Synchronet 3.22a-Linux NewsLink 1.2
Free Software Project!
George Neuner <gneuner2@comcast.net> writes:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo <anton@safunu.org>
wrote:
How about the [Racket] macro system? So perfect, yet so annoying.
One thing I love about Common Lisp is precisely macro's (lack of) >>>hygiene. I'm totally fine with complete guarantee. Anaphoric
macros are so useful. (No idea how to implement them in Racket >>>---impossible?)
Racket has its roots in Scheme. Scheme is defined in terms of source
/text/ rather than the compiler's AST. So there is no real equivalent
of Lisp's AST macros.
Interesting. I bet this has been one my major difficulties because I had >never quite understood that and I probably still don't. I had realized
I always needed to manipulate the syntax objects as opposed to sexps and
it was always confusing to insert a new identifier into the generating
code and so on. The blame is of course always on me, but >yeah---difficult-to-understand stuff. Common Lisp is a lot simpler, I
feel. (Let me also say that I was never able to understand Scheme
compilers' error messages, Racket included.)
Is there an article out there that elaborate your paragraph here? I'd
like to learn more about these differences. I suppose the Scheme people >would have very strong arguments to go their way.
--- Synchronet 3.22a-Linux NewsLink 1.2That said, Racket does support Lisp-like unhygienic macros with
'define-macro'. Apologies for the ridiculous length of the URL.
https://docs.racket-lang.org/compatibility/defmacro.html#%28form._%28%28lib._compatibility%2Fdefmacro..rkt%29._define-macro%29%29
We need a project that can promise to shorten and maintain URLs for 50
years, say. (I say fifty so a single hacker can keep it running during
his lifetime. After 50 years, a young hacker takes it on for another
50.) It'a pity that Google Inc. let us down with goo.gl.
Aidan Kehoe <kehoea@parhasard.net> writes:
Ar an deichi|| l|i de m|! L||nasa, scr|!obh Lawrence DrCOOliveiro:
On Sun, 09 Aug 2026 18:42:29 -0400, steve g wrote:
[...] GC is for user space, not kernel space. Kernel developers are usually very good programmers.
Do different laws of physics apply in kernel space or something? And/or is that an admission that garbage collection is not for rCLvery good programmersrCY?
Let me digress for a moment:
Within medicine, my day job, [...]
Very cool that we have people from areas such as medicine here. (In reality, there's no academic discipline called programming---people in Computer Science are more often than not not programmers at all.) Medicine, in particular, is an unexpected one. Can you share a bit more about your history as in how did you get interested in medicine and computers (and Lisp specially)? That'd be cool to hear. (Assuming a little social chat is acceptable here given the current low volume.)
This would require essentially assembler written with the quality of
the Apollo code, without an operating system. (IrCOm sure everyone
reading this accepts that good assembler, if it has no bugs, is going
to make better use of the hardware than their language of choice.)
Perfectly reasonable.
The trade-off is that the resulting software is slower than the above ideal, and, e.g. that my Windows install decides that it is going to update whether I like it or not and the Cygwin terminal that I had
open, in the middle of debugging something, with a command history
that I would ideally like to have kept, evaporates.
Isn't that irritating? Windows is a system that's really not very respectful at all with what the user is doing---lots of interruptions
such as alerts by Windows Defender and whatnot. Many other programmers
on Windows follow suit, so it's not Microsoft's fault completely. And
that might be the same thing in the usual GNU system these days. For
window management, I run CWM, which is one that really only lets
anything happen that the user has actively made it happen.
And speaking of Medicine, how is it disrespectful these days as well,
but I won't digress on this (and it's perhaps just something that
plagues the entirety of society).
|--------------------------------------------------------|
|"degree from the best university in my country, [. . .]"| |--------------------------------------------------------|
arsa Aodh|in ua Ciothaigh ar an 11|| l|i de mh|! L||nasa 2026.
Chan in |eirinn d'ollscoil ar bith!
|------------------------------------------------------------------------------|
|"If there were no resource constraints, a fully informed user aware of what is|
|possible would like bug-free software that does exactly what is desired as |
|quickly as the hardware can do it. |
| |
|[. . .] |
|Operating systems, [. . .] are all examples |
|of tools that make programming [. . .] less likely to have bugs." |
|------------------------------------------------------------------------------|
arsa Aodh|in || Ceoth|inaigh ar an 11|| l|i de mh|! L||nasa 2026.
Windows is buggy.
|------------------------------------------------------------------------------|
|"This means that the cost ([. . .] often in money) of developing software to |
|do a given thing goes down. [. . .] |
|[. . .] |
| |
|[. . .] |
|[. . .] my Windows install decides that it is going to update whether I |
|like it or not" |
|------------------------------------------------------------------------------|
arsa Aodh|in || Ciothaigh ar an 11|| l|i de mh|! L||nasa 2026.
A license for Windows costs money.
|------------------------------------------------------------------------------|
|"and the Cygwin terminal that I had open, in the middle of |
|debugging something, with a command history that I would ideally like to have |
|kept, evaporates." |
|------------------------------------------------------------------------------|
arsa Aodh|in mac Eochadha ar an 11|| l|i de mh|! L||nasa 2026.
Is BASh on Windoze without its features on gratis operating systems?
Is mise le meas,--
Niocl|iis|!n C||il|!n Glost|-ir
(S. HTTP://Gloucester.Insomnia247.NL/ fuer Kontaktdaten!)
tfb <tfb@work.it.out> writes:
It is so weird that people use a language whose defining feature is
the incremental construction of languages and then say they don't use
that feature. I mean, I'm aware people do that, but it's just so
fucking weird.
For a long time, Scheme didn't have macros, but it was still considered
cool.
Lisp macros are generally a way for user code to get hold of unevaluated
args in a sexp. If your language has lazy evaluation (Haskell) and/or syntactic support for your likely macro use cases (lots of languages),
macros become less important.
As Lispers like to say, syntax is no big
deal. So why obsess about being able to redefine it?
|Hmm? The University of Dublin, founded 1592 by Queen Elizabeth as Trinity| |College Dublin, four Nobel laureates, alumni including Samuel Beckett, | |Oscar Wilde, Denis Burkitt of BurkittrCOs lymphoma is not a university?" |
|-------------------------------------------------------------------------| arsa Aodh P||l ua Ceoth|inaigh.
Dar liom!
|-------------------------------------------------------------------------| |"Where did | |you study[. . .]?" | |-------------------------------------------------------------------------| arsa Aodh|in ua Ciothaigh.
Le deirfi||r daoibh.
Is mise le meas,
On So 09 Aug 2026 at 05:26, Johann 'Myrkraverk' Oskarsson wrote:
I've found the Common Lisp macro system annoying enough that I rarely
use it. I'm OK with functions most of the time, and CLOS the rest of
the time. And only resort to macros when I can't do anything else in
the situation.
That us exactly where it should be used - when there is no other way.
On Mon, 10 Aug 2026 17:41:30 -0300, Anton Antimo wrote:
For select (called unix-fast-select in SBCL), see sb-unix.
select(2) is considered an archaic way of doing things these days,
because of its ABI limitations. The modern way is poll() <https://manpages.debian.org/poll(2)> (POSIX) or even epoll() <https://manpages.debian.org/epoll(7)> (Linux-specific).
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 06/08/2026 5:48 AM, Lawrence DrCOOliveiro wrote:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
To be fair, a big part of my struggle is the thick layer of RacketSounds very Java-like. Though perhaps not as irritating as Java.
on top of POSIX. For instance, try to locate the equivalent
select-call on it. It's so hard to recognize exactly how your Racket
maps to the lower level. I understand that may a strong point of
Racket's design, but it certainly hits my weakness.
Compare Python <https://docs.python.org/3/library/select.html> --
thatrCOs less than 10 pages (i.e. number of times I have to hit
Page-Down in the browser) of docs.
I admit I'm not sure why the select system call seems to be missing from
this selection of networking functions, [...]
It would be like writing C in Lisp notation. For select (called unix-fast-select in SBCL), see sb-unix.
(defun wait-for-stdin-select ()
(sb-alien:with-alien ((read-fds (sb-alien:struct sb-unix:fd-set)))
(sb-unix:fd-zero read-fds)
(sb-unix:fd-set 0 read-fds)
(format t "Waiting up to 5 seconds for input on stdin... Type something!~%")
(force-output)
(multiple-value-bind (count err)
(sb-unix:unix-fast-select 1 (sb-alien:addr read-fds) nil nil 5 0)
(cond
((null count)
(format t "Select failed with errno: ~A~%" err))
((zerop count)
(format t "Timeout! No input received.~%"))
((sb-unix:fd-isset 0 read-fds)
(format t "Data is ready to be read from stdin!~%"))
(t
(format t "Something else woke up select!~%"))))))
;; run it
(wait-for-stdin-select)
Is BASh on Windoze without its features on gratis operating systems?
This would require essentially assembler written with the quality of
the Apollo code, without an operating system.
For me, garbage collection as it is actually implemented (I would
phrase this -+real existierende Garbage-Collection-2 in German, by
analogy with -+real existierender Sozialismus) has a non-negligible
runtime cost. This is usually acceptable but sometimes not.
If you use any emacs itrCOs hard to avoid Lisp. Emacs Lisp is not a
paragon of good design nor of good implementation-- (aset
(symbol-name nil) 0 ?\u0192) , (fillarray obarray 0) , anyone?--so
the natural thing is to look around for something better. The
consensus within XEmacs was that Common Lisp was better. On
investigating, yes, it is.
Even if the update process is manual, e.g. when IrCOm using Debian and migrating a server to a new VM, I do not actually want to spend my
time working out with trial and error what invocation of certbot
will allow me to put Letsencrypt certificates on a new server that
already has Apache installed. (Spoiler; spin down Apache, use
certbot --certonly, which spins up its own HTTP server.)
(I certainly donrCOt want to have to migrate well-written PHP of
twenty years ago that carefully wrapped access to a database using then-best-practice APIs because those APIs are unmaintained and
removed, but that is entirely on me, we all know PHP is terrible,
and I knew it then.
Ar an deichi|| l|i de m|! L||nasa, scr|!obh Lawrence DrCOOliveiro:
On Sun, 09 Aug 2026 18:42:29 -0400, steve g wrote:
[...] GC is for user space, not kernel space. Kernel developers are usually very good programmers.
Do different laws of physics apply in kernel space or something?
And/or is that an admission that garbage collection is not for rCLvery good programmersrCY?
Let me digress for a moment:
Within medicine, my day job, decision making should be and mostly is (absent resource constraints) guided by what is right for the patient.
(This sounds obvious but it does need to be re-emphasised and
re-emphasised as part of training, because it is not always intuitive
in the details of every decision made. Every six year old who bumps
his or her head should not have a CT brain, for example.) Now, you can obviously ask patients (or parents in that last example) what they
feel would be right for the patient, and that is often helpful, but it
is not the case that every patient has thought through every specific clinical situation before, and it is not the case that every patient
has an informed command of the relevant research.
In practice, you have to develop a mental picture of what is right for almost everyone. Practically no-one wants to die young (and if they do, practically none of their family members want them to die young, and practically no-one continues to want to die young once the twelve Buckfasts have worn off or their
depression is treated). Practically everyone wants to continue to be able to walk. Practically everyone wants to continue to have control of their bowels and bladders. Practically no-one wants to have dementia. No-one wants to die of
metastatic cancer. Frail people in their high eighties may not want colonoscopy
if they have a change to their bowel habit with some blood in their stool, and,
if they are unlikely to be fit for treatment of any bowel cancer that is found,
that is very reasonable and it is not a good use of time to attempt to talk them round to the investigation.
This becomes more important when the patient is not paying directly for their care (they are paying through their taxes, or they have health insurance), since the body that pays for the care is incentivised to minimise investigations and management. If you are employed directly by the body that pays for care part of the job is, often and effectively, to market the investigations and management as necessary to other people in the organisation.
Digression ended.
When I returned to software I found it helpful, by analogy to rCLwhat is right
for the patientrCY above, to consider what is right for the end user.
If there were no resource constraints, a fully informed user aware of what is possible would like bug-free software that does exactly what is desired as quickly as the hardware can do it.
This would require essentially assembler written with the quality of the Apollo
code, without an operating system. (IrCOm sure everyone reading this accepts that
good assembler, if it has no bugs, is going to make better use of the hardware
than their language of choice.) This is not going to happen, because we have resource constraints; no-one is going to pay for that. But itrCOs helpful to keep it in mind as a possibility.
Operating systems, virtual memory, and non-assembler languages are all examples
of tools that make programming less demanding and less likely to have bugs. This means that the cost (in time and often in money) of developing software to
do a given thing goes down. Portable non-assembler languages have the additional advantage that the development time can be amortised over multiple generations of hardware, reducing the cost further.
The trade-off is that the resulting software is slower than the above ideal, and, e.g. that my Windows install decides that it is going to update whether I
like it or not and the Cygwin terminal that I had open, in the middle of debugging something, with a command history that I would ideally like to have kept, evaporates.
The question just becomes what point in the trade-off of increasing development
time versus decreasing does-exactly-what-I-want-making-best-use-of-the-hardware
a given piece of software should make.
For me, garbage collection as it is actually implemented (I would phrase this -+real existierende Garbage-Collection-2 in German, by analogy with -+real existierender Sozialismus) has a non-negligible runtime cost. This is usually acceptable but sometimes not.
Aidan Kehoe <kehoea@parhasard.net> writes:
Ar an deichi|| l|i de m|! L||nasa, scr|!obh Lawrence DrCOOliveiro:
On Sun, 09 Aug 2026 18:42:29 -0400, steve g wrote:
[...] GC is for user space, not kernel space. Kernel developers are
usually very good programmers.
Do different laws of physics apply in kernel space or something?
And/or is that an admission that garbage collection is not for rCLvery
good programmersrCY?
Let me digress for a moment:
Within medicine, my day job, [...]
Very cool that we have people from areas such as medicine here. (In
reality, there's no academic discipline called programming---people in Computer Science are more often than not not programmers at all.)
Medicine, in particular, is an unexpected one. Can you share a bit more about your history as in how did you get interested in medicine and
computers (and Lisp specially)? That'd be cool to hear. (Assuming a
little social chat is acceptable here given the current low volume.)
This would require essentially assembler written with the quality of
the Apollo code, without an operating system. (IrCOm sure everyone
reading this accepts that good assembler, if it has no bugs, is going
to make better use of the hardware than their language of choice.)
Perfectly reasonable.
The trade-off is that the resulting software is slower than the above
ideal, and, e.g. that my Windows install decides that it is going to
update whether I like it or not and the Cygwin terminal that I had
open, in the middle of debugging something, with a command history
that I would ideally like to have kept, evaporates.
Isn't that irritating? Windows is a system that's really not very
respectful at all with what the user is doing---lots of interruptions
such as alerts by Windows Defender and whatnot. Many other programmers
on Windows follow suit, so it's not Microsoft's fault completely. And
that might be the same thing in the usual GNU system these days. For
window management, I run CWM, which is one that really only lets
anything happen that the user has actively made it happen.
And speaking of Medicine, how is it disrespectful these days as well,
but I won't digress on this (and it's perhaps just something that
plagues the entirety of society).
once the twelve Buckfasts have worn off
Suppressing evaluation is not the same thing as delaying evaluation.
https://man.freebsd.org/cgi/man.cgi?kqueue
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
https://man.freebsd.org/cgi/man.cgi?kqueue
Is this something like io_uring? Is it just for i/o on open fd's or can
you also use it for stuff like opening files?
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
I've found the Common Lisp macro system annoying enough that I rarely
use it. I'm OK with functions most of the time, and CLOS the rest of
the time. And only resort to macros when I can't do anything else in
the situation.
It is so weird that people use a language whose defining feature is the incremental construction of languages and then say they don't use that feature. I mean, I'm aware people do that, but it's just so fucking weird.
On 12/08/2026 11:59 AM, Paul Rubin wrote:
Is this something like io_uring? Is it just for i/o on open fd's or canThe kqueue() is for open file descriptors, created as sockets or open
you also use it for stuff like opening files?
files, or anything else the FreeBSD kernel decides is a file. I'm not
aware of any interface to create one and open a file with the same func-
tion call.
I _think_ what Paul was asking was is it possible to get notified
when a specific file in the file system is opened. If that's what
he's asking, then the answer is: yes kqueue/kevent can do that. You
open the file in question using O_PATH, and then create a kevent
using that descriptor with filter EVFILT_VNODE and event NOTE_OPEN.
On 09/08/2026 4:52 PM, tfb wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:No the subject of /weird/, I've also found it highly bizarre, if not
outright disturbing, that people don't use do ... while(); in C. It's
an eminently useful structured programming pattern.
On the subject of Common Lisp, I find it more than disturbing when a
codebase lacks the basic usage of hash tables.
https://www.sbcl.org/manual/#hash-table-extensions
I _think_ what Paul was asking was is it possible to get notified when a specific file in the file system is opened.
On 11/08/2026 4:41 AM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 06/08/2026 5:48 AM, Lawrence DrCOOliveiro wrote:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
To be fair, a big part of my struggle is the thick layer of RacketSounds very Java-like. Though perhaps not as irritating as Java.
on top of POSIX. For instance, try to locate the equivalent
select-call on it. It's so hard to recognize exactly how your Racket >>>>> maps to the lower level. I understand that may a strong point of
Racket's design, but it certainly hits my weakness.
Compare Python <https://docs.python.org/3/library/select.html> --
thatrCOs less than 10 pages (i.e. number of times I have to hit
Page-Down in the browser) of docs.
I admit I'm not sure why the select system call seems to be missing from >>> this selection of networking functions, [...]
It would be like writing C in Lisp notation. For select (called
unix-fast-select in SBCL), see sb-unix.
(defun wait-for-stdin-select ()
(sb-alien:with-alien ((read-fds (sb-alien:struct sb-unix:fd-set)))
(sb-unix:fd-zero read-fds)
(sb-unix:fd-set 0 read-fds)
(format t "Waiting up to 5 seconds for input on stdin... Type something!~%")
(force-output)
(multiple-value-bind (count err)
(sb-unix:unix-fast-select 1 (sb-alien:addr read-fds) nil nil 5 0) >> (cond
((null count)
(format t "Select failed with errno: ~A~%" err))
((zerop count)
(format t "Timeout! No input received.~%"))
((sb-unix:fd-isset 0 read-fds)
(format t "Data is ready to be read from stdin!~%"))
(t
(format t "Something else woke up select!~%"))))))
;; run it
(wait-for-stdin-select)
Thank you. This is indeed helpful.
Unhelpfully, Lawrence is always talking about some sort of select in
Python, and then talks about polling in Linux, when he knows we don't
care about the Linux kernel here in comp.lang.lisp, because the Steel
Banks Common Lisp encapsulates the kernel for us.
And no, I don't know why Lawrence is always pretending to be a Python influencer here in comp.lang.lisp. I hope he's getting paid for it.
I liked the idea of
(with-current-readtable (xyz)
...)
using macros to enhance performance is usually a bad idea.
using macros to enhance performance is usually a bad idea.
Why should it be termed "weird" at all? Is this one of these things
where somebody comes up with a definition of the "normal" way to do
things and points fingers at anyone who deviates from that? Or is macro system usage somehow mandatory for Lisp programming?
For a long time, Scheme didn't have macros, but it was still considered
cool.
Lisp macros are generally a way for user code to get hold of unevaluated
args in a sexp.
If your language has [...]
syntactic support for your likely macro use cases (lots of languages),
macros become less important.
As Lispers like to say, syntax is no big
deal. So why obsess about being able to redefine it?
The Apollo code *did* have an operating system. And remember, it
crashed twice during the Apollo 11 landing. And got very confused by
that lightning strike during the Apollo 12 launch.
(I certainly donrCOt want to have to migrate well-written PHP of | twenty years ago that carefully wrapped access to a database using | then-best-practice APIs because those APIs are unmaintained and | removed, but that is entirely on me, we all know PHP is terrible, || |
and I knew it then. |
A very long time ago, Lisp had many unique features. Today it has exactly >one, but that feature is critical. It just seems weird to me to ignore its >defining characteristic. Not wrong: weird.
On Mon, 10 Aug 2026 10:48:48 -0300, Anton Antimo <anton@safunu.org>
wrote:
George Neuner <gneuner2@comcast.net> writes:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo <anton@safunu.org>
wrote:
How about the [Racket] macro system? So perfect, yet so annoying.
One thing I love about Common Lisp is precisely macro's (lack of) >>>>hygiene. I'm totally fine with complete guarantee. Anaphoric
macros are so useful. (No idea how to implement them in Racket >>>>---impossible?)
Racket has its roots in Scheme. Scheme is defined in terms of source
/text/ rather than the compiler's AST. So there is no real equivalent
of Lisp's AST macros.
:
Is there an article out there that elaborate your paragraph here? I'd
like to learn more about these differences. I suppose the Scheme people >>would have very strong arguments to go their way.
:
It is implicit in the semantics sections of the R_RS documents. Might
be explicit in some of them, I don't recall - the earlier documents
tended to contain more detail about intent, but I haven't (re)read any
of them in ages. I'm sure I've seen it explicitly stated somewhere,
but it may have been in some book.
[One of my college professors was Mitchell Wand who co-wrote
"Essentials of Programming Languages" and served on the Scheme
defining committee for many years.]
TLDR; Scheme's formal semantics are based on the syntax of forms in
the /external/ representation - ie. the source text - not on any
compiler's internal representation.
Reddit concluded that with macros they were now supposed to learn
to read several entirely unique, personalized programming languages,
and preferred to rewrite their system in Python.
R6RS has in Appendix (A) a discussion of the formal semantics in which
they do state that Scheme's denotation semantics are based on
/strings/. Unfortunately the statement is offhand and the discussion
itself is non-normative.
Stefan Ram <ram@zedat.fu-berlin.de> wrote:
Reddit concluded that with macros they were now supposed to learnIf that's a problem for you, I'd suggest doing the same. But, if this was >the reason (fully willing to believe it was the reason)
to read several entirely unique, personalized programming languages,
and preferred to rewrite their system in Python.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
https://man.freebsd.org/cgi/man.cgi?kqueue
Is this something like io_uring? Is it just for i/o on open fd's or can
you also use it for stuff like opening files?
Aidan Kehoe <kehoea@parhasard.net> writes:
once the twelve Buckfasts have worn off
I had to look that up. Wow, that's the medicine we all need, lol.
https://en.wikipedia.org/wiki/Buckfast_Tonic_Wine
Alan Bawden <alan@csail.mit.edu> writes:
I _think_ what Paul was asking was is it possible to get notified when a
specific file in the file system is opened.
No in linux that's called inotify. io_uring is basically an alternative system call interface that's relatively new, and maybe not complete.
You send off a request to do the system call, and get back a queued
response when the call is completed, unlike traditional syscalls that
appear to be synchronous.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 11/08/2026 4:41 AM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 06/08/2026 5:48 AM, Lawrence DrCOOliveiro wrote:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
To be fair, a big part of my struggle is the thick layer of Racket >>>>>> on top of POSIX. For instance, try to locate the equivalentSounds very Java-like. Though perhaps not as irritating as Java.
select-call on it. It's so hard to recognize exactly how your Racket >>>>>> maps to the lower level. I understand that may a strong point of
Racket's design, but it certainly hits my weakness.
Compare Python <https://docs.python.org/3/library/select.html> --
thatrCOs less than 10 pages (i.e. number of times I have to hit
Page-Down in the browser) of docs.
I admit I'm not sure why the select system call seems to be missing from >>>> this selection of networking functions, [...]
It would be like writing C in Lisp notation. For select (called
unix-fast-select in SBCL), see sb-unix.
(defun wait-for-stdin-select ()
(sb-alien:with-alien ((read-fds (sb-alien:struct sb-unix:fd-set)))
(sb-unix:fd-zero read-fds)
(sb-unix:fd-set 0 read-fds)
(format t "Waiting up to 5 seconds for input on stdin... Type something!~%")
(force-output)
(multiple-value-bind (count err)
(sb-unix:unix-fast-select 1 (sb-alien:addr read-fds) nil nil 5 0) >>> (cond
((null count)
(format t "Select failed with errno: ~A~%" err))
((zerop count)
(format t "Timeout! No input received.~%"))
((sb-unix:fd-isset 0 read-fds)
(format t "Data is ready to be read from stdin!~%"))
(t
(format t "Something else woke up select!~%"))))))
;; run it
(wait-for-stdin-select)
Thank you. This is indeed helpful.
But don't assume I'd ever write something like that in Lisp. Again,
that's like C programming in Lisp notation. See IOLib, for example.
Unhelpfully, Lawrence is always talking about some sort of select in
Python, and then talks about polling in Linux, when he knows we don't
care about the Linux kernel here in comp.lang.lisp, because the Steel
Banks Common Lisp encapsulates the kernel for us.
No sarcasm here. Lawrence has been doing a great service to the current USENET. We can say whatever we want about his knowledge or opinions or whatever, but he keeps a lot of people distracted here and I'm sure
these people are all looking for a distraction. And his distractions
are not all inadequate. He's usually bring up on-topic things that
allows people here to exercise their own skills. If these contributions
are too shallow---well---I'd say that's something we can say about most USENET traffic these days. Because we're very low volume these days, I
think shallow contributions are better than nothing. I prefer the
shallow chat than no chat at all.
And no, I don't know why Lawrence is always pretending to be a Python
influencer here in comp.lang.lisp. I hope he's getting paid for it.
From what I can tell, Lawrence never really caught the Lisp culture---it
can be seen in how he writes Lisp in the occasion he does it. This
means his criticism aren't very serious. He loves Python, which is a
way of saying---``thanks, Lisp, for the things you've done for me.''
On Wed, 12 Aug 2026 03:23:45 -0400, Alan Bawden wrote:
I _think_ what Paul was asking was is it possible to get notified
when a specific file in the file system is opened. If that's what
he's asking, then the answer is: yes kqueue/kevent can do that. You
open the file in question using O_PATH, and then create a kevent
using that descriptor with filter EVFILT_VNODE and event NOTE_OPEN.
There is no POSIX API for this. Linux has inotify(7) for watching
particular files, and certain kinds of directory operations, and
fanotify(7) for more general watching of entire
directories/filesystems.
<https://manpages.debian.org/inotify(7)> <https://manpages.debian.org/fanotify(7)>
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 12/08/2026 11:59 AM, Paul Rubin wrote:
Is this something like io_uring? Is it just for i/o on open fd's or can >>> you also use it for stuff like opening files?The kqueue() is for open file descriptors, created as sockets or open
files, or anything else the FreeBSD kernel decides is a file. I'm not
aware of any interface to create one and open a file with the same func-
tion call.
I _think_ what Paul was asking was is it possible to get notified when a specific file in the file system is opened. If that's what he's asking,
then the answer is: yes kqueue/kevent can do that. You open the file in question using O_PATH, and then create a kevent using that descriptor
with filter EVFILT_VNODE and event NOTE_OPEN.
So I believe we need more books about Common Lisp. Especially how to
make production games in Common Lisp.
WordPress. Ugh!
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
So I believe we need more books about Common Lisp. Especially how to
make production games in Common Lisp.
I mentioned Land of Lisp a couple days ago. Its sample programs are
games, if that helps. They're closer to Hunt the Wumpus than to a
modern AAA game, but it's a start.
You might also like Tim Sweeney's old slide deck about a hypothetical
new language for game dev:
https://groups.csail.mit.edu/cag/crg/papers/sweeney06games.pdf
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
So I believe we need more books about Common Lisp. Especially how to
make production games in Common Lisp.
I mentioned Land of Lisp a couple days ago. Its sample programs are
games, if that helps. They're closer to Hunt the Wumpus than to a
modern AAA game, but it's a start.
Hello everyone!
I want to learn Common Lisp, but I don't really know what resources to
use.
What did you all use to learn? Is that even relevant? Is this newsgroup active?
On Sun, 02 Aug 2026 16:42:37 +0000, kotorifan wrote:
For learning the basics about the language I highly recommend the
book "Practical Common Lisp" by Peter Seibel.
Common Lisp is a museum-worthy spec by this point. There needs to be something more modern, not so full of legacy baggage tied to old, proprietary, pre-POSIX OS platforms which are all extinct by now.
Also it does help to have a background in Emacs Lisp ...
Emacs Lisp contains some useful functionality beyond that specified by
Common Lisp, but it still isnrCOt really enough for a general-purpose programming language. Not in this day and age.
Ar an t-aon|| l|i d|-ag de m|! L||nasa, scr|!obh Anton Antimo:
Aidan Kehoe <kehoea@parhasard.net> writes:
Ar an deichi|| l|i de m|! L||nasa, scr|!obh Lawrence DrCOOliveiro:
On Sun, 09 Aug 2026 18:42:29 -0400, steve g wrote:
[...] GC is for user space, not kernel space. Kernel developers are usually very good programmers.
Do different laws of physics apply in kernel space or something? And/or
is that an admission that garbage collection is not for rCLvery good programmersrCY?
Let me digress for a moment:
Within medicine, my day job, [...]
Very cool that we have people from areas such as medicine here. (In reality,
there's no academic discipline called programming---people in Computer Science are more often than not not programmers at all.) Medicine, in particular, is an unexpected one. Can you share a bit more about your history as in how did you get interested in medicine and computers (and Lisp
specially)? That'd be cool to hear. (Assuming a little social chat is acceptable here given the current low volume.)
My first degree was 1998-2002 and the professor (clearly taking
shelter from the first AI winter) assigned the GNU Emacs manual as
required reading for the first class. (This is, I understand, not
typical.)
At that point XEmacs was a better editor so after using GNU Emacs for
a few weeks I switched to XEmacs. It still meets my needs and I have
no plan to switch away from it.
2002 was the Dot Com bust, and after six months unemployment following
a 2.1 degree from the best university in my country, I ended up in
technical support. To my surprise, I really enjoyed solving peoplerCOs problems then and there. Continued working in IT here in Europe (got
out of technical support given it was clear that was moving to India,
was in software development roles) realised I was not going to be able
to comfortably raise a family in the roles I was doing.
2007 my parents pointed me towards a new rCLGraduate Entry MedicinerCY
course in Dublin, on the US model of requiring another degree but
being only four years in length; I realised from the technical support experience that I would likely enjoy the day-to-day of this, and you
can comfortably raise a family in medicine in Ireland.
Studied medicine 2008-2012, worked like a demon 2013-2021, and am no
longer at the point where I have to work and study relentlessly to
make forward progress. Very happy with the job and with my
day-to-day, and I finally have a bit of breathing space to be back on
Usenet.
If you use any emacs itrCOs hard to avoid Lisp. Emacs Lisp is not a paragon of
good design nor of good implementation-- (aset (symbol-name nil) 0 ?\u0192) , (fillarray obarray 0) , anyone?--so the natural thing is to look around for something better. The consensus within XEmacs was that Common Lisp was better.
On investigating, yes, it is. But, XEmacs needs work, no-one else is doing it,
so my software work these days is C with a very Common-Lisp-oriented Emacs Lisp.
This would require essentially assembler written with the quality of
the Apollo code, without an operating system. (IrCOm sure everyone reading this accepts that good assembler, if it has no bugs, is going
to make better use of the hardware than their language of choice.)
Perfectly reasonable.
The trade-off is that the resulting software is slower than the above ideal, and, e.g. that my Windows install decides that it is going to update whether I like it or not and the Cygwin terminal that I had
open, in the middle of debugging something, with a command history
that I would ideally like to have kept, evaporates.
Isn't that irritating? Windows is a system that's really not very respectful at all with what the user is doing---lots of interruptions
such as alerts by Windows Defender and whatnot. Many other programmers
on Windows follow suit, so it's not Microsoft's fault completely. And that might be the same thing in the usual GNU system these days. For window management, I run CWM, which is one that really only lets
anything happen that the user has actively made it happen.
The comment wasnrCOt intended to be specifically about Windows, that
just happened to be the most recent example that sprung to mind. All
the common operating systems take time to boot, time which would
ideally be spent doing what you, as the user, actually wish to
do. Even resume-from-hibernation is not instant.
All of the common operating systems update, often requiring a reboot,
taking time which would ideally be spent doing what you, as the user, actually wish to do.
Even if the update process is manual, e.g. when IrCOm using Debian and migrating a server to a new VM, I do not actually want to spend my
time working out with trial and error what invocation of certbot will
allow me to put Letsencrypt certificates on a new server that already
has Apache installed. (Spoiler; spin down Apache, use certbot
--certonly, which spins up its own HTTP server.)
(I certainly donrCOt want to have to migrate well-written PHP of twenty
years ago that carefully wrapped access to a database using then-best-practice APIs because those APIs are unmaintained and
removed, but that is entirely on me, we all know PHP is terrible, and
I knew it then. But Debian shouldnrCOt be terrible, and in the grand
scheme of things it isnrCOt terrible.)
There are reasons and many of them are good for these things. I donrCOt
plan to switch my day-to-day to TempleOS. But that we have them is a
trade off.
And speaking of Medicine, how is it disrespectful these days as
well, but I won't digress on this (and it's perhaps just something
that plagues the entirety of society).
What do you mean? Respect towards and from medicine varies by
country. Doctors are regularly assaulted in India by family members of patients unhappy with the patientsrCO care. I get Christmas presents.
I never ran XEmacs, but I watched a documentary once that said that
XEmacs was born out of something to do with font locking---my intuition
says XEmacs started out with coloring? IIRC, Stallman or someone would
have said that the idea was not properly designed. I can't recall, but
I might research the question and report back here.
ADDENDUM
On Tue, 11 Aug 2026 12:20:00 -0400, George Neuner
<gneuner2@comcast.net> wrote:
On Mon, 10 Aug 2026 10:48:48 -0300, Anton Antimo <anton@safunu.org>
wrote:
George Neuner <gneuner2@comcast.net> writes:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo <anton@safunu.org>
wrote:
How about the [Racket] macro system? So perfect, yet so annoying. >>>>>One thing I love about Common Lisp is precisely macro's (lack of) >>>>>hygiene. I'm totally fine with complete guarantee. Anaphoric >>>>>macros are so useful. (No idea how to implement them in Racket >>>>>---impossible?)
Racket has its roots in Scheme. Scheme is defined in terms of source
/text/ rather than the compiler's AST. So there is no real equivalent >>>> of Lisp's AST macros.
:
Is there an article out there that elaborate your paragraph here? I'd >>>like to learn more about these differences. I suppose the Scheme people >>>would have very strong arguments to go their way.
:
It is implicit in the semantics sections of the R_RS documents. Might
be explicit in some of them, I don't recall - the earlier documents
tended to contain more detail about intent, but I haven't (re)read any
of them in ages. I'm sure I've seen it explicitly stated somewhere,
but it may have been in some book.
[One of my college professors was Mitchell Wand who co-wrote
"Essentials of Programming Languages" and served on the Scheme
defining committee for many years.]
TLDR; Scheme's formal semantics are based on the syntax of forms in
the /external/ representation - ie. the source text - not on any
compiler's internal representation.
R6RS has in Appendix (A) a discussion of the formal semantics in which
they do state that Scheme's denotation semantics are based on
/strings/. Unfortunately the statement is offhand and the discussion
itself is non-normative.
So far I haven't been able to find it stated explicitly in any
normative (authoritative) source, but I don't have access to the ISO
or IEEE standard documents.
On 12/08/2026 8:01 PM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 11/08/2026 4:41 AM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 06/08/2026 5:48 AM, Lawrence DrCOOliveiro wrote:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
Unhelpfully, Lawrence is always talking about some sort of select in
Python, and then talks about polling in Linux, when he knows we don't
care about the Linux kernel here in comp.lang.lisp, because the Steel
Banks Common Lisp encapsulates the kernel for us.
No sarcasm here. Lawrence has been doing a great service to the
current USENET. We can say whatever we want about his knowledge or
opinions or whatever, but he keeps a lot of people distracted here
and I'm sure these people are all looking for a distraction. And his
distractions are not all inadequate. He's usually bring up on-topic
things that allows people here to exercise their own skills. If
these contributions are too shallow---well---I'd say that's something
we can say about most USENET traffic these days. Because we're very
low volume these days, I think shallow contributions are better than
nothing. I prefer the shallow chat than no chat at all.
And I prefer polite chat, such as the one we are now having. Thank you.
I can only talk about my own skillset in Common Lisp, which I will prob-
ably have to say is not that great, having used it much less in anger
than C -- and prior to that, C++ but that's a different story -- and so
I got myself all the Lisp books I have amassed, most or all of them al-
ready mentioned in various topics here in comp.lang.lisp.
That said, life happened, and continues to happen, so I don't know when
I'll get to increase my skillset in Lisp. As everyone in comp.lang.c
knows, I'm currently going through Appel's compiler book in C, and well,
also took a detour by re-reading Loudon's /Mastering Algorithms in C/,
which while somewhat basic in the C, is very good at giving practical examples of the data structures in question.
I've previously mentioned a similar book in Lisp, by Domkin. I'll get
to it one of these decades.
And no, I don't know why Lawrence is always pretending to be a Python
influencer here in comp.lang.lisp. I hope he's getting paid for it.
From what I can tell, Lawrence never really caught the Lisp
culture---it can be seen in how he writes Lisp in the occasion he
does it. This means his criticism aren't very serious. He loves
Python, which is a way of saying---``thanks, Lisp, for the things
you've done for me.''
I'm not sure I did either, to be honest. I just find it fascinating in
many ways, and wish to increase my own skillset in Lisp, and of course,
get a better immersion in the culture.
Personally, I think Lisp people need -- well, need is a strong word, but
I'll go with it -- to get a little bit more behind the notion of practi- cality. I mean, the Steel Banks Common Lisp is fine, but many others
aimed at beginners are exclusively geared towards facing the programmer
him- -- or her- -- self. There is very little attention paid to the de- tails of creating binaries to share with friends. And by this, I mean
the parts of the programmer facing documentation. I believe the Steel
Banks Common Lisp manual does not mention how to create binary executa-
bles? I believe I learned that from /Stack Overflow/ which everyone
here in comp.lang.lisp knows is not a good place to learn how to do
anything; not anymore.
If I'm not mistaken, we also have this problem with Racket. Racket is
aimed at students, mostly, learning to code in Scheme, or the Scheme
dialect that is Racket, but not how to create binaries to share their
work with their loved ones who don't code.
So I believe we need more books about Common Lisp. Especially how to
make production games in Common Lisp. I mean, the Steel Banks Common
Lisp garbage collector cannot be worse than the old one in Unity, and
I currently believe C.L.O.S. is eminently suitable for three
dimensional game objects.
What do you think?
* Here I'm making fun of the YouTubian culture of only ever talk** about videos, and never anything published in books. "This guy made a video
about something, and I'm going to talk about too" is the typical intro duction, if I remember correctly. I don't watch much of YouTube any-
more.
** I'm going to leave this grammatical error.
If I'm not mistaken, we also have this problem with Racket. Racket is
aimed at students, mostly, learning to code in Scheme, or the Scheme
dialect that is Racket, but not how to create binaries to share their
work with their loved ones who don't code.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 12/08/2026 8:01 PM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 11/08/2026 4:41 AM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 06/08/2026 5:48 AM, Lawrence DrCOOliveiro wrote:
On Wed, 05 Aug 2026 13:13:42 -0300, Anton Antimo wrote:
[...]
Unhelpfully, Lawrence is always talking about some sort of select in
Python, and then talks about polling in Linux, when he knows we don't
care about the Linux kernel here in comp.lang.lisp, because the Steel
Banks Common Lisp encapsulates the kernel for us.
No sarcasm here. Lawrence has been doing a great service to the
current USENET. We can say whatever we want about his knowledge or
opinions or whatever, but he keeps a lot of people distracted here
and I'm sure these people are all looking for a distraction. And his
distractions are not all inadequate. He's usually bring up on-topic
things that allows people here to exercise their own skills. If
these contributions are too shallow---well---I'd say that's something
we can say about most USENET traffic these days. Because we're very
low volume these days, I think shallow contributions are better than
nothing. I prefer the shallow chat than no chat at all.
And I prefer polite chat, such as the one we are now having. Thank you.
Yeah---rudeness in USENET is a reflection of the health state of its participants.
I can only talk about my own skillset in Common Lisp, which I will prob-
ably have to say is not that great, having used it much less in anger
than C -- and prior to that, C++ but that's a different story -- and so
I got myself all the Lisp books I have amassed, most or all of them al-
ready mentioned in various topics here in comp.lang.lisp.
That said, life happened, and continues to happen, so I don't know when
I'll get to increase my skillset in Lisp. As everyone in comp.lang.c
knows, I'm currently going through Appel's compiler book in C, and well,
also took a detour by re-reading Loudon's /Mastering Algorithms in C/,
which while somewhat basic in the C, is very good at giving practical
examples of the data structures in question.
I've previously mentioned a similar book in Lisp, by Domkin. I'll get
to it one of these decades.
I've thankfully read this one by Kyle Loudon as well. Keep your
studying going slowly, but constantly. There's no rush. Things
meaningfully evolve as fast as everybody says. There's no royal road to knowledge and wisdom; no AI-road either. Keep it up; be careful with
your time on the USENET.
And no, I don't know why Lawrence is always pretending to be a Python
influencer here in comp.lang.lisp. I hope he's getting paid for it.
From what I can tell, Lawrence never really caught the Lisp
culture---it can be seen in how he writes Lisp in the occasion he
does it. This means his criticism aren't very serious. He loves
Python, which is a way of saying---``thanks, Lisp, for the things
you've done for me.''
I'm not sure I did either, to be honest. I just find it fascinating in
many ways, and wish to increase my own skillset in Lisp, and of course,
get a better immersion in the culture.
Try to understand when, why and how people did what they did. In other words, I think history is very important in studying. New is not always better.
Personally, I think Lisp people need -- well, need is a strong word, but
I'll go with it -- to get a little bit more behind the notion of practi-
cality. I mean, the Steel Banks Common Lisp is fine, but many others
aimed at beginners are exclusively geared towards facing the programmer
him- -- or her- -- self. There is very little attention paid to the de-
tails of creating binaries to share with friends. And by this, I mean
the parts of the programmer facing documentation. I believe the Steel
Banks Common Lisp manual does not mention how to create binary executa-
bles? I believe I learned that from /Stack Overflow/ which everyone
here in comp.lang.lisp knows is not a good place to learn how to do
anything; not anymore.
See SBCL's sb-ext:save-lisp-and-die.
(sb-ext:save-lisp-and-die #P"my-executable.exe"
:toplevel #'my-package:main
:executable t
:save-runtime-options t)
Source:
https://www.sbcl.org/manual/
If I'm not mistaken, we also have this problem with Racket. Racket is
aimed at students, mostly, learning to code in Scheme, or the Scheme
dialect that is Racket, but not how to create binaries to share their
work with their loved ones who don't code.
That's what Racket claims. They claim it to be real-world, batteries included and whatnot. They also create executable binaries like SBCL
does above.
So I believe we need more books about Common Lisp. Especially how to
make production games in Common Lisp. I mean, the Steel Banks Common
Lisp garbage collector cannot be worse than the old one in Unity, and
I currently believe C.L.O.S. is eminently suitable for three
dimensional game objects.
What do you think?
I never think about games, thankfully. I've played video-games from 11
to 14 years old, replacing them completely with UNIX, a great
investment.
Economically speaking, if CL had more users, there'd be more books. I
don't have much need for Common Lisp (strictly speaking) books myself.
I'm not trying myself to read more books on the language. What I'm
doing is writing more Common Lisp and reading more of it. What
certainly helps me is for people to use it, which then indirectly asks
for more books (but for the wrong reasons: the beginner often thinks
that something new is required for him to invest his time; reading an
old book seems like a waste of time for so many of them, but that's only because they're beginners and might be for the rest of their lives).
* Here I'm making fun of the YouTubian culture of only ever talk** about
videos, and never anything published in books. "This guy made a video
about something, and I'm going to talk about too" is the typical intro
duction, if I remember correctly. I don't watch much of YouTube any-
more.
** I'm going to leave this grammatical error.
Yeah---knowing how to use a natural language includes knowing how to
violate ``its grammar'' as well.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
If I'm not mistaken, we also have this problem with Racket. Racket is
aimed at students, mostly, learning to code in Scheme, or the Scheme
dialect that is Racket, but not how to create binaries to share their
work with their loved ones who don't code.
In practise the answer is 'raco exe' which makes an executable. You have
to have a suitable main function &c, but it's not hard.
Mario Rosell <mario@mariorosell.es> writes:
Hello everyone!
I want to learn Common Lisp, but I don't really know what resources to
use.
What did you all use to learn? Is that even relevant? Is this newsgroup
active?
Book already mentioned that was very useful to me, apologies to re-post
1. Practical Common Lisp
2. OnLisp
3. Land Of Lisp
one of my favorites but it's maybe controversial is Let Over Lambda
A proper setup with Emacs with Sly, and lately I was able to enable
open local HyperSpec from a symbol ( that was a game changer for my brain that can not hold to much info and unfortunately I have to use C++ at work).
Quicklisp is very very handy, and I'm trying to setup quicklisp lookup textinfo from symbol as well similar to the HyperSpec, but the mileage
vary here.
Anton Antimo <anton@safunu.org> wrote:
I never ran XEmacs, but I watched a documentary once that said that
XEmacs was born out of something to do with font locking---my intuition
says XEmacs started out with coloring? IIRC, Stallman or someone would
have said that the idea was not properly designed. I can't recall, but
I might research the question and report back here.
The Emacs schism was not fundamentally technical: it happened because cooperation with RMS is impossible. Lucid needed some features in what
would have been Emacs 19 to support a programming environment (for C++, I think, not Lisp, despite them being Lucid) and were willing to donate the time to implement them & donate the results (remember Emacs 18 had an entirely minimal interface to X: equivalent to running it in a terminal emulator). And ... cooperation with RMS turned out to be impossible. So LEmacs happened, which became XEmacs after Lucid died.
I wasn't there, but I was around a few months later and perhaps before the split was really final. I perhaps no longer have the trove of emails from the split: they made depressing reading.
(If you're thinking of posting a followup explaining why cooperation with
RMS is, in fact, possible, just ... don't, please.)
tfb <tfb@work.it.out> writes:
Anton Antimo <anton@safunu.org> wrote:
I never ran XEmacs, but I watched a documentary once that said that
XEmacs was born out of something to do with font locking---my intuition
says XEmacs started out with coloring? IIRC, Stallman or someone would
have said that the idea was not properly designed. I can't recall, but
I might research the question and report back here.
The Emacs schism was not fundamentally technical: it happened because
cooperation with RMS is impossible. Lucid needed some features in what
would have been Emacs 19 to support a programming environment (for C++, I
think, not Lisp, despite them being Lucid) and were willing to donate the
time to implement them & donate the results (remember Emacs 18 had an
entirely minimal interface to X: equivalent to running it in a terminal
emulator). And ... cooperation with RMS turned out to be impossible. So
LEmacs happened, which became XEmacs after Lucid died.
I wasn't there, but I was around a few months later and perhaps before the >> split was really final. I perhaps no longer have the trove of emails from >> the split: they made depressing reading.
(If you're thinking of posting a followup explaining why cooperation with
RMS is, in fact, possible, just ... don't, please.)
Thank you for describing the matter. You must be the best one here to elaborate on the schism? Can you elaborate it more technically? For instance, there's font locking today on the GNU EMACS---was it done in a dramatically different way relative to LEmacs?
An LLM is an emulation of a neural net. There's plenty of study
material regarding neural nets.
Modern implementations forgo the traditional graph representation and
instead are based on matrix math. Ie. you take a bunch of inputs,
multiply each input by a weight, offset the result by adding some
value, then summ and pass the summ put through a (possibly per node)
equation to get an output. That ptoentially feeds into the inputs of
the next layer of nodes.
The difficulty is in getting the topology correct. Too many nodes,
the nodes start to specialize, too few nodes the results are fuzzy.
Bad connection scheme - either it doesn't work or training becomes
very difficult. NNs have been studied since the 1970s, and there are
known topologies to create various kinds of recognizers and types of
(app specific) memories. You can (sort of) plug and play using these
as modules. But still a lot of it is just trial and error. That's why
so much effort is needed to build them.
LLMs [I agree it's a stupid name] are hidden node models having tens
of thousands (or more) of nodes, and many millions of inputs [and
weights and offsets]. You can't build one without a supercomputer.
There's a PHd and potential billions of $$$ waiting if you can figure
out how to make a NN reliably forget something it has learned, without retraining from scratch and without affecting anything else it knows.
Have fun!
On Sun, 09 Aug 2026 19:12:49 -0400, steve g <Sgonedes1977@gmail.com>
wrote:
I'm not aware that Racket can run over Cygwin. If it can, I would bet
that GUI/graphical programs won't work.
Certainly you can create an interface to Cygwin and use it directly.
[You can do this with pretty much any library.]
On 2026-08-02, Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
Common Lisp is a museum-worthy spec by this point. There needs to
be something more modern, not so full of legacy baggage tied to
old, proprietary, pre-POSIX OS platforms which are all extinct by
now.
SBCL tells me otherwise, ditto with the Kandria engine, or projects
like Nyxt. Also, Coalton + Quilc in quantum mechanics basically
makes any 'legacy' assumption on CL laughable.
I never ran XEmacs, but I watched a documentary once that said that
XEmacs was born out of something to do with font locking---my
intuition says XEmacs started out with coloring? IIRC, Stallman or
someone would have said that the idea was not properly designed.
On 13/08/2026 11:19 PM, Anton Antimo wrote:
Personally, I think Lisp people need -- well, need is a strong word, but >>> I'll go with it -- to get a little bit more behind the notion of practi- >>> cality. I mean, the Steel Banks Common Lisp is fine, but many others
aimed at beginners are exclusively geared towards facing the programmer
him- -- or her- -- self. There is very little attention paid to the de- >>> tails of creating binaries to share with friends. And by this, I mean
the parts of the programmer facing documentation. I believe the Steel
Banks Common Lisp manual does not mention how to create binary executa-
bles? I believe I learned that from /Stack Overflow/ which everyone
here in comp.lang.lisp knows is not a good place to learn how to do
anything; not anymore.
See SBCL's sb-ext:save-lisp-and-die.
(sb-ext:save-lisp-and-die #P"my-executable.exe"
:toplevel #'my-package:main
:executable t
:save-runtime-options t)
Source:
https://www.sbcl.org/manual/
And herein lies the conundrum. I believe I took a quick glance at the manual, looked at the able of contents, and even tried ctrl+f and the
terms /binary/ or /binaries/, and /executable/, and found nothing.
Being /technically/ in the manual does not help if one cannot easily
find what one is looking for. It also doesn't help if one doesn't have expectations of finding it in the first place.
So I believe we need more books about Common Lisp. Especially how to
make production games in Common Lisp. I mean, the Steel Banks Common
Lisp garbage collector cannot be worse than the old one in Unity, and
I currently believe C.L.O.S. is eminently suitable for three
dimensional game objects.
What do you think?
I never think about games, thankfully. I've played video-games from
11
to 14 years old, replacing them completely with UNIX, a great
investment.
Economically speaking, if CL had more users, there'd be more books.
I don't have much need for Common Lisp (strictly speaking) books
myself. I'm not trying myself to read more books on the language.
What I'm doing is writing more Common Lisp and reading more of it.
What certainly helps me is for people to use it, which then
indirectly asks for more books (but for the wrong reasons: the
beginner often thinks that something new is required for him to
invest his time; reading an old book seems like a waste of time for
so many of them, but that's only because they're beginners and might
be for the rest of their lives).
Well, I don't only mean beginner books. I mean some of the more ad-
vanced books as well, when it comes to C. Of course /Common Lisp Re-
cipes/, and /The Common Lisp Condition System/ should be good examples
that I'll get to read one of these decades. Here I'm thinking of Adam Tornhill's /Patterns in C/. There are even several more, some of which
I've lost track of, because I believe they were only available as a PDF
and I neglected to print them out.
Right now I'm not inclined to cross post this to comp.lang.c, and ask if they'd be willing to fill in some of those blanks.
Hm, as-is, there seems to be a /blank/ in my knowledge, when it comes to thinking of an equivalent book in Lisp. Specifically about these /patt- erns/, and how to use them.
Perhaps there is no need? After all, the original patterns book in Java
was all about working around deficiencies in the Java programming lang-
uage, and maybe Common Lisp has few enough of those we don't care about
a specific set of patterns?
Or is this simply covered in /Common Lisp Recipes/ and I forgot?
Have a nice day, and Lisp well!
I never ran XEmacs, but I watched a documentary once that said that
XEmacs was born out of something to do with font locking---my
intuition says XEmacs started out with coloring? IIRC, Stallman or
someone would have said that the idea was not properly designed.
Thank you for describing the matter. You must be the best one here to elaborate on the schism? Can you elaborate it more technically? For instance, there's font locking today on the GNU EMACS---was it done in a dramatically different way relative to LEmacs?
Hm, as-is, there seems to be a /blank/ in my knowledge, when it comes to thinking of an equivalent book in Lisp. Specifically about these /patt- erns/, and how to use them.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 13/08/2026 11:19 PM, Anton Antimo wrote:
[...]
Personally, I think Lisp people need -- well, need is a strong word, but >>>> I'll go with it -- to get a little bit more behind the notion of practi- >>>> cality. I mean, the Steel Banks Common Lisp is fine, but many others
aimed at beginners are exclusively geared towards facing the programmer >>>> him- -- or her- -- self. There is very little attention paid to the de- >>>> tails of creating binaries to share with friends. And by this, I mean >>>> the parts of the programmer facing documentation. I believe the Steel >>>> Banks Common Lisp manual does not mention how to create binary executa- >>>> bles? I believe I learned that from /Stack Overflow/ which everyone
here in comp.lang.lisp knows is not a good place to learn how to do
anything; not anymore.
See SBCL's sb-ext:save-lisp-and-die.
(sb-ext:save-lisp-and-die #P"my-executable.exe"
:toplevel #'my-package:main
:executable t
:save-runtime-options t)
Source:
https://www.sbcl.org/manual/
And herein lies the conundrum. I believe I took a quick glance at the
manual, looked at the able of contents, and even tried ctrl+f and the
terms /binary/ or /binaries/, and /executable/, and found nothing.
Being /technically/ in the manual does not help if one cannot easily
find what one is looking for. It also doesn't help if one doesn't have
expectations of finding it in the first place.
Try the ``executable'' keyword; you'll find this:
--8<-------------------------------------------------------->8---
Executable Delivery: The :executable argument to
sb-ext:save-lisp-and-die can produce a "standalone" executable
containing both an image of the current Lisp session and an SBCL
runtime.
--8<-------------------------------------------------------->8---
Source:
https://www.sbcl.org/manual/
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
Hm, as-is, there seems to be a /blank/ in my knowledge, when it comes to
thinking of an equivalent book in Lisp. Specifically about these /patt-
erns/, and how to use them.
Winston and Horn "Lisp" was a favorite way back in the day:
https://en.wikipedia.org/wiki/LISP_(book)
It was originally part of the book "Artificial Intelligence" but the
Lisp part split off into a separate volume, per the Wikipedia article
above.
The thing is, CL's design makes some sense, but only up to a point.
It's not holistic like Scheme, so don't expect too much consistency.
CL's unifying purpose was to maintain some level of commonality with a
bunch of incompatible predecessor Lisps of varying origin. It didn't
try to run earlier dialects without modification, but it tried to keep
the porting effort manageable, as I understand it. Old timers here will
know more about this than I do. There are some good history documents
around whose names I don't remember.
In my case I found CLTL1 to be pretty understandable after first gaining
an understanding of Lisp by reading through the Emacs Lisp interpreter
source code (written in C) and mucking around with some Emacs Lisp code.
The CADR manual was also enlightening, even though I never actually used
a CADR or any other Lisp machine (I guess that's a sign of a deprived childhood). See:
https://tumbleweed.nu/r/lm-3/uv/chinual.html
As for Scheme, I think of it more as an assembly language for a cosmic
sized computer, than as something for humans program much in directly.
Others believe the opposite.
On Tue, 11 Aug 2026 18:31:24 +0100, Aidan Kehoe wrote:
If you use any emacs itrCOs hard to avoid Lisp. Emacs Lisp is not a paragon of good design nor of good implementation-- (aset
(symbol-name nil) 0 ?\u0192) , (fillarray obarray 0) , anyone?--so
the natural thing is to look around for something better. The
consensus within XEmacs was that Common Lisp was better. On
investigating, yes, it is.
ItrCOs a museum-worthy spec. Needs updating to, at least support POSIX-type features that we take for granted nowadays.
Even if the update process is manual, e.g. when IrCOm using Debian and migrating a server to a new VM, I do not actually want to spend my
time working out with trial and error what invocation of certbot
will allow me to put Letsencrypt certificates on a new server that
already has Apache installed. (Spoiler; spin down Apache, use
certbot --certonly, which spins up its own HTTP server.)
But you need to be able to keep the certs up to date without having to
shut down Apache (or whatever web server yourCOre using) each time.
Trust the standard Debian packages to take care of this automatically.
[...] I have never developed any web app from scratch in PHP. The only time IrCOve used it is to maintain existing code, or write plugins for existing code (WordPress, WooCommerce).
As a language, its features read like a shopping list of sadness.
tfb <tfb@work.it.out> wrote or quoted:The price for that is the need to rewrite the codebase in whatever
A very long time ago, Lisp had many unique features. Today it has exactly >> one, but that feature is critical. It just seems weird to me to ignore its >> defining characteristic. Not wrong: weird.
Reddit concluded that with macros they were now supposed to learn
to read several entirely unique, personalized programming languages,
and preferred to rewrite their system in Python.
Python's wrappers and resource contexts give developers a way to
pass executable blocks to functions or objects achieving what devel-
opers often use macros for without exposing the chaotic power of
full AST manipulation.
On 2026-08-10, Andreas Eder <a_eder_muc@web.de> wrote:
On So 09 Aug 2026 at 05:26, Johann 'Myrkraverk' Oskarsson wrote:
I've found the Common Lisp macro system annoying enough that I rarely
use it. I'm OK with functions most of the time, and CLOS the rest of
the time. And only resort to macros when I can't do anything else in
the situation.
That us exactly where it should be used - when there is no other way.
I don't agree, because that amounts to macros never being used.
It's never the case that there is no other way, because in place of
any macro, you can write the expansion by hand.
Ar an dara l|i d|-ag de m|! L||nasa, scr|!obh Lawrence DrCOOliveiro:
[Common Lisp is] a museum-worthy spec. Needs updating to, at least
support POSIX-type features that we take for granted nowadays.
ItrCOs better than Emacs Lisp.
But you need to be able to keep the certs up to date without having to
shut down Apache (or whatever web server yourCOre using) each time.
Trust the standard Debian packages to take care of this automatically.
This wasnrCOt practical. In any event I wasnrCOt asking for help ...
As a language, [PHPrCOs] features read like a shopping list of sadness.
Yep. And, of course, itrCOs one of the most popular programming
languages around.
Similarly, as far as I can tell the most used Lisp is AutoCAD Lisp.
This is not the most full-featured or well-thought-through Lisp out
there.
Aidan Kehoe <kehoea@parhasard.net> writes:
[...] My first degree was 1998-2002 and the professor (clearly taking shelter from the first AI winter) assigned the GNU Emacs manual as required reading for the first class. (This is, I understand, not typical.)
Very atypical these days. Your first degree must have been Computer Science? So you got two degrees. Having a degree or not in such areas,
I think that understanding the fundamentals of computers and programming
is a pretty good skill these days. There might be other areas I miss
for sheer lack of wisdom here.
I took a ``programming 102'' engineering class a few years ago in which
the professor offered us a ZIP package containing the GNU EMACS set up
with Python. Students on the first day of class protested against their ``programming 101'' (a Python primer) saying it was essentially useless
with no real-world anything (which I fully agree: that course's real objective was to teach us the syntax of Python [with no OOP, which is
the job of ``programming 102'']).
The professor replied saying he would present us with some illustrations
of real-world stuff. To my surprise, one of these things was the GNU
EMACS. His EMACS came with all of its default configuration but some additional ones for people to run Python and ESHELL. (To run it, we'd double click on a icon on the desktop.) Students were welcome to ignore
it all and use Python's IDLE or whatever, which I think 99% of them did. What students couldn't ignore, which was cool (lol), was that the way to turn in homework was through fossil. The professor introduced us to
fossil in another lecture, saying he chose fossil over git due to
slightly greater simplicity (compared to git, which I couldn't quite
see). I was likely the one exception that didn't struggle with
fossil----I had never heard of it until then, but I've been using git
for years.
Anyway, after these lectures, he went on with the course, which didn't work very well at all because I think after the GNU EMACS and fossil most students had already given up on him---there were many other professors teaching the same course in a way that it had a lot less new things to learn.
At that point XEmacs was a better editor so after using GNU Emacs for
a few weeks I switched to XEmacs. It still meets my needs and I have
no plan to switch away from it.
I never ran XEmacs, but I watched a documentary once that said that
XEmacs was born out of something to do with font locking---my intuition
says XEmacs started out with coloring? IIRC, Stallman or someone would
have said that the idea was not properly designed. I can't recall, but
I might research the question and report back here.
[...] If you use any emacs itrCOs hard to avoid Lisp. Emacs Lisp is not a paragon of good design nor of good implementation-- (aset (symbol-name nil) 0 ?\u0192) , (fillarray obarray 0) , anyone?--so the natural thing is to look around for something better. The consensus within XEmacs was that Common Lisp was better. On investigating, yes, it is. But, XEmacs needs work, no-one else is doing it, so my software work these days is C with a very Common-Lisp-oriented Emacs Lisp.
I tried the code above on the GNU EMACS. The first crashes it
immediately. The second doesn't seem to do its job anymore, throwing a
type error. They must have created a new type called obarray. Saying (type-of obarray) produces obarray, while fillarray expects a vector.
(I certainly donrCOt want to have to migrate well-written PHP of twenty years ago that carefully wrapped access to a database using then-best-practice APIs because those APIs are unmaintained and
removed, but that is entirely on me, we all know PHP is terrible, and
I knew it then. But Debian shouldnrCOt be terrible, and in the grand scheme of things it isnrCOt terrible.)
What did you write 20 years ago?
That's indeed PHP's prime time. I know the language. I used it seriously back then as well. I never went into PHP 4, remaining in PHP 3 for as long as I could until I gave up on PHP completely---I've always appreciated language stability.
[...] And speaking of Medicine, how is it disrespectful these days as well, but I won't digress on this (and it's perhaps just something that plagues the entirety of society).
What do you mean? Respect towards and from medicine varies by
country. Doctors are regularly assaulted in India by family members of patients unhappy with the patientsrCO care. I get Christmas presents.
It is indeed. If my sources are correct, in the United States (for example), we get deaths due to medical error top ranked---I don't mean
top 1st, but highly ranked (top 3 a while ago?).
But what I had meant was that I get the feeling from hearing from the population that the attention and time doctors spend with patients now
has been greatly reduced; that doctors are often rude, get easily
irritated and so on. That then makes me think they might be working too much.
I in fact see a parallel with programmers: in the typical company, the typical programmer can be slightly arrogant, easily irritated, the explanation for which might be too much work, not very competent and not living very joyful days. So in the end I don't see anything specific to Medicine, but something much larger. I'm a student at a large university---what can I say about professors? They're very easily offended with students' lack of interest; they inadvertently and incorrectly take a lot of things personally; my overall conclusion is that they're not doing very well health-wise, not living very joyful days (they might miss days in which there was more glamour in the profession, when they feel they would be better regarded). Something like that.
ItrCOs better than Emacs Lisp. (I admit, with RMS not as active, GNU Emacs including their Emacs Lisp, has made impressive progress over the last few years, but itrCOs still shaped by years of his technical decisions, and the development culture was shaped by him.)
> ZetaLisp's innovations extended beyond Flavors to include proper
IrCOm sure they do have their own extensions to make up for the
deficiencies of Common Lisp. But then, they are no longer rCLCommonrCY,
are they?
Right, if the language you already has supports every construct anyone
might ever want to do anything, then nobody needs macros.
Do they say that? Which ones? This one thinks that domain-specific
and application-specific languages are useful and thinks that
languages with facilities which allow the simple incremental
construction of such languages are therefore also useful.
And herein lies the conundrum. I believe I took a quick glance at the manual, looked at the able of contents, and even tried ctrl+f and the
terms /binary/ or /binaries/, and /executable/, and found nothing.
Being /technically/ in the manual does not help if one cannot easily
find what one is looking for. It also doesn't help if one doesn't have expectations of finding it in the first place.
On Mon, 10 Aug 2026 17:41:30 -0300, Anton Antimo wrote:
For select (called unix-fast-select in SBCL), see sb-unix.
select(2) is considered an archaic way of doing things these days,
because of its ABI limitations. The modern way is poll() <https://manpages.debian.org/poll(2)> (POSIX) or even epoll() <https://manpages.debian.org/epoll(7)> (Linux-specific).
On 14/08/2026 7:58 AM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 13/08/2026 11:19 PM, Anton Antimo wrote:
[...]
Personally, I think Lisp people need -- well, need is a strong word, but >>>>> I'll go with it -- to get a little bit more behind the notion of practi- >>>>> cality. I mean, the Steel Banks Common Lisp is fine, but many others >>>>> aimed at beginners are exclusively geared towards facing the programmer >>>>> him- -- or her- -- self. There is very little attention paid to the de- >>>>> tails of creating binaries to share with friends. And by this, I mean >>>>> the parts of the programmer facing documentation. I believe the Steel >>>>> Banks Common Lisp manual does not mention how to create binary executa- >>>>> bles? I believe I learned that from /Stack Overflow/ which everyone >>>>> here in comp.lang.lisp knows is not a good place to learn how to do
anything; not anymore.
See SBCL's sb-ext:save-lisp-and-die.
(sb-ext:save-lisp-and-die #P"my-executable.exe"
:toplevel #'my-package:main
:executable t
:save-runtime-options t)
Source:
https://www.sbcl.org/manual/
And herein lies the conundrum. I believe I took a quick glance at the
manual, looked at the able of contents, and even tried ctrl+f and the
terms /binary/ or /binaries/, and /executable/, and found nothing.
Being /technically/ in the manual does not help if one cannot easily
find what one is looking for. It also doesn't help if one doesn't have
expectations of finding it in the first place.
Try the ``executable'' keyword; you'll find this:
--8<-------------------------------------------------------->8---
Executable Delivery: The :executable argument to
sb-ext:save-lisp-and-die can produce a "standalone" executable
containing both an image of the current Lisp session and an SBCL
runtime.
--8<-------------------------------------------------------->8---
Source:
https://www.sbcl.org/manual/
Please be patient with me. Here is a screenshot. I'm afraid the link
is ridiculously long, and I don't use url shorteners anymore.
https://www.dropbox.com/scl/fi/07asmp90gza39utr55wro/SBCL-manual-execu.jpg?rlkey=jd3tcevbchchpsge37xfmjh1j&st=pk2y5hvh&dl=0
What I'm looking at here seems to be the word "execu" -- or the prefix
of which -- not being found. Should I have continued to type the whole
word? I thought this worked like Emacs' incremental search, and as I
typed more characters, it would search longer words, until it wouldn't
find what I've typed so far.
Is this perhaps a matter of not using the right browser? I mean, what browser do the team players behind S.B.C.L. habitually use themselves?--
On 14/08/2026 12:14 AM, tfb wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
If I'm not mistaken, we also have this problem with Racket. Racket is
aimed at students, mostly, learning to code in Scheme, or the Scheme
dialect that is Racket, but not how to create binaries to share their
work with their loved ones who don't code.
In practise the answer is 'raco exe' which makes an executable. You have
to have a suitable main function &c, but it's not hard.
Well, aside from technically correct answers, I was talking about the culture. In my recollection, and by now I guess that would be an old Racket,* there was no emphasis on creating binaries in the Racket intro- ductory material, nor user interface. It's more like, here's a pro-
gramming language, use it!
And until binaries are habitually made with Racket, and by that I mean production binaries, with code signatures for the Microsoft and fruit
vendor platforms, that's not likely to change.
Best wishes, and happy Racketteering!
* Pun totally intended afterwards.--
On 14/08/2026 3:52 AM, Anton Antimo wrote:
tfb <tfb@work.it.out> writes:
Anton Antimo <anton@safunu.org> wrote:
I never ran XEmacs, but I watched a documentary once that said that
XEmacs was born out of something to do with font locking---my intuition >>>> says XEmacs started out with coloring? IIRC, Stallman or someone would >>>> have said that the idea was not properly designed. I can't recall, but >>>> I might research the question and report back here.
The Emacs schism was not fundamentally technical: it happened because
cooperation with RMS is impossible. Lucid needed some features in what
would have been Emacs 19 to support a programming environment (for C++, I >>> think, not Lisp, despite them being Lucid) and were willing to donate the >>> time to implement them & donate the results (remember Emacs 18 had an
entirely minimal interface to X: equivalent to running it in a terminal
emulator). And ... cooperation with RMS turned out to be impossible. So >>> LEmacs happened, which became XEmacs after Lucid died.
I wasn't there, but I was around a few months later and perhaps before the >>> split was really final. I perhaps no longer have the trove of emails from >>> the split: they made depressing reading.
(If you're thinking of posting a followup explaining why cooperation with >>> RMS is, in fact, possible, just ... don't, please.)
Thank you for describing the matter. You must be the best one here
to elaborate on the schism? Can you elaborate it more technically?
For instance, there's font locking today on the GNU EMACS---was it
done in a dramatically different way relative to LEmacs?
Just to chime in for the newcomers who don't know about this publicly available summary.
https://www.xemacs.org/Documentation/21.5/html/internals_4.html
And.
https://www.xemacs.org/About/XEmacsVsGNUemacs.html
That said, I do hope tfb is willing to write out a technical summary, or
even a social one like in the first link.
Note that since then, GNU Emacs did indeed add loadable modules in C.
Adding comp.emacs.xemacs to the discussion, because that group shouldn't
be empty all the time.
Happy text editing in XEmacs!
LLMs [I agree it's a stupid name] are hidden node models having tens
of thousands (or more) of nodes, and many millions of inputs [and
weights and offsets]. You can't build one without a supercomputer.
I suppose that a typical medic is of a different personality type than
a typical computer programmer. I do not think that being overworked is
the overriding cause of the behavior of medics and programmers.
(S. HTTP://Gloucester.Insomnia247.NL/ fuer Kontaktdaten!)
No language has 100% of constructs anyone might ever want. If it has
90% and requires a little stretching for the other 10%, it's doing ok.
There's more to language than syntax, even if you find syntax important.
E.g. some users want fancy type systems including for their DSL's.
There are Lisp dialects that have that, but it's unfeasible in CL other
than through the Turing tarpit of macros.
For students, it'd perhaps be much more valuable to teach them how to
disable anything that nags if the resulting binary doesn't carry a
signature made with a certificate from the CA system, especially when it needs to be a more expensive certificate and/or requires ID validation.
George Neuner <gneuner2@comcast.net> writes:
[...]
LLMs [I agree it's a stupid name] are hidden node models having tens
of thousands (or more) of nodes, and many millions of inputs [and
weights and offsets]. You can't build one without a supercomputer.
On the names. I don't think LLM is such a stupid name---it describes
what it is (at least for now, since sizes evolve over time). But isn't ChatGPT even sillier? Who came up with the idea of tagging GPT on the
name of the thing? I suppose the idea was to make it very clear it was
not a person? In that case, they shouldn't be done like it's always
been done: GPT meaning [G]PT is not a [P]erson, [T]hanks (for asking)! (Lol---I'm so good at this.)
One I've seen used that's adequate is "Generative Autocomplete".
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
And herein lies the conundrum. I believe I took a quick glance at the
manual, looked at the able of contents, and even tried ctrl+f and the
terms /binary/ or /binaries/, and /executable/, and found nothing.
Being /technically/ in the manual does not help if one cannot easily
find what one is looking for. It also doesn't help if one doesn't have
expectations of finding it in the first place.
Um, section 2.4.3 Generating Executables, in the manual. It's not quite in the first page on my screen, but, ad they say, RTFM.
On 2026-08-13, Johann 'Myrkraverk' Oskarsson wrote:
On 14/08/2026 12:14 AM, tfb wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
If I'm not mistaken, we also have this problem with Racket. Racket is >>>> aimed at students, mostly, learning to code in Scheme, or the Scheme
dialect that is Racket, but not how to create binaries to share their
work with their loved ones who don't code.
In practise the answer is 'raco exe' which makes an executable. You have >>> to have a suitable main function &c, but it's not hard.
Well, aside from technically correct answers, I was talking about the
culture. In my recollection, and by now I guess that would be an old
Racket,* there was no emphasis on creating binaries in the Racket intro-
ductory material, nor user interface. It's more like, here's a pro-
gramming language, use it!
And until binaries are habitually made with Racket, and by that I mean
production binaries, with code signatures for the Microsoft and fruit
vendor platforms, that's not likely to change.
For students, it'd perhaps be much more valuable to teach them how to
disable anything that nags if the resulting binary doesn't carry a
signature made with a certificate from the CA system, especially when it needs to be a more expensive certificate and/or requires ID validation.
And perhaps teach them about more suitable means to sign executables,
like OpenPGP, that actually is based on a web of trust and not on some centralized issuer?
No, I'm not so "lucky" to get payments for other people's criminal acti- vities. Do you?Best wishes, and happy Racketteering!
Running afoul of RICO, are we? :-P
No single language has 1% of constructs anyone might ever want.
Sometimes there is a pretense of some limited form of democracy: perhaps
you, as a mere serf, can join the politburo and have a vote on what happens to the language.
I haven't seen this url in a while but I guess it's time to post it
again.
https://www.marktarver.com/bipolar.html
I haven't seen this url in a while but I guess it's time to post it
again.
https://www.marktarver.com/bipolar.html
On Sat, 21 Feb 2026 12:25:06 +0100, Mario Rosell wrote:
Just for fun. It seems like a pretty interesting language.
Lisp is a pretty interesting language, but it was never standardized
to the extent that we expect of languages today. Look at the Common
Lisp spec, and it still retains a lot of baggage to maintain
compatibility with obsolete OSes that simply donrCOt matter any more.
And also, which particular Lisp do you want to learn? There are a
number in common use today:
* In the rCLLisp-2rCY camp: Emacs Lisp, SBCL
* In the rCLLisp-1rCY camp: GNU Guile
And thatrCOs just what I think of as the most notable ones.
On 2026-02-21, Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
Lisp is a pretty interesting language, but it was never
standardized to the extent that we expect of languages today. Look
at the Common Lisp spec, and it still retains a lot of baggage to
maintain compatibility with obsolete OSes that simply donrCOt matter
any more.
And also, which particular Lisp do you want to learn? There are a
number in common use today:
* In the rCLLisp-2rCY camp: Emacs Lisp, SBCL
* In the rCLLisp-1rCY camp: GNU Guile
And thatrCOs just what I think of as the most notable ones.
Guile and every other Scheme it's both lib, SRFI and R_RS
incompatible with each other. CL with ANSI and the HyperSpec in the
end can be ironicaly much smaller and compact.
Personally, I think Lisp people need -- well, need is a strong word, but
I'll go with it -- to get a little bit more behind the notion of practi- >cality. I mean, the Steel Banks Common Lisp is fine, but many others
aimed at beginners are exclusively geared towards facing the programmer
him- -- or her- -- self. There is very little attention paid to the de- >tails of creating binaries to share with friends. And by this, I mean
the parts of the programmer facing documentation. I believe the Steel
Banks Common Lisp manual does not mention how to create binary executa-
bles? I believe I learned that from /Stack Overflow/ which everyone
here in comp.lang.lisp knows is not a good place to learn how to do
anything; not anymore.
Games with Gabe wrote* about that extensively in his YouTube video, at
https://www.youtube.com/watch?v=IbDAmvUwo5c
and I heartily agree.
If I'm not mistaken, we also have this problem with Racket. Racket is
aimed at students, mostly, learning to code in Scheme, or the Scheme
dialect that is Racket, but not how to create binaries to share their
work with their loved ones who don't code.
So I believe we need more books about Common Lisp. Especially how to
make production games in Common Lisp. I mean, the Steel Banks Common
Lisp garbage collector cannot be worse than the old one in Unity, and
I currently believe C.L.O.S. is eminently suitable for three dimensional
game objects.
is it possible to use a truth maintenance system? Just curious, it would >probably take up too much space and time. Just a jtms is a lot of
overhead. You could try to use an LTMS but we all know that this just
leads to more wasted space and aggravation. I would think an ATMS would
work; I dunno, I do not have a super computer or a billion dollars.
On 2026-08-14, Anton Antimo wrote:
George Neuner <gneuner2@comcast.net> writes:
[...]
LLMs [I agree it's a stupid name] are hidden node models having tens
of thousands (or more) of nodes, and many millions of inputs [and
weights and offsets]. You can't build one without a supercomputer.
On the names. I don't think LLM is such a stupid name---it describes
what it is (at least for now, since sizes evolve over time). But isn't
ChatGPT even sillier? Who came up with the idea of tagging GPT on the
name of the thing? I suppose the idea was to make it very clear it was
not a person? In that case, they shouldn't be done like it's always
been done: GPT meaning [G]PT is not a [P]erson, [T]hanks (for asking)!
(Lol---I'm so good at this.)
One I've seen used that's adequate is "Generative Autocomplete".
I'd also propose "GIGO As A Service".
I think it's worth understanding what macros actually mean.
On 14/08/2026 7:58 AM, Anton Antimo wrote:
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
On 13/08/2026 11:19 PM, Anton Antimo wrote:[...]
Try the ``executable'' keyword; you'll find this:Personally, I think Lisp people need -- well, need is a strong word, but >>>>> I'll go with it -- to get a little bit more behind the notion of practi- >>>>> cality. I mean, the Steel Banks Common Lisp is fine, but many others >>>>> aimed at beginners are exclusively geared towards facing the programmer >>>>> him- -- or her- -- self. There is very little attention paid to the de- >>>>> tails of creating binaries to share with friends. And by this, I mean >>>>> the parts of the programmer facing documentation. I believe the Steel >>>>> Banks Common Lisp manual does not mention how to create binary executa- >>>>> bles? I believe I learned that from /Stack Overflow/ which everyone >>>>> here in comp.lang.lisp knows is not a good place to learn how to do
anything; not anymore.
See SBCL's sb-ext:save-lisp-and-die.
(sb-ext:save-lisp-and-die #P"my-executable.exe"
:toplevel #'my-package:main
:executable t
:save-runtime-options t)
Source:
https://www.sbcl.org/manual/
And herein lies the conundrum. I believe I took a quick glance at the
manual, looked at the able of contents, and even tried ctrl+f and the
terms /binary/ or /binaries/, and /executable/, and found nothing.
Being /technically/ in the manual does not help if one cannot easily
find what one is looking for. It also doesn't help if one doesn't have
expectations of finding it in the first place.
--8<-------------------------------------------------------->8---
Executable Delivery: The :executable argument to
sb-ext:save-lisp-and-die can produce a "standalone" executable
containing both an image of the current Lisp session and an SBCL
runtime.
--8<-------------------------------------------------------->8---
Source:
https://www.sbcl.org/manual/
Please be patient with me. Here is a screenshot. I'm afraid the link
is ridiculously long, and I don't use url shorteners anymore.
https://www.dropbox.com/scl/fi/07asmp90gza39utr55wro/SBCL-manual-execu.jpg?rlkey=jd3tcevbchchpsge37xfmjh1j&st=pk2y5hvh&dl=0
What I'm looking at here seems to be the word "execu" -- or the prefix
of which -- not being found. Should I have continued to type the whole
word? I thought this worked like Emacs' incremental search, and as I
typed more characters, it would search longer words, until it wouldn't
find what I've typed so far.
Is this perhaps a matter of not using the right browser? I mean, what browser do the team players behind S.B.C.L. habitually use themselves?
YMMV. I think the LAST thing we need is more games. Too many gamers
need to pull their heads out of the game and go get a life.
I'm not a programmer, but as computer science is allowing me to get
things in my stomach (and as a French guy, what I put in my stomach is
very important don't belittle that part), I have to follow up on what's happening in computer world. And I found a lot of things about LISP.
Don't get me wrong. I find something like 1% of blogs/articles/whatever related to LISP. You can think it as small, but compared to what LISP is
used in real life, it's huge. For each article/blog/whatever about C or
C++ or COBOL, I can see at least ten articles/blog/whatever about LISP.
And it's something.
On Tue, 11 Aug 2026 18:35:58 -0000 (UTC), C||il|!n Niocl|is|!n Glost|-ir wrote:
Is BASh on Windoze without its features on gratis operating systems?
ItrCOs not about gratis, itrCOs about libre.
Is BASh on Windoze without its features on gratis operating systems?
On 2026-08-10, Paul Rubin <no.email@nospam.invalid> wrote:
Suppressing evaluation is not the same thing as delaying evaluation.
Macfros suppress evaluation so that the expression can be given an
arbitrary meaning. One such meaning could be that evaluation is delayed,
e.g. classic (delay <form>) macro, returning a promise. That's only a
small point in a large universe.
steve g <Sgonedes1977@gmail.com> wrote:
I liked the idea of
(with-current-readtable (xyz)
...)
That is unuseful unless the body is a bunch of file compilations / loads.
It should be apparent why.
but hygenic-macros and late evaluation is one of the best features
about lisp macros.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
I try to keep in shape by reading books in languages I'm not using. Or
converse with people about programming languages I don't use anymore,
such as Pascal.
I've managed to keep my French more or less intact, but could use a
brush up on Danish, and of course German as I said. I'm sure I'll
find something to inspire me to keep practicing German. After all,
I'm struggling to read Asterisk and Obelisk in Latin.
Best wishes, and happy language studies in comp.lang.lisp!
Have you tried shortwave radio? You'll get all kinds of people talking different languages; not to mention it is rather entertaining.
Steve G <SGonedes1977@GMail.com> wrote: |----------------------------------------------------------------------------|
|"Aidan Kehoe <kehoea@parhasard.net> writes: |
|[. . .] |
| |
|[. . .] |
|[. . .] stallman [. . .] |
|he is sometimes very prophetic. I recommend reading his essay on the |
|right to read." |
|----------------------------------------------------------------------------|
Dear Mister Stephen G:
I had bought many books. They have been robbed. I never got to read
them :(
I do not write cursive writings. I am an Asperger autist.
A neighbor in Ireland recently alleged to me that children here are
not taught to write handwriting at all - not just not cursive
handwritings! Handwriting is too important to be neglected!
A journalist reported more than 3 years ago that a primary school
which is located at the end of a route of circa 5.5 miles (according
to
HTTPS://WWW.ViaMichelin.com
) from me stopped using books! A primary school might be what you call
an elementary school. The pupils in a primary school are younger than teenagers. A neighbor is related to a teacher here. This teacher
laughed at a relative because this non-teacher relative uses a
dictionary instead of Google.
|----------------------------------------------------------------------------|
|"[. . .] you |
|did not even tell me to quit smoking cigarettes :)" |
|----------------------------------------------------------------------------|
Do not smoke :)
Mario Rosell <mario@mariorosell.es> writes:
Hello everyone!
I want to learn Common Lisp, but I don't really know what resources to
use.
What did you all use to learn? Is that even relevant? Is this newsgroup
active?
bixbox <noreply@example.invalid> writes:
Mario Rosell <mario@mariorosell.es> writes:
Hello everyone!
I want to learn Common Lisp, but I don't really know what resources to
use.
start using emacs. Read the tutorial and the built in manual. It does take some time, a couple of weekes until you feel like you are in a home.
steve g <Sgonedes1977@gmail.com> writes:
but hygenic-macros and late evaluation is one of the best features
about lisp macros.
Lisp (CL) doesn't have hygienic macros, I thought. It took a long while
for Scheme to standardize its version.
On Thu, 13 Aug 2026 11:20:20 +0800, Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
Personally, I think Lisp people need -- well, need is a strong word, but
I'll go with it -- to get a little bit more behind the notion of practi-
cality. I mean, the Steel Banks Common Lisp is fine, but many others
aimed at beginners are exclusively geared towards facing the programmer
him- -- or her- -- self. There is very little attention paid to the de-
tails of creating binaries to share with friends. And by this, I mean
the parts of the programmer facing documentation. I believe the Steel
Banks Common Lisp manual does not mention how to create binary executa-
bles? I believe I learned that from /Stack Overflow/ which everyone
here in comp.lang.lisp knows is not a good place to learn how to do
anything; not anymore.
Games with Gabe wrote* about that extensively in his YouTube video, at
https://www.youtube.com/watch?v=IbDAmvUwo5c
and I heartily agree.
If I'm not mistaken, we also have this problem with Racket. Racket is
aimed at students, mostly, learning to code in Scheme, or the Scheme
dialect that is Racket, but not how to create binaries to share their
work with their loved ones who don't code.
The biggest issue I see with learning Racket is the sheer weight of
its documentation. The reference is pushing ~1,800 pages and the user
guide is twice that.
It all could use a better [relational] index. The docs /are/ indexed,
but if you don't know what keyword(s) to search for, it can be hard to
find relevant information. Racket's preferred terminology is a mashup
that stems from many sources.
Racket isn't really aimed at students - its predescessor PLT Scheme
/was/ aimed at teaching, but Racket is meant for general development.
Racket is not a Scheme, but it is closely related.
The main distribution bundle includes a large number of libraries and development tools, and additionally there are hundreds of user
contributed packages.
Racket /does/ remain popular for teaching because of the (relative)
ease of creating DSLs having arbitrary [ie. non-sexpr] syntax that
will compile to and interoperate with Racket. It is fairly easy to
mix and match modules written using different DSLs.
There are a number of subset "teaching languages", R5RS and R6RS
Scheme implementations, and others, all implemented as DSLs.
So I believe we need more books about Common Lisp. Especially how to
make production games in Common Lisp. I mean, the Steel Banks Common
Lisp garbage collector cannot be worse than the old one in Unity, and
I currently believe C.L.O.S. is eminently suitable for three dimensional
game objects.
YMMV. I think the LAST thing we need is more games. Too many gamers
need to pull their heads out of the game and go get a life.
On 16/08/2026 7:44 AM, George Neuner wrote:
YMMV. I think the LAST thing we need is more games. Too many gamers
need to pull their heads out of the game and go get a life.
I disagree. Not about gamers, they absolutely need to get a life, but
about the games. It's generally hard for me to find games I personally >enjoy, so I've started to amass a library of game making related books.
Of course, that can be just a symptom of my severe Tsundoku, but a
creature can dream of making games in the future.
Plus, making games is a completely different activity from playing them.
Happy game making in Common Lisp!
On Sat, 22 Aug 2026 02:28:49 +0800, Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
On 16/08/2026 7:44 AM, George Neuner wrote:
YMMV. I think the LAST thing we need is more games. Too many gamers
need to pull their heads out of the game and go get a life.
I disagree. Not about gamers, they absolutely need to get a life, but
about the games. It's generally hard for me to find games I personally
enjoy, so I've started to amass a library of game making related books.
Of course, that can be just a symptom of my severe Tsundoku, but a
creature can dream of making games in the future.
I don't play games - I drive fast cars and fly small planes.
[Yes, I have a private pilot license.]
For fun I dabble in programming languages, compilers and runtimes.
Plus, making games is a completely different activity from playing them.
A good point. Programming a game might be more fun than playing one.
OTOH, I worked in HRT machine vision QA/QC for over a decade, so now I
find graphics largely to be boring. Currently I do databases, and occasionally middleware apps to support them.
I think it's worth understanding what macros actually mean.
Most programming languages are dictatorships: a small, usually
self-elected, self-important group of people designs a language, and thousands or millions of serfs have to suffer the consequences of their choices.
Sometimes there is a pretense of some limited form of democracy: perhaps
you, as a mere serf, can join the politburo and have a vote on what happens to the language. Sometimes this involves a payment to some nebulous standards organisation. Sometimes you can comment on suggested changes; sometimes people might listen to those comments. Sometimes the politburo
is not largely made up of representatives (either explicit or implicit) of huge corporations who care not one jot about your interests.
Changes, when they happen at all, take years. The language is ossified almost as soon as it exists.
Almost always, for large systems, there will be tools built on top of the ossified substrate language which allow people to write programs in a way which actually matches their problem domain. Those tools are, in fact, *programming languages*, although they're usually implemented in an ad-hoc way by people who don't even realise that what they are doing is designing
a programming language. They are therefore predictably horrible. If you have not used such an ad-hoc language you probably have not worked on a
large system.
Sometimes people make a better decision: they take an existing (usually dynamically typed as basically nobody likes static typing in the real
world, usually either not compiled or dynamically compiled) language which has a good interface to the ossified substrate and expose functionality written in the ossified substrate to the more flexible surface language. NumPy and all its relations are the canonical example of this.
That's at least better than the thing implemented using m4 on top of
Fortran or whatever. But the thing written in m4 on top of Fortran is *still* better than using Fortran directly (and this is not because
Fortran, today, is a bad language, which is is not, it's because it's an ossified language).
Quite often what happens is that user or group of users of a language gets
so fed up with this process that they design a new language which better meets their needs, perhaps starting with one of the ad-hoc languages above.
That language then develops its own self-important politburo, becomes ossified.
Recurse.
Lisp chose something else. Lisp chose not to be a dictatorship, but to
treat its users as adults capable of making their own decisions: decisions which were as good as the decisions of the politburo if not better. Decisions which, certainly, relfected the needs of the users making the decisions rather than some distant observer.
Lisp looked at what *actually happens* in the world rather than in the
heads of the politburo members, and it saw that what happened was the
endless invention of new languages, either for specific problem domains, or just because the existing languages were so terrible. And it said, 'OK, let's make that a feature, not something you have to fight your way
towards. Let's build a language whose defining feature is that it lets you build languages. Let's allow it to let you build languages
*incrementally*, rather than putting some enormous barrier in your way. So you can take an existing language and define some extensions to it, and
those extensions wil have exactly the same status as the original language does.'
If you disagree with the decisions of the politburo you don't have to wait five years for the members to die and the decision to change, you can just make the system do what you want, today.
Lisp understood that this means you have to make some compromises. The
most significant is that the syntax of the language must have very low commitment to the semantics. That makes the language rather austere, but
it means that you, the user of the language, get to say what the semantics is, without having to jump through some huge ring of fire and getting
burned in the process.
Lisp is a system built by people who understand how utterly stupid the
claim that any programming language contains 90% of all the constructs
anyone will ever need is.
Lisp is a democracy. It is perhaps more than a democracy: it either is or
is close to an anarchy. Anarchies obviously work only if their citizens
are actually adults and if they are willing to cooperate with one another. But, well, Lisp assumes you are. If you're not an adult, or if you can't deal with cooperating with other people in the design of the language
you're going to use, or if you like someone telling you what to do then, well, do what thou wilt.
Lisp understands that a consequence of this anarchy is that different
groups of users working on different projects will end up using differing languages, or dialects (*a shprakh iz a dyalekt mit an armey un flot*, famously), and it also understands that *that's what happens anyway*,
except the languages and dialects people end up using are usually things created using tools whose only datatype is the string.
Like I say: if you're happy to live as a serf in a dictactorship, or if you feel you might become a dictator, then that's OK. But please, stay the
fuck away from those of us who want not to be serfs or dictators, and who want to make our own decisions in a community of our equals.
bixbox <noreply@example.invalid> writes:
I want to learn Common Lisp, but I don't really know what
resources to use.
start using emacs.
Let me mention some decision of the polibiuro that I do not like.
1) I am a Unix man and doing
(compile-file "foo/bar.lisp" :output-file "baz/bar.fasl")
I want output to live is file "baz/bar.fasl" relative to current
directory. But polibiuro decided differently. I solve this in
Blub way, that is writing wrapper function that converts
"baz/bar.fasl" to absolute path and then calls 'compile-file'.
2) Program that I am developing has a user language which is
implemented converting user input to Lisp and then using 'eval' to
evaluate it. That is good, but there is a catch: from users point of
view "T" is a perfectly good variable name. But polibiuro decided
that it is reserved. I could try to work around this using packages,
but this has serious drawback. So I solve this in Blub way, that is convertion replaces "T" by a different name.
3) I would like to so symbolic computation with arbitrary symbols.
For my purpose a symbol is always different from a list. But
polibiuro decided that "NIL" is identical to the empty list. I would
like "NIL" to be a constant symbol which when evaluated gives empty
list.
On Tue, 18 Aug 2026 21:34:40 -0700, Paul Rubin
<no.email@nospam.invalid> wrote:
steve g <Sgonedes1977@gmail.com> writes:
but hygenic-macros and late evaluation is one of the best features
about lisp macros.
Lisp (CL) doesn't have hygienic macros, I thought. It took a long while >>for Scheme to standardize its version.
You are correct - Lisp doesn't have hygienic macros. However, Lisp
macros can be made safe(r) [for some definition] through careful use
of (gensym).
3) I would like to so symbolic computation with arbitrary symbols.
For my purpose a symbol is always different from a list. But
polibiuro decided that "NIL" is identical to the empty list. I would
like "NIL" to be a constant symbol which when evaluated gives empty
list.
You want more than one empty-list object? I think that is
traditionally treated as a rCLsingletonrCY (not just in Lisp), which means the answer is rCLnorCY.
On 22/08/2026 3:23 AM, George Neuner wrote:
On Sat, 22 Aug 2026 02:28:49 +0800, Johann 'Myrkraverk' Oskarsson
<johann@myrkraverk.invalid> wrote:
On 16/08/2026 7:44 AM, George Neuner wrote:
For fun I dabble in programming languages, compilers and runtimes.
Yes, that is indeed fun. I have amassed quite an extensive library on
the subject. Though not in Common Lisp. Compiler literature, at least
in physical copies -- is lacking in the language of the Lisp.
Plus, making games is a completely different activity from playing them.
A good point. Programming a game might be more fun than playing one.
OTOH, I worked in HRT machine vision QA/QC for over a decade, so now I
find graphics largely to be boring. Currently I do databases, and
occasionally middleware apps to support them.
Fair enough. I am also not at all impressed by the modern game engines,
and have no desire to pick up a project in Unity again.
Here in Common Lisp, I'd be delighted to make use of SDL2 or SDL3
bindings, along with the OpenGL for a simple game.
I have also been in databases on and off for the past sixteen years, and
have -- I would not say extensive -- but enough experience in tuning
both Postgres and MariaDB that you can feel free, if your database sys-
tem needs to handle about million people per day -- possibly more, but I >stopped counting at million -- to ask tuning questions.
I have not seen fit to subscribe to any of the database groups yet, so
please let me know which ones you'd like to use for such discussions.
In the mean time, we can discuss SQLite bindings for S.B.C.L, because I
did not find anything of the sort with a casual websearch. Is there
such a thing already in QuickLisp?
Best wishes, and happy database queries on Common Lisp!
I just want symbol NIL to be a real symbol distingushable from empty
list.
On Sat, 22 Aug 2026 12:07:45 -0000 (UTC), Waldek Hebisch wrote:
I just want symbol NIL to be a real symbol distingushable from empty
list.
But this is a fundamental part of the traditional way that Lisp works:
an rCLempty listrCY isnrCOt really a list at all, it is just a pointer that points nowhere (in C: NULL; in Lisp: NIL). Hence the need for a
special symbol to denote it.
Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
On Sat, 22 Aug 2026 12:07:45 -0000 (UTC), Waldek Hebisch wrote:
I just want symbol NIL to be a real symbol distingushable from
empty list.
But this is a fundamental part of the traditional way that Lisp
works: an rCLempty listrCY isnrCOt really a list at all, it is just a
pointer that points nowhere (in C: NULL; in Lisp: NIL). Hence the
need for a special symbol to denote it.
No, you do not need special symbol to denote empty list, "()" works
fine:
* ()
NIL
Concering tradition, I suspect that basically the same behaviour
appears in newer Lisp system "because it was always done that way".
But it seem to be rather specific to Lisp, there are other system
having similar handling of lists and I know of no other repeating
Lisp misfeature.
On Sat, 22 Aug 2026 23:08:44 -0000 (UTC), Waldek Hebisch wrote:
Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
On Sat, 22 Aug 2026 12:07:45 -0000 (UTC), Waldek Hebisch wrote:
I just want symbol NIL to be a real symbol distingushable from
empty list.
But this is a fundamental part of the traditional way that Lisp
works: an rCLempty listrCY isnrCOt really a list at all, it is just a
pointer that points nowhere (in C: NULL; in Lisp: NIL). Hence the
need for a special symbol to denote it.
No, you do not need special symbol to denote empty list, "()" works
fine:
* ()
NIL
But that equivalence is the very thing you were complaining about.
<snip>Concering tradition, I suspect that basically the same behaviour
appears in newer Lisp system "because it was always done that way".
It has to do with the implementation. A list consists of cons
structures linked together via pointers. An empty list consists of no
cons structures, hence there is nothing to point to.
But it seem to be rather specific to Lisp, there are other system
having similar handling of lists and I know of no other repeating
Lisp misfeature.
I can think of one: multiple-value-return. This requires the creation
of a whole mechanism involving data structures that are not really
data structures.
I don't play games - I drive fast cars and fly small planes.
[Yes, I have a private pilot license.]
For fun I dabble in programming languages, compilers and runtimes.
Plus, making games is a completely different activity from playing them.
A good point. Programming a game might be more fun than playing one.
OTOH, I worked in HRT machine vision QA/QC for over a decade, so now I
find graphics largely to be boring. Currently I do databases, and occasionally middleware apps to support them.
Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
3) I would like to so symbolic computation with arbitrary symbols.
For my purpose a symbol is always different from a list. But
polibiuro decided that "NIL" is identical to the empty list. I would
like "NIL" to be a constant symbol which when evaluated gives empty
list.
You want more than one empty-list object? I think that is
traditionally treated as a rCLsingletonrCY (not just in Lisp), which means >> the answer is rCLnorCY.
No, a single empty list object. I just want symbol NIL to be
a real symbol distingushable from empty list. Consider
On Sat, 22 Aug 2026 07:54:06 +0800, Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
On 22/08/2026 3:23 AM, George Neuner wrote:
On Sat, 22 Aug 2026 02:28:49 +0800, Johann 'Myrkraverk' Oskarsson
<johann@myrkraverk.invalid> wrote:
On 16/08/2026 7:44 AM, George Neuner wrote:
Haven't had opportunity to play with MariaDB. I have worked a lot
with Postgresql [and with Sybase back in the day], and some with
SQLServer, MySQL and SQLite.
Most of the Usenet DBMS groups are dead - moved to web forums.
In the mean time, we can discuss SQLite bindings for S.B.C.L, because I
did not find anything of the sort with a casual websearch. Is there
such a thing already in QuickLisp?
antispam@fricas.org (Waldek Hebisch) writes:
Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
3) I would like to so symbolic computation with arbitrary symbols. For >>> my purpose a symbol is always different from a list. But polibiuro
decided that "NIL" is identical to the empty list. I would like "NIL" to >>> be a constant symbol which when evaluated gives empty list.
You want more than one empty-list object? I think that is traditionally >> treated as a rCLsingletonrCY (not just in Lisp), which means the answer is
rCLnorCY.
No, a single empty list object. I just want symbol NIL to be
a real symbol distingushable from empty list. Consider
I usually use deconstant or define symbol macro.--
(deconst +eof+ '+eof+)
; SLIME 2.27
CL-USER> (defconstant +eof+ '+eof+)
CL-USER> +eof+
+EOF+
CL-USER> (defconstant +eol+ '(nil . nil))
+EOL+
CL-USER> +eol+
(NIL)
CL-USER>
If your priority is purity, there is not reason for end-of-list to
be a symbol.
antispam@fricas.org (Waldek Hebisch) writes:
Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
3) I would like to so symbolic computation with arbitrary symbols.
For my purpose a symbol is always different from a list. But
polibiuro decided that "NIL" is identical to the empty list. I would
like "NIL" to be a constant symbol which when evaluated gives empty
list.
You want more than one empty-list object? I think that is
traditionally treated as a rCLsingletonrCY (not just in Lisp), which means >>> the answer is rCLnorCY.
No, a single empty list object. I just want symbol NIL to be
a real symbol distingushable from empty list. Consider
I usually use deconstant or define symbol macro.
(deconst +eof+ '+eof+)
; SLIME 2.27
CL-USER> (defconstant +eof+ '+eof+)
CL-USER> +eof+
+EOF+
CL-USER> (defconstant +eol+ '(nil . nil))
+EOL+
CL-USER> +eol+
(NIL)
CL-USER>
More radical approach as above means that I can no longer use
standard Common Lisp functions so I need to add "buggy and slow implementation of half of the Common Lisp" to my program.
* George Neuner <jg7h8ldp0ka3hd8nan3spb6avc199q53k6@4ax.com> :
Wrote on Fri, 21 Aug 2026 15:23:45 -0400:
I don't play games - I drive fast cars and fly small planes.
So you're not part of the 200-250 billion dollar market, big deal.
[Yes, I have a private pilot license.]
For fun I dabble in programming languages, compilers and runtimes.
Plus, making games is a completely different activity from playing them.
A good point. Programming a game might be more fun than playing one.
OTOH, I worked in HRT machine vision QA/QC for over a decade, so now I
find graphics largely to be boring. Currently I do databases, and
occasionally middleware apps to support them.
I think the fundamental principle on which the programming industry is >bankrolled is based on what was enunciated by brooks in "no silver
bullet" -- the goose that lays golden eggs.
given bankable developments
in hardware and consumption, given access to fiat capital from satan's
wazoo, and given the power to launder it, the creation of an essentially >managable but fake "developer market" is inevitable. you may have
perceived tfb to be petulant when he characterised the "serfs", but they >really operate as a "middle class" ratifying the leadership and
producing the consumption patterns that are needed (apart from the
occasional profits in wage arbitrage).
"programming glory" goes to shit. the discipline of graphics has
essentially been thrown away, replaced and shaped with by "hardware >developments", and it is in the interests of the bankers managing the
deficts to bless the slop. (i'm surprised if tfb still in adam smith)
Yes, I can get half way by using packages and shadowing real NIL. But
in such approach Common Lisp still considers empty list to be a symbol
tfb <tfb@work.it.out> writes:
No single language has 1% of constructs anyone might ever want.
If I can code fluently in a language, that is, I can think entirely
about the application-level problem I'm trying to solve and not putting
much effort into choosing language constructs, then it's supplying 100%
of what I want at least at that moment. That's great.
I don't follow.
I don't follow.
You are correct - Lisp doesn't have hygienic macros. However, Lisp
macros can be made safe(r) [for some definition] through careful use
of (gensym).
|| |
I had bought many books. They have been robbed. I never got to read|
them :( |
But this is a fundamental part of the traditional way that Lisp works:
an rCLempty listrCY isnrCOt really a list at all, it is just a pointer that points nowhere (in C: NULL; in Lisp: NIL). Hence the need for a
special symbol to denote it.
Python and JavaScript have a simpler approach to the same concept: destructuring assignment.
Yes, I can get half way by using packages and shadowing real NIL. But
in such approach Common Lisp still considers empty list to be a symbol
and prints it a symbol. More radical approach as above means that
I can no longer use standard Common Lisp functions so I need to add
"buggy and slow implementation of half of the Common Lisp" to my
program.
Paul Rubin <no.email@nospam.invalid> wrote:
tfb <tfb@work.it.out> writes:
No single language has 1% of constructs anyone might ever want.
If I can code fluently in a language, that is, I can think entirely
about the application-level problem I'm trying to solve and not putting
much effort into choosing language constructs, then it's supplying 100%
of what I want at least at that moment. That's great.
Here's the thing: you are one person. There are, shockingly, other people
in the world who might want to write programs. You may also have noted
that more than one programming language exists. Although you are clearly happy with whatever language it is you use and never inclined to look at anything else, perhaps some if these other languages might exist because other people might want a different set of constructs, don't you think?
This article (which, as you say is old now, if not in this form)
misdiagnoses what is happening.
Yes, BBMs are a thing (I am not one: I am *lazy* which is its own problem, and I make mo claim to brilliance), and yes, there are perhaps more of them in Lisp than elsewhere. But the reason is more complicated.
People who are, in whatever way is required, smart, will want to do things which are hard in the right way. A subset of those people will be BBMs.
That means that fields which are hard will necessarily get more BBMs,
because of the first 'B'.
Fields which are hard are also never going to be popular, just because not many people are smart in the right way to do them.
General relativity is hard: nobody berates it because not many people can hack it. Because it is hard it is also not popular: again nobody berates
it because of that.
Lisp is not popular because a lot of its best uses are doing hard things. Python is popular because a lot of its best uses are doing easy things (or things which are, as a programming problem, easy). There is nothing wrong with using a language designed for doing easy things when what you want to
do is an easy thing: my problem with Python is that its notion of interface stability is a bad joke: even so I write plenty of tools in Python.
Like the article says: 'the answer is that there is no problem with Lisp, because Lisp is, like life, what you make of it'.
On Sat, 22 Aug 2026 00:00:42 -0000 (UTC), Waldek Hebisch wrote:
Let me mention some decision of the polibiuro that I do not like.
1) I am a Unix man and doing
(compile-file "foo/bar.lisp" :output-file "baz/bar.fasl")
I want output to live is file "baz/bar.fasl" relative to current
directory. But polibiuro decided differently. I solve this in
Blub way, that is writing wrapper function that converts
"baz/bar.fasl" to absolute path and then calls 'compile-file'.
Note how the defaults for input-file are filled in from *input-pathname-defaults*, but the same does not apply to output-file: <https://www.lispworks.com/documentation/HyperSpec/Body/f_cmp_fi.htm>.
This is what I mean by Common Lisp being full of baggage for catering
to non-POSIX operating systems which are all extinct now.
2) Program that I am developing has a user language which is
implemented converting user input to Lisp and then using 'eval' to
evaluate it. That is good, but there is a catch: from users point of
view "T" is a perfectly good variable name. But polibiuro decided
that it is reserved. I could try to work around this using packages,
but this has serious drawback. So I solve this in Blub way, that is
convertion replaces "T" by a different name.
Or alternatively, you shouldnrCOt be equivalencing user-defined
variables directly to Lisp variables.
3) I would like to so symbolic computation with arbitrary symbols.
For my purpose a symbol is always different from a list. But
polibiuro decided that "NIL" is identical to the empty list. I would
like "NIL" to be a constant symbol which when evaluated gives empty
list.
You want more than one empty-list object? I think that is
traditionally treated as a rCLsingletonrCY (not just in Lisp), which means the answer is rCLnorCY.
Lawrence D-|Oliveiro <ldo@nz.invalid> wrote:
Python and JavaScript have a simpler approach to the same concept:
destructuring assignment.
One more time: destructuring binding, which CL has, is not a substitute for multiple values.
On Sun, 23 Aug 2026 21:57:01 +0100, Aidan Kehoe wrote:
If your priority is purity, there is not reason for end-of-list to
be a symbol.
There is this assumption, is there, that rCLlistrCY must mean the
traditional Lisp implementation in terms of two-field cells, so
processing always involves a lot of pointer-chasing?
I donrCOt think there is any such assumption in Python, just for
example. Expressions of the form rCL[...]rCY are said to construct rCLlistsrCY, but the underlying implementation is more likely to be a flex array (to use Algol 68 terminology).
On Sun, 23 Aug 2026 22:37:36 -0000 (UTC), Waldek Hebisch wrote:
More radical approach as above means that I can no longer use
standard Common Lisp functions so I need to add "buggy and slow
implementation of half of the Common Lisp" to my program.
Some have proposed coming up with more modern Lisps as an alternative
to Common Lisp. Are any of them realistic yet?
antispam@fricas.org (Waldek Hebisch) writes:
Yes, I can get half way by using packages and shadowing real NIL. But
in such approach Common Lisp still considers empty list to be a symbol
I think the Lisp machines had that, and they got it from Maclisp, which
may have inherited it from even older Lisps. CL by intention retained
quirks like that to keep supporting pre-CL codebases. I don't know how
CL's other ancestors like Interlisp handled empty lists. Anyway, if you
want Scheme, you know where it is.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> writes:
I try to keep in shape by reading books in languages I'm not using. Or
converse with people about programming languages I don't use anymore,
such as Pascal.
I've managed to keep my French more or less intact, but could use a
brush up on Danish, and of course German as I said. I'm sure I'll
find something to inspire me to keep practicing German. After all,
I'm struggling to read Asterisk and Obelisk in Latin.
Best wishes, and happy language studies in comp.lang.lisp!
Have you tried shortwave radio? You'll get all kinds of people talking different languages; not to mention it is rather entertaining.
I have no idea what you're talking about.
I believe you are wrong about Python's popularity. Python is popular
because of constant effort by /Python influencers/ such as our very own Lawrence D'Oliveiro. It's not exactly easy for anyone to use, in the
long term.
What are you talking about? Of course it is a substitute for multiple values. It's a design decision per function to return either a list or multiple values, and each has its pros and cons.
Biggest obstacles [to Lisp] are closures, dynamic scoping, and GC -
most everything else is transferrable from other languages.
Closures and GC are covered by modern texts - explicit examples are
sorely lacking, but the discussions are good enough that you can
figure out how to implement things.
Dynamic scoping - if you care - is something you really have to figure
out on your own. Not that it's /that/ hard, but making it efficient
and [possibly] dealing with multiple threads both are PITA.
I simply accuse you of having poor reading comprehension, and even worse writing comprehension.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
I believe you are wrong about Python's popularity. Python is popular
because of constant effort by /Python influencers/ such as our very own
Lawrence D'Oliveiro. It's not exactly easy for anyone to use, in the
long term.
I can't think of any single thing that would put me off Python more than
him.
But more generally: no, I think this is false. For instance the existence
of NumPy and a great number if libraries built on it have made a huge (and >justified) difference to Python's popularity. Also remember that the
choice for many tasks was shell script (very high ickyness, unsafe, no >libraries), Perl (high ickyness, safe, libraries) or Python (low ickyness
at first, safe, libraries). (Here 'safe' doesn't mean anything formal, it >means things like no repeated evaluation of strings.)
I simply accuse you of having poor reading comprehension, and even worse
writing comprehension.
Do you really think that a thread about language extensibility and whether any given language could have enough co structs to satisfy all posdible
users of that language had suddenly changed topic to how familiar an individual was with a given language? Really? Oh well.
George Neuner [2026-08-22 18:13:00] wrote:
Biggest obstacles [to Lisp] are closures, dynamic scoping, and GC -
most everything else is transferrable from other languages.
Closures and GC are covered by modern texts - explicit examples are
sorely lacking, but the discussions are good enough that you can
figure out how to implement things.
Indeed closures and automatic memory management are nowadays supported
by the vast majority of programming languages.
Dynamic scoping - if you care - is something you really have to figure
out on your own. Not that it's /that/ hard, but making it efficient
and [possibly] dealing with multiple threads both are PITA.
Efficiency was important back in the Maclisp days when all let-bindings
used dynamic scoping. Nowadays you can expect that dynamically scoped >let-bindings are relatively infrequent ...
On Sun, 23 Aug 2026 23:08:27 -0400, Stefan Monnier
Efficiency was important back in the Maclisp days when all let-bindings
used dynamic scoping. Nowadays you can expect that dynamically scoped
let-bindings are relatively infrequent ...
In Lisp, that may be true. OTOH, dynamic scoping is useful enough
that Racket has explicit support for it.
The problem with Python is that its wonderful libraries mostly could
not be written /in/ Python because the implementations are so bloody
slow.
The problem with Python is that its wonderful libraries mostly could
not be written /in/ Python because the implementations are so bloody
slow.
It's true that many high level languages make writing low level system
code difficult or impossible - but Python is unique among the popular
general purpose languages in that its performance is so bad as to make
it effectively impossible to write /user/ code without using low level non-Python libraries.
Yes, because that's how human to human real world conversations work.
Being strictly /on topic/ without any deviation is a social construct invented by psychopaths for psychopaths. It's because they can't deal
with real human to human interactions, and have to /hide themselves/,
and pretend.
All. The. Time.
You are being dangerously close to expose yourself as a psychopath, so I suggest you stop replying to me, and /touch grass/ or something.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
I have no idea what you're talking about.
You really don't, no.
Hint: I am not talking about whether you know the language you are using
well enough, but whether the language you are using provides the constructs you need to address the problem you are solving in it succinctly.
The person you're talking to has deliberately added cross-posts to comp.lang.misc and comp.lang.c. If you must reply to this troll,
please limit your replies to comp.lang.lisp.
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
What are you talking about? Of course it is a substitute for multiple
values. It's a design decision per function to return either a list or
multiple values, and each has its pros and cons.
It is not, because you can ignore additional values (note Racket, at least, >has got this spectacularly wrong).
You can of course emulate multiple
values with destructuring but it either makes every call look ugly or
bloats the language by requiring functions which perform the same operation >with two different interfaces. Example: gethash.
I have no use for continuations, but I need UNWIND-PROTECT. I need multidimensional arrays. I need good performance and portability to
wide range of platforms.
Yes, because Clojure is a thing, but then you have to use the JVM, and
not the Pythong interpreter, so that rules you out.
Do you really think that a thread about language extensibility and whether any given language could have enough co structs to satisfy all posdible
users of that language had suddenly changed topic to how familiar an individual was with a given language?
The problem which I can not solve is that empty list is printed as 'COMMON-LISP:NIL' instead of '()'. And Common Lisp functions still
will treat empty list as a symbol.
Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
I can think of one: multiple-value-return. This requires the
creation of a whole mechanism involving data structures that are
not really data structures.
multiple-value-return is a different story. One can easily get
equivalent effect with explict stack.
But AFAICS motivation for multiple values is to generate more
efficient code and more efficient implementation will return first
few values in machine registers.
That saves allocation of intermediate container that would became
garbage after return.
I admit I did not consider shortwave radio for language learning.
I consider continuations to be most distingushing feature of Scheme.
On Sun, 23 Aug 2026 23:08:27 -0400, Stefan Monnier
<monnier@iro.umontreal.ca> wrote:
George Neuner [2026-08-22 18:13:00] wrote:
Biggest obstacles [to Lisp] are closures, dynamic scoping, and GC -
most everything else is transferrable from other languages.
Closures and GC are covered by modern texts - explicit examples are
sorely lacking, but the discussions are good enough that you can
figure out how to implement things.
Indeed closures and automatic memory management are nowadays supported
by the vast majority of programming languages.
Yes ... but I was talking about learning how to /implement/ them in
the compiler that you are writing.
Dynamic scoping - if you care - is something you really have to figure
out on your own. Not that it's /that/ hard, but making it efficient
and [possibly] dealing with multiple threads both are PITA.
Efficiency was important back in the Maclisp days when all let-bindings
used dynamic scoping. Nowadays you can expect that dynamically scoped
let-bindings are relatively infrequent ...
In Lisp, that may be true. OTOH, dynamic scoping is useful enough
that Racket has explicit support for it.
https://docs.racket-lang.org/reference/parameters.html
Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> wrote:
Yes, because that's how human to human real world conversations work.
Being strictly /on topic/ without any deviation is a social construct
invented by psychopaths for psychopaths. It's because they can't deal
with real human to human interactions, and have to /hide themselves/,
and pretend.
All. The. Time.
You are being dangerously close to expose yourself as a psychopath, so I
suggest you stop replying to me, and /touch grass/ or something.
I must admit to being pretty amused by how quickly some random internet buffoon, who very obviously is not a native English speaker, has moved from accusing me of poor English reading comprehension rCo and 'writing comprehension', which as a native English speaker I assume must mean 'comprehensible writing', but I dunno rCo to saying I'm about to expose myself as a psychopath because I 'can't deal with human to human interactions' (which is ... funny). (I half expect the same person is now wondering whether I'm using an LLM because of the spaced dashes. Hint:
no.)
And now, because I admit to laughing at you, it will no doubt confirm whatever pop-psychology rubbish you want to believe about people you've
never met and never will. No: quite ordinary people laugh at fools, it
turns put: there's a whole genre of comedy based on that.
So be it.
tfb <tfb@work.it.out> writes:
Do you really think that a thread about language extensibility and whether >> any given language could have enough co structs to satisfy all posdible
users of that language had suddenly changed topic to how familiar an
individual was with a given language?
Fluency does matter.
If fluency in a language lets me do most of my daily tasks with at most occasional inconvenience, I'd call the language satisfactory. Stuff
like macros make inconvenient things convenient. They don't make the impossible possible. And if the language makes enough everyday things convenient, it's ok with me if some inconvenient ones are left over.
So I haven't felt lack of macros to be a serious shortcoming of non-Lisp languages. There are usually alternate mechanisms offered, like
function decorators in Python.
However, Lisp has the failing that catching the 4th returned value
requires catching the first 3 even though you don't care about them.
What bugs me is that catching [however many] values with
destructuring-bind in Lisp or the various *-values forms in Scheme
requires unambigiously naming each of them.
[...]
A while back I created a Modula3 inspired language that included
multiple value returns, and used the underscore ('_') as a placeholder
for ignored return values in calls.
[I liked the visual of having a "hole" in the variable list.]
I think dynamic-wind in Scheme is similar to UNWIND-PROTECT.
Fluency does matter.
If fluency in a language lets me do most of my daily tasks with at most occasional inconvenience, I'd call the language satisfactory. Stuff
like macros make inconvenient things convenient. They don't make the impossible possible. And if the language makes enough everyday things convenient, it's ok with me if some inconvenient ones are left over.
So I haven't felt lack of macros to be a serious shortcoming of non-Lisp languages. There are usually alternate mechanisms offered, like
function decorators in Python.
It is not, because you can ignore additional values (note Racket, at least, >>has got this spectacularly wrong).
Holdover from Scheme which requires catching all returned values.
However, Lisp has the failing that catching the 4th returned value
requires catching the first 3 even though you don't care about them.
However, Lisp has the failing that catching the 4th returned value
requires catching the first 3 even though you don't care about
them.
this was covered upthread where it was mentioned that you can ignore
the [first three] values, so the compiler [in theory] can not catch
them.
There would probably be some extremists who would say, well, if only
everyone saw and understood the blinding light of (Python|Ruby|Lisp)
then they would achieve true happiness.
It should be possible to write functions in an existing language which
map constructs expressing that new (or borrowed) idea into the
existing language. Those functions have a name: macros.
The Blub fallacy. Yes it applies to CL just like to anything else.
The fact is that LISP is almost never used is the real life. I know
stump, nyxt and guix are LISP programs,
tfb <tfb@work.it.out> writes:
There would probably be some extremists who would say, well, if only
everyone saw and understood the blinding light of (Python|Ruby|Lisp)
then they would achieve true happiness.
The Blub fallacy. Yes it applies to CL just like to anything else.
It should be possible to write functions in an existing language which
map constructs expressing that new (or borrowed) idea into the
existing language. Those functions have a name: macros.
Meh, if the old language can express the new idea at all, then the new
idea isn't that big of a change. Like try implementing Scheme
continuations as macros in CL.
There's a theoretical paper by Felleisen about what really adds
expressive power to programming languages. Sadly, I don't understand
it, but maybe someday.
https://www2.ccs.neu.edu/racket/pubs/scp91-felleisen.pdf
Meh, if the old language can express the new idea at all, then the new
idea isn't that big of a change. Like try implementing Scheme
continuations as macros in CL.
St|-phane CARPENTIER <sc@fiat-linux.fr> writes:
The fact is that LISP is almost never used is the real life. I know
stump, nyxt and guix are LISP programs,
I'd say LISP gave special abilities to programmers 50 years ago. More recently though, other approaches started giving similar abilities, so
the abilities aren't so special, and Lisp (CL anyway) became old
fashioned, though still useful and interesting to some of us. The
spelling "LISP" gave way to "Lisp" sometime around 1980 maybe.
To add a note of cheer, there's a famous quote from Edsger W. Dijkstra's Turing award lecture of 1972:
With a few very basic principles at its foundation, it [LISP] has
shown a remarkable stability. Besides that, LISP has been the
carrier for a considerable number of in a sense our most
sophisticated computer applications. LISP has jokingly been
described as "the most intelligent way to misuse a computer". I
think that description a great compliment because it transmits the
full flavour of liberation: it has assisted a number of our most
gifted fellow humans in thinking previously impossible thoughts.
Like try implementing Scheme continuations as macros in CL.Doug Hoyte does it in Let Over Lambda.
https://www2.ccs.neu.edu/racket/pubs/scp91-felleisen.pdfCare to share what you don't understand about the paper?
Paul Rubin <no.email@nospam.invalid> wrote:
And that's the point: languages which make this kind extension easy (which needs more than just functions between ASTs) remove barriers to the
Meh, if the old language can express the new idea at all, then the new
idea isn't that big of a change. Like try implementing Scheme
continuations as macros in CL.
creation of new languages. Those new languages might be anything from CL
(a much smaller Lisp with a bunch of fancy macros), CL with new binding or iteration or other constructs to entirely new languages like Coalton (statically-typed functional language) to whatever.
Anton Antimo <anton@safunu.org> writes:
Like try implementing Scheme continuations as macros in CL.Doug Hoyte does it in Let Over Lambda.
I don't see how that is possible, other than by using the Turing
completeness of CL macros to implement Scheme, more or less.
Continuations automatically give you stackful coroutines and that
requires runtime support that's not built into CL. I haven't read that
book though.
One way to implement continuations is to convert program to
"continuation passing style" and have garbage collection of the
stack. Continuation passing style means that you explicitely pass
next function to call to each function. And normally functions do
not return, simply tail-call to passed "continuation".
On Mon, 24 Aug 2026 12:02:33 -0000 (UTC), Waldek Hebisch wrote:
I consider continuations to be most distingushing feature of Scheme.
Continuations are cool! I was disappointed to discover theyrCOre not considered a normal part of Lisp.
I implemented my own little language which is closely modelled on
PostScript, but drops the antiquated graphics model and adds lexical
binding and continuations. It is true that the combination of an
explicit operand stack with continuations can get a bit mind-boggling
at times ...
<https://gitlab.com/ldo/gxscript>--- Synchronet 3.22a-Linux NewsLink 1.2
steve g <Sgonedes1977@gmail.com> wrote:
I don't follow.
Consider (with-current-readtable (...) <form>): what is the current
readtable when <form> is read?
Steve G <Sgonedes1977@GMail.com> wrote: |---------------------------------------------------------------------|
|"> Dear Mister Stephen G: |
|| |
I had bought many books. They have been robbed. I never got to read|
them :( |
|same here." | |---------------------------------------------------------------------|
Dear Mister Steve G:
I am sorry and I empathize :(
Anton Antimo <anton@safunu.org> writes:
Like try implementing Scheme continuations as macros in CL.Doug Hoyte does it in Let Over Lambda.
I don't see how that is possible, other than by using the Turing
completeness of CL macros to implement Scheme, more or less.
Continuations automatically give you stackful coroutines and that
requires runtime support that's not built into CL. I haven't read that
book though.
antispam@fricas.org (Waldek Hebisch) writes:
And normally functions do not return, simply tail-call to passed
"continuation".
Continuations are nontrivial precisely because of the non-tail-call
case, where the continuation is re-used. So you can use them to
implement coroutines, multitasking, etc. If they can't do that, they're
not "full" continuations. I don't see how to implement full
continuations using CL macros.
Nuno Silva <nunojsilva@invalid.invalid> wrote or quoted:
One I've seen used that's adequate is "Generative Autocomplete".
The first "L" in "LLM" is what distinguishes those LLM from
LMs which can be described as "glorified autocompleters".
LLMs have additional features like emergent efficient internal
representations of abstract concepts and their relations.
For one example, today's chatbots can follow meta-constraints
(like, "Summarize this article in 50 words"). A raw model
would just continue writing more text similar to the prompt.
LLMs have recently solved some math problems human mathematicians
were not able to solve for decades. There is no way you can subsume
such behavior under "autocomplete".
Paul Rubin <no.email@nospam.invalid> writes:
All CPython integers are boxed, but small ones (-5 through +250 or
something like that) are pre-allocated. Sounds awful but I think some
Lisps also have done that.
For example, PDP-10 MacLisp. The PDP-10 is a word addressed machine,
where addresses are 18 bits, and words are 36 bits. PDP-10 integers are
36 bits long, so pretty much your only choice for representing fixnums
is as an 18-bit pointer to a 36-bit signed integer, i.e. "boxed".
rCo If an intermediate fixnum needs to be allocated, say to pass as an
argument to another function, it can be allocated in a special area
of memory that has fixnum type, but that is managed as a stack -- the
GC doesn't touch it. That temporary number is then popped out of
existence after the function call returns. This does mean that the
compiler has to constantly worry that an object that it is about to
store someplace permanent might be a stack allocated "PDL number".
The utility that replaces a potential PDL number with a permanent
number is named "PDLNMK", and every serious MacLisp programmer knows
exactly what it does because it frequently appears in our compiled
code.
There's a paper by Guy Steele titled "Fast Arithmetic in MacLisp" that describes all these techniques in detail: <hdl.handle.net/1721.1/6279>.
Alan Bawden wrote:
There's a paper by Guy Steele titled "Fast Arithmetic in MacLisp"
that describes all these techniques in detail:
<hdl.handle.net/1721.1/6279>.
Thank you very much! IrCOd never read it. For the peanut gallery,
thatrCOs AIM-421.pdf
But, from my limited experience and from examples I've seen: don't they
still exhibit some of these "autocompletion" traits, just perhaps at a
higher level?
Alan Bawden <alan@csail.mit.edu> writes:
For example, PDP-10 MacLisp. The PDP-10 is a word addressed machine,
where addresses are 18 bits, and words are 36 bits. PDP-10 integers are
36 bits long, so pretty much your only choice for representing fixnums
is as an 18-bit pointer to a 36-bit signed integer, i.e. "boxed".
I had no idea! Never having used it, I had always assumed that MACLISP shared the behavior of things like SBCL, Smalltalk, and recent versions
of PythonrCerCorCetransparently overflowing from fixnums to bignums.
One advantage of the transparent-overflow approach is that most of the
time users donrCOt care what the actual fixnum limit isrCerCorCeitrCOs rCLjustrCY a
performance optimization, in that your arithmetic starts consing when
you exceed the limit.
Kragen Javier Sitaker <kragen@canonical.org> writes:
I had no idea! Never having used it, I had always assumed that MACLISP
shared the behavior of things like SBCL, Smalltalk, and recent versions
of PythonrCerCorCetransparently overflowing from fixnums to bignums.
Note that MacLisp _does_ have "transparent-overflow" arithmetic, you
just have to use `PLUS`, `TIMES` and `DIFFERENCE` instead of `+`, `*`
and `-`. The `+` family is fixnum-only, but the `PLUS` family handles
all types of numbers.
Dear steve g,
I admit I did not consider shortwave radio for language learning.
A
friend of mine suggested we'd group up and learn French together, and
we're currently planning to visit Alliance Francaise this week. I hope
that works out.
I mean, I'll be renewing my own knowledge, and she'll be learning from scratch. I'm sure both of us will have lots of fun.
I've added comp.edu.languages.natural to this discussion.
Paul Rubin <no.email@nospam.invalid> wrote:
antispam@fricas.org (Waldek Hebisch) writes:
And normally functions do not return, simply tail-call to passed
"continuation".
Continuations are nontrivial precisely because of the non-tail-call
case, where the continuation is re-used. So you can use them to
implement coroutines, multitasking, etc. If they can't do that, they're
not "full" continuations. I don't see how to implement full
continuations using CL macros.
Le me try again. Do you see how to implement continuations at say
assembler level?
If not, then I affraid that CL macros will not
help you. At assembly level each function has some machine code
and environment. In simple case environment reduces to stack frame,
it is created when function is invoked and destroyed when it exits.
Closures complicate this, function may access lexical variable of
containing functions and we must ensure that this access is possible
even after retrun from containing function. Continations add similar problem, we can only discard a stack frame if it is not reachable
via continations or closures. One possible way to do this is to have
garbage collector capable of garbage collecting stack frame.
But
there is another possiblity, namely to keep only return address on
the stack and keeping all other data in heap. In such case tail
call optimization will ensure bounded stack use, so no need to
garbage collect stack frames.
As I wrote, idea is to treat Lisp as a garbage collected assembly
language. With tail call optimization calls are translated to
goto-s, so collection of Lisp functions can implement arbitrary
control flow. If additinaly all local variables are collected
into a data structure allocated at function entry and if needed
passed as an extra argument, then your program at abstract level
will work as before, but data which previously was stored on the
stack is on the heap. After contination passing transformation
you may support continations.
How macros enter the picture: Lisp macro can perform arbitrary transformation, in particular can "compile" code into low
level form indicated above. In a sense this is Turing completeness,
but we avoid general argument going via interpretation and
instead use compilation. And this clearly depends on ability
to do non-local transformations. Simple AST substitution
would be too weak.
AFAICS main trouble with continuations is efficiency.
If you do not need efficiency, then implementing continuations is just
some extra work, but otherwise not a problem. Trouble is that
relatively easy tactic of allocating stack frames on the heap puts
serious load on garbage collector and on caches. If program is doing
small number of function calls, then impact may be negligible. But
people wanting continuations are likely to have a lot of function
calls in their programs and speed is likely to suffer. So basically,
you need to do some serious optimization work which would be
unnecessery in language that does not implement continuations.
Keith Thompson <Keith.S.Thompson+u@gmail.com> wrote:
They did, didn't they. Sorry: my rather primitive newsreader makes that
hard to see, but I should have noticed in any case. Sorry for wasting people's time (people who won't see this, but still, sorry).
(I do have to wonder though: in the pop-psychology world, what term would
be used for someone who adds a bunch of unrelated newsgroups in that way?)
antispam@fricas.org (Waldek Hebisch) writes:
And normally functions do not return, simply tail-call to passed
"continuation".
Continuations are nontrivial precisely because of the non-tail-call
case, where the continuation is re-used. So you can use them to
implement coroutines, multitasking, etc. If they can't do that, they're
not "full" continuations. I don't see how to implement full
continuations using CL macros.
There is some sentiment[1] in the Scheme world that mandating full continuations in Scheme was a mistake and that it would have been
preferable to stop with "delimited" or "one-shot" continuations. Those
are maybe closer to catch/throw than to coroutines. I don't know if
those can be done with CL macros but it seems more plausible.
[1] https://okmij.org/ftp/continuations/against-callcc.html
I believe that these call/cc continuations were created far before
threads. Being I don't use either; just wondering if they are similiar.
Paul Rubin <no.email@nospam.invalid> writes:
antispam@fricas.org (Waldek Hebisch) writes:
And normally functions do not return, simply tail-call to passed
"continuation".
Continuations are nontrivial precisely because of the non-tail-call
case, where the continuation is re-used. So you can use them to
implement coroutines, multitasking, etc. If they can't do that, they're
not "full" continuations. I don't see how to implement full
continuations using CL macros.
There is some sentiment[1] in the Scheme world that mandating full
continuations in Scheme was a mistake and that it would have been
preferable to stop with "delimited" or "one-shot" continuations. Those
are maybe closer to catch/throw than to coroutines. I don't know if
those can be done with CL macros but it seems more plausible.
[1] https://okmij.org/ftp/continuations/against-callcc.html
I believe that these call/cc continuations were created far before
threads. Being I don't use either; just wondering if they are similiar.
Paul Rubin <no.email@nospam.invalid> writes:
antispam@fricas.org (Waldek Hebisch) writes:
And normally functions do not return, simply tail-call to passed
"continuation".
Continuations are nontrivial precisely because of the non-tail-call
case, where the continuation is re-used. So you can use them to
implement coroutines, multitasking, etc. If they can't do that, they're
not "full" continuations. I don't see how to implement full
continuations using CL macros.
There is some sentiment[1] in the Scheme world that mandating full
continuations in Scheme was a mistake and that it would have been
preferable to stop with "delimited" or "one-shot" continuations. Those
are maybe closer to catch/throw than to coroutines. I don't know if
those can be done with CL macros but it seems more plausible.
[1] https://okmij.org/ftp/continuations/against-callcc.html
I believe that these call/cc continuations were created far before
threads. Being I don't use either; just wondering if they are similiar.
thanx
steve g <Sgonedes1977@gmail.com> writes:
I believe that these call/cc continuations were created far before
threads. Being I don't use either; just wondering if they are similiar.
There is some conceptual overlap between continuations and OS threads,
but the traditional implementations are totally different.
Continuations are more general and you can simulate almost every control >method with them, including loops, subroutines, threads, exceptions,
etc. Their behaviour can be complicated and paradoxical. The Okmij
post that I linked argues that Scheme would been better off with a
simpler primitive.
Continuations as we think of them today really were introduced with
Scheme in ~1975, however they are just a more modern approach to code "threading",
George Neuner <gneuner2@comcast.net> writes:
Continuations as we think of them today really were introduced with
Scheme in ~1975, however they are just a more modern approach to code
"threading",
A Scheme-style continuation in full generality has to save a copy of
the activation stack, and be able to restore it multiple times.
What Oleg (okmij.org) wanted instead was "one-shot" or "delimited" >continuations, maybe closer to ordinary stackful coroutines. They still
have to save and restore the stack, but only once. I've never tried to >understand either type very carefully though.
What Oleg (okmij.org) wanted instead was "one-shot" or "delimited" >>continuations, maybe closer to ordinary stackful coroutines. They still >>have to save and restore the stack, but only once. I've never tried to >>understand either type very carefully though.
I've never figured out what makes "delimited" continuations different
from general continuations except that the implementation constrains
where a "delimited" continuation may be invoked. But that seems to be
a difference in usage rather than in kind.
Full continuations are, conceptually, a copy of the whole stack,
wrapped as a kind of function that never returns. Delimited
continuations offer, conceptually, a copy of a chunk of the stack,
wrapped as a kind of function that does return.
On Sun, 20 Sep 2026 16:31:49 -0400, Stefan Monnier wrote:
Full continuations are, conceptually, a copy of the whole stack,
wrapped as a kind of function that never returns. Delimited
continuations offer, conceptually, a copy of a chunk of the stack,
wrapped as a kind of function that does return.
Why do you need to copy anything, beyond some very basic context info?
Call frames just form a tree and are allocated on the heap. So the
fact that a frame is referenced (directly or indirectly) from a
continuation is sufficient to keep it from being deleted.
Keith Thompson <Keith.S.Thompson+u@gmail.com> wrote:
The person you're talking to has deliberately added cross-posts to
comp.lang.misc and comp.lang.c. If you must reply to this troll,
please limit your replies to comp.lang.lisp.
They did, didn't they. Sorry: my rather primitive newsreader makes that
hard to see, but I should have noticed in any case. Sorry for wasting people's time (people who won't see this, but still, sorry).
(I do have to wonder though: in the pop-psychology world, what term would
be used for someone who adds a bunch of unrelated newsgroups in that way?)
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 53:53:23 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,448 |