morganw has quit [Remote host closed the connection]
akoana has quit [Quit: leaving]
dre has joined #commonlisp
<mathrick>
is it possible for something related to CFFI to get saved in a FASL in some way? I'm seeing crashes that don't seem very related to what my code is doing, and mysteriously, a lot of the time I can get it to run successfully once. And that's not "once per SBCL start", just once period. If I rerun SBCL with the same code again, it ends up in LDB immediately
<mathrick>
I'm not doing any image dumps
<mathrick>
but it very clearly works once, and then to get it to allow another "once only" cycle, I need to change my code in some meaningful way
<mathrick>
which makes me suspect that FASLs are involved somehow
<mathrick>
the same code seems happy under CCL
orestarod has quit [Ping timeout: 268 seconds]
wheelsucker has quit [Remote host closed the connection]
wheelsucker has joined #commonlisp
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
<hefner>
has anyone attempted to run Garnet in the past decade (or two)? I was always curious but never quite got around to it.
phantomics has joined #commonlisp
<Bike>
mathrick: stuff like the wrapper functions and all will go into the fasl... does forcing recompilation count as another "once only"?
<Nilby>
hefner: Yes. I even got ½ way through some slight modernizing it with asdf and packages and a little CLOS, but like most I lost interest, especially when considering regenerating the documentation. But I think the old version can still load and run.
<aeth>
mathrick: if there's some kind of weird corruption going, maybe you're accidentally mutating a literal somewhere
<aeth>
(the latest few versions of SBCL should detect this)
<beach>
mathrick: LET can't be defined in terms of LAMBDA, at least not in a straightforward way. (let ((&rest 234) (x 345)) x) is not the same as ((lambda (&rest x) x) 234 345)
<aeth>
oh, wow, that's evil
<Bike>
ugh, that. was a real nasty bug in cleavir for a little while
<aeth>
that's the kind of thing where an implementation starts with my one-liner, then someone like beach comes along with that evil example, and now the implementation has to remove the elegance to check for stuff like that
<aeth>
oh, wow, it's even harder than it looks because you can't put a LET in there if you gensym &rest
tyson2 has quit [Remote host closed the connection]
<drakonis>
an evil example, innit
<neominimum>
I can only find older threads and posts on the interwebs regarding custom specialisers and how the implementations don't really support creating them without copy pasting large swathes of object system code/modifying the object system implementation. Is that still the case today?
<beach>
neominimum: I believe Krystof has a paper about implementing specializers with arbitrary types.
<neominimum>
Warning scrolling the page creates a flashing effect due to the background texture
wheelsucker has quit [Remote host closed the connection]
wheelsucker has joined #commonlisp
masinter has joined #commonlisp
<Nilby>
beach: Are you joking? There's a picture of you presenting at it.
<neominimum>
Space in memory was re-appropriated for the CL spec. Some sacrifices had to be made.
* neominimum
salutes
<beach>
Oh, I remember it now.
<beach>
*blush*
<beach>
I think it ended when ELS was created.
<mathrick>
Bike: I'm not entirely sure how to force recompilation TBH
<mathrick>
aeth: I don't think mutating a literal has the power to drop me into LDB though
<mathrick>
I mean, yes, mutating literals is a really good way of getting weird behaviour, but in this case it's probably not that?
<mathrick>
I'll look over it with that in mind
<aeth>
mathrick: even if it's not, it could be something on a similar line of thinking, perhaps?
<aeth>
I almost didn't say it but it really does feel like that sort of thing
<beach>
mathrick: I haven't followed the discussion, but recent versions of SBCL allocate literals in read-only space I think.
<mathrick>
beach: the problem I'm hitting are a memory corruption because it's in CFFI code
<mathrick>
the issue being that I can literally only run that code once. Restarting SBCL doesn't help
<beach>
Ah, yes. That must be why I didn't follow the discussion.
<Nilby>
tempus fugit et loca confusa
<aeth>
mathrick: do you use a library like static-vectors perhaps?
<aeth>
some sort of double free maybe?
<mathrick>
aeth: it does, but that's why I'm thinking of something getting saved in a FASL that I don't want it to. It has all the hallmarks of "did you reload your libraries after dumping the image?"
<mathrick>
no static vectors in my code
<aeth>
or, yeah, a static-vector escaping scope
<mathrick>
I think some of my deps do use static vectors, but I don't believe they're anywhere on the path crashing
<mathrick>
there's a fairly shallow stack above where it goes off into the C land
<mathrick>
and I either wrote or touched most of it
<Nilby>
mathrick: You might want to check if C functions are being called at compile time.
<mathrick>
Nilby: I want to say "no", but that's precisely what that bug feels like, so I'll have to look for that
<Nilby>
Or some pointer is getting initialized at compile which is wrong at later runtimes.
gma has joined #commonlisp
<mathrick>
(as an aside, it's not *good* audio output code, and the C libs I'm using are not a *good* target to be wrapping, but the purpose of me doing it right now is to solidify a design in which weird C libs with odd threading requirements are possible, so I'm using these bad libs sort of on purpose)
<mathrick>
Nilby: yeah. CFFI has at least one known bug filed against it where the port to use libffi made it incompatible with dumping images if it's not dumped early enough, but I don't know if it'd also apply to FASLs, and I'm not hitting it on CCL
<mathrick>
which, if it were an issue with CFFI code, would most likely show up on both
Noisytoot has quit [Remote host closed the connection]
Noisytoot has joined #commonlisp
Noisytoot has quit [Excess Flood]
pve has joined #commonlisp
wheelsucker has quit [Remote host closed the connection]
wheelsucker has joined #commonlisp
Noisytoot has joined #commonlisp
* neominimum
wishes there existed an (and superclass1 superclass2 ... superclassN) specialiser so they could avoid defining many permutations of classes just to use as class specialisers
gma has quit [Ping timeout: 265 seconds]
_gma_ has quit [Ping timeout: 260 seconds]
epony has quit [Read error: Connection reset by peer]
<neominimum>
contrapunctus: I have a semi-flat class hierarchy w/ three or so orthogonal classes, and was trying to use them like mixin classes I think? I was using the dynamic-mixins library to construct objects with the intended superclasses but wanted to dispatch based on the presence of any number of superclasses.
<neominimum>
thanks Krystof I found that one too. I follow the high-level description but the specifics of how to use generalisers are a bit outside of my ability to understand and implement atm.
shka has joined #commonlisp
<pve>
Hi, is there a name for this thing were the intent is to do (f3 (f2 (f1 x))) but if any of the functions return nil, it "bails" early (thus skipping the remaining functions) and the whole thing becomes nil?
<neominimum>
I don't think there is a way to break out of a chain of synchronous function calls without changing the control flow some how.
<pve>
neominimum: I didn't mean to use that form literally, just that I want to compose a number of functions and have the early exit check between each call
<pve>
but was really wondering if this pattern has a name
<hayley>
Similar is "safe navigation".
<pve>
hayley: aha, thanks
Noisytoot_ is now known as Noisytoot
cosimone has quit [Remote host closed the connection]
<Nilby>
pve: a common arrow macro that does that is (some-> x f1 f2 f3) also known in haskell as the maybe monad
<neominimum>
Hmm don't know the name sorry. I guess one could do: (every #'(lambda (fn &optional (x 'some-value)) (funcall fn x)) (list #'f1 #'f2 #'f3))
Dynom_ has joined #commonlisp
Dynom_ is now known as Guest6588
genpaku has quit [Remote host closed the connection]
genpaku has joined #commonlisp
aartaka has quit [Ping timeout: 264 seconds]
<neominimum>
if you need the return value of the last call: (let ((x 6)) (and (setf x (f1 x)) (setf x (f2 x)) (setf x (f3 x))))
aartaka has joined #commonlisp
taiju has quit [Ping timeout: 244 seconds]
pjb has quit [Read error: Connection reset by peer]
<ski>
pve : "short-circuiting" ? there's also `and-let*', i think ?
random-nick has joined #commonlisp
<ski>
(and-let* ((y (f1 x)) (z (f2 y)) (w (f3 z))) ..w..)
<ski>
(if you don't want/need to name intermediates, then i guess something like that `some->' .. or maybe some more general kind of "reflective syntax" (cf. idiom brackets))
<ski>
.. seems to me that `every' one wouldn't propagage the intermediates to the next function
wheelsucker has quit [Read error: Connection reset by peer]
wheelsucker has joined #commonlisp
cosimone has joined #commonlisp
<ski>
(perhaps it should also be added that the "nil or something else" idiom isn't *exactly* corresponding to maybe/option (since the latter doesn't have the domain contagion .. non-failure is wrapped, so you can have a non-failure `nil' result), although it's the same, disregarding that)
<neominimum>
ski: true, I didn't catch that. Also every doesn't return the result of the last call
orestarod has joined #commonlisp
<ski>
ah, didn't know that, ty. .. i wonder if there were any particular rationale
Helmholtz1 has joined #commonlisp
<neominimum>
Hyperspec says it's supposed to be used to apply a predicate to each element of a sequence. So someone using it may only want to see if the whole sequence passes the test.
causal has joined #commonlisp
pjb has joined #commonlisp
<ski>
yea. if we think of `(every fn (list a b c d))' as achieving the same as `(and (funcall fn a) (funcall fn b) (funcall fn c) (funcall fn d))', then that would suggest returning the value of the call on the last element. but if we're only thinking of "check if every element satisfies predicate", then it's not obvious we'd expect that. also noting SRFI-1 `every' in Scheme returns the value from the call on
<ski>
the last element (and that call being a tail call)
pjb has quit [Ping timeout: 264 seconds]
<Helmholtz1>
Is there a CL web framework that supports Open API (Swagger)? I found one but it's experimental
<Helmholtz1>
Do people actually use CL for webdev or what?
<Josh_2>
Ofc
aartaka has quit [Ping timeout: 265 seconds]
aartaka has joined #commonlisp
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
karlosz has quit [Remote host closed the connection]
<hayley>
Does the web not exist without OpenAPI?
karlosz has joined #commonlisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #commonlisp
<hayley>
I'm confused. I just used DuckDuckGo to look up OpenAPI, and as far as I can tell, no protocol specifications were transferred.
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
Helmholtz1 has joined #commonlisp
Helmholtz2 has quit [Ping timeout: 244 seconds]
Helmholtz2 has joined #commonlisp
Helmholtz1 has quit [Ping timeout: 244 seconds]
Helmholtz2 has quit [Ping timeout: 244 seconds]
tyson2 has joined #commonlisp
selfish has quit [Ping timeout: 252 seconds]
leo_song has quit [Ping timeout: 244 seconds]
_cymew_ has joined #commonlisp
leo_song has joined #commonlisp
azimut has joined #commonlisp
<mathrick>
Nilby: OK, so it seems that my SBCL doesn't even have FSBV, so that's not the culprit
<Bike>
mathrick: (compile-file filename)
<Bike>
to force compilation
<mathrick>
Bike: oh, I don't know what file that would need to be, and since I'm loading it all through ASDF, it would be difficult even to inject it
<Bike>
(asdf:compile-system whatever :force t) or :force :all
<mathrick>
I did try with (asdf:disable-output-translations), but even then it seems that it only recompiled everything once, and on subsequent runs it doesn't really do much
<mathrick>
Bike: same results, it all seems to make a difference *once*, then it's back to immediate LDB
<mathrick>
it often still lands me in LDB even on the first run, but that happens after my code has run
<mathrick>
on subsequent runs, it gets to LDB almost immediately after it starts running my test code, much earlier than on the first run
<Bike>
sounds pretty mysterious. i dont think i can really guess much without seeing the code
<mathrick>
Bike: do you have a github account? The repo is currently private, but I could give you access and commit the test code I'm using
_cymew_ has quit [Ping timeout: 265 seconds]
<dbotton>
_death the reason for you nginx issue was the choice of /clog for your url as that is clog uses that directory name to identifying the incoming websocket connectionl I'll add code to and document it for future. slipped mind when mentioned issue Friday
<_death>
not exactly.. if I used say /foo then clog would still try to use /clog, and that wouldn't then be passed to the clog process by nginx.. one solution would be to let the user specify the prefix
thuna` has quit [Ping timeout: 260 seconds]
<_death>
if clog had used a relative path that could work
<Bike>
mathrick: that's getting a little too elaborate for casual help, sorry
<NotThatRPG_away>
hefner: I was trying to update Garnet a while ago, but it was too big a job to do on spare time. I am really fond of it, though. Still think it's one of the best ways to design a UI that's available. I had a colleague once "re-skin" it for me, because the default look is SUPER ugly. High contrast, black and white, all square corners. Giving it a better look is critical for seeing how great it can be
<NotThatRPG_away>
hayley: I tried to use CL-SWAGGER and it's a total mess. Ended up using open-api-generator to make a Python server and invoking CL with cl4py ...
NotThatRPG_away is now known as NotThatRPG
<mathrick>
Bike: fair
<NotThatRPG>
hefner: If you are interested, check in with me later: have to go do some errands.
NotThatRPG is now known as NotThatRPG_away
tevo has joined #commonlisp
morganw has joined #commonlisp
pjb has joined #commonlisp
let-over-lambda has quit [Ping timeout: 265 seconds]
let-over-lambda has joined #commonlisp
masinter has joined #commonlisp
<masinter>
what do I call to find out of a symbol is external in its package?
<Bike>
(find-symbol symbol-name package)'s second value
<masinter>
(so if I have symbol and symbol-package and i just need the 1 bit I need to find-symbol search?
<Bike>
it's more than one bit, but yes, i think that's the best way to do it
<Bike>
the symbol being external or internal or inherited or whatever is more a property of the package than of the symbol itself, since the same symbol can have different statuses in different packages
<masinter>
I suppose I could see if the symbols wa eq to any value do-external-symbols
<Bike>
masinter: right, but iterating is probably not as efficient as find-symbol, which is probably just a hash lookup or two.
jmdaemon has joined #commonlisp
shka has quit [Quit: Konversation terminated!]
cosimone` has quit [Ping timeout: 265 seconds]
<Josh_2>
Does anyone know what stream log4cl uses?
<Josh_2>
hmm perhaps it is *terminal-io*
nij- has joined #commonlisp
shka has joined #commonlisp
<nij->
any de facto way to do posix memory share ipc in common lisp?
nij- has quit [Read error: Connection reset by peer]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
<mathrick>
Josh_2: wouldn't that be configurable in whatever handlers you set it up with?
<Josh_2>
It doesn't matter now
<Josh_2>
I added an :after and :before method around layout-to-stream
<jeosol>
In the abbreviation of different CL implementations, is SCL an abbreviation for Scieneer CL?
<jcowan>
Not usually, I think, though there is no obvious reason why it should not be.
tyson2 has quit [Remote host closed the connection]
McParen has joined #commonlisp
Everything has joined #commonlisp
<Bike>
i don't have any reason to talk about scieneer, but i have seen it referred to as SCL
_cymew_ has joined #commonlisp
tyson2 has joined #commonlisp
ttree has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ is now known as Lord_of_Life
xlarsx has joined #commonlisp
chipxxx has joined #commonlisp
<McParen>
Hello, normally I can refer from package a to symbols in package b like b:bar, and to a:foo from b. But it doesnt seem to be possible to do that when I want to use local nicknames. You basically can not have a local nickname in A to package B if B is defined after A.
<McParen>
this seems weird, because you cant do with local nicknames what you can do with full package names.
<Bike>
you can't put it in the defpackage form, but you can add local nicknames after the fact
<Bike>
add-package-local-nickname
<McParen>
okay, that seems to be the solution to my problem, but that means that the defpackage interface is kind of useless. i've never used that till today, and in my absolutely firt use i immediately reach its limits.
<McParen>
I cant imagine how they agreed upon that interface if you cant use it in its most basic use case.
wheelsucker has quit [Remote host closed the connection]
wheelsucker has joined #commonlisp
<Bike>
people usually only use it one way. like nicknaming alexandria as a or something.
<McParen>
I thought that one package one file was a thing.
<yitzi>
defpackage is useless? How so?
waleee has joined #commonlisp
<McParen>
the "new" local nicknames interface in defpackage is useless if you cant actually use it in a very basic case.
<McParen>
i cant nickname foo to A in b and bar to B in A, because b is defined after a.
<yitzi>
Either that or local nicknames are overrated....imho.
<Bike>
the obvious (to me, anyway) would be to make local nicknames resolve to a package _name_ instead of a package itself, but that would be more complicated in a couple ways
<yitzi>
Aside from that, I wish I understood why people care about it...but that is just my opinion.
<McParen>
I've come to like not :use-ing packages, but refering to symbols with package prefixes, and for that, they need to be short.
<McParen>
foo:a is more readable that foo-bar-my-baz:a.
cercopith_ has joined #commonlisp
cercopith_ has quit [Remote host closed the connection]
cercopith_ has joined #commonlisp
<yitzi>
Well, that's good. Unless there is a good reason only :CL should used.
nij- has joined #commonlisp
<yitzi>
But, I don't see why you care about the length of the package names. I mean, there are some ridiculously long package names out there, but most are pretty reasonable. What is too long for you? ... Just curious.
attila_lendvai has quit [Ping timeout: 265 seconds]
<Bike>
a problem with USEing packages is that as soon as one of them adds or removes external symbols it can cause surprising and possibly silent conflicts. using package local nicknames lets you avoid that.
<McParen>
the reason i can tell is that once people :use a package, you cant add more symbols to the package and then you have to make up something like alexandria+.
tyson2 has quit [Remote host closed the connection]
<masinter>
I thought packages might be like XML namespaces (or the other way around), but use a URL a the "true name" of the package, with local short prefixes
<McParen>
yitzi: I dont know, a package name should not be longer that the symbol, i guess, that seems to be a matter of aesthetics. I seems "wrong" to deal with foo-bar-baz:a.
<masinter>
cl-user::a is bad enough
aartaka has quit [Ping timeout: 265 seconds]
<McParen>
in python they shorten even shorten short names like numpy in code, you regularly see np.this np.that.
<yitzi>
McParen: That isn't bad logic, but you are right it is aesthetics. My argument against LPN's is that aliasing a = alexandria makes the code a lot less readable.
xlarsx has quit [Remote host closed the connection]
<McParen>
yitzi, this is right, but when you have 5 times the name alexandria in a 10-lines function, that creates a kind of annoying noise.
<McParen>
I do not want some name, that does absolutely add no functionality, to be repeated over and over and over a function.
<contrapunctus>
Some facts which may influence everyone's choice -
<contrapunctus>
1. `:import-from` can import even internal symbols
<contrapunctus>
2. Using PLNs means freedom from switching to the `defpackage` and fiddling with the `:import-from` each time you need a new symbol and each time you're no longer using a symbol.
<McParen>
Even outside programming languages, you do not want to repeat long, multi-syllable names like Joseph, Gabriel, etc, so people make up Gabe, Joe, etc, to avoid going mad.
<contrapunctus>
McParen: one-package-per-file makes life harder for you for no reason.
<McParen>
contrapunctus: I know, I do not do that.
aartaka has joined #commonlisp
<contrapunctus>
Ah, I see.
<McParen>
I mentioned that earlier because I thought this was a thing, and that thing is not compatible with local nicknames if you refer from A to B and from B to A.
<Bike>
i think one-package-per-file predates PLNs
<contrapunctus>
Recursive dependencies between packages might be a sign of code requiring restructuring...I've managed to avoid them in my CL projects so far, but perhaps that's due to inexperience 😀
<contrapunctus>
* Mutual dependence, actually
<Bike>
i have also wanted mutual PLNs in the past, which is why i've thought about this stuff. it's not that weird, it just means you have subsystems using each other's APIs
_cymew_ has quit [Ping timeout: 260 seconds]
tyson2 has joined #commonlisp
igemnace has quit [Remote host closed the connection]
<McParen>
contrapunctus, that might be correct, but what irks me is that this is not a problem with packages, but just with local nicknames. I dont know about the internals, but it seems weird that people who worked on this api for years let such a "obvious" flaw sli through.
<McParen>
maybe it was not possible any other way, i dont know. but as I said, today was actually the first time i used PLNs, and i immediately stumbled upon the bug.
<contrapunctus>
I wonder if it can be fixed across all implementations.
<McParen>
like in: "ok, lets try using local nicknames for a change. *googles sbcl manual* *copy pasta* oh, it doesnt work."
<pjb>
On the other hand, a function foo remains a function foo, whatever the package she's implemented in.
<pjb>
alexandria:foo or com.informatimago.common-lisp.cesarum.foos:foo should do the same thing. So using the package and calling (foo …) should be a no-brainer.
<pjb>
Granted, it happens sometimes, that the API, or the bugs differ.
<pjb>
You can always M-. to check.
aartaka has quit [Ping timeout: 244 seconds]
Guest6588 has quit [Quit: WeeChat 3.6]
nij- has quit [Ping timeout: 260 seconds]
cosimone has joined #commonlisp
cercopith_ has quit [Quit: Leaving]
cercopith has joined #commonlisp
<jeosol>
jcowan Bike: Thanks for your response regarding the Scieneer CL abbreviation. I don't recall seeing any SCL lisp but thought Scieneer CL is abbreviated that way.
makomo has quit [Ping timeout: 252 seconds]
waleee has quit [Ping timeout: 268 seconds]
McParen has left #commonlisp [#commonlisp]
nij- has joined #commonlisp
makomo has joined #commonlisp
ttree has quit [Ping timeout: 268 seconds]
Everything has quit [Quit: leaving]
morganw has quit [Remote host closed the connection]
waleee has joined #commonlisp
pve has quit [Quit: leaving]
akoana has joined #commonlisp
shka has quit [Ping timeout: 244 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
nij- has quit [Ping timeout: 260 seconds]
SAL9000 has quit [Ping timeout: 244 seconds]
dre has joined #commonlisp
brandflake11 has joined #commonlisp
makomo has quit [Ping timeout: 265 seconds]
makomo has joined #commonlisp
<brandflake11>
Hello, does anyone know of a way, or a package, to get a file's last modified date in common lisp?
<brandflake11>
Right now, my program is using inferior shell with date -r, but I figured there may be a faster solution