<zovt>
hello, has anyone here got any experience getting SLIME/Sly set up to include packages from qlot?
alexanderbarbosa has quit [Remote host closed the connection]
<zovt>
been messing around with it with no luck
<dlowe>
wow, antik's date-time stuff is nice
ivansviatenko has quit [Read error: Connection reset by peer]
Oladon has joined #lisp
jack_rabbit_ has quit [Ping timeout: 250 seconds]
noark9 has joined #lisp
kwhalekiller has joined #lisp
kwhalekiller is now known as Guest40463
libertyprime has quit [Quit: leaving]
Guest40463 has quit [Client Quit]
noark9 has quit [Quit: noark9]
GoldRin has quit [Remote host closed the connection]
GoldRin has joined #lisp
astronavt has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
astronavt has joined #lisp
vutral- has joined #lisp
libertyprime has joined #lisp
slightlycyborg has joined #lisp
count3rmeasure has quit [Quit: Leaving]
slightlycyborg has quit [Ping timeout: 245 seconds]
slightlycyborg has joined #lisp
torbo has joined #lisp
Lycurgus has quit [Quit: Exeunt]
semz has quit [Ping timeout: 264 seconds]
ebrasca has quit [Remote host closed the connection]
<pjb>
zovt: I fail to see what relationship there may be between slime and qlot.
<pjb>
(or slime and quicklisp at that).
<zovt>
pjb: something seems to be going wrong when running slime, but it's probably on my end. Was hoping that I could have the qlot packages loaded automatically and made available to slime
<zovt>
but no worries, a bit more manual set up
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
Oladon has quit [Quit: Leaving.]
GoldRin has quit [Ping timeout: 248 seconds]
t58 has quit [Quit: Night]
<pjb>
zovt: again, you have some misconception. Slime is an emacs lisp body of code. qlot is a Common Lisp library manager. qlot cannot provide anything to slime, since they are not in the same universe!
dmiles has quit [Ping timeout: 245 seconds]
dmiles has joined #lisp
Frobozz_ has joined #lisp
Frobozz has quit [Ping timeout: 245 seconds]
orivej has quit [Ping timeout: 245 seconds]
slightlycyborg has quit [Ping timeout: 248 seconds]
slightlycyborg has joined #lisp
ltriant has quit [Ping timeout: 272 seconds]
EvW has quit [Ping timeout: 250 seconds]
quazimodo has quit [Ping timeout: 258 seconds]
slightlycyborg has quit [Ping timeout: 245 seconds]
slightlycyborg has joined #lisp
Josh_2 has quit [Remote host closed the connection]
mindthelion has joined #lisp
<LdBeth>
pjb: zovt probably means to have qlot quickloaded whenever a SLIMR repl starts
<zovt>
would have helped if I read that before I wasted an hour tinkering :)
techquila has quit [Ping timeout: 264 seconds]
<LdBeth>
GG
slightlycyborg has quit [Ping timeout: 246 seconds]
slightlycyborg has joined #lisp
slightlycyborg has quit [Ping timeout: 272 seconds]
<mfiano>
also note that since it effectively places quicklisp-fetched systems and places them relative to your project, you often times get into a state where you are working on a non-qlot project and it is loading systems from the sub-path under the qlot-enabled project, since both are in your asdf central registry. qlot is loaded with bugs, but this behavior takes the cake.
vaporatorius has quit [Ping timeout: 246 seconds]
ltriant has joined #lisp
GoldRin has joined #lisp
<zovt>
mfiano: is there a sane alternative to it if I want to distribute a project with source code but not the libraries it depends on?
<mfiano>
yes, quicklisp
<zovt>
doesn't that require that the user has installed the libraries prior to working on the project?
<zovt>
I guess it's no different from C or something in that sense
<mfiano>
no
<zovt>
hmmm ok, will play around with it some more
<zovt>
thanks for the heads up, will cut qlot
dale has quit [Quit: My computer has gone to sleep]
ltriant has quit [Ping timeout: 245 seconds]
remexre has joined #lisp
GoldRin has quit [Ping timeout: 248 seconds]
akoana has left #lisp ["Leaving"]
CloseToZero has joined #lisp
CrazyEddy has quit [Ping timeout: 268 seconds]
CrazyEddy has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
ltriant has joined #lisp
CrazyEddy has joined #lisp
_whitelogger has joined #lisp
gravicappa has joined #lisp
scymtym has joined #lisp
zovt has quit [Remote host closed the connection]
Bike has quit [Quit: Lost terminal]
jeosol has joined #lisp
<jeosol>
good morning
<LdBeth>
Morning jeosol
torbo has quit [Remote host closed the connection]
dddddd has quit [Remote host closed the connection]
Arcaelyx has quit [Quit: Arcaelyx]
shka_ has joined #lisp
LdBeth has quit [Changing host]
LdBeth has joined #lisp
LdBeth has joined #lisp
<beach>
Good morning everyone!
Inline has quit [Quit: Leaving]
alexanderbarbosa has joined #lisp
shka_ has quit [Ping timeout: 258 seconds]
<jeosol>
Morning beach
shka_ has joined #lisp
ggole has joined #lisp
sonologico has quit [Remote host closed the connection]
quazimodo has joined #lisp
GoldRin has joined #lisp
quazimodo has quit [Ping timeout: 258 seconds]
quazimodo has joined #lisp
SaganMan has joined #lisp
shka_ has quit [Ping timeout: 245 seconds]
seteeri has joined #lisp
seteeri has left #lisp [#lisp]
quazimodo has quit [Ping timeout: 248 seconds]
quazimodo has joined #lisp
flamebeard has joined #lisp
kushal has quit [Excess Flood]
kushal has joined #lisp
frgo has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
kazinator has left #lisp ["WeeChat 0.3.7"]
schweers has joined #lisp
FennecCode has quit [Quit: ERC (IRC client for Emacs 26.2)]
jprajzne has joined #lisp
ebrasca has joined #lisp
krwq has joined #lisp
quazimodo has quit [Ping timeout: 244 seconds]
quazimodo has joined #lisp
orivej has joined #lisp
count3rmeasure has joined #lisp
quazimodo has quit [Ping timeout: 246 seconds]
milanj has joined #lisp
ltriant has quit [Quit: leaving]
Ricchi has quit [Remote host closed the connection]
jeosol has quit [Remote host closed the connection]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 272 seconds]
vlatkoB has joined #lisp
khisanth_ has quit [Ping timeout: 245 seconds]
khisanth_ has joined #lisp
stepnem_ has joined #lisp
stepnem has quit [Ping timeout: 272 seconds]
mathrick has quit [Ping timeout: 250 seconds]
varjag has joined #lisp
mathrick has joined #lisp
frgo_ has quit [Ping timeout: 272 seconds]
heisig has joined #lisp
oni-on-ion has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
mindthelion has quit [Read error: Connection reset by peer]
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
manualcrank has quit [Quit: WeeChat 1.9.1]
mindthelion has joined #lisp
techquila has quit [Ping timeout: 276 seconds]
techquila has joined #lisp
mindthelion has quit [Ping timeout: 248 seconds]
Frobozz_ is now known as Frobozz
frgo has joined #lisp
techquila has quit [Ping timeout: 245 seconds]
techquila has joined #lisp
Lord_of_Life has quit [Ping timeout: 248 seconds]
mindthelion has joined #lisp
Lord_of_Life has joined #lisp
techquila has quit [Ping timeout: 276 seconds]
cosimone has joined #lisp
hhdave has joined #lisp
igemnace_ has joined #lisp
igemnace has quit [Ping timeout: 245 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
SaganMan has quit [Quit: WeeChat 1.6]
igemnace_ is now known as igemnace
Necktwi has joined #lisp
remexre has quit [Quit: WeeChat 2.4]
krwq has quit [Remote host closed the connection]
remexre has joined #lisp
stepnem_ has quit [Ping timeout: 248 seconds]
stepnem has joined #lisp
amerlyq has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
remexre has quit [Quit: WeeChat 2.4]
bg52 has joined #lisp
dpl has joined #lisp
bg52 has quit [Ping timeout: 260 seconds]
Necktwi has quit [Ping timeout: 268 seconds]
libertyprime has quit [Ping timeout: 268 seconds]
Necktwi has joined #lisp
patrixl has quit [Remote host closed the connection]
pfdietz has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
frgo has quit [Ping timeout: 268 seconds]
Guest74056 has joined #lisp
<Guest74056>
quit
Guest74056 has quit [Client Quit]
milanj has joined #lisp
michalisko has quit [Ping timeout: 272 seconds]
michalisko has joined #lisp
EvW has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
dddddd has joined #lisp
maxxcan has joined #lisp
maxxcan has quit [Client Quit]
scymtym has quit [Ping timeout: 248 seconds]
zhlyg has joined #lisp
amerlyq has quit [Quit: amerlyq]
orivej has joined #lisp
jxy has quit [Read error: Connection reset by peer]
jxy has joined #lisp
libertyprime has quit [Ping timeout: 244 seconds]
libertyprime has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
t58 has joined #lisp
vaporatorius has joined #lisp
Bike has joined #lisp
Josh_2 has joined #lisp
fivo has joined #lisp
cosimone has joined #lisp
<alexanderbarbosa>
i dont think that packages should rely on posix locations of system binaries as /bin/xxx or /usr/bin/xxx
<alexanderbarbosa>
I had to add an symlink to uname to /bin/uname so dexador works
<alexanderbarbosa>
ive some relying on posix pwd position.... damn
<alexanderbarbosa>
s/position/location
<p_l>
alexanderbarbosa: well, you could propose patches to the specific packages
<alexanderbarbosa>
p_l: I will, at weekends :D
<p_l>
I've been thinking of maybe making a library to help that kind of issues, especially finding dynamic libraries
<alexanderbarbosa>
p_l: that would be awesome...
pfdietz has joined #lisp
<alexanderbarbosa>
software world have changed, there are people that rely on local buildings rather than system binaries as the late might be not updated enough
<p_l>
also I'm working on "application framework", which handles various common features in modular way
<LdBeth>
Why not use logical pathname :P
<p_l>
LdBeth: apart from logical pathnames having issues, I was actually thinking of my framework setting a bunch of them up in reliable way
cosimone has quit [Ping timeout: 264 seconds]
cosimone has joined #lisp
jmercouris has joined #lisp
<LdBeth>
p_l: I think CFFI provides a place to add place to looking for dylibs
milanj has quit [Quit: This computer has gone to sleep]
<p_l>
CFFI often is the source of problems, as people hardcode things like expecting "dylib" as extension
<LdBeth>
And the user can also set a UNIX environment variable for that
<LdBeth>
Oh. That’s an even common thing in other languages
EvW has quit [Ping timeout: 250 seconds]
catchme has joined #lisp
cosimone has quit [Ping timeout: 264 seconds]
<LdBeth>
But even things like logical pathname are provided, people always hard code things
LiamH has joined #lisp
<pjb>
)-,;
oni-on-ion has joined #lisp
cosimone has joined #lisp
<astronavt>
"use a reasonable default and let the OS package manager fix it" is a common strategy
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
<p_l>
that requires the package to be packaged and overridable easily
<pfdietz>
Whenever I've tried using LPNs it's ended in pain. I shy away from them now.
FreeBirdLjj has joined #lisp
dplan has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
FreeBirdLjj has quit [Ping timeout: 246 seconds]
lucasb has joined #lisp
igemnace has joined #lisp
milanj has joined #lisp
shka__ has quit [Ping timeout: 245 seconds]
<ebzzry>
Is there a mature Java interop on SBCL?
shka__ has joined #lisp
<jmercouris>
ebzzry: I don't think there is any Java interop on SBCL
<minion>
jmercouris, memo from pjb: I would say that it depends on how many such strings you have in your sources. If only one or two #.(format …) will be ok. Otherwise the specific reader macro is indicated. You can use another character than #\", eg. #\« … #\» or #\[ #\]
<jmercouris>
pjb: then you will have an issue of indentation by emacs!
<jmercouris>
ebzzry: what about ABCL?
cosimone has quit [Quit: WeeChat 2.4]
<p_l>
pfdietz: I was thinking of doing it like SBCL does it
<p_l>
pfdietz: as aliases
gareppa has joined #lisp
jmercouris has quit [Ping timeout: 244 seconds]
remexre has joined #lisp
gareppa has quit [Remote host closed the connection]
jmercouris has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
heisig has quit [Quit: Leaving]
saravia has joined #lisp
saravia has quit [Remote host closed the connection]
Oladon_work has joined #lisp
mindCrime has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
dplan has quit [Quit: dplan]
libertyprime has quit [Remote host closed the connection]
smazga has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
shka_ has joined #lisp
scymtym has joined #lisp
flamebeard has quit []
aoeu256 has joined #lisp
dpl has quit [Read error: Connection reset by peer]
edgar-rft has quit [Quit: Leaving]
jprajzne has quit [Quit: Leaving.]
cosimone has joined #lisp
sammich has quit [Quit: No Ping reply in 180 seconds.]
schweers has quit [Ping timeout: 250 seconds]
sammich has joined #lisp
jmercouris has quit [Ping timeout: 246 seconds]
rippa has joined #lisp
jmercouris has joined #lisp
kajo has joined #lisp
ggole has quit [Remote host closed the connection]
ggole has joined #lisp
ebrasca has quit [Ping timeout: 245 seconds]
frgo has joined #lisp
ebrasca has joined #lisp
zhlyg has quit [Ping timeout: 244 seconds]
varjag has joined #lisp
jmercouris has quit [Remote host closed the connection]
wigust- has joined #lisp
mkrauss has joined #lisp
wigust has quit [Ping timeout: 248 seconds]
amerlyq has joined #lisp
<mkrauss>
Hello... Having trouble getting registered on gitlab.common-lisp.net - I've seen the instructions at https://common-lisp.net/registration but that is not my situation. I tried to log in with my github account (mkrauss) and it said my account is blocked, which was surprising as I'm pretty sure I've never signed into gitlab.common-lisp.net before, and wouldn't do anything to get blocked if I had... So I tried to make
<mkrauss>
a new account (mkrauss) and it said that it already exists - possibly because of the attempt to sign in with my gitlab? Anybody here able to help?
<mkrauss>
Or should I just make a new accound with a diferent name? (Already started that)
manualcrank has joined #lisp
<pjb>
You're surprised. But what would you say is the probability that amongst the 10 billions human being alive, there's one another whose nickname is mkrass too?
mkrauss has quit [Ping timeout: 264 seconds]
xkapastel has joined #lisp
<amerlyq>
And... here I am. Hi there ヽ(・∀・)ﾉ . I have a wish to use standalone Lisp scripts in similar way I use filters written in perl/python/bash. Shebang with SBCL works OK until it's self-sufficient. But I'm in deep trouble trying to add "cl-ppcre" into it. I tried Quicklisp, I tried Roswell, tried embedding ASDF into script itself -- but everything feels... unnatural. What is recommended way here?
kilimanjaro has quit [Ping timeout: 252 seconds]
iovec has joined #lisp
<pjb>
amerlyq: you may consider cl-launch, but since it pre-compile the code, it loses the script aspect of your source. For this reason, I abandonned the idea of writing scripts. Instead, I write lisp programs and compile them. For all those little "script"-like or one-liners, I just put them all in a single program, and symlink to it.
<pjb>
amerlyq: otherwise, you can just do (load #P"~/quicklisp/setup.lisp") (ql:quickload :cl-ppcre) (ppcre:scan "foo" "bar")
<pjb>
amerlyq: notice that you are expecting quicklisp to be installed in the user of the script, which is not a good idea.
Tristam has quit [Excess Flood]
Tristam has joined #lisp
<pjb>
amerlyq: so you should rather install quicklisp in /usr/share/your-script/quicklisp and /usr/local/bin/your-script should load /usr/share/your-script/quicklisp/setup.lisp instead.
jerme_ has quit [Ping timeout: 276 seconds]
<pjb>
amerlyq: but then, you will have the problem that quicklisp will WRITE into /usr/share/your-script/quicklisp (to install dependencies), so multiple users will have conflicting access rights, or you will have a security problem.
banjiewen has quit [Ping timeout: 264 seconds]
asedeno has joined #lisp
<pjb>
So again, back to my first suggest: forget about scripts, compile a standalone executable image program.
<astronavt>
pjb is there a way for quicklisp to read without trying to download or save anything?
<amerlyq>
pjb, thanks for alternative idea, I will look into it. Still, what I meant, when using ArchLinux there are package dependencies. So, when distributing my one-script-program I may directly write it depends on e.g. python-kitchen. But I can't do this with Lisp, do I? After all these packages aren't packed for Arch -- otherwise I could directly use ASDF to load them from /usr/share/cl... Probably. Arch has
<amerlyq>
prepacked quicklisp... but then it will work only for Arch.
<astronavt>
conflating loading w/ installation always felt odd to me
wilfredh has joined #lisp
<pjb>
astronavt: yes, pre-download and install all the dependendencies.
kilimanjaro has joined #lisp
<astronavt>
pjb quicklisp doesn't offer that functionality on its own? separate "download" and "load" functions?
<pjb>
astronavt: then it will just try to compile in ~/.cache/common-lisp for each user.
<pjb>
astronavt: I don't know. I don't think so.
<astronavt>
hm. i always wondered about that
<astronavt>
seems like a weird design
<astronavt>
many of the vim "package managers" do it like that as well, i never understood the appeal
<pjb>
It works in a given context.
<amerlyq>
astronavt, same question here. pjb, maybe you know how to cleanly separate two phases -- download/install and actually loading?
<astronavt>
i mean i get having a convenience function for it. but why make that the _only_ api?
<pjb>
I think that's mostly because those are sources distributions, not binaries.
jerme_ has joined #lisp
<astronavt>
i suppose i could look at the quicklisp code and see how easy it would be to separate those two functions
<pjb>
There are more dependendencies and steps with source distributions.
Tristam has quit [Excess Flood]
banjiewen has joined #lisp
<pjb>
astronavt: or you could NOT use quicklisp. Instead, download all the dependencies, and use asdf to load them.
<pjb>
Also, you can use quicklisp to download them ;-)
Tristam has joined #lisp
<pjb>
Copy the dependencies from ~/quicklisp to /usr/share/your-script/dependencies/ and use asdf to load them from here.
<pjb>
But agian, once you start considering do that, it's easier to generate an executable image program.
khisanth_ has quit [Ping timeout: 272 seconds]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
<astronavt>
hmmm
<amerlyq>
pjb, I think separating actually would be great: you run quicklisp to download and install all necessary desp in BUILD time and then only load them in app launch time. This way it will be no different from any other source distribution -- like may AUR packages which build for you repo-git
<astronavt>
or like pip or npm or gem or cpan :)
<amerlyq>
yep
<astronavt>
but yeah ill have to poke at this more
<astronavt>
i want to do the same for vim
<astronavt>
some kind of generic cli package manager would be really handy i think
<astronavt>
CL is a good language for writing this kind of stuff imo
banjiewen has quit [Ping timeout: 264 seconds]
jerme_ has quit [Ping timeout: 245 seconds]
mkrauss has joined #lisp
hhdave has quit [Quit: hhdave]
banjiewen has joined #lisp
tfb has quit [Ping timeout: 276 seconds]
<Josh_2>
dlowe: do you have an example of (format-timestring ..)?
wilfredh has quit [Ping timeout: 244 seconds]
lispyone has quit [Ping timeout: 252 seconds]
kilimanjaro has quit [Ping timeout: 245 seconds]
jerme_ has joined #lisp
<mkrauss>
Oops got disconnected for a few, in case there were any responses to my previous question, I missed it sorry
wilfredh has joined #lisp
lispyone has joined #lisp
tfb has joined #lisp
<tfb>
astronavt: you may want ql:bundle-systems
kilimanjaro has joined #lisp
<astronavt>
"a Lisp file that can be loaded to configure ASDF"
<astronavt>
that looks right
<amerlyq>
tfb, thanks, it looks like what I wanted too
<astronavt>
it looks like you could implement some kind of npm-style dependency management this way
jerme_ has quit [Ping timeout: 264 seconds]
jerme_ has joined #lisp
khisanth_ has joined #lisp
<amerlyq>
Still I don't understand how to resolve bootstrapping correctly. System-bundle must be created by somebody. OK. Then installed into e.g. /usr/share/myexe/bundle.lisp at build time -- and loaded into my script installed into /usr/bin/myexe by explicit (load "/usr/share/myexe/bundle.lisp"). It somewhat looks like black opaque box for me...
banjiewen has quit [Ping timeout: 268 seconds]
<dlowe>
Josh_2: there's some constants in local-time that are format-timestring formats
<Josh_2>
Yes but I don't understand how to use it
<Josh_2>
basically I don't want 2019-07-15T01:00:00.000000+01:00 I just want 2019-07-15 as the printed representation
<Josh_2>
the former is very messy on a webpage ʕ·͡ᴥ·ʔ
<pjb>
amerlyq: you could read ~/quicklisp/setup.lisp nothing's hidden.
banjiewen has joined #lisp
<tfb>
amerlyq: you are going to need to load something from somewhere to get things loaded. If you think this is opaque, go and look at a large python package's loading mechanisms, like NumPy say...
<pjb>
amerlyq: the alternative to loading things to get things loaded, is to pre-load them, and to save an image where everything is saved together, then you can just load this image.
<pjb>
amerlyq: and if it's an executable image, then it's loaded automatically when you execute it.
<Josh_2>
I guess I could just subseq it ¯\_(ツ)_/¯
<pjb>
amerlyq: hence again my advice to write programs and compile them into executable images.
<tfb>
pjb: that was my original reason for learning about ql:bundle-systems -- I wanted to build binaries, and I wanted to be able to *rebuild* them a year later with identical versions of everything
<amerlyq>
is there a way to register something in ASDF directly? Likewise placing site-packages into specified paths in /usr/share, which do the trick. Then I could use directly ASDF in script header instead of boilerplate code from bundle.lisp. I understand it's more like packaging problem and varies greatly between distributions. Calling things "opaque" I meant too many things sitting in-between my script and default
<amerlyq>
importing mechanism.
<pjb>
tfb: yes, that's yet another problem, freezing versions.
<pjb>
amerlyq: yes. But I only know the ancestral way: push the directory where your asd files are onto asdf:*central-registry*
<pjb>
amerlyq: there are more modern ways to do it.
<pjb>
(read the asdf manual)
<amerlyq>
I start feeling somewhat teary :)
smazga has quit [Read error: Connection reset by peer]
smazga has joined #lisp
<amerlyq>
despite the fact you are right I must rtfm that instead of postponing inevitable
<Josh_2>
dlowe: I just get 'odd number of keyword arguments' error
<tfb>
amerlyq: I think you are stressing too much. QL & ASDF are these little tiny things you can kind of understand. I wrote Python for a few years in a scientific environment, and the standard approach to package management was to ship a conda seup which *included a complete python distribution* and at least two package managers on top of it. It was just insanely complicated.
<amerlyq>
still I slightly miss abundance of easily foundable perlmonk/stackoverflow examples on typical problems like these
<tfb>
(and you'd probably be installing these on top of some Docker instance sitting on a VM)
<amerlyq>
tfb, you are talking about creepy things...)
remexre has quit [Remote host closed the connection]
<tfb>
amerlyq: in the time I've been using it (which, OK, is a long time) CL and its environment has gone from the leading edge of complexity to this laughably simple thing which is so easy to understand, because everything else is just insane
remexre has joined #lisp
<amerlyq>
about QL -- generally I don't want startup delay of 0.8sec spent on loading QL itself for filter scripts, which must be launched and stopped many times. Unless until somebody will explain me how to only LOAD script by QL without trying to check and download anything. Second problem -- everybody setups QL however they wish (and somebody not at all), so depending on foreign QL is somewhat tricky. For example
<amerlyq>
read-only filesystems or where installing new package in QL will require sudo.
<Josh_2>
dlowe: thanks :)
<amerlyq>
tfb, "complexity" is somewhat loose concept. In modern times of abused insanity you can see pattern like "here, here, and here -- and don't touch thick layer of glue between that". And when everything follows this pattern -- it becomes "simple" because you know what to expect where. With CL... it seemply doesn't "click". So learning whole pattern from scratch is actually more complex than expected
<amerlyq>
even if pattern itself is much simpler
orivej has joined #lisp
<tfb>
amerlyq: if you are worrying about R/O filesystems or needing sudo use bundles. Then load the bundles in the build script and dump an executable image.
m00natic has quit [Remote host closed the connection]
<tfb>
(related to the above) Does anyone know a way to get a list of systems that Quicklisp has local copies of?
<jackdaniel>
for sake of avoiding segfault questions on this channel, please make it safety 1
<pjb>
or better: (safety 3)
<jackdaniel>
yes
Oladon_work has joined #lisp
<mkrauss>
pjb: just found the log and saw I missed your response before. Yes, there could be another mkrauss, and if so that's fine, but I don't think that would explain why it said my github account is blocked, would it? Unless the hypothetical other mkrauss got blocked, and gitlab.common-lisp.net just assumes it is the same mkrauss? That would seem quite surprising, yes.
<pjb>
mkrauss: indeed, another mkrauss interested in Common Lisp would be highly improbable. I don't know what it means for the github account on gitlab to be blocked, and how to unblock it.
warweasle has quit [Quit: leaving on vacation!]
<pjb>
mkrauss: perhaps, check in github your settings about applications allowed to connect to the github API. Perhaps you need to allow gitlab there.
<mkrauss>
Seems unlikely to me, but I'll check that, thank you
<trafaret1>
does it possible to use c++ function in common lisp?
<pjb>
trafaret1: theorically, yes.
<alexanderbarbosa>
everything is possible in the world of lisp ...
<pjb>
trafaret1: in practice, you can use clasp, or make a C wrapper!
<alexanderbarbosa>
even an lispOS
<trafaret1>
damn good
<pjb>
trafaret1: there are 2 problems for FFI to C++: 1- the ABI can be different than the C ABI, so you may have some problems with some parameter types (eg. C++ references, structures, etc); 2- the C++ names are mangled in a C++-implementation dependent way. So your FFI is becoming C++-implementation dependent too.
<pjb>
Also, of course, if your C++ function is templated, or you need to pass arguments or get results that use templates, you won't be able to do it in Lisp (you need a C++ compiler to expand the C++ template).
mhd2018 has joined #lisp
<pjb>
This is why it's better to define the API in terms of a C wrapper.
<pjb>
In general, forget C++; don't use it to write any new code. Use C if you have. But better, use Common Lisp to write everything.
<trafaret1>
ok theoretically it is possible
<trafaret1>
"use Common Lisp to write everyting" :)
<alexanderbarbosa>
pjb: wise words... lets re-write the world in LISP.... Rust pff
<pjb>
trafaret1: be sure to try clasp. With clasp, it should just work.
<drmeister>
trafaret1: We have developed a new implementation of Common Lisp that interoperates with C++. It includes a C++ template library that automatically exposes C++ functions, classes, methods and enumerated types to Common Lisp.
amerlyq has joined #lisp
<drmeister>
trafaret1: Just as importantly, this new implementation uses C++ exception handling to unwind the stack. So it's fully compatible with C++ in that C++ stack frames and Common Lisp stack frames are interleaved on the stack and CL calls C++ and C++ calls CL in any combination.
trafaret1 has quit [Ping timeout: 272 seconds]
mkrauss has quit [Ping timeout: 250 seconds]
<zhlyg>
drmeister: is it like ECL that compiles down to C? (but c++ in this case)
<Bike>
no, it uses llvm more directly.
<Josh_2>
So what sort of effect does that have on speed?
kajo has quit [Remote host closed the connection]
gareppa has quit [Quit: Leaving]
<Bike>
what effect does what have on speed?
<Bike>
llvm? c++ exception handling?
kajo has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
zotan has quit [Ping timeout: 245 seconds]
<Josh_2>
llvm
<drmeister>
zhlyg: Clasp uses the llvm C++ API to generate llvm-IR directly. Furthermore it uses the llvm C++ API to do ahead of time and just in time compilation.
zotan has joined #lisp
edgar-rft has joined #lisp
<astronavt>
how usable is clasp right now?
EvW has quit [Ping timeout: 250 seconds]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 272 seconds]
<Bike>
it runs slime and passes most of the ansi tests.
<Bike>
Josh_2: kind of hard to talk about the effect - it's not like we have an llvm-less version. but it's a pretty good optimizing compiler
zhlyg has quit [Ping timeout: 258 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<drmeister>
"passes most of the ansi tests" means clasp is passing 21,265 of 21,734 ansi tests.
<drmeister>
So 98% of the tests - that's thanks to kpoeck and Bike
<dlowe>
wow, that's really quite good
orivej has joined #lisp
<drmeister>
Yeah - it's comparable to other Common Lisp implementations.
<drmeister>
We are working on reducing compilation times and code size now.
<drmeister>
and... of course... the speed of generated code.
<shka_>
drmeister: good evening!
<drmeister>
Hello shka_
<shka_>
drmeister: could you consider writing blog post about clasp status once in a while?
<drmeister>
I should reach out more - yeah.
<antoszka>
does clasp support (close) MOP too?
<Bike>
ya.
<Bike>
and gray streams and bordeaux threads
<Bike>
grey? whatever
<Josh_2>
supports basically everything then
<drmeister>
antoszka: Everything - it's a full Common Lisp
<antoszka>
Excellent!
<antoszka>
Bike: in that case lparallel should work, too, it uses bordeaux as the backend afair
<shka_>
antoszka: not sure about that, lparallel uses some atomic operations, and i am not sure if it falls back to locking if that is not available
<p_l>
drmeister: what's the status on too-aggressive inlining in compiler btw?
<antoszka>
shka_: yeah, guess I'd have to try.
<drmeister>
That's what we are working on right now - rather than inlining everything at the AST level we are going to defer to the HIR stage and then decide whether we call a discriminating function or inline specific code.
<p_l>
just switching to not-inlining would fix some stuff, iirc from ELS'19
<drmeister>
Sure - but then we don't get the benefits of inlining.
<drmeister>
The goal is to get a really performant Common Lisp - better than anything else.
<p_l>
maybe configurable compiler policy?
<drmeister>
First we need a decent starting point. Inlining everything at the AST level turned out to be a bad idea in terms of code size and compilation time. The problem with knobs that control the code generation is that then you have to worry about the knobs that control code generation.
alexanderbarbosa has quit [Remote host closed the connection]
<shka_>
why is vector-push-extend slow in adjustable vectors in sbcl?
<jackdaniel>
I would expect it to be slow because it needs to reallocate and copy the vector
<jackdaniel>
drmeister: "antoszka: Everything - it's a full Common Lisp", in principle MOP is not something standarized in Common Lisp (like threads etc)
shka_ has quit [Ping timeout: 268 seconds]
<jackdaniel>
congrats on the ansi-tests progress
<astronavt>
drmeister thats great
<astronavt>
sbcl is already quite fast, no?
<astronavt>
how do the binaries compare in size?
manualcrank has quit [Ping timeout: 245 seconds]
mindCrime has quit [Ping timeout: 245 seconds]
<selwyn>
shka, antoszka: last time i tried it lparallel worked well enough in clasp
ebrasca has quit [Read error: Connection reset by peer]
Bike has joined #lisp
<pjb>
shka__: vector-push-extend is as fast as you want; you adjust its speed with the third (optional) parameter!
<pjb>
shka__: for asymptitical O(1) you would do (vector-push-extend element vector (length vector))
<pjb>
shka__: for asymptotical O(n), you would do (vector-push-extend element vector 1)
<pjb>
shka__: so it doesn't depend on sbcl, but on YOU!
<semz>
wouldn't that be O(log n) rather than O(1)?
manualcrank has joined #lisp
<semz>
since every further extension will hold twice as long as the previous before adjustment becomes necessary again
<pjb>
but since it occurs twice the time after the previous one, we get O(1).
<pjb>
Which is what is good in (vector-push-extend … (length vector)).
<pjb>
Note that the same asymptote is obtained with any value > 1
<pjb>
well no.
<pjb>
any value proportional to (length vector). It can be (* 0.1 (length vector)).
smazga has quit [Quit: leaving]
<semz>
am i missing something obvious? a vector of K elements that has its length doubled 1,2,3,...,N times will be able to hold 2*K, 4*K, 8*K, ..., 2^N * K elements, i.e. 2^N (resp. N) insertions (into an empty vector, but the initial arguments are negligible) will require N (resp. log(N)) extensions
<semz>
well, that's missing the constant K, but since we're talking asymptotically that doesn't matter
ltriant has joined #lisp
<sahara3>
bye
<pjb>
What we count, is the number of times each element is copied. 1/2^1 of the elements are not copied (we just allocated last time). 1/2^2 of the elements are copied once. 1/2^3 twice, etc. lim (size->∞, Sum(i=1,log(size), (i-1) * 1/2^i)) = 1
mfiano has quit [Ping timeout: 248 seconds]
alexanderbarbosa has quit [Remote host closed the connection]
<aeth>
pjb: from the Hyperspec, "Extension is the minimum number of elements to be added to vector if it must be extended." I'm guessing that 1 will be rounded up to something.
<semz>
Where does the (i-1) come from? The fractions are relative to the final size.
alexanderbarbosa has joined #lisp
mfiano has joined #lisp
<pjb>
semz: half have zero copies, so (i-1) copies times half the elements.
<pjb>
since I start the sum at 1.
<pjb>
If you want to count the "insertion" as one copy, then you can use i instead of (i-1) and get a limit of 2, still O(1).
catchme has quit [Quit: Connection closed for inactivity]
<semz>
something is fishy about this, even if i can't find the exact problem right now. there are always more copies than extensions, so O(1) copies would mean that a constant amount doublings is enough to house any number of elements, which is blatantly false
<semz>
amount of doublings*
<pjb>
If you use a constant, you fail to get O(1). You need to use a value proportional to the current size. eg doubling the size. So "constant amount doublings" is contradictory.
varjag has quit [Ping timeout: 245 seconds]
Ricchi has joined #lisp
<semz>
tbh i have no idea what you are trying to say
saravia has quit [Remote host closed the connection]
milanj has joined #lisp
<pjb>
(vector-push-extend element vector constant-extension) makes O(n) copies of each element. with n = (length vector)/constant-extension
<pjb>
(vector-push-extend element vector (* k (length vector))) makes O(1) copies of each element.
<pjb>
That's all there is to it.
<pjb>
Now, of course, it's asymptotical, ie. for big sizes. If you have a maximum number of elements, then you don't need -extend, you can just allocate your vector once, and use vector-push.
<semz>
i think i'm starting to get where you're coming from, but that metric is completely useless
<semz>
and not at all what people are interested in when they talk about the performance of extending a vector
<pjb>
I agree, it's not necessarily the most interesting metric. It's the one that is classically used by algorithmicians using the big-O notation…
<pjb>
semz: since our computers have a finite memory, and a finite time to execute, all our programs are O(1).
<semz>
that's not what i meant
<pjb>
if (length v) is big, (vector-push-extend e v (length v)) will take a lot of time. It may be better if you want to do something (not some hypothetical asymptotical thing, but some definite thing) quickly, it may be faster to use a small constant here. If you're adding 8 elements, and won't be adding more for the forseable future, (vector-push-extend e v 8) is better.
<semz>
in big-O you have some parameter N that goes up and look at some function F(N) (typically #actions for problem of size N) of that. when extending a vector, the interesting thing to ask would be "given N elements i want to add, how often do i have to extend the vector (or how many things do i have to copy, basically same question) using extension scheme XYZ?"
<semz>
in the first line, you look at how long a single copy of a vector of size N takes (the answer is unsurprisingly "approx. N steps")
<semz>
but in the second line you're doing something else
<pjb>
Usually N is the size of the structure, ie. N=(length vector).
<semz>
then it would be O(n) in both cases
<pjb>
But you're right, when you say anything, you have to precise what you mean.
<semz>
since in the second, you are still just copying a vector of length N
<pjb>
Often it's obvious what is meant, so mathematician (algorithmicians) often omit those precisions, but they're important.
<pjb>
An operation can be O(1) in additions, but O(n^n^n) in memory accesses, with n = number of particules in the universe.
akoana has left #lisp ["Leaving"]
aindilis has quit [Read error: Connection reset by peer]