cosimone has quit [Remote host closed the connection]
s-liao has joined #commonlisp
morganw has quit [Remote host closed the connection]
thomaslewis has joined #commonlisp
dre has joined #commonlisp
jstoddard has left #commonlisp [ERC (IRC client for Emacs 27.2)]
asarch has quit [Quit: leaving]
asarch has joined #commonlisp
VincentVega has quit [Quit: ERC (IRC client for Emacs 27.2)]
s-liao has quit [Ping timeout: 256 seconds]
s-liao has joined #commonlisp
<asarch>
Learnig is fun
s-liao has quit [Quit: Ping timeout (120 seconds)]
s-liao has joined #commonlisp
igemnace has joined #commonlisp
cosimone has joined #commonlisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
Algernon91 has joined #commonlisp
Common-Lisp has joined #commonlisp
<Common-Lisp>
I didn't realize they turned me into a channel!
<Catie>
I can't believe they distilled an entire person out of the contents of this channel
<Common-Lisp>
Modern technology really is amazing.
<asarch>
Have you seen Alexa?
* moon-child
wants symbolic ai
s-liao has quit [Ping timeout: 256 seconds]
s-liao has joined #commonlisp
Algernon91 has quit [Ping timeout: 240 seconds]
ebrasca has quit [Remote host closed the connection]
random-nick has quit [Ping timeout: 256 seconds]
s-liao1 has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
Catie has quit [Remote host closed the connection]
dec0d3r has joined #commonlisp
Catie has joined #commonlisp
lisp123 has joined #commonlisp
waleee has quit [Ping timeout: 240 seconds]
lisp123 has quit [Ping timeout: 240 seconds]
waleee has joined #commonlisp
Common-Lisp has quit [Quit: bye.]
miique has quit [Ping timeout: 256 seconds]
thomaslewis has left #commonlisp [#commonlisp]
ec has joined #commonlisp
<White_Flame>
moon-child: there's plenty of it out there
<moon-child>
not really
<moon-child>
all the funding is for ml
<White_Flame>
all the old stuff still works
<White_Flame>
and is out there
pieguy128 has quit [Ping timeout: 240 seconds]
thomp has joined #commonlisp
pieguy128 has joined #commonlisp
<Catie>
This is a pretty open-ended question, but sometimes I can load systems using Quicklisp, but I get COMPILE-FILE-ERRORs if I try loading them with ASDF:LOAD-SYSTEM or REQUIRE. Is this a known issue, and if so what causes it?
pieguy128 has quit [Ping timeout: 240 seconds]
<White_Flame>
dependencies?
<White_Flame>
(although I'm not sure they'd be compile-file-errors specifically)
<etimmons>
That does seem odd. Do you have an example?
pieguy128 has joined #commonlisp
<Catie>
For me the most common one is CLX. If I don't have the FASLs cached, I can't REQUIRE it, but I can QL:QUICKLOAD it. Let me clear my cache to get the exact error
tyson2 has quit [Read error: Connection reset by peer]
tyson2 has joined #commonlisp
<Catie>
Well okay, now I just straight up can't REQUIRE Quicklisp systems. So never mind for now I guess?
<etimmons>
I'm surprised REQUIRE worked at all
<White_Flame>
isn't REQUIRE basically deprecated?
thomaslewis has joined #commonlisp
<Catie>
I've been using it wherever I'm able because it's worked, basically. For the most part, at least
thomaslewis has left #commonlisp [#commonlisp]
<mfiano>
Yeah don't use require, except maybe for implementation modules in your rc file
<Catie>
What's the preferred method?
<mfiano>
asdf:load-system
<etimmons>
+1
<mfiano>
or the quicklisp wrapper
<mfiano>
or since etimmons is here, CLPM :)
<Catie>
Can you do that without modifying asdf:*central-registry*? Because that's the onerous part that I've been trying to avoid
<White_Flame>
are you modifying search paths for REQUIRE or something?
<etimmons>
If you're using QL then any system you've quickloaded in the past can be asdf:load-system'd after QL has been loaded
<White_Flame>
also the QL allows the local-projects dir
<mfiano>
I don't think it's recommended by asdf maintainers to go messing with the registry iirc
<mfiano>
but you can control it via special files in your dotfiles
<Catie>
"modifying" in this case includes locally binding. Historically I've done a (let ((asdf:*central-registry* (cons #P"..." asdf:*central-registry*))) (asdf:load-system :whatever))
<Catie>
I've been using REQUIRE because it's part of the standard, but Quicklisp isn't. Basically I'm trying not to assume Quicklisp will be available. I suppose ASDF isn't either, but it's a de facto standard. Though again, Quicklisp kind of is as well. Hhhhh this made more sense in my head
<etimmons>
require is really only useful for implementation provided modules. because it's pretty underspecified
<mfiano>
Using REQUIRE, or Common Lisp modules, is usually a big mistake
<etimmons>
ASDF is very configurable, so if you want to manually manage all your systems you can pretty easily configure it via environment variables (useful for build scripts) or configuration files in any number of places on your file system
<Catie>
Hmm okay, so it sounds like I mostly just need to get more familiar with ASDF
<etimmons>
If you don't want to manually manage all your systems (i.e., you want to have your dependencies resolved and downloaded for you), QL or CLPM are great for that.
<mfiano>
Or just use QL or CLPM and leave the magic be
<etimmons>
And both of them have ways to then load your downloaded systems directly with asdf:load-system
<mfiano>
But knowing ASDF magic can certainly be helpful, but there be dragons
<Catie>
See, and it sounds like I had some pretty cool magic being able to REQUIRE things willy-nilly, but then I went and observed it and it went away
<etimmons>
BTW, asdf:_central-registry_ still works (and I imagine will continue to work for quite a while), but I really recommend the "source registry" configuration methods. Much more flexible and can be done without modifying rc files for N implementations
biog has quit [Quit: ZZZzzz…]
<Catie>
Thank you everyone! I appreciate the help
thomp has quit [Ping timeout: 268 seconds]
s-liao1 has quit [Ping timeout: 256 seconds]
Algernon91 has joined #commonlisp
s-liao has joined #commonlisp
Algernon91 has quit [Ping timeout: 252 seconds]
selwyn has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
s-liao has quit [Quit: Ping timeout (120 seconds)]
pranavats has left #commonlisp [Error from remote client]
lisp123 has quit [Ping timeout: 256 seconds]
Catie has quit [Quit: going home]
asen has joined #commonlisp
asarch has quit [Quit: leaving]
s-liao has joined #commonlisp
ec has quit [Ping timeout: 276 seconds]
Devon has quit [Ping timeout: 256 seconds]
aartaka has joined #commonlisp
<beach>
Good morning everyone!
<drakonis>
morn'
thomp has joined #commonlisp
Bike has quit [Quit: Lost terminal]
lisp123 has joined #commonlisp
s-liao has quit [Quit: Client closed]
perrierjouet has quit [Quit: WeeChat 3.4]
euandreh has quit [Ping timeout: 240 seconds]
perrierjouet has joined #commonlisp
waleee has quit [Ping timeout: 256 seconds]
myrrh has joined #commonlisp
semz has quit [Ping timeout: 268 seconds]
<ns12>
I am worried about getting viruses from Quicklisp. Deoes Quicklisp contain viruses?
<sm2n>
It could, if someone here was evil. Hopefully that is not true though
<moon-child>
do you expect every line of code there has been vetted?
<moon-child>
you must trust. Or not.
<moon-child>
But beware of falling into hypothetical rabbitholes like the thompson hack
<ns12>
cl-alexandria includes code to mine BItcoins.
<sm2n>
lol no
lisp123 has quit [Remote host closed the connection]
semz has joined #commonlisp
<sm2n>
I would say reading library code is more of a cultural habit in the CL community than it might be in other language communities. Especially with M-.
<drakonis>
M-?
<sm2n>
But I don't know if people go and read libraries from start to finish (I do sometimes).
<aeth>
quicklisp is curated, unlike larger languages (it doesn't scale)
<sm2n>
Many libraries are short enough for it to be feasible
<aeth>
of course, something could slip by
<ns12>
With a MITM attack on a network used by Lisp zealots, it might be possible to mine Bitcoins using Alexandria.
<sm2n>
drakonis: M-. The emacs command to jump to defn
<drakonis>
oh
<drakonis>
right
<ns12>
aeth: Curated by whom? What if it is "curated" by someone with malicious intent?
<aeth>
afaik, every package goes through Xach
<sm2n>
I'm pretty sure he doesn't read all the code though
<aeth>
as opposed to many package management systems where you can just point it at a github or whatever
<ns12>
The security of almost every Lisper's computer depends on one person?
<sm2n>
he just checks if they build
<ns12>
"All test cases for cl-trojan-and-worms are passing".
<sm2n>
yes, so read the code in your dependencies beforehand if you are worried
<White_Flame>
everybody uses npm, even though there's malicious stuff there, too
<White_Flame>
probably in pip as well
<ns12>
sm2n: That is a lot of work.
<aeth>
npm is impossible to track
<White_Flame>
it's part of the model
<sm2n>
ns12: That is the only way no matter what package manager you use.
<aeth>
use any package and pull in hundreds of dependencies with npm
<aeth>
at least you have a chance to read all of your dependencies' code with CL
<ns12>
That is silly of JavaScripters.
<sm2n>
There are some efforts for distributed auditing/attestation, but they haven't really taken off.
<sm2n>
It's actually not bad in CL, since in my experience the set of dependencies that most projects have is relatively small
<aeth>
kind of sounds like a job for the government
X-Scale` has joined #commonlisp
<aeth>
everyone needs code audited, nobody's going to spend time or money to audit it
mrmr3 has joined #commonlisp
perrierjouet has joined #commonlisp
<sm2n>
or similar governance orgs, yeah
<moon-child>
why the hell should I trust the government?
scymtym_ has joined #commonlisp
dmgk_ has joined #commonlisp
* moon-child
looks askance at nsa-backdoored crypto
sndr has joined #commonlisp
<sm2n>
Some languages are single implementation, and also have "blessed" libraries
cognemo_ has joined #commonlisp
<sm2n>
the idea being that if you trust that the implementation is not malware, you should trust the libraries too
Lord_Nightmare2 has joined #commonlisp
pieguy128_ has joined #commonlisp
<White_Flame>
no system that I know which supports downloading libraries off the internet has a preventative vetting process for finding malicious things
<sm2n>
doesn't really work here either, but it seems plausible that people could pool money to pay people to audit code, through some foundation (the CL foundation?) or something
<White_Flame>
quicklisp as least (afaik) ensures that all dependencies in a single release all build & test with each other
<White_Flame>
you don't get that in most other languages
<sm2n>
The issue is that most people don't care enough to actually make such a thing happen anyway
<White_Flame>
if you're concerned about security, you download a package and stop using quicklisp
<semz>
^
<White_Flame>
include that source code in your own internal repository and don't allow updates from teh outside world
Demosthe1ex has joined #commonlisp
<sm2n>
This is a problem everywhere, even outside language ecosystems — how do you verify any software you have isn't malicious?
<semz>
That also has the upside that you're thinking more about which dependencies you add
<sm2n>
(You can't really)
gpiero_ has joined #commonlisp
<White_Flame>
sm2n: you'd have to be able to recognize 100% of all forms of maliciousness
<aeth>
it's just a subset of the problem of internet communities scaling beyond manual moderation of everything being possible... in this case, of code
<White_Flame>
as well as 100% of the means to obfuscate maliciousness
<aeth>
and the answer is people prefer scale to safety
tyson2 has quit [Remote host closed the connection]
<sm2n>
In general, it comes down to economics
<Alfr>
For this purpose start with considering all non-halting programs malicious.
<White_Flame>
heh
pieguy128 has quit [*.net *.split]
gpiero has quit [*.net *.split]
amb007 has quit [*.net *.split]
monaaraj has quit [*.net *.split]
shka has quit [*.net *.split]
sander has quit [*.net *.split]
OlCe has quit [*.net *.split]
scymtym has quit [*.net *.split]
danieli has quit [*.net *.split]
skyl4rk has quit [*.net *.split]
Lord_Nightmare has quit [*.net *.split]
hhdave has quit [*.net *.split]
Demosthenex has quit [*.net *.split]
materialfuture has quit [*.net *.split]
X-Scale has quit [*.net *.split]
ns12 has quit [*.net *.split]
Krystof has quit [*.net *.split]
cognemo has quit [*.net *.split]
dmgk has quit [*.net *.split]
mrmr has quit [*.net *.split]
tsiolkov has quit [*.net *.split]
flip214 has quit [*.net *.split]
sndr is now known as sander
mrmr3 is now known as mrmr
dmgk_ is now known as dmgk
X-Scale` is now known as X-Scale
shka has joined #commonlisp
Lord_Nightmare has joined #commonlisp
Lord_Nightmare2 has quit [Ping timeout: 256 seconds]
monaaraj has joined #commonlisp
Krystof has joined #commonlisp
danieli has joined #commonlisp
materialfuture has joined #commonlisp
flip214 has joined #commonlisp
skyl4rk has joined #commonlisp
tsiolkov has joined #commonlisp
ns12 has joined #commonlisp
amb007 has joined #commonlisp
loke has quit [Ping timeout: 256 seconds]
perrierjouet has quit [Quit: WeeChat 3.4]
loke has joined #commonlisp
perrierjouet has joined #commonlisp
OlCe` has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.4]
perrierjouet has joined #commonlisp
lisp123 has joined #commonlisp
karlosz has joined #commonlisp
parjanya has quit [Ping timeout: 240 seconds]
lisp123 has quit [Ping timeout: 240 seconds]
rgherdt has joined #commonlisp
tsiolkov has quit [Ping timeout: 256 seconds]
karlosz has quit [Quit: karlosz]
iamFIREcracker has joined #commonlisp
thomp has quit [Ping timeout: 268 seconds]
s-liao has joined #commonlisp
igemnace has quit [Ping timeout: 268 seconds]
jealousmonk has quit [Remote host closed the connection]
igemnace has joined #commonlisp
monaaraj has quit [Ping timeout: 256 seconds]
karlosz has joined #commonlisp
monaaraj has joined #commonlisp
asen has quit [Quit: Leaving]
Jing has joined #commonlisp
myrrh has quit [Remote host closed the connection]
Cymew has joined #commonlisp
karlosz has quit [Quit: karlosz]
alfonsox has joined #commonlisp
Algernon69 has joined #commonlisp
Algernon91 has joined #commonlisp
monaaraj has quit [Ping timeout: 256 seconds]
monaaraj has joined #commonlisp
Algernon69 has quit [Ping timeout: 245 seconds]
theothornhill has joined #commonlisp
cosimone has quit [Remote host closed the connection]
thomaslewis has joined #commonlisp
cosimone has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
Demosthe1ex is now known as Demosthenex
notzmv has quit [Ping timeout: 240 seconds]
gaqwas has joined #commonlisp
MajorBiscuit has joined #commonlisp
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
mgl has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
nij- has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
theothornhill has quit [Remote host closed the connection]
amb007 has joined #commonlisp
treflip has joined #commonlisp
Colleen has quit [Read error: Connection reset by peer]
<frodef>
I'm looking at Hunchentoot sessions, and I'm curious to understand why sessions are internally stored/referenced by an integer ID (rather than, say, the SESSION-STRING/cookie), anyone happen to know?
s-liao has joined #commonlisp
rgherdt has quit [Ping timeout: 256 seconds]
rgherdt has joined #commonlisp
notzmv has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
igemnace has quit [Ping timeout: 245 seconds]
taiju has quit [Ping timeout: 240 seconds]
rogersm has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
igemnace has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
pillton has quit [Remote host closed the connection]
Lord_of_Life_ is now known as Lord_of_Life
igemnace_ has joined #commonlisp
igemnace has quit [Ping timeout: 240 seconds]
perrierjouet has quit [Quit: WeeChat 3.4]
s-liao has quit [Quit: Client closed]
<rotateq>
With what in the MOP does a class track which instances it made to know what to update? I also mean the ones that weren't bound to symbols, but are still existent till the next full garbage collection.
s-liao has joined #commonlisp
igemnace has joined #commonlisp
monaaraj has quit [Ping timeout: 256 seconds]
igemnace_ has quit [Ping timeout: 240 seconds]
monaaraj has joined #commonlisp
<Krystof>
a class doesn't track them
<rotateq>
okay Krystof, so do you know what does it then? :)
<Krystof>
yes!
<Krystof>
at least in some commonly-used implementations
<rotateq>
would you tell me this deep magical secret?
perrierjouet has joined #commonlisp
<rotateq>
SBCL is enough for now
<Krystof>
every time you ask me a question, I delete my half-finished description to answer your question
<rotateq>
heh! :D sry
<Krystof>
the class holds a description of its current layout (slots, inheritance, etc.). That might be called a "layout" or a "wrapper" depending on context in sbcl
<Krystof>
each instance also refers to that layout
<rotateq>
yes okay ..
<Krystof>
if a class is updated, it marks the current layout as obsolete, and gets a new layout. Now the class no longer refers to the old layout, but instances do
<Krystof>
when you access an instance, part of the access protocol is checking whether the instance's layout is up-to-date or obsolete. If it's obsolete, you go into the update-instance flow
xsperry has quit [Ping timeout: 240 seconds]
<Krystof>
if you never access an instance, it is never updated; it stays in its obsolete state (but it doesn't matter, because nothing accesses it)
<rotateq>
yes right I got that by little experimenting, also with the :allocation :class similarly
<rotateq>
so to say how i came to my question: in another talk with someone it came to singleton classes and I thought "hah, i have an idea" so I did it but the only thing that now misses is to look if there's still a referenced instance of a class anywhere
<Krystof>
so, the point is that nothing in this protocol requires the class to keep track of instances. Instead, instances keep track of which version of the class they were defined with
<rotateq>
alright! thank you very much (again)
<rotateq>
so i could also do it with a locally scoped data structure to mimic it properly
<Krystof>
no problem. For singletons, you could make allocate-instance throw an error, and use the class-prototype as the singleton instance?
<rotateq>
ahh right, didn't thought of allocate instance :) but made it with some other and a SINGLETON-CLASS metaclass for SINGLETON-OBJECTs
<rotateq>
then we came to this "oh so your methods aren't owned by the class?" and I thought longer, but not aware enough now how to make metaclass stuff (eg with funcallable-standard-class or standard-generic-function) to mimic even that safely for certain generic functions
<rotateq>
Krystof: and not aware how to use prototypes :) but it comes by time I hope
Jing has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
parjanya has quit [Ping timeout: 240 seconds]
s-liao has quit [Ping timeout: 256 seconds]
perrierjouet has quit [Quit: WeeChat 3.4]
perrierjouet has joined #commonlisp
monaaraj has quit [Ping timeout: 240 seconds]
amb007 has quit [Ping timeout: 256 seconds]
<rotateq>
and i realized again why it makes absolutely no sense (by logic!) to ask for the slot-values of an instance in the (allocate-instance :before)-method :D
amb007 has joined #commonlisp
monaaraj has joined #commonlisp
<rotateq>
ahh sry I surely meant the (initialize-instance :before)-method
<rotateq>
and "throw" an error? :D
s-liao has joined #commonlisp
scymtym_ is now known as scymtym
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
anticomputer has quit [Quit: quit]
anticomputer_ has joined #commonlisp
Jing has joined #commonlisp
attila_lendvai has quit [Ping timeout: 240 seconds]
random-nick has joined #commonlisp
pranavats has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
igemnace has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
theothornhill has joined #commonlisp
nij- has left #commonlisp [#commonlisp]
theothornhill has quit [Remote host closed the connection]
igemnace has joined #commonlisp
taiju has joined #commonlisp
tyson2 has joined #commonlisp
<beach>
Krystof: In Common Lisp, errors are not "thrown", they are "signaled". :)
* beach
thinks Krystof might be using other languages these days.
<moon-child>
(throw nil (make-instance 'error))
<beach>
C'mon, allow me to pester Krystof a bit.
dec0d3r has quit [Quit: Leaving]
<Duuqnd>
Now I'm really tempted to print out a DESCRIBE output of an error object and start tossing it around.
<Duuqnd>
Literally throwing errors
<moon-child>
beach: :)
perrierjouet has quit [Quit: WeeChat 3.4]
perrierjouet has joined #commonlisp
heisig has joined #commonlisp
<phoe>
d'oh
<phoe>
beach: it's easy and practical to throw errors in Common Lisp
<phoe>
(throw 'somewhere (make-instance 'error))
<phoe>
oh wait moon-child already mentioned that
* phoe
hides
<moon-child>
phoe: considering you wrote the common lisp condition system book, I think you have way more right to say that than I do :P
<phoe>
nope
<phoe>
everyone has a right to throw errors
<phoe>
it's a part of standard Common Lisp
<phoe>
just like throwing non-errors
* moon-child
throws phoe a sandwich
* phoe
thankfully is wrapped in a (catch 'phoe ...), calls #'CONSUME on the sandwich
<yitzi>
I want a sandwich. Throw one to me moon-child!
<yitzi>
I'm off to go teach. Thanks phoe, moon-child and edgar-rft for making me laugh so early here. Cheers!
<madnificent>
Any clues on where to find documentation regarding woo? (and I suspect dexador)
<phoe>
nowhere
<phoe>
I doubt you can find that what does not exist
<madnificent>
phoe: I don't know where that is. Is that a new tool? I've seen the name before so it must be very popular! ^_^
<phoe>
AFAIK the only real source of information is the source code itself
<moon-child>
that's not true! There is a readme
<moon-child>
it has ~10 lines of code examples
<moon-child>
:^)
<madnificent>
that's very exact documentation on the behaviour, but sadly any change would become a breaking change. must lean towards browser version numbers.
jpl01 has joined #commonlisp
miique has joined #commonlisp
z3t0 has quit [Read error: Connection reset by peer]
parjanya has joined #commonlisp
<Krystof>
beach: oh boy it's too long since I've talked about, let alone written, proper Lisp code
<phoe>
(declare (optimize)) ;; the compiler should know what to do
<phoe>
Xach: ooh, a missing split-sequence dependency
<jackdaniel>
technically correct speak is means towards the end of making the communication easier. in a spirit of this definition the fact that in common lisp conditions are "signaled" and code is organized in "packages" is very unfortunate - it is a barrier for efficient communication with people not immersed in common lisp
<rotateq>
phoe: QOCLC -> Quantum Oracle Common Lisp Compiler
<semz>
very unfortunate acronym
<random-nick>
jackdaniel: I thought java also uses the word package?
theothornhill has quit [Ping timeout: 240 seconds]
<moon-child>
'A Content distribution Overlay Network Service for LISP' ... what ??
<jackdaniel>
name coincidence
<jackdaniel>
for both lisp and cons
<Xach>
and car and cdr
<Xach>
it's a prank
<jackdaniel>
right, I was about to say that it sounds like a poor joke
<Xach>
that's why it makes me mad.
<heisig>
Xach, phoe: Thanks, I just added the missing dependency on split-sequence.
<phoe>
if I had a cent I had for every time I did that mistake
<phoe>
...I would certainly have some US foreign currency in my household now
<phoe>
I wonder if there could be a Lisp bot that figures out which system needs the dependency, opens its ASD file, inserts the dependency, and automatically files a quicklisp PR
<phoe>
of course it would be wrong like 20% of the time
<phoe>
but the remaining 80%, hmm
<phoe>
s/quicklisp PR/a PR from quicklisp/
<_death>
with package-inferred-systems, an :import-from suffices
<phoe>
that too!
<heisig>
I think I should just add extra CI jobs that load each system independently, and not just all of them in the 'usual' order.
<jackdaniel>
wasn't that we have too many 80% correct solutions and too little complete ones? at least that's what a blog post I see every 1,5 year on hackernews says
<jackdaniel>
the lisp curse or something
<jackdaniel>
I suppose that the curse is that I have to see it every 1,5 year, and lisp is only accidental
<phoe>
^
<phoe>
a bot that automatically files PRs for missing dependencies would be good enough I guess
<phoe>
even if it sometimes will fail to do the right thing
<phoe>
Xach: would you accept anything like that into your workflow, or is that a silly and/or unnecessary idea?
<jackdaniel>
like it will file an issue instead of a pr?
<phoe>
jackdaniel: yes - if it can't reliably insert a dependency or make it build after inserting it, it should just file an issue IMO
<jackdaniel>
I was joking - you've said that "bot (...) files PRs, (...)it sometimes will fail to do the right thing"
<jackdaniel>
so the only thing beside PR that comes to mind is an issue
<_death>
github bots are bad.. if I started getting issues from them, I'd disable issues
<Xach>
phoe: i don't really want to automatically file PRs. i have code that automatically formats PRs for me, but I submit them "manually" to some degree.
<Xach>
err
<Xach>
sorry, not PRs. issues.
* Xach
got confused
<Xach>
I would never ever want to automatically file PRs.
<phoe>
Xach: OK - just wondering if there's anything that could optimize your workflow a bit
<phoe>
_death: also fair point
<_death>
when a program makes work for a person..
<Xach>
phoe: it would be great if people just stopped making software for a while
<Xach>
say, for 2 to 5 years
<Xach>
not just for lisp
<phoe>
oh
<phoe>
I'll try
<rotateq>
so taking a step back and proving some more critical things and let other things ripe out maybe?
monaaraj has quit [Ping timeout: 256 seconds]
<moon-child>
would be cool if you could take a parameter in the function namespace. (defun f (#'x y) (x y)). But it would make for inconsistencies w/destructuring lambda lists
<phoe>
(defun f (x y) (fbind ((x x)) (x y))) is a workaround
<phoe>
where fbind is available in serapeum
<moon-child>
I mean, could just make my own defun/lambda/
<_death>
but it's not the same function, is it?
<moon-child>
_death: what do you mean?
<phoe>
_death: AFAIK correct, it's not EQ
<moon-child>
ah, yes
heisig has quit [Quit: Leaving]
<phoe>
there's no way to make it both EQ and portably I think
<moon-child>
can do it with a code walker
OlCe` has quit []
OlCe has joined #commonlisp
<mfiano>
Hmm...did I find a conformance bug in SBCL?
<mfiano>
(subtypep foo-instance 'foo) is an error, but (subtypep foo-instance foo-instance) ;=> T,T
<mfiano>
When would an instance be considered a type specifier?
<beach>
phoe: If it is not a class, it is not a type specifier.
<mfiano>
And it is not
<beach>
I know.
<Bike>
the instance is not a type specifier. as such, subtypep has been called incorrectly and the behavior is undefined.
<phoe>
but in case of (defclass foo () ()), (make-instance 'foo) is not a valid argument to SUBTYPEP
<phoe>
sbcl could possibly signal an error, something like a type-error because the argument is not of type (or symbol cons class)
<phoe>
but that's already a zone of SBCL being nice or not
<phoe>
since it's already UB
<mfiano>
Ok yes, I understand now.
<phoe>
Bike: OK, and by pure luck that defers to EQ for standard objects
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<phoe>
so, an (un)fortunate accident
amb007 has joined #commonlisp
<moon-child>
phoe: that's not luck, that's specified :P
<phoe>
I meant pure luck that SUBTYPEP on SBCL does EQUAL before anything else
<moon-child>
ah, yes
<phoe>
could possibly file a wishlist issue for SBCL, at least to have a type check in there
<phoe>
could work in safe code, I guess
Algernon91 has quit [Quit: Leaving]
<mfiano>
Thanks all, I haven't been Lisping for some months (unfortunately missed the 2-5 years), and made a mistake when I really wanted (eq (class-name (class-of instance)) type-specifier).
<_death>
I should get back to Lisping for a few hours ;)
_ante_ has joined #commonlisp
euandreh has joined #commonlisp
ec has joined #commonlisp
ec has quit [Ping timeout: 276 seconds]
xaltsc has joined #commonlisp
ec has joined #commonlisp
<mfiano>
Stupid question, but is there a library that mimics "interfaces" from other languages. What I mean, is I'd like it to be an error if the user forgets to implement a method for all of a set of generic functions for some given class/classes/etc specializers (that the library author decides on)
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
<moon-child>
coalton
<mfiano>
When dealing with very composable APIs with lots of mixins etc, it can be difficult to remember to specialize them all. I could just say "their problem" when they inherit the wrong behaviors, but it would be nice to issue a warning. I know the semantics aren't exactly clear here, and that is why I'd like to look at if some libraries ever attempted to solve it, excluding some DSL/statically
<mfiano>
typed language written in CL. I just want a somewhat light MOP wrapper.
<semz>
When would this error be throw^W signalled?
<mfiano>
Maybe runtime on each invocation. I don't want to sacrifice the dynamism of Lisp for a mere correctness check.
<mfiano>
But that falls under the "unclear semantics"
<moon-child>
(defclass c ...) (defmethod ... ((c)))... (check-class c)
<semz>
^ is how I'd do it ad-hoc too
<semz>
but I'm not aware of any library
<mfiano>
Heh ok, thanks.
<moon-child>
you could also make some kinda scope. (my-defclass c (super) (slots) (methods))
<moon-child>
and it checks you define all the required methods
taiju has quit [Remote host closed the connection]
<moon-child>
(can still define other methods later ofc)
rotateq has quit [Remote host closed the connection]
tyson2 has quit [Remote host closed the connection]
thomp has joined #commonlisp
<madnificent>
mfiano: I also work with (check-xyz) but it's for configuration files rather than classes. We want something similar in software related to our lisp code too. But very much ad-hoc.
Oladon has joined #commonlisp
thomaslewis has joined #commonlisp
thomp has quit [Ping timeout: 256 seconds]
Catie has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<madnificent>
Anyone know if it's intentional that #'woo:run does not yield? it runs forever (the webserver works though)
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<etimmons>
I've never used woo, but I imagine it's intentional and the thread that calls run becomes the thread in charge of the event loop
monaaraj has quit [Ping timeout: 256 seconds]
unyu has quit [Read error: Connection reset by peer]
monaaraj has joined #commonlisp
<madnificent>
etimmons: could be, though there's a stop-server command and that expects some input.
unyu has joined #commonlisp
waleee has joined #commonlisp
monaaraj has quit [Ping timeout: 256 seconds]
Jing has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
tyson2 has joined #commonlisp
treflip has quit [Ping timeout: 256 seconds]
raeda_ has joined #commonlisp
raeda has quit [Ping timeout: 256 seconds]
monaaraj has joined #commonlisp
mgl has quit [Quit: Client closed]
Cymew has quit [Ping timeout: 240 seconds]
jeosol has quit [Quit: Client closed]
<etimmons>
madnificent: That does seem weird then
igemnace has quit [Ping timeout: 245 seconds]
VincentVega has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
jstoddard has joined #commonlisp
thomp has joined #commonlisp
monaaraj has quit [Ping timeout: 250 seconds]
<luis>
etimmons: I'd rather "merge" osicat pull requests using rebase as I find the history is much more readable that way, but you're the one doing actual work so if you prefer to work that way that's fine too
shka has quit [Quit: Konversation terminated!]
shka has joined #commonlisp
<luis>
etimmons: we can enable the "enforce linear history" option on github, if you agree
<jackdaniel>
oh oh, I've came with a saying: "technically correct to real world is what matematically equal is to floats"
<phoe>
:D
<phoe>
jackdaniel: I like that one
<jackdaniel>
great, my place among wilde and goethe is granted now
<etimmons>
luis: I agree. I don't normally use GitHub (and have all my Gitlab projects set up for linear history) so I totally forgot to check what would happen when hitting the merge button
nij- has joined #commonlisp
<luis>
etimmons: ok, done. We share the same sort of OCD then :D
<etimmons>
:)
<nij->
Hi! Any defacto way to quickly get places in a deeply nested sequence? Something like
<remexre>
if I have an end-user print method and a developer print method, what variable am I supposed to branch on in PRINT-OBJECT such that the latter gets used in ~s and error messages, but the former gets used in ~a?
<phoe>
what do you mean, end-user and developer?
<Bike>
*print-escape*
<phoe>
that doesn't look like a standard CL distinction
<Bike>
probably
<phoe>
oh wait - I understand now
karlosz has joined #commonlisp
<Bike>
~s binds *print-escape* to true and ~a binds it to false
<remexre>
ah, yep, *print-escape* works great, thanks
<remexre>
I was using *print-readably* before
<remexre>
oh, which I guess ~s doesn't actually bind, only ~a does? werid
<phoe>
I have a possibly cyclic graph data structure that I would like to get a modified copy of, where "modified copy" means that I'd like some of the nodes to be different, and also that I want not to mutate the original, and also that I want to maximize structure sharing wherever possible. Is anyone aware of any Lisp code that will help me do that?
<etimmons>
I can't work on it for a bit, but I've got a connection pool built on top of drakma. I'm working to get it pulled out into a sensible library and also married with schannel for TLS on Windows
<phoe>
a simple example of what I'd like to do is turning (1 2 3 . #1=(4 5)) into (1 2 :three . #1#)
<theothornhill>
phoe: FSet? Sounds like a persistent data structure, doesn't it?
<etimmons>
When it's in a clean-ish state, I'm planning to reach out to see if it should be incorporated into drakma itself or live as a wrapper around it
<Josh_2>
In this case there is a serious chance that I will be making a lot of HTTP requests (webhooks) to listeners
<phoe>
a slightly more involved one is turning #1=(1 2 3 4 5 . #1#) into #2=(1 2 :three 4 5 . #2#) because then everything needs to be copied due to a cycle
<phoe>
theothornhill: yes, except the catch is, I'd like to use standard Lisp data structures for the nodes - conses, vectors, standard objects
<phoe>
hence it sounds more like a GF protocol to participate in if anything
<phoe>
if there's no code, is anyone aware of already existing algorithms that I can try to implement for doing that?
<Josh_2>
etimmons: Thank you :)
<Josh_2>
It would be nice if he fixed connection pools :facepalm:
<Josh_2>
I think I will just go with Dex
<phoe>
everyone can fix it, actually! it's free software
Kyuvi has quit [Ping timeout: 256 seconds]
<Josh_2>
In principle
<theothornhill>
Josh_2: Wasn't there a new drakma maintainer just recently?
<Josh_2>
etimmons: have you ever used Snooze?
thomaslewis has joined #commonlisp
<Josh_2>
I think I will use Snooze instead of Carlyle. If I was to modify Carlyle it would just end up like Snooze anyway
thomaslewis has left #commonlisp [#commonlisp]
<Josh_2>
Carlyle works great for less complex applications, but the one I have to build now is going to end up exceptionally complicated I think
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
citizenandrew has joined #commonlisp
<citizenandrew>
Josh_2: If you really want to use Dexador and have a working connection pool, you could try https://github.com/ajberkley/dexador ... Fukamachi isn't answering pull requests...
<_death>
phoe: I think it depends on how you actually want to "modify" it.. if it's a kind of sublis that works on graphs, that's one thing.. if you want to substitute for a specific element not necessarily based on its value, it's another..
<phoe>
let me split this into two parts
<phoe>
part one: I want to make a part of the whole graph "fresh", where the part involves making a shallow copy of everything between some root vertex of the graph and one or more "target" vertices that I want to mutate in part two
<Josh_2>
citizenandrew: hmm I could
VincentVega has quit [Quit: ERC (IRC client for Emacs 27.2)]
<phoe>
because of cycles, such copying also involves copying everything that refers to any of the copied vertices, because otherwise they'd refer to the "old" version
Oladon has joined #commonlisp
<Josh_2>
For now I will just use normal dex with :use-connection-pool nil and later if a PR is accepted or a permanent fork is made I will change this
<_death>
not sure I understand.. since each node can presumably refer to its children, when you replace a child what do you think should happen?
IPmonger has joined #commonlisp
IPmonger has quit [Remote host closed the connection]
<phoe>
a simple example of what I'd like to do is turning (1 2 3 . #1=(4 5)) into (1 2 :three . #1#)
<phoe>
so in that example, the conses whose CARs and 1 and 2 need to be copied
<phoe>
same with the cons whose CAR is 3, we need to copy it and its new CAR becomes :THREE
<phoe>
but #1# doesn't need to be copied
<phoe>
s/whose CARs and/whose CARs are/
<citizenandrew>
Josh_2: also make sure if you do not explicitly set :keep-alive nil, beware that you should close the streams that are returned to you... there is no auto-closing / finalizing.
<etimmons>
Josh_2: No, never tried snooze nor carlyle
attila_lendvai has joined #commonlisp
<Josh_2>
citizenandrew: is this your fork?
<citizenandrew>
Josh_2: yes... that's me. I made the changes because I saw some complaints on irc or reddit about dexador being broken so I figured it was worth fixing... but now I've got a bad taste in my mouth because there's no response to my PR.
<Josh_2>
I see, I left a comment on your PR, I think if it is not accepted than you should hard fork and rename honestly
<_death>
phoe: in this example there is no cycle, so a simple sublis could work
<etimmons>
citizenandrew: I got a PR merged to dexador back in December.
<etimmons>
sometimes they can take a while
<phoe>
_death: yes, but then #1=(1 2 3 4 5 . #1#) should turn into #2=(1 2 :three 4 5 . #2#)
<Josh_2>
Thank you for your work citizenandrew :)
<phoe>
and things like #1=(1 2 #1# 4 5) → #2=(1 :two #2# 4 5) and so on
<citizenandrew>
etimmons: OK. I'll keep my hopes up!
<phoe>
I need to figure out which part of the structure to copy, then do the copying while making the modifications, then return the modified version
<phoe>
s/which part/which parts/
lagash has joined #commonlisp
<_death>
phoe: in both of these you need to recreate the whole structure, correct? and #1=(1 #3=(a b) #1# 4 5) => #2=(1 #3# #2# 4 5)? but #1=(1 #3=(a b #1#) #1# 4 5) => #2=(1 (a b #2#) #2# 4 5)?
<phoe>
_death: the (4 5) can be shared
<_death>
right
<phoe>
(a b) too
<phoe>
since it doesn't cause a cycle to happen
<phoe>
it's a "leaf", in a way
<_death>
in my first example yes (hence #3#) but in my second example?
thomaslewis has joined #commonlisp
<phoe>
oh, second example - yes, (a b #1#) needs to be copied
thomaslewis has left #commonlisp [#commonlisp]
<_death>
(my examples should've contained a suitable modification to justify the copying)
citizenandrew has left #commonlisp [#commonlisp]
<phoe>
that's the easy part, I know what you meant
waku has quit [Remote host closed the connection]
waku has joined #commonlisp
attila_lendvai has quit [Ping timeout: 250 seconds]
<_death>
so you need to determine whether any of the descendants refer to the parents, and if so, replace those parents and so on
<phoe>
yes
lagash has quit [Ping timeout: 250 seconds]
random-nick has quit [Ping timeout: 256 seconds]
dec0d3r has joined #commonlisp
<_death>
I'm thinking connected components with cut points..
<phoe>
OK, that's an idea
thomaslewis has joined #commonlisp
mrmr has joined #commonlisp
<_death>
maybe a search can result in a ready made algorithm, but otherwise I'd just try to work it out on paper
<phoe>
yes
<phoe>
I'll try doing that tomorrow when I'm a bit fresher
<sveit_>
The reason I ask is that it is of course fairly simple to just implement an additional object that can store information on the "view" I'd like to provide on a flat array (as suggested in that comment) but why would my user-space implementation be better than what is in the compiler?
<Bike>
well, it kind of wouldn't be
<Bike>
which is why they usually perform poorly
<sveit_>
(in case it's not claer, that link is directly to the comment by someone named Dan Robertson that has the statement i'm confused about)
<Bike>
so the problem is, say we have (aref a ...) in the code. if the compiler knows a is NOT displaced, that's pretty straightforward - bounds check and a memory read
<Bike>
but if it could be displaced, it has to compile in a check for that, and then code to loop through displacements to get the underlying array
<Bike>
with what the comment describes, you'd have one simple vector which can be accessed quickly, and then you just briefly compute the index you actually want
<mfiano>
Implementations just don't optimize everything they could.
<mfiano>
On SBCL at least, bounds checking occurs on both
<sveit_>
Bike: i think you have revealed that I don't understand what array displacement means :) I thought it was exactly what you described in your last statement: a backing vector and some new procedure for computing indices
<Bike>
sveit_: the trick is that you can displace to another array that is itself displaced
igemnace has joined #commonlisp
<sveit_>
Bike: sure, but doesn't the procedure "close" on itself? meaning if A0 is the original array, A1 is displaced to A0, and A2 is displaced to A1, can't the implementation just treat A2 as displaced to A0?
<Bike>
no, because the array-displacement function allows you get at the underlying array
<Bike>
and, for example, if A1 is adjusted, A2 needs to reflect that adjustment, even if A0 itself has not changed
<sveit_>
Bike: ah, thank you very much, this makes a lot more sense now.
<Bike>
think the standards committee should have put a little more thought into this thing, honestly
<Catie>
Adjusting a displaced array is something they actually put a decent bit of thought into, there's an issue writeup about it
lagash has joined #commonlisp
<Bike>
sure, i mean it all works, just not very well.
<Catie>
Oh well. Yeah okay, hard to argue with that
<Bike>
something like a flat array view might have been both useful and efficient.
thomp has joined #commonlisp
<Catie>
Like row-major-aref, but for displacement purposes?
<Bike>
no, i mean instead of having displaced arrays like they exist, having a more limited construct that can't get recursive
<mfiano>
Wish we had conformal displacement
Oladon has quit [Quit: Leaving.]
kevingal has joined #commonlisp
tanners has quit [Ping timeout: 256 seconds]
tanners has joined #commonlisp
phadthai_ is now known as phadthai
<aeth>
there's no incentive to optimize displaced arrays because nobody uses displaced arrays... because they're not optimized
<aeth>
the idiomatic way of thinking is start/end indices and almost everything in the standard library has it, as well as any well-written third-party library
rgherdt has quit [Ping timeout: 240 seconds]
gaqwas has joined #commonlisp
<Bike>
i mean, how would you optimzie displaced arrays
<Bike>
given that, in general, you have this indefinite-length chain of displacements to navigate
<aeth>
if the problem is the function ARRAY-DISPLACEMENT, and someone really wanted to optimize displaced arrays, couldn't they just optimize them if ARRAY-DISPLACEMENT cannot possibly show up in the program?
<aeth>
couldn't really do that in current implementations, but maybe in a conforming one
<Bike>
did you read the message i wrote after that one
<_death>
Bike: what about keeping both the immediate displacement and the farthest one possible, and recomputing the latter when needed
<Bike>
yeah i guess you could have each array maintain weak backpointers to every array that's displaced to it