<Josh_2>
I keep getting the error bad-file-descriptor when calling socket-accept on my listen socket, the fd is -1 for some reason
<Josh_2>
I restarted the entire machine and sbcl
<aeth>
jfrancis: Well, I think you brought up a good point with project managers, but most people do CL on their own time, in which case the problem is motivation, so the order to do things in imo kind of reverses. Instead of building a solid foundation of libraries and then the application, you need to get a MVP of the application/library done as quickly as possible to maintain motivation. At least, imo/ime.
<aeth>
So it doesn't surprise me that people work with an 80% good-enough JSON library instead of writing a perfect fit one, even though 80% good-enough isn't actually good enough.
<White_Flame>
"always have a running version"
<Josh_2>
Okay found the problem
mathrick has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
mathrick has joined #lisp
FreeBirdLjj has quit [Ping timeout: 276 seconds]
khisanth__ has joined #lisp
clothespin__ has quit [Ping timeout: 268 seconds]
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
nchambers has joined #lisp
Jeanne-Kamikaze has joined #lisp
clothespin has joined #lisp
wxie has joined #lisp
wxie has quit [Ping timeout: 245 seconds]
``Erik has joined #lisp
Kundry_Wag has joined #lisp
FennecCode has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
<lavaflow>
from what I understand common lisp doesn't guarantee tail call optimization in every scenario, but does it in any specific circumstances, like a procedure invoking itself in the tail position?
<lavaflow>
I'm reading land of lisp and some of the examples have procedures invoking themselves in the tail position to loop. I thought that was a scheme-ism
slyrus has joined #lisp
slyrus_ has quit [Ping timeout: 265 seconds]
<Xach>
lavaflow: it is a scheme-ism and land of lisp has some little odd bits like that
<Xach>
lavaflow: implementations might convert calls like that in some circumstances but nothing is guaranteed by the standard
<lavaflow>
ah okay, good to know
PuercoPope has joined #lisp
<PuercoPope>
no-defun-allowed: an alternative to modifying the sources, if you use SBCL, is to restrict the compiler policy. ie. (restrict-compiler-policy 'safety 1)
bitmapper has quit [Ping timeout: 268 seconds]
nydel has joined #lisp
nydel has quit [Changing host]
nydel has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 265 seconds]
smokeink has joined #lisp
ebrasca has quit [Remote host closed the connection]
brettgilio has joined #lisp
quazimodo has quit [Ping timeout: 268 seconds]
quazimodo has joined #lisp
ebzzry_ has quit [Read error: Connection reset by peer]
wiselord has quit [Ping timeout: 240 seconds]
akoana has left #lisp ["Leaving"]
kscarlet has quit [Read error: Connection reset by peer]
kscarlet has joined #lisp
Kundry_Wag has joined #lisp
kscarlet has quit [Read error: Connection reset by peer]
kscarlet has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
megalography has quit [Ping timeout: 250 seconds]
kscarlet has quit [Read error: Connection reset by peer]
megalography has joined #lisp
kscarlet has joined #lisp
kscarlet has quit [Read error: Connection reset by peer]
kscarlet has joined #lisp
ahungry has joined #lisp
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 252 seconds]
<vsync>
huh... why is it allowed to have a zero-dimensional array? or more properly, why does a zero-dimensional array have an element?
<pjb>
vsync: a 0-dim array doesn
<pjb>
't HAVE an element, in a way, it IS an element.
<aeth>
vsync: it's kind of the array equivalent of a point
<vsync>
what use would such a thing have?
<vsync>
and why wouldn't it be an array that isn't allowed to hold anything?
<aeth>
vsync: (make-array '() :element-type 'double-float :initial-element 4d0) ; now you have a box
<pjb>
vsync: to represent scalars in a package that deals with arrays of all dimensions.
<no-defun-allowed>
The size of an array is the product of its dimensions, i.e (apply #'* (array-dimensions <the array>)).
<aeth>
vsync: a 0D array of a double-float or (unsigned-byte 64) or (signed-byte 64) in 64-bit implementations that support such optimizations is essentially micromanaging your own box instead of automatically heap-allocating that number
<no-defun-allowed>
(*) [nullary multiplication] is 1.
<pjb>
Also, such an array still has attributes, sut as the element-type!
<pjb>
So it's a way to bring the value along with some (super-)type.
<vsync>
huh
<vsync>
pjb: more on this last?
<aeth>
vsync: technically speaking if you're writing hyper-optimized numerical code it's more efficient to pass in a 0D double float array containing an element and then optionally perhaps setting that with the new result rather than actually passing in a heap-boxed double float. Do you need to do this? Probably not. Does a library you use that wants to compete with C/C++/Fortran need to do this? Maybe.
<aeth>
vsync: of course, a length 1 array does pretty much exactly the same thing
<pjb>
Of course, you get the upgraded element type, which may not be too useful, but still…
<aeth>
The difference between a length-1 array and a length-() array is (aref foo 0) vs. (aref foo)
gioyik has joined #lisp
gravicappa has joined #lisp
Jeanne-Kamikaze has quit [Remote host closed the connection]
orivej has joined #lisp
enrio has joined #lisp
Lycurgus has joined #lisp
Lord_of_Life_ has joined #lisp
mathrick has quit [Ping timeout: 268 seconds]
mathrick has joined #lisp
Lord_of_Life has quit [Ping timeout: 276 seconds]
Lord_of_Life_ is now known as Lord_of_Life
Lycurgus has quit [Remote host closed the connection]
ggole has joined #lisp
<vsync>
is there an equivalent of CONSTANTLY but for functions/forms rather than values?
<vsync>
or, more generally, a sort of inverse-curry?
kscarlet has quit [Read error: Connection reset by peer]
kscarlet has joined #lisp
Oladon has quit [Quit: Leaving.]
rippa has joined #lisp
kscarlet has quit [Read error: Connection reset by peer]
kscarlet has joined #lisp
<vsync>
haha, turned out I could just do what I wanted with (map-into (make-array N) #'WHATEVER)
benjamin-l has joined #lisp
wxie has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 246 seconds]
tourjin has joined #lisp
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
gravicappa has quit [Ping timeout: 250 seconds]
kscarlet has quit [Ping timeout: 268 seconds]
Finnfinn has quit [Quit: The humanity!]
torbo has quit [Remote host closed the connection]
kscarlet has joined #lisp
xkapastel has joined #lisp
ahungry has quit [Remote host closed the connection]
wxie has quit [Quit: wxie]
wxie has joined #lisp
gioyik has quit [Quit: WeeChat 2.6]
Finnfinn has joined #lisp
myrkraverk has joined #lisp
tourjin has quit [Ping timeout: 268 seconds]
32NABJQKY has joined #lisp
<jackdaniel>
alexandria has curry and rcurry
dale has quit [Quit: My computer has gone to sleep]
Kundry_Wag has joined #lisp
Grauwolf_ has joined #lisp
Blkt has quit [Ping timeout: 276 seconds]
fe[nl]ix has quit [Ping timeout: 276 seconds]
Grauwolf has quit [Ping timeout: 276 seconds]
Blkt has joined #lisp
fe[nl]ix has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
vlatkoB has joined #lisp
benjamin-l has quit [Ping timeout: 252 seconds]
dale has joined #lisp
<beach>
Good morning everyone!
orivej has quit [Ping timeout: 252 seconds]
FennecCode has quit [Quit: ERC (IRC client for Emacs 26.2)]
_whitelogger has joined #lisp
<fe[nl]ix>
hi beach
<beach>
fe[nl]ix: Hey. Are you going to ELS2020?
benjamin-l has joined #lisp
<fe[nl]ix>
yes, I'll go to Zurich one week earlier to also help with organizing
<beach>
Excellent!
_whitelogger has joined #lisp
tourjin has joined #lisp
wiselord has joined #lisp
nullniverse has quit [Read error: Connection reset by peer]
nullniverse has joined #lisp
nullniverse has joined #lisp
nullniverse has quit [Changing host]
dddddd has quit [Remote host closed the connection]
rgherdt has joined #lisp
tourjin has quit [Ping timeout: 276 seconds]
slyrus_ has joined #lisp
wxie has quit [Quit: wxie]
wxie has joined #lisp
slyrus has quit [Ping timeout: 268 seconds]
gravicappa has joined #lisp
wxie has quit [Ping timeout: 250 seconds]
ebrasca has joined #lisp
surrounder has quit [Quit: WeeChat 2.4]
kritixilithos has joined #lisp
wxie has joined #lisp
benjamin-l has quit [Quit: WeeChat 2.6]
wxie has quit [Ping timeout: 268 seconds]
Finnfinn has quit [Quit: The humanity!]
karlosz has joined #lisp
Finnfinn has joined #lisp
Necktwi has quit [Ping timeout: 252 seconds]
gareppa has joined #lisp
Finnfinn has quit [Quit: The humanity!]
Finnfinn has joined #lisp
enrioog has joined #lisp
enrio has quit [Ping timeout: 276 seconds]
random-nick has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
random-nick has quit [Ping timeout: 240 seconds]
<smokeink>
http://pastecode.ru/d2d04e/ failed AVER: (SB-C::LEAF-HAS-SOURCE-NAME-P SB-C::LEAF) This is probably a bug in SBCL (1.5.9) itself.
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
<flip214>
UIOP has WITH-TEMPORARY-FILE -- is there some library that has WITH-TEMPORARY-DIRECTORY?
<flip214>
OSICAT-POSIX:MKDTEMP looks like a solution
karlosz has quit [Quit: karlosz]
jonatack has quit [Quit: jonatack]
<flip214>
I found QL-IMPL-UTIL:DELETE-DIRECTORY-TREE. Is there some other function in a library that's very likely to be used already?
stzsch has joined #lisp
Necktwi has joined #lisp
random-nick has joined #lisp
kmeow has joined #lisp
<phoe>
flip214: the best I've found is (uiop:temporary-directory) that returns the base temporary directory to you
<phoe>
you can likely make directories in there yourself and implement your own with-temporary-directory macro on top of that
<phoe>
...if you feel like reimplementing, that is
kmeow has quit [Remote host closed the connection]
Finnfinn has quit [Quit: The humanity!]
Finnfinn has joined #lisp
vaporatorius has quit [Read error: Connection reset by peer]
orivej has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 265 seconds]
enrioog has quit [Ping timeout: 268 seconds]
shka_ has joined #lisp
wxie has joined #lisp
<flip214>
phoe: osicat also has a *temporary-directory*
<flip214>
and yes, I already have such a macro
<flip214>
isn't quite rocket-science, after all ;)
surrounder has joined #lisp
ebzzry_ has joined #lisp
wxie has quit [Ping timeout: 245 seconds]
wxie has joined #lisp
EvW has joined #lisp
Inline has quit [Quit: Leaving]
Inline has joined #lisp
shifty has joined #lisp
gareppa has quit [Ping timeout: 268 seconds]
montxero has joined #lisp
<Xach>
Arrgh. My Quicklisp build computer is now crashing every few days. Time to troubleshoot instead of just restarting it.
<edgar-rft>
Quicklisp has ruined your computer.
wxie has quit [Ping timeout: 250 seconds]
<Xach>
it seems so
kmeow has joined #lisp
<phoe>
crashing, how?
<Xach>
phoe: the machine stops responding to network traffic and cannot be shut down with the hardware acpi shutdown. it has to be force-shutdown and restarted.
<Xach>
i haven't attached a screen and keyboard to see if there's any useful console info yet.
Kundry_Wag has joined #lisp
Finnfinn has quit [Quit: The humanity!]
<phoe>
Xach: that sounds like the thing that's required. This smells of kernel panic or another hardware-induced hang.
Finnfinn has joined #lisp
<phoe>
s/another/some/
<Xach>
very irritating.
<Xach>
i want my hardware to be free of flaws, just like my software
Kundry_Wag has quit [Ping timeout: 252 seconds]
<phoe>
this might already be getting offtopic, but is your CPU Intel-made? /s
wxie has joined #lisp
FreeBirdLjj has joined #lisp
<edgar-rft>
Xach: please tell us when we need to fundraise a new computer for you
wxie has quit [Ping timeout: 268 seconds]
<Xach>
I feel like I need to set things up on The Cloud instead of buying hardware to tinker with any more
<Xach>
As much as I enjoy owning and controlling the Quicklisp hardware
<flip214>
Xach: a serial console might be easier than keyboard+screen
<Xach>
flip214: possibly, though i have a keyboard and screen and do not have a serial console.
kscarlet has quit [Ping timeout: 240 seconds]
<phoe>
Xach: the recent discussions have made me think of setting up some sort of semi-public CI for Common Lisp projects, so one can get their code to build and run its tests on the major operating systems and a series of available implementations.
<phoe>
It would require a considerable amount of hacking, though, plus hardware expenses and licenses for the proprietary operating systems.
<phoe>
And either buying some Apple hardware or deciding to hackintosh in spite of Apple's licenses.
<phoe>
Summing all of that up, I think it would be a substantial investment to set up and then to get someone to maintain the hell out of this while accepting more and more projects to be built there.
<phoe>
Maybe the clnet foundation would be willing to help with that. I don't know, I haven't asked anyone or even shared that full thought with anyone before.
<galdor>
technically you already have multiple CI systems, e.g. Github Actions or CircleCI, depending on what you need
<galdor>
it's really easy to write CircleCI orbs to support multiple CL implementations in an easy way
<galdor>
sourcehut has a lot of potential too
<phoe>
correct, one other way would be to depend on another existing CI service for each project
<phoe>
Travis, CircleCI, sr.ht or anything else
<galdor>
commercial CL vendor could decide to support opensource by providing some kind of special CircleCI account for example, or a collaboration with Drew DeVault for sourcehut
<phoe>
I've already seen Travis configs that allow one to run tests against multiple CL implementations, too
<galdor>
personnally I do not care too much about CI, I can already do that easily, I'm more concerned by the absence of a rebar3-like tool to manage dependency source/versioning on a per-project basis
<galdor>
I'd love to include some non-critical CL tools at work, but the whole "go install quicklisp and run commands in a CL repl" is never going to fly
gaqwas has quit [Ping timeout: 276 seconds]
gaqwas has joined #lisp
scymtym has quit [Ping timeout: 252 seconds]
pbgc has joined #lisp
<Xach>
galdor: qlot does something like that (i don't know what rebar3 is)
rgherdt has quit [Remote host closed the connection]
<phoe>
Xach: rebar3 is a module manager for erlang and other BEAM-based languages like elixir and LFE
<phoe>
and a version manager and a deployment utility at that
<Xach>
ok
rgherdt has joined #lisp
<flip214>
Xach: "easier" as in "only one cable required", but if there's none available, the point is moot
vaporatorius has joined #lisp
ebzzry_ has quit [Ping timeout: 245 seconds]
Inline has quit [Quit: Leaving]
Inline has joined #lisp
wxie has joined #lisp
FreeBirdLjj has quit [Ping timeout: 250 seconds]
EvW has quit [Ping timeout: 250 seconds]
Inline has quit [Quit: Leaving]
Inline has joined #lisp
gaqwas has quit [Ping timeout: 276 seconds]
orivej has quit [Ping timeout: 250 seconds]
shka_ has quit [Ping timeout: 265 seconds]
gravicappa has quit [Ping timeout: 240 seconds]
gravicappa has joined #lisp
wxie has quit [Ping timeout: 245 seconds]
_paul0 has joined #lisp
gabiruh_ is now known as gabiruh
paul0 has quit [Ping timeout: 246 seconds]
hiroaki has joined #lisp
smokeink has quit [Ping timeout: 276 seconds]
scymtym has joined #lisp
EvW1 has joined #lisp
shifty has quit [Ping timeout: 276 seconds]
shifty has joined #lisp
josemanuel has joined #lisp
kmeow has quit [Remote host closed the connection]
drl has joined #lisp
Kundry_Wag has joined #lisp
brettgilio has quit [Ping timeout: 245 seconds]
FreeBirdLjj has joined #lisp
varjag has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
<p_l>
Sourceforge in its heyday had a fleet of machines to make testing across different arches easier
<p_l>
Xach: Do you have your setup documented somewhere?
FreeBirdLjj has quit [Ping timeout: 252 seconds]
<easye>
Neil Lindquist has made a good start to abstracting a generic need to test Lisp on a CI <https://github.com/neil-lindquist/ci-utils/>. I haven't evaluated this yet, but it looks promising.
<easye>
The CLF has long had the intention to "refactor" a given developer's common needs into something reusable and available under gitlab.common-lisp.net
<easye>
From ambiently following phoe's forays on the CI available from gitlab.common-lisp.net in the past week or so, I gather there is a fair amount of work to do.
vaporatorius has quit [Read error: Connection reset by peer]
<phoe>
easye: we'd basically need Windows/Linux/macOS VMs. Given that CI can run foreign code, we'd need some way do dispose of these VMs and create them on the fly - preferably via snapshotted VM states or something similar.
<phoe>
And that already starts being resource-hungry.
<easye>
One idea that the CLF tossed around was getting donations from commercial entities in the Common Lisp space to fund such a generalized CL CI by enticing them with versions that would easily allow a developer to test on a given commercial implementation as well.
pbgc has quit [Quit: Computer has gone to sleep.]
vaporatorius has joined #lisp
<easye>
> we'd basically need Windows/Linux/macOS VMs : I'll bring this up at the monthly CLF meeting this Wednesday to see how we could possibly get such resources abundantly avaialable. One idea might be to approach AWS/Azure/GOOG with a request for donating such services.
<easye>
"donating" in return for publicity.
<boeg>
Anyone here use sly for common lisp in emacs? How do I quit sly without manually killing the buffers? Like a quit command that brings things down and removes buffers and so on
<beach>
I don't know sly, but with SLIME it is ",quit".
gravicappa has quit [Ping timeout: 265 seconds]
gravicappa has joined #lisp
<boeg>
beach: when I type , it shows a "command" with commands available like disconnect and clear, no quit though. Does ",quit" also clean up buffers or just close connections?
<boeg>
it shows it down in the line in the bottom of emacs, i forgot what its called
<beach>
It doesn't close buffers containing source code.
<boeg>
no, i mean the sly buffers - like the repl, buffer with previous errors and so on
<beach>
It does close the REPL buffer.
<beach>
I mean, it removes it.
<phoe>
easye: that sounds good. Please do. I could try setting these up in some way.
EvW1 has quit [Ping timeout: 252 seconds]
<boeg>
hmm, alright. I've tried the sayoonara command, the disconnect-all command and they just seems to close connectins to the underlying sbcl, but does clean up the compilation buffer and repl and so on
<easye>
phoe: cool, I'll let you know more when I do.
<phoe>
easye: note that this would allow to have a kinda-centralized CI for CL projects - Quicklisp could use it during its build process to build and run tests on multiple OSes/implementations, for example.
raghavgururajan has joined #lisp
<easye>
Yeah, ideally we could merge the cl-test-grid style reports on top.
<phoe>
yesssssss. That would be ideal.
pbgc has joined #lisp
mrcom has quit [Read error: Connection reset by peer]
montxero has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 268 seconds]
dddddd has joined #lisp
raghavgururajan has quit [Read error: Connection reset by peer]
32NABJQKY has quit [Ping timeout: 250 seconds]
Blukunfando has quit [Ping timeout: 268 seconds]
mrcom has joined #lisp
Oladon has joined #lisp
gaqwas has joined #lisp
brettgilio has joined #lisp
trittweiler has joined #lisp
lnostdal has quit [Quit: "Fascism, Nazism, Communism and Socialism are only superficial variations of the same monstrous theme—collectivism." -- Ayn Rand]
EvW has joined #lisp
bitmapper has joined #lisp
_whitelogger has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
kritixilithos has quit [Remote host closed the connection]
kritixilithos has joined #lisp
17SAA8HAV has joined #lisp
dxtr has quit [Ping timeout: 240 seconds]
trittweiler has joined #lisp
<ebrasca>
What is this CLD for?
<beach>
ebrasca: It says so on the web page.
<ebrasca>
beach: I have read it. Can they be trusted?
<beach>
Definitely.
nowhere_man has quit [Ping timeout: 246 seconds]
aindilis has quit [Read error: Connection reset by peer]
aindilis has joined #lisp
trittweiler has quit [Ping timeout: 268 seconds]
varjag has quit [Ping timeout: 268 seconds]
Cymew has joined #lisp
Grauwolf_ has quit [Quit: WeeChat 2.5]
Grauwolf has joined #lisp
Grauwolf has quit [Client Quit]
Grauwolf has joined #lisp
Grauwolf has quit [Changing host]
Grauwolf has joined #lisp
raghavgururajan has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
aindilis has quit [Read error: Connection reset by peer]
maxxcan has joined #lisp
aindilis has joined #lisp
Lord_of_Life_ has joined #lisp
vaporatorius has quit [Ping timeout: 268 seconds]
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
aindilis has quit [*.net *.split]
dddddd has quit [*.net *.split]
hiroaki has quit [*.net *.split]
_paul0 has quit [*.net *.split]
stzsch has quit [*.net *.split]
srji has quit [*.net *.split]
beach has quit [*.net *.split]
shaakyamuni[m] has quit [*.net *.split]
akanouras has quit [*.net *.split]
Nistur has quit [*.net *.split]
jdz has quit [*.net *.split]
cmatei has quit [*.net *.split]
X-Scale has quit [*.net *.split]
rixard has quit [*.net *.split]
hiredman has quit [*.net *.split]
creat has quit [*.net *.split]
leo_song has quit [*.net *.split]
heredoc has quit [*.net *.split]
mjsir911 has quit [*.net *.split]
dvdmuckle has quit [*.net *.split]
sbryant has quit [*.net *.split]
kqr has quit [*.net *.split]
emacsomancer has quit [*.net *.split]
fowlduck has quit [*.net *.split]
jsatk has quit [*.net *.split]
theBlackDragon has quit [*.net *.split]
newcup has quit [*.net *.split]
mfiano has quit [*.net *.split]
jackhill has quit [*.net *.split]
simplegauss has quit [*.net *.split]
trn has quit [*.net *.split]
stylewarning has quit [*.net *.split]
johs has quit [*.net *.split]
asedeno has quit [*.net *.split]
gendl has quit [*.net *.split]
drmeister has quit [*.net *.split]
chewbranca has quit [*.net *.split]
tazjin has quit [*.net *.split]
jhei has quit [*.net *.split]
gingerale has quit [*.net *.split]
p_l has quit [*.net *.split]
parisienne has quit [*.net *.split]
<Josh_2>
Can I convert an instance of a classes superclass into that class? I have a superclass called packet, can I instantiate that and then later convert it into an instance of class kill-packet which inherits from packet?
aindilis has joined #lisp
hiroaki has joined #lisp
_paul0 has joined #lisp
Nistur has joined #lisp
trn has joined #lisp
shaakyamuni[m] has joined #lisp
mjsir911 has joined #lisp
X-Scale has joined #lisp
jdz has joined #lisp
cmatei has joined #lisp
hiredman has joined #lisp
creat has joined #lisp
rixard has joined #lisp
leo_song has joined #lisp
sbryant has joined #lisp
emacsomancer has joined #lisp
heredoc has joined #lisp
dvdmuckle has joined #lisp
fowlduck has joined #lisp
kqr has joined #lisp
theBlackDragon has joined #lisp
jsatk has joined #lisp
newcup has joined #lisp
mfiano has joined #lisp
simplegauss has joined #lisp
jackhill has joined #lisp
drmeister has joined #lisp
stylewarning has joined #lisp
johs has joined #lisp
srji has joined #lisp
stzsch has joined #lisp
beach has joined #lisp
akanouras has joined #lisp
dddddd has joined #lisp
gendl has joined #lisp
chewbranca has joined #lisp
asedeno has joined #lisp
gingerale has joined #lisp
parisienne has joined #lisp
tazjin has joined #lisp
jhei has joined #lisp
p_l has joined #lisp
jsatk has quit [Max SendQ exceeded]
creat has quit [Max SendQ exceeded]
emacsomancer has quit [Max SendQ exceeded]
creat has joined #lisp
emacsomancer has joined #lisp
mfiano2 has quit [Remote host closed the connection]
jsatk has joined #lisp
X-Scale has quit [Ping timeout: 246 seconds]
mfiano2 has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
<phoe>
Josh_2: smells like CHANGE-CLASS
<Josh_2>
Well I suppose that'll be it then
<Josh_2>
Works perfectly. Thanks phoe :)
X-Scale has joined #lisp
brown121407 has joined #lisp
17SAA8HAV has quit [Ping timeout: 240 seconds]
slyrus__ has joined #lisp
Kundry_Wag has joined #lisp
<phoe>
don't abuse it
<phoe>
it's a powerful tool
<phoe>
when you create any Lisp object, usually its type stays the same throughout its whole lifetime
<phoe>
and CHANGE-CLASS is a way to change this state of matters
slyrus_ has quit [Ping timeout: 265 seconds]
Kundry_Wag has quit [Client Quit]
vaporatorius has quit [Read error: Connection reset by peer]
maxxcan has quit [Quit: maxxcan]
raghavgururajan has quit [Remote host closed the connection]
<Shinmera>
Obviously if you change instances you do not control that's bad, but that goes for changing slot values too, not just changing class.
<phoe>
basically, this is a way to defeat type safety in Lisp, since an object can stop being of a particular type because you executed some code on it
<phoe>
yes, correct
brown121408 has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
dxtr has joined #lisp
scymtym has quit [Ping timeout: 250 seconds]
clothespin has quit [Ping timeout: 268 seconds]
aindilis has quit [Read error: Connection reset by peer]
<_death>
(let ((x 5)) (assert (> x 3)) (setf x -123))
<phoe>
_death: I meant the actual object, not a variable
<phoe>
or a variable binding
<_death>
the issue with change-class is that it can be slow, and sometimes it is a sign of unoptimal design.. it may also have issues with multithreading
shka_ has joined #lisp
aindilis has joined #lisp
<Shinmera>
any object change will have multithreading problems.
clothespin has joined #lisp
<_death>
yeah, but there's more familiarity with using locks or atomics when it comes to modifying slots than when it comes to change-class..
<jeosol>
Good morning
vaporatorius has joined #lisp
<_death>
when you need change-class, however, it's really great that it's there :)
<jeosol>
I have a question related to deployment and commercialization of lisp apps, e.g., protecting exe (?), do it as API calls. Or it's a lot of work.
<jeosol>
To give an example, imagine, applications that people spend time to assemble, and that requires deep domain expertise, and I want to package them as exes (simplest option) or expose some API for it
Oladon has quit [Quit: Leaving.]
clothespin has quit [Ping timeout: 252 seconds]
<mister_m>
does common lisp have a flatMap analog?
<phoe>
mister_m: give an example?
brown121408 has quit [Ping timeout: 246 seconds]
<phoe>
you have an array of some stuff and you want to apply a function on each element and get a new array?
<Josh_2>
yes you pass an empty array the same length as the sequences you pass
<mister_m>
for context I have a list of directories I want to "map" to a list of files in those directories, then just flatten the nested list. I _think_ I can do that by reducing with #'append.
<phoe>
alexandria:mappend would be the way to go
<phoe>
you don't need to reduce if each directory can be processed separately
<phoe>
but if the created lists are fresh, you should be able to use mapcan
wiselord has quit [Read error: Connection reset by peer]
jjkola has quit [Quit: Ex-Chat]
wiselord has joined #lisp
random-nick has quit [Ping timeout: 265 seconds]
random-nick has joined #lisp
Inline has quit [Quit: Leaving]
lucasb has joined #lisp
torbo has joined #lisp
mathrick has quit [Read error: Connection reset by peer]
brown121407 has quit [Read error: Connection reset by peer]
brown121408 has joined #lisp
random-nick has joined #lisp
trittweiler has quit [Ping timeout: 265 seconds]
Bike has joined #lisp
josemanuel has quit [Quit: leaving]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
shifty has quit [Ping timeout: 268 seconds]
shka_ has quit [Ping timeout: 265 seconds]
shka_ has joined #lisp
dddddd has quit [Ping timeout: 246 seconds]
xuxuru has joined #lisp
gravicappa has quit [Ping timeout: 265 seconds]
scymtym has joined #lisp
EvW has joined #lisp
maxxcan has quit [Quit: maxxcan]
bitmapper has joined #lisp
xuxuru has quit [Quit: xuxuru]
random-nick has quit [Ping timeout: 240 seconds]
vlatkoB has quit [Remote host closed the connection]
pbgc has quit [Quit: Computer has gone to sleep.]
pbgc has joined #lisp
<slyrus__>
happy new month everyone
<slyrus__>
<funny beginning of the month debugging story follows...>
<slyrus__>
anyone ever have code that stopped working on December 1st?
<slyrus__>
all of sudden some code that used to work started throwing an error about 12 being an invalid index for a (SIMPLE-VECTOR 12). I suppose I should have guessed what was going on right away.
<_death>
is it about 1-based vs. 0-based?
<slyrus__>
Heh.
<slyrus__>
Turns out decoded time months are 1-based. Oops.
<_death>
we should return to old times, where names meant something and december was the tenth month
<slyrus__>
So (elt 9 ...)?
<_death>
your error would be postponed to february :)
<_death>
was the workaround to increase vector size by 1? or to change indices?.. if the former, hope there's no modular arithmetic
Blukunfando has joined #lisp
<slyrus__>
subtract one from the month when indexing the array of month names
pbgc has quit [Quit: Computer has gone to sleep.]
<_death>
hmm, so the month name was wrong all this time?
random-nick has joined #lisp
<vsync>
slyrus__: hehehheh
<vsync>
I wish there was an easy way built-in to have arrays with custom indexing
Oladon has joined #lisp
<_death>
that would drive people insane :)
<vsync>
wow, just realized you're not even allowed to have a negative displaced-index-offset
<slyrus__>
_death: yeah, that's what I get for using some random library on github :)
<vsync>
imagine if in our calendaring for some reason we kept the numbers associated with names like "tenth month" and indexed the rest chronologically
<vsync>
so one would actually write "2019-10-01" for today; july and august would end up as 11 and 12
<vsync>
it technically makes perfect sense
<_death>
sense? it's just the long painful history of time
<Bike>
"why isn't october the eighth month? i wish the guy who made it the tenth got stabbed" "Good news!"
<pjb>
slyrus__: In Pascal, you would define an enum january .. december, and use it to index the array. In CL, you could use keywrods and a hash-table…
<pjb>
Bike: because the guy who named it was a Roman, and Romans started they year in March. But then Christians came and started it in January.
<nirved>
for something small alist might be better than hash-table
<pjb>
Bike: become world dictator, and set the start of the year to your birth month for fun!
slyrus has joined #lisp
slyrus__ has quit [Ping timeout: 268 seconds]
random-nick has quit [Read error: Connection reset by peer]
pbgc has joined #lisp
aamukastemato has joined #lisp
<vsync>
Bike: lol
grobe0ba_ is now known as grobe0ba
random-nick has joined #lisp
varjag has joined #lisp
<vsync>
stupid date/array tricks: (let ((year (make-array '(52 7) :initial-element nil))) (dotimes (month 12 year) (map-into (make-array 30 :displaced-to year :displaced-index-offset (* month 30)) (constantly (elt #(jan feb mar apr may jun jul aug sep oct nov dec) month)))))
<vsync>
wasn't there a proposal to do that and have a big festival with those extra days?
<vsync>
"don't you hate that there are so many calendar systems? good news, everyone!"
dddddd has joined #lisp
<_death>
the whole purpose of moving the leap day around was so that people celebrate less and work more.. and your calendar adds FOUR nil days
<_death>
but it would make for a simpler doomsday rule..
cosimone has joined #lisp
<aeth>
Shinmera, _death: The problem with change-class here is that the one reference where you're changing the class might not be the only reference. Especially not related to _death's example where you're setf'ing x, not changing the value of 5 into -123. It'd be more like (setf (aref x) -123) there.
<_death>
aeth: change-class preserves identity
<aeth>
In particular, you could have objects that use the MOP to enforce constraints about the information that can be stored in the object. Obviously, the compiler won't trust that because of things like change-class, but the user might.
<aeth>
Imagine having a class that restricts x to plusp via a check on all sets to the slot, which is afaik bulletproof except for change-class.
<aeth>
(Maybe it can also be bypassed by the debugger, not sure.)
cosimone has quit [Remote host closed the connection]
<_death>
I'm not sure I understand the scenario you're describing..
<_death>
ok, but you change-class to a different class..
<aeth>
I did this because more than half of my docstrings for slots were basically expressable as types, although since that apparently requires ASSERT instead of CHECK-TYPE (since the type isn't known at compile time) you could assert basically anything.
<aeth>
_death: Right. So let's say you enforce a PLUSP on slot x via the MOP. That enforcement can be completely broken by CHANGE-CLASS afaik. In another thread, too.
<_death>
you mean converting a non-checked object to a checked object?
<_death>
but there is an issue.. if update-instance-for-different-class signals an error, what is the state of the object? it's already of the target class, and the discarded slots are nowhere to be found.. maybe a change-class wrapper would do.. this suggests a more elaborate protocol
<Xach>
it has saved me many days of failing to make it, probably!
EvW1 has joined #lisp
<_death>
cool.. does the author know how to submit to quicklisp?
<_death>
maybe it's not ready for prime-time yet.. encode->image is not exported
<Xach>
I don't know. There's no license info in the source that I can find.
<Xach>
I'd like to modify it to just return the 2d bitmap so I can draw it however I please, but that will have to wait for license info
<_death>
good idea
aindilis has quit [Read error: Connection reset by peer]
<_death>
oh well, tried to read the QR code with google goggles, but apparently they disabled it with only a link to google lens.. the store page for it tells me it's not compatible with my device.. hooray. but at least I came up with a new Bruce Schneier fact: Bruce Schneier can not only decode QR codes with his eyes, but also encode them
aindilis has joined #lisp
techquila has joined #lisp
<Xach>
my test code worked for me on my phone
Oladon has quit [Quit: Leaving.]
wiselord has quit [Read error: Connection reset by peer]
wiselord has joined #lisp
X-Scale has joined #lisp
Oladon has joined #lisp
<p_l>
some phones have built-in readers
<Xach>
iphone among them
<p_l>
dunno, I keep away from that brand unless forced by work
* p_l
looks at ~$3100 used MBP he was forced to buy recently :|
varjag has quit [Remote host closed the connection]
<vsync>
is there a good acronym for "concatenate"?
<grewal_>
cat?
<ebrasca>
vsync: concat?
<ebrasca>
Like from concat-symbols
<antoszka>
cnctnt
<antoszka>
rplacd-style
<antoszka>
:)
dmc00 has quit [Remote host closed the connection]
pfdietz has joined #lisp
<ebrasca>
Why cl don't have consistent naming?
<LdBeth>
It depends on what is the criteria for consistent
<fengshaun>
I remember there was something like `let/let*` but for functions
<mfiano>
flet/labels
<fengshaun>
I don't remember the name
<LdBeth>
flet
<fengshaun>
nice, thanks
<mfiano>
labels is a bit different than let* though...not an complete parallel
<mfiano>
such as, earlier labels can call later ones
<no-defun-allowed>
It is foremost a "common" language that's made of several somewhat incompatible Maclisp dialects (and Scheme if you check the CLTL1 cover).
<aeth>
ebrasca: CL conventions are mostly consistent, but it has to maintain almost complete compatibility with legacy Lisp, which can date to the 1960s/1970s.
<fengshaun>
mfiano, labels binds can call earlier binds, right?
<fengshaun>
I should just test it
<fengshaun>
thanks
<mfiano>
yes
<aeth>
ebrasca: Some of the older functions like rplacd were probably from systems with character limits
<aeth>
You see this a lot more in C
<LdBeth>
Probably not C but APL
<LdBeth>
IBM 360 stuff
<ebrasca>
Maybe it is time to make new common lisp. (NCL)
<nirved>
vsync: conc
<LdBeth>
But what can be the benefit by renaming a few functions
<aeth>
ebrasca: Scheme does update some of the naming, e.g. set-cdr! instead of rplacd. It goes too far, though, and in some cases it's actually a disadvantage, because it replaced MAPCAR with map, leaving map as a list-specific procedure, unlike CL's MAP function because CL had the name available.
<ebrasca>
LdBeth: It is going to have more consistent naming.
<aeth>
LdBeth: Function argument order is arguably more important to be consistent because it makes things more easily guessable. e.g. for accessing an item, you need to put the index/key/etc. second so you can have AREF's arbitrary indicies, e.g. (aref foo) (aref foo 1) (aref foo 1 2) ...
<ebrasca>
I think consistent is important.
<aeth>
LdBeth: All new functions are in AREF's order, but a lot of the old ones aren't, like NTH
<pfdietz>
"A foolish consistency is the hobgoblin of little minds." -- Emerson
<LdBeth>
Well the better thing is use the definition as the function name
<nirved>
CL has just the right consistency
gabiruh has quit [Ping timeout: 276 seconds]
<LdBeth>
Which can only be practically done in a very terse language though
marusich has quit [Ping timeout: 245 seconds]
<ebrasca>
pi is constant but it is not +pi+
<aeth>
LdBeth: I like that CL is the opposite of terseness. Very little of the naming changes made in Clojure actually improve things. I mean, sure, certain things like aref and + are good as short names, but most things don't have to be that short. If DEFUN was DEFINE-FUNCTION, things wouldn't be that bad.
<no-defun-allowed>
aeth: I don't think APROPOS would work so well with shortened names.
<aeth>
What's good about traditional Lisps including CL and Scheme is that they're concise at a syntactic token level but not at an absolute character level. So the names tend to be longer and meaningful, but replace foo-bar-baz with µ or whatever and you can see just how concise Lisps really are.
<aeth>
But don't actually use µ in your code.
<LdBeth>
Just get cozy with Hungarian notation :)
* no-defun-allowed
defenestrates LdBeth
<Josh_2>
I honestly like the long names, and I like giving my functions and my variables descriptive names
<aeth>
Names should only be short if they're frequently used and intended to be used "inline", like AREF and +. So vec+ is probably better than vector-add, but for the most part, your names should be pretty long.
<no-defun-allowed>
I didn't choose the update-system-for-new-interesting-object-predicate life, the update-system-for-new-interesting-object-predicate life chose me.
<Josh_2>
^ this exactly :D
<aeth>
hmm, I described that poorly, perhaps I should say "in one line"
<aeth>
no-defun-allowed: at least that isn't in CamelCase
libertyprime has joined #lisp
<LdBeth>
Unfortunately I see why people get used to x y z I j k a b c
<fengshaun>
where does one get a human-readable overview of all `loop` keywords and how they fit together?
<fengshaun>
it looks like an untamable beast
<aeth>
LdBeth: The only reason you should use single character names (except perhaps i, j, k, ..., for iterating) is if you're doing mathematics/physics and that's the most clear name for the variable you're using. It's kind of unfortunate that "t" is taken since it shows up all of the time.
<aeth>
I often use "u" or "t*" instead of "t" there.
<LdBeth>
Sometimes they just give up spend brain juice on inventing meaningful names
<nirved>
recently someone was using := and :+ for setf and incf, but I find it slower to type
<ebrasca>
aeth: t for time
<aeth>
ebrasca: Eh, talk to a computer scientist or a physics and they might say "t for time" is accurate. Talk to a mathematician working with the same differential equations sort of stuff and they will tell you that "t" absolutely is just a meaningless character and not necessarily "time"
<aeth>
s/a physics/a physicist/
<LdBeth>
nirved: that’s because : needs a shift key press, assuming you are using US keyboard layout
<aeth>
I do sometimes substitute in "time", of course, but for the most general stuff like an RK4 implementation, "t" is absolutely not necessarily just time.