<pl>
aeth: also don't run the migration for so long the languages diverge more and more
<aeth>
took me a second to parse that because I thought you were talking about a (SQL-using relational) database migration
<aeth>
Fortunately, Common Lisp could avoid most issues with renaming by simply versioning the COMMON-LISP (nickname CL) package (as long as it doesn't touch the reader or a few other things). Although I guess library interop with other libraries could suffer.
<aeth>
The only problem is that that becomes a user-effort rather than a core-language-effort and users tend to... make radical changes just to make radical changes. Thus, not really getting anyone to use it.
<kakuhen>
eh... coming from a mathematics background, I don't generalized booleans to be all that confusing in Common Lisp. The only object of type NULL is NIL, and NIL can represent an empty list too, so it's pretty intuitive to me that *type* NIL is "empty" and hence a subtype of everything else.
<kakuhen>
I think the confusion here is that NIL can possibly refer to a type or a constant
<masinter>
use URLs for package full-names on a per-file basis, and at least you'll hve more resilience
<aeth>
kakuhen: NIL is either false or an empty list (or both, I guess) depending on the context. NIL the type is the type of nothing. NULL the type is the type of NIL, which isn't a null in things like JSON, SQL, etc., that you might interact with (unless you choose to represent it as null instead of as false when converting it, which is probably a mistake).
<aeth>
masinter: the only reason I don't do that is because nobody puts hyphens in domain names but everybody puts hyphens in project names... So if I did that everywhere, it would double my domain costs.
<aeth>
"com.example" will actually show up as just "example" afaik, but it gets ugly when you use two words without a hyphen in the domain.
<masinter>
change / to - on the way
<masinter>
;json-ld uses URLs
<kakuhen>
aeth: sure, that's exactly my point: the confusion seems to come from nil representing both the (generalized) boolean false and the empty list. But otherwise, the design is not very counterintuitive to me
<aeth>
masinter: well, no, because now the owner of example-regular-expression.com (which might actually be a site, don't go there, I'm making it up, poorly) will be mad at you if you express example.com/regular-expression as com.example-regular-expression
<aeth>
masinter: the point is to be unambiguous after all and now you just introduced ambiguity again
<kakuhen>
as for interchange of data between Common Lisp and languages that distinguish a false value and a null value, I agree it's annoying deciding how to designate this kind of data
<aeth>
which is probably best done with a :null or a your-package:null
<masinter>
ambiguity is endemic to data conversion
<aeth>
(for null)
<aeth>
empty list vs false is a bit trickier, though
<aeth>
you can't represent [1, 2, 3] as merely (1 2 3) if you map false to nil
<masinter>
it's a beauty mark, not a blemish (From David Moon)
<aeth>
it gets even trickier if you want to represent {"foo" : 42} as (:foo 42) because now you have nil that could be {}, [], false, or null (but please don't let it be null)
<masinter>
well, data interchange is only one part of software
<masinter>
so having NIL = () is really convenient
<masinter>
(OR A B C) => the first non-NIL ofAA B C
<masinter>
and all variables initialized to NIL
<masinter>
Scheme made the other choice
<masinter>
JavaScript took it further
<masinter>
if you have two systems with people's names
<masinter>
and one has first and last name, and the other has family and given name, you have to work hard to disambiguate
<masinter>
so you're already doing a lot of work to convert from one schema to the other
<masinter>
nil = false is just a small [piece
tyson2 has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
thuna` has quit [Remote host closed the connection]
pmwals096 has joined #commonlisp
jmes has quit [Remote host closed the connection]
random-nick has quit [Ping timeout: 256 seconds]
tmpee has joined #commonlisp
X-Scale has quit [Ping timeout: 268 seconds]
karlosz has joined #commonlisp
karlosz has quit [Quit: karlosz]
tyson2 has joined #commonlisp
dilated_dinosaur has quit [Ping timeout: 256 seconds]
gxt has quit [Ping timeout: 268 seconds]
dilated_dinosaur has joined #commonlisp
gxt has joined #commonlisp
<jcowan>
Guile has (), #f, and #nil so that it can handle both the Elisp/CL system and the Scheme system. Specifically, #nil and #f are both false, and #nil and () are both empty lists.
<jcowan>
So you shouldn't make inquiries like (eq x nil), instead you should use (not x) or (null x).
<aeth>
asarch: "the integrity of the image" is either a CFFI or (safety 0) or similar bug, probably out of bounds, maybe something like use-after-free... perhaps even a dynamic-extent that escaped the scope. Something dangerous happened, poorly.
<aeth>
asarch: but it doesn't mean build, just M-x slime-restart-inferior-lisp or similar
<asarch>
It was from CLI actually: sbcl --load myproject.lisp
<aeth>
It's basically something that would have resulted in "Segmentation fault" if C or C++, but instead the image continues running, but probably shouldn't because it's probably still broken.
<aeth>
Just restarting it should work, except, of course, the same bug's in there somewhere.
<asarch>
That's great
<asarch>
I thought it was something critical
<aeth>
It is critical... for the running image.
<aeth>
And if you're one of those people who has an emacs server with SLIME running 24/7 then it's probably really annoying.
<aeth>
Since one Lisp process could run multiple programs, perhaps even the entire DE (see e.g. stumpwm) and needs restarting
<aeth>
But if you're running it from the shell, no big deal. Just find the bug with CFFI, (safety 0), dynamic-extent, or similar
<aeth>
(Really, you shouldn't use (safety 0) at all except perhaps inside a LOCALLY to very, very clearly limit the possible damage)
<asarch>
Emacs is actually sleeping right now
Lord_of_Life has quit [Ping timeout: 256 seconds]
<asarch>
I thought it was IRONCLAD: "[2022-08-18 09:01:08 [WARNING]] Warning while processing connection: redefining IRONCLAD:WITH-DECRYPTING-STREAM in DEFMACRO"
<hayley>
It would be handy to get a backtrace for those errors.
Brucio-61 has joined #commonlisp
shka has quit [Quit: Konversation terminated!]
azimut has joined #commonlisp
shka has joined #commonlisp
<aeth>
lots of little bugs like that if you pay attention
<aeth>
libraries will also e.g. inline at the wrong place so they don't actually get inlined etc etc
Furor has quit [Remote host closed the connection]
waleee has quit [Ping timeout: 255 seconds]
Furor has joined #commonlisp
Furor is now known as Colere
ec has quit [Quit: ec]
comatory has quit [Ping timeout: 256 seconds]
<asarch>
I got another different address: Memory fault at (nil) (pc=0x54033624 [code 0x54033330+0x2F4 ID 0xd00b], fp=0x7f06c795daf0, sp=0x7f06c795dac0) tid 16400
<asarch>
CORRUPTION WARNING in SBCL pid 13397 tid 16400:
<jackdaniel>
asarch: grep your projects / dependencies for (safety 0) and learn who is the bad guy
<jackdaniel>
naive person (like me) would wonder whether the "bin" directory is the directory that contains the source code with dependencies (because it stands for 'binary')
<asarch>
I put the source code of the project in that dir :-P
<jackdaniel>
along with all dependencies?
<asarch>
Those from quicklisp are in ~/quicklisp
<asarch>
The project dir from (caveman2:make-project #P"/path/to/myapp/" :author "<Your full name>")
<asarch>
That's the only one in ~/bin
vassenn has joined #commonlisp
thomaslewis has joined #commonlisp
<asarch>
Anyway. Let's do the downgrade :-)
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
nij- has joined #commonlisp
knusbaum has joined #commonlisp
vassenn has quit [Remote host closed the connection]
<mfiano>
No tacos today?
<jackdaniel>
?
<mfiano>
asarch always uses tacos in his code snippets :)
<jackdaniel>
I'm not that much of a connoisseur of their code to know ,)
<mfiano>
Topologically they are like parens anyway.
<mfiano>
I can tell I need sleep. I'm being goofy
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
<asarch>
No, not tacos today (maybe later if the downgrade is successful) :-P
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<asarch>
Yeah! It worked! :-)
<nij->
Suppose I have multiple lisp images working across multiple machines. I want them to cooperate. Sometimes, some big data (50M~50G) must be sent from one to another. What kind method or package would you recommend for that?
<mfiano>
cl-mw
<mfiano>
A friend of mine wrote that at their old job in a cluster of over 10k machines. I'm sure it will scale to "multiple"
ec has joined #commonlisp
<Demosthenex>
mfiano: that's neat
<nij->
10k machines!!
irc_user has joined #commonlisp
<nij->
mfiano what did your friend do that with.. 10k machines..
comatory has joined #commonlisp
<mfiano>
Distributed computing research of course
<nij->
I'm digging which protocol of communication it uses. Do you happen to know?
<Demosthenex>
wonder if (zero|rabbit)mq can help there
<Fade>
standard message queues are good for signalling, not so much for mass data transfer.
<Fade>
I guess you could write an encoder/decoder to do it, but it wouldn't be fast.
<aeth>
that gets it to ((a 1) (a 2) (a 3) (b 1) (b 2) (b 3) (c 1) (c 2) (c 3))
<gendl>
yep that's what i need
<aeth>
ofc it's probably not going to be as fast as something like LOOP... but if you want a fast answer rather than fast code, that should work
<gendl>
yep my data is not big
<aeth>
if you build lists with LOOP's collect, you can replace that with LOOP's append (which is the same word as #'append so it's not hard to remember) if you need it flat
<aeth>
but that requires thinking about things differently.
<gendl>
oh i was trying mapcan but i used it inner instead of outer
<gendl>
i actually have 3 levels not two
<gendl>
i think it should work with mapcan for the outer two and mapcar for the inner
ec has joined #commonlisp
<gendl>
lemme try...
<aeth>
But as far as concise goes, you have to use LOOP, a MAP-family function, or just APPEND it down. There may be other ways and they might even be faster, but they're longer.
<aeth>
(The other ways afaik would all involve thinking in conses, with cars/cdrs, etc.)
<gendl>
`(mapcan #'(lambda(color) (mapcan #'(lambda(item) (mapcar #'(lambda(other) (list item other color)) '(1 2 3))) '(a b c))) '(red blue green))`
<gendl>
👆 that form solves my exact problem
ttree has joined #commonlisp
<Bike>
you shouldn't use mapcan on quoted data
<gendl>
oh right
<aeth>
oh, if you do use #'append in places, you probably should use reduce, not apply, because reduce does things on arbitrary pairs, while apply applies it as a function and thus is subject to the function call length on the implementation (which might be short, even if it's not short on the ones you test it on)
<gendl>
but the inner mapcar is generating a new list isn't it?
<gendl>
anyway i'll use `(list ...)` for my real data instead of quoted lists
<Bike>
oh you might be right
<Bike>
sorry then
<gendl>
aeth: thanks, I think I do over-use `apply` and under-use `reduce` -- i need to keep that in mind.
<aeth>
afaik, apply is normally for things of known length, or for writing compilers/interpreters
<aeth>
while reduce is more for arbtirary-length pairwise operations
<aeth>
*arbitrary
<jcowan>
Good to have fold(l/t) around too
ec has quit [Remote host closed the connection]
ec has joined #commonlisp
nij- has joined #commonlisp
<nij->
Is there anyway to do "condition forwarding"? I want a client runtime (maybe in another lang) to have full control of a thread in my Lisp Image. The thread should be non-blocking, meaning when there's a condition in a thread, it gets "forwarded" to the client. The client decides what to do next; in the meanwhile, the main thread shouldn't get blocked.
<Bike>
what would doing next entail, if the main thread is already off doing some other thing?
<Bike>
conditions are just objects, and you can toss them around and invoke the debugger in whichever thread you like. but without the dynamic context of where the condition was actually signaled, the obvious ways to debug are out
comatory_ has joined #commonlisp
comatory has quit [Ping timeout: 252 seconds]
<Bike>
this isn't to say that you can't arrange something. like you could set up a mailbox so that the out of line debugger can send some action to complete to the main thread. but it's not gonna be like, trivial
<nij->
The thread controlled by the client should obey the main thread.
<Bike>
that is not enough detail
<nij->
What is missing, for example?
<Bike>
like, example: say the main thread does a cerror, a continutable error. if the debugger is in the same process, the user could choose to move on by invoking the continue restart, or they could do something else like substitute a value
<Bike>
but with what you're talking about, if i understand correctly, the main thread will just continue on to something else and present the condition to some other thread/process
<Bike>
and from that thread/process, the usual debugging options of "continue" or "substitute a value" or whatever are nonsensical, because the main thread has already moved on to greener pastures
<Bike>
like, what exactly the other thread/process is controlling is not clear
<nij->
I think of that other thread as a process in an OS. It must listen to the OS, but most of the time we as clients/users do not have to care too much about the OS.
<Bike>
I understand that and it is not what I'm talking about
<Bike>
Just, what exactly do you want that other thread to be able to do, if presented with an error condition?
<nij->
If that an error condition rised in that thread, you mean?
<Bike>
I mean if the main thread hits a condition, and sends off that condition to the controlling thread, and the main thread continues on to something else, what should the controlling thread be able to order in response to that condition
<Bike>
Like I said, when you say "the client decides what to do next", what is "do next"
<nij->
Then the controlling thread asks the client what to do, immediately after it is freezed until the answer from the client is received.
<Bike>
but what is the thing to do.
<Bike>
What actions are available. Because the normal debugging actions are not
<yitzi>
I'm not clear on which thread the condition was generated in. Is it generated in the main thread or in this "client" thread?
<White_Flame>
also what is the client thread doing, just monitoring the main thread or does it have its own other work to do?
<nij->
White_Flame it has its own other work to do.
<nij->
yitzi In Bike's scenario, the main thread generates the condition.
thomaslewis has joined #commonlisp
<nij->
Bike: the available things are exactly those that could be done in a local repl.
<yitzi>
nij-: then in order for the restarts in the main thread to still be applicable it will need to block
livoreno has quit [Ping timeout: 255 seconds]
<yitzi>
Also, not that most languages don't even have the concept of a "restart" hence this concept is completely missing from debugging protocols such as the Debugger Adapter Protocol.
<yitzi>
s/not/note/
thomaslewis has left #commonlisp [#commonlisp]
<Bike>
nij-: what i'm trying to tell you is that some of those things do not make sense of a local repl, because the context of the condition will be gone. you cannot substitute a value and continue the computation if the computation has exited.
<Bike>
ugh
<Bike>
do not make sense OUTSIDE of a local repl
<Bike>
sorry
<yitzi>
You can hack it in with the stop and continue message in that protocol, but it would a non-standard extension.
<nij->
lemme think a bit..
waleee has quit [Ping timeout: 268 seconds]
tyson2 has joined #commonlisp
comatory_ has quit [Ping timeout: 256 seconds]
comatory_ has joined #commonlisp
rainthree has joined #commonlisp
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
rainthree has quit [Read error: Connection reset by peer]
<nij->
BikeI see what you mean now
tyson2 has quit [Remote host closed the connection]
thomaslewis has joined #commonlisp
livoreno has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
Guest4076 has quit [Quit: WeeChat 3.6]
<jcowan>
What does the term "match" mean in the case, ecase, and ccase macros? It is not defined there or in the glossary.
<Bike>
eql, under the general rule that that's what phrases like "on the basis of its identity" means
<Bike>
mean
<Bike>
so (case x ((f g h) ...) ...) is like (cond ((member x '(f g h)) ...) ...)
_whitelogger has joined #commonlisp
comatory_ has quit [Ping timeout: 268 seconds]
thomaslewis has joined #commonlisp
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
comatory_ has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
MajorBiscuit has joined #commonlisp
thomaslewis has joined #commonlisp
<_death>
especially since "identical" means "eq" (while "same" means "eql"...)
thomaslewis has left #commonlisp [#commonlisp]
<jcowan>
Dpne
<jcowan>
Done, even
pve has quit [Quit: leaving]
dra_ has joined #commonlisp
cage has quit [Remote host closed the connection]
ec has quit [Remote host closed the connection]
ec has joined #commonlisp
MajorBiscuit has quit [Quit: WeeChat 3.5]
scymtym has joined #commonlisp
livoreno has quit [Read error: Connection reset by peer]
livoreno has joined #commonlisp
livoreno has quit [Read error: Connection reset by peer]
<edgar-rft>
jcowan: I think the "match" is defined a few lines above: "If the test-key is the same as any key for that clause, ..."
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<jcowan>
It's still vague: I've filed a WSCL issue to change "matches" to "is the same as"
Lord_of_Life has joined #commonlisp
Lord_of_Life has quit [Read error: Connection reset by peer]
livoreno has joined #commonlisp
[deleted] has joined #commonlisp
Lord_of_Life has joined #commonlisp
Lord_of_Life has quit [Read error: Connection reset by peer]
livoreno has quit [Ping timeout: 248 seconds]
<Bike>
er, have you? i don't see it
ec has quit [Remote host closed the connection]
[deleted] has quit [Ping timeout: 256 seconds]
ec has joined #commonlisp
Lord_of_Life has joined #commonlisp
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #commonlisp
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #commonlisp
morganw has quit [Remote host closed the connection]