<NotThatRPG>
Here's a thing I realized that I don't know. If I'm running on a linux box, how do I (politely) ask the OS to give me access to some number of cores to use for multiple threads?
pjb has joined #commonlisp
<NotThatRPG>
I guess it's as easy as using `taskset` ?
chkhd has joined #commonlisp
chkhd has quit [Remote host closed the connection]
Posterdati has quit [Ping timeout: 248 seconds]
waleee has joined #commonlisp
Posterdati has joined #commonlisp
waleee has quit [Ping timeout: 252 seconds]
waleee has joined #commonlisp
occ has joined #commonlisp
mingus has joined #commonlisp
X-Scale has quit [Quit: Client closed]
bitmapper has joined #commonlisp
beach has quit [Ping timeout: 260 seconds]
sweatshirt has quit [Ping timeout: 246 seconds]
X-Scale has joined #commonlisp
pillton has joined #commonlisp
selfish has quit [Quit: Leaving.]
tevo has joined #commonlisp
sweatshirt has joined #commonlisp
waleee has quit [Ping timeout: 252 seconds]
occ has quit [Ping timeout: 246 seconds]
Lord_of_Life has quit [Read error: Connection reset by peer]
ym has quit [Remote host closed the connection]
Lord_of_Life has joined #commonlisp
sweatshirt has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.2)]
bilegeek has joined #commonlisp
kevingal has quit [Ping timeout: 246 seconds]
occ has joined #commonlisp
rwxrwxrwx has quit [Ping timeout: 260 seconds]
Posterdati has quit [Ping timeout: 255 seconds]
X-Scale has quit [Quit: Client closed]
Posterdati has joined #commonlisp
jmbr has joined #commonlisp
jmbr is now known as rwxrwxrwx
rwxrwxrwx has quit [Changing host]
rwxrwxrwx has joined #commonlisp
samedi has quit [Quit: Leaving]
jeosol has quit [Quit: Client closed]
pdietz has joined #commonlisp
akoana has joined #commonlisp
bitmapper has quit [Quit: Connection closed for inactivity]
<elderK>
Hey guys, is "Anatomy of Lisp" still worth a read? :)
<beach>
Yes, definitely.
<beach>
It is not about Common Lisp, but it is still good.
<elderK>
Excellent :) I'm glad there's a good version of it up on libgen. I might try and purchase a copy if I can find it for a decent price. Kind of exited: Today I received my hardcopies of AMOP, LiSP, LOL and PAIP :)
<beach>
Oh, wow. You have got some reading to do there.
<elderK>
It's interesting seeing things in m-expressions!
<elderK>
Oh yeah, big reading. It's funny: When I started learning C and stuff when I was younger, I kind of just muddled my way through it. Lots of little projects that led to large projects and always learning. With CL and Scheme, I'm doing a lot more reading.
<elderK>
I was reflecting last night while I was reading some stuff in CLHS that it would've been like learning C++ from the reference manuals :P Those are not particularly easy to learn from.
<elderK>
:) I've started reading through the CLOSOS publication, too, although it might take me a few days to finish it :)
<beach>
Heh, sure.
<beach>
C++ is a much "bigger" language than Common Lisp. There is lots of stuff in Common Lisp, but it is mostly "library" stuff.
pdietz has quit [Quit: Client closed]
<elderK>
Aye. C++ grows more and more complex, too. To really like, write bleeding-edge modern C++ code, you need to be a whizz at metaprogramming and templates and stuff are very complex. Lisp expresses those things so much more elegantly.
<elderK>
C++20 and stuff are helping with that but there are still so many corner cases.
son0p has quit [Ping timeout: 255 seconds]
<elderK>
My wife was telling a workmate of hers how I was tinkering with Lisp: Many of the people around her didn't know what it was as they're all quite young but one of her colleagues remarked "but the manual is THIS big!" Apparently "big" was pretty "big."
<elderK>
I find that kind of an unfair comparison, though. She's a QA and a C# and Java shop. If you think about the formal standards of any widely used programming language, well, those standards are going to be pretty thick. Excepting maybe Scheme but then, it's too minimal to use for much without implementation-specific extensions.
<elderK>
I like how in Anatomy of Lisp, the author stresses abstractions and the difference between a concrete implementation of an idea and the idea itself. :)
<beach>
I haven't read it for some time, so I don't remember the details. I do remember understanding about things like environments from that book.
<elderK>
I can't wait to get to that stuff :D I read elsewhere that it goes quite deep into the implementation of Lisp, similar LiSP. Even if it may be outdated, it'll be fascinating.
<elderK>
Similar to LiSP, even.
<beach>
LiSP is very good. And the translation is better than the French original, thanks to a brilliant translator.
pranavats has joined #commonlisp
<elderK>
Excellent! I was wishing earlier that I could read French so that I could read the updated LiSP text.
<beach>
Yeah, that one has not been translated as far as I know.
<elderK>
That's a shame. I wonder how it compares to the older translated text.
<beach>
I haven't read the new French one. Maybe I should.
<elderK>
I'd be interested to hear your thoughts on it.
<beach>
Yeah, well, I have more items on my TODO list than my remaining life expectancy will allow me to finish.
<elderK>
If it helps any, I feel that way too and I have no idea how much longer I've got left. I'm really holding out for nanotech :P
<beach>
I also don't know how much longer I really have left. I was just going by statistics.
pdietz has joined #commonlisp
<hirez>
howdy everyone
<hirez>
a strange thing
<hirez>
after much digging it appears CL has no straight forward way to convert a base 10 variable to octal
<hirez>
of course I can write my own implementation but perhaps I am just not using CLHS right
<beach>
Decimal and octal are just external representations. Internally there are just integers.
<White_Flame>
base-N is a manner of printing & reading. variables do not hold numbers of any particular base
<White_Flame>
(missed it by _that_ much)
<beach>
Heh.
<hirez>
well yes.
<beach>
White_Flame: I'm off for a while, so I'll let you continue. :)
<White_Flame>
heh, k
<hirez>
However to do the thing I need to do I need to be operating on the octal representation.
<pdietz>
Often I find the way to solve a problem is to precisely define the problem.
<White_Flame>
hirez: then you need to be working with a string instead of a number?
<White_Flame>
or maybe convert to an array/list of numeric digit values, depending on what you need?
<hirez>
So, I decided to suffer and try to implement base64 in CL from scratch
X-Scale has quit [Quit: Client closed]
<hirez>
the simplest way of course is to convert the digit-pairs to octal and then use that as an index in the base64 character array.
<hirez>
So both the string and list idea while fine otherwise may not work for my purposes.
<White_Flame>
it's not really pairs, though, is it?
<White_Flame>
6 bytes <=> 8 chars iirc?
<hirez>
mmm yes I made a mistake in my explanation. You first have a hex value, convert to octal, and then split it pair-wise to get the index.
<ixelp>
GitHub - svenvc/s-base64: A Common Lisp implementation of Base64 Encoding/Decoding
<hirez>
pdietz: that ruins the fun :)
<White_Flame>
by "hex value", do you mean a single byte value, or the hex representation of the concatenation of 6 bytes' values?
<hirez>
The hex representation of the string. Good question.
<White_Flame>
because hex splits into 4-bit digits, and you need to pull out 6
<hirez>
So, going off the wiki: Man => 0x4d616e => 23260556 => (23, 26, 05, 56) and then the decimal representation of those is the index.
contrapunctus has left #commonlisp [#commonlisp]
<White_Flame>
oh right, instead of 6<=>8, it's 3<=>4, same ratio
<hirez>
Perhaps there is a smarter more lispy way to approach it instead of trying to beat lisp into submission
<White_Flame>
so you have a 24-bit integer (eg 3 byte chunk concatenated), print in octal, each 2 octal digits is read back into an integer, and you use that for an offse
<White_Flame>
t
contrapunctus has joined #commonlisp
<hirez>
oh, so you're suggesting essentially printf'ing it into an octal string and then pulling the digits out of that
contrapunctus has left #commonlisp [#commonlisp]
<White_Flame>
well, that's a naive way of doing it, without making a bunch of div/mod steps manually
<White_Flame>
printing is generally the way to convert a number into digits (of some base)
<White_Flame>
although those digits are characters instead of numbers
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
<White_Flame>
and you have to be real careful with big vs little endian in this particular exercise
<hirez>
yeah thankfully I do not plan on releasing this code to anyone
<hirez>
mostly just a way to induce enough pain to bring about learning
<hirez>
My day job is in Python unfortunately so I have been made soft by it's conveniences
<hirez>
I feel my CS degree atrophying by the day
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
<White_Flame>
would you prefer the string method, or manual div/modding digits out?
<hirez>
div/modding is likely more instructive in this case.
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
<hirez>
In that case it seems that splitting and multiplying by successive powers of 8 will get you to where you need to be
<hirez>
well sorta
<White_Flame>
well, really the first step is to chunk your input bytes into 24-bit numbers, as well as know how many digits are missing in the last chunk
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
<hirez>
yeah, count the bits and then pad before anything else.
<White_Flame>
then for each 24-bit number, loop/collect digits out of it
<White_Flame>
or mapcan all of those together into 1 big list of octal-digit numbers
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
<hirez>
wow looked up mapcan
<hirez>
had no idea it existed
contrapunctus has joined #commonlisp
<White_Flame>
the (loop for (hi lo) on oct-digits by #'cdddr ...) to assemble each 6-bit value
<White_Flame>
*cddr
contrapunctus has left #commonlisp [#commonlisp]
<hirez>
cool, I will run with this
pdietz has quit [Quit: Client closed]
<White_Flame>
or, you have a stateful iterator that grabs the next 2 bits from the input byte stream, and call it 3 times per output digit
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
<White_Flame>
(or the next 6 bits from the stream directly, as there's only 4 cases to deal with anyway)
<White_Flame>
but the digit method can be fun to implement :)
contrapunctus has joined #commonlisp
<White_Flame>
note also that by processing the entire input byte stream in multiple passes like this, you'll use a big multiple of memory to hold those intermediate full states, as opposed to just working on a little chunk at a time
<White_Flame>
but the ease of coding it is likely higher
shka has joined #commonlisp
bilegeek has quit [Quit: Leaving]
lottaquestions_ has quit [Remote host closed the connection]
lottaquestions_ has joined #commonlisp
azimut has quit [Ping timeout: 255 seconds]
rgherdt has joined #commonlisp
igemnace has joined #commonlisp
semarie has quit [Quit: WeeChat 3.8]
semarie has joined #commonlisp
Cymew has joined #commonlisp
<flip214>
Is the ELS deadline prolonged for a week, as usual?
<beach>
I think you need to wait for the announcement.
<beach>
But authors expect it these days, so it seems likely.
MajorBiscuit has joined #commonlisp
<beach>
If I were an author, I would submit what I have before the original deadline anyway.
<flip214>
well, is easychair still open so that papers can be dropped?
<beach>
I haven't checked. Sorry.
<flip214>
yeah, me too, but if one needs an official "okay"
<flip214>
good enough, thanks!
pve has joined #commonlisp
attila_lendvai_ has joined #commonlisp
lottaquestions has joined #commonlisp
lottaquestions_ has quit [Ping timeout: 246 seconds]
attila_lendvai_ has quit [Ping timeout: 260 seconds]
LW has joined #commonlisp
attila_lendvai has joined #commonlisp
attila_lendvai has quit [Ping timeout: 246 seconds]
* easye
is on the ELS 2023 program committee, and has no access yet to papers, so they haven't been pushed to review yet.
X-Scale has joined #commonlisp
attila_lendvai has joined #commonlisp
_cymew_ has joined #commonlisp
lxi has joined #commonlisp
lxi has quit [Client Quit]
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #commonlisp
lxi has joined #commonlisp
LW has quit [Read error: Connection reset by peer]
LW has joined #commonlisp
<splittist>
Modern c++ seems like a really interesting language obscured by layer upon layer of suboptimal syntax required by compatibility with decades of now-outmoded practices and the fundamentally less extensible Algol style
<jackdaniel>
it is not that common lisp has a clean design that is not obscured by backward-compatibility with (more than one!) ancestors
<jackdaniel>
but I can't think of exact instances, it is one coffee too early for that :P
quoosp has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 246 seconds]
MajorBiscuit has joined #commonlisp
occ has quit [Ping timeout: 246 seconds]
<splittist>
jackdaniel: exactly - but lisp's syntax and compilation model usually allows for extensibility without too much obscurantism. Not that I'm going to say I'm an expert in c++ - to me, any sufficiently-advanced c++ program looks like a soup of instructions to the compiler to overcome unsafe default behaviour where the actual functionality gets lost...
<splittist>
But I'm willing to believe it becomes easy to see what is going on, just as we tend not to get hung up on parens.
<jackdaniel>
I'm not that much interested in c++ either way (but I've been writing it professionally a few years back), modern c is much more interesting
<jackdaniel>
although many people shame the language for some reason
<aeth>
Imo... C++ isn't really a general purpose language anymore (too many now-common use cases where it's very low on the list), but when it shines, it shines. Writing a program might be harder than CL or just about any other language, but writing something fast (that uses SIMD, etc.) is probably easier in C++ than in CL.
<aeth>
Which is why a lot of people write tiny pieces of fast code in C++ to call from another language.
<aeth>
It's definitely not the approach CL programmers prefer, though.
<aeth>
CL programmers would probably prefer to use asm.
<jackdaniel>
c++ is a disaster as a ffi callee
<aeth>
well, yeah, because you need to pretend to be C
<aeth>
I guess CL's fast enough that you don't need to resort to calling out to C++ even when it would be faster to do so, so there's not a lot of work done to make it easy, so it's not worth doing.
OlCe has quit [Ping timeout: 246 seconds]
KaitoDaumoto has quit [Remote host closed the connection]
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
xlarsx has joined #commonlisp
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
contrapunctus has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
dcb has quit [Quit: MSN Messenger 3.8]
epony has quit [Remote host closed the connection]
epony has joined #commonlisp
epony has quit [Remote host closed the connection]
epony has joined #commonlisp
quoosp has quit [Ping timeout: 252 seconds]
<jackdaniel>
somewhat obvious but it hit me today: (setf (fdefinition 'xxx) #'foobar) and (defmethod xxx ((a object)) ...) adds a method to foobar
quoosp has joined #commonlisp
<mfiano>
but does it work when you recompile the generic function foobar?
<mfiano>
a new function object would be constructed, voiding the read-time one, no?
<jackdaniel>
no, the identity is preserved like with defclass
xlarsx has quit [Remote host closed the connection]
<mfiano>
Cool
xlarsx has joined #commonlisp
xlarsx has quit [Ping timeout: 255 seconds]
pillton has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.2)]
azimut has joined #commonlisp
bitmapper has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
Inline has joined #commonlisp
scymtym has joined #commonlisp
edgar-rft has quit [Ping timeout: 248 seconds]
xlarsx has joined #commonlisp
pranavats has joined #commonlisp
xlarsx has quit [Ping timeout: 246 seconds]
edgar-rft has joined #commonlisp
xlarsx has joined #commonlisp
xlarsx has quit [Ping timeout: 268 seconds]
quoosp has quit [Ping timeout: 248 seconds]
quoosp has joined #commonlisp
Lycurgus has joined #commonlisp
edgar-rft has quit [Ping timeout: 268 seconds]
pranavats has left #commonlisp [Error from remote client]
karlosz has joined #commonlisp
Lycurgus has quit [Quit: Exeunt: personae.ai-integration.biz]
<ebrasca>
Hi , I can't understand what is the problem with this error http://ix.io/4ptC
MajorBiscuit has quit [Ping timeout: 252 seconds]
samedi has joined #commonlisp
MajorBiscuit has joined #commonlisp
xlarsx has joined #commonlisp
<Bike>
i think it is interpreting something as a wildcard?
quoosp has quit [Ping timeout: 248 seconds]
<Bike>
if you plug in #p"thatfilename" you can see that wild-pathname-p is true
<Bike>
with \\[PNG] it seems to parse more literally
<Bike>
i don't actually know why it ends up as sa wildcard anyway, though.
<Bike>
i guess it's a glob wildcard? weird.
xlarsx has quit [Ping timeout: 268 seconds]
edgar-rft has quit [Ping timeout: 246 seconds]
edgar-rft has joined #commonlisp
xlarsx has joined #commonlisp
<ebrasca>
I just use (format nil "~amedia/img/~a" (user-homedir-pathname) name) to make the path.
<Bike>
your name has square brackets in it. you (apparently) need to escape them.
xlarsx has quit [Remote host closed the connection]
xlarsx has joined #commonlisp
<ebrasca>
I get the name from the web browser.
<Bike>
irrelevant
<ebrasca>
How do I escape the characters in a string?
<jackdaniel>
never trust the irrelevant web browser -- chopin
lxi has joined #commonlisp
<Bike>
backslashes. i already wrote it out for you.
<Bike>
you can also use parse-native-namestring (from pathname-utils or sb-ext) looks like
xlarsx has quit [Remote host closed the connection]
xlarsx has joined #commonlisp
jmdaemon has quit [Ping timeout: 252 seconds]
xlarsx has quit [Remote host closed the connection]
xlarsx has joined #commonlisp
xlarsx has quit [Remote host closed the connection]
xlarsx has joined #commonlisp
xlarsx has quit [Remote host closed the connection]
xlarsx has joined #commonlisp
xlarsx has quit [Read error: Connection reset by peer]
Ellenor is now known as AmyMalik
qhong_ has joined #commonlisp
tibfulv has quit [Remote host closed the connection]
tibfulv has joined #commonlisp
random-nick has joined #commonlisp
dirtcastle has quit [Ping timeout: 265 seconds]
lordmzte has quit [Ping timeout: 246 seconds]
VOID[m] has quit [Ping timeout: 256 seconds]
gridbugsmasher42 has quit [Ping timeout: 252 seconds]
tiziodcaio has quit [Ping timeout: 246 seconds]
edgarvincent[m] has quit [Ping timeout: 252 seconds]
artemon has quit [Ping timeout: 252 seconds]
sp has quit [Ping timeout: 260 seconds]
infra_red[m] has quit [Ping timeout: 248 seconds]
char[m] has quit [Ping timeout: 248 seconds]
kakuhen has quit [Ping timeout: 246 seconds]
paulapatience has quit [Ping timeout: 256 seconds]
xlarsx has joined #commonlisp
BrownJenkin has quit [Ping timeout: 265 seconds]
Mrtn[m] has quit [Ping timeout: 265 seconds]
xlarsx has quit [Read error: Connection reset by peer]
qhong has quit [Ping timeout: 252 seconds]
buffet has quit [Ping timeout: 248 seconds]
an_origamian[m] has quit [Ping timeout: 260 seconds]
danieli has quit [Quit: Ping timeout (120 seconds)]
danieli has joined #commonlisp
MetaYan has quit [Ping timeout: 248 seconds]
pranavats has joined #commonlisp
Cymew has quit [Ping timeout: 246 seconds]
buffet has joined #commonlisp
tevo has quit [Ping timeout: 260 seconds]
dirtcastle has joined #commonlisp
<pjb>
ebrasca: I see parentheses in the name. Parentheses can be interpreted as regular expression grouping for a pattern. In any case, they're not conforming valid characters in a logical pathname, so they can be interpreted as an implementation specific syntax.
<ebrasca>
pjb: I have these files with that names in my file system.
<pjb>
but you pass a string to OPEN, not a pathname. If you got that pathname with eg. DIRECTORY, it would work.
<pjb>
(and indeed, it's the [PNG] the problem not the parentheses, sorry).
<pjb>
ebrasca: otherwise, I have a script to clean pathnames, remove spaces, and special characters, etc…
<pjb>
In my sysadmin days, I would merely remove those files…
<pjb>
I had some interesting crontab entries >:-}~
atgreen has joined #commonlisp
infra_red[m] has joined #commonlisp
kevingal has joined #commonlisp
NotThatRPG has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
NotThatRPG has joined #commonlisp
tevo has joined #commonlisp
waleee has joined #commonlisp
Guest63 has joined #commonlisp
gridbugsmasher42 has joined #commonlisp
Mrtn[m] has joined #commonlisp
zxcvz has joined #commonlisp
eddof13 has joined #commonlisp
lordmzte has joined #commonlisp
edgarvincent[m] has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
VOID[m] has joined #commonlisp
sp has joined #commonlisp
<ebrasca>
pjb: I like to preserve the original file names.
artemon has joined #commonlisp
<pjb>
ebrasca: pathname and parse-namestring will interpret it as wildcard, so you will need to escape the string yourself.
<pjb>
ie use parse-native-namestring (from pathname-utils or sb-ext).
<ebrasca>
How can I change the type of the file wichout problems?
bitmapper has quit [Quit: Connection closed for inactivity]
samedi has quit [Remote host closed the connection]
samedi has joined #commonlisp
BrownJenkin has joined #commonlisp
<ebrasca`>
pjb: It works, thanks!
ebrasca` is now known as ebrasca
waleee has quit [Ping timeout: 248 seconds]
NotThatRPG has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
NotThatRPG has joined #commonlisp
luna-is-here has quit [Quit: luna-is-here]
luna-is-here has joined #commonlisp
markb1 has quit [Ping timeout: 260 seconds]
tasty has quit [Quit: rebooting for kernel updates]
tasty_ has joined #commonlisp
tasty_ has quit [Changing host]
tasty_ has joined #commonlisp
<jcowan>
elderK: Give me another decade or two, and the Scheme standard will be plenty big.
<jcowan>
(if I am spared)
<bjorkintosh>
perhaps a dimunitive kernel would be derived from that, perhaps.
<bjorkintosh>
it might fit on a napkin, even.
<bjorkintosh>
it will generate many papers I'm sure. seems to be what scheme is good at: generating academic papers.
cdegroot has quit [*.net *.split]
OlCe has quit [*.net *.split]
SenFache has quit [*.net *.split]
yottabyte has quit [*.net *.split]
brettgilio has quit [*.net *.split]
Jach has quit [*.net *.split]
kaskal has quit [*.net *.split]
phadthai has quit [*.net *.split]
boigahs_ has quit [*.net *.split]
SAL9000 has quit [*.net *.split]
molson has quit [*.net *.split]
EsoAlgo8 has quit [*.net *.split]
Fade has quit [*.net *.split]
krjst has quit [*.net *.split]
phoe has quit [*.net *.split]
<jackdaniel>
if you want to compare standard sizes or something else then please go somewhere else. 'mine language is better because it is miner' is a boring and outworn trope
OlCe has joined #commonlisp
cdegroot has joined #commonlisp
SenFache has joined #commonlisp
yottabyte has joined #commonlisp
phadthai has joined #commonlisp
kaskal has joined #commonlisp
boigahs_ has joined #commonlisp
Jach has joined #commonlisp
Bike has joined #commonlisp
molson has joined #commonlisp
SAL9000 has joined #commonlisp
EsoAlgo8 has joined #commonlisp
brettgilio has joined #commonlisp
Fade has joined #commonlisp
krjst has joined #commonlisp
phoe has joined #commonlisp
<bjorkintosh>
nope. it will just be derived from the bigger one is all. not better or anything. it's all just 1s and 0s in the end.
SenFache has quit [Remote host closed the connection]
SenFache has joined #commonlisp
<White_Flame>
all ones are the same size. there is no bigger one
<jcowan>
jackdaniel: I was not the first to mention it
tyson2 has joined #commonlisp
rgherdt_ has joined #commonlisp
jaimelm_ is now known as jaimelm
rgherdt has quit [Ping timeout: 264 seconds]
waleee has joined #commonlisp
Guest63 has quit [Quit: Ping timeout (120 seconds)]
markb1 has joined #commonlisp
repeter`` has joined #commonlisp
repeter` has quit [Ping timeout: 252 seconds]
euandreh has joined #commonlisp
MetaYan has joined #commonlisp
Guest63 has joined #commonlisp
kenran has quit [Remote host closed the connection]
morganw has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
mariari has quit [Ping timeout: 268 seconds]
jmdaemon has joined #commonlisp
MajorBiscuit has quit [Quit: WeeChat 3.6]
pranavats has left #commonlisp [Error from remote client]
mariari has joined #commonlisp
<jackdaniel>
if anyone is interested in new text input gadgets in McCLIM then clone the repository and try them. there is a new demo in clim-examples text gadgets
<jackdaniel>
since it is an ongoing work there will probably be some issues, so please let me know if you found them
<ixelp>
GitHub - McCLIM/McCLIM: An implementation of the Common Lisp Interface Manager, version II
euandreh has quit [Remote host closed the connection]
euandreh has joined #commonlisp
rwxrwxrwx has quit [Remote host closed the connection]
pranavats has joined #commonlisp
igemnace has quit [Remote host closed the connection]
pranavats has left #commonlisp [Error from remote client]
varjag has joined #commonlisp
kevingal has quit [Ping timeout: 246 seconds]
green_ has joined #commonlisp
epony has quit [Read error: Connection reset by peer]
<ober>
jackdaniel: thanks. nice work.
atgreen has quit [Ping timeout: 256 seconds]
inline__ has joined #commonlisp
luna-is-here has quit [Quit: luna-is-here]
Inline has quit [Ping timeout: 264 seconds]
luna-is-here has joined #commonlisp
* ober
did not realize Clim was from Franz
<elderK>
jackdaniel: Did you used to hang out in #osdev? I'm sure I remember you from there :)
<jcowan>
That's why it needed to be replaced: it is proprietary.
<elderK>
jcowan: That'd be interesting. Don't get me wrong: I'm not saying Scheme is not useful. I really, really like Scheme. If I could find an implementation that was more image based, I'd probably use it over CL.
<jcowan>
Chibi has images. But we should discuss this in either #lisp or #scheme.
* ober
knew Symbolics did a lot of it, just did not know Franz had contributed as well
epony has joined #commonlisp
<jackdaniel>
ober: clim originates from symbolics
euandreh has quit [Remote host closed the connection]
<jackdaniel>
mcclim is not franz clim fork
<jackdaniel>
thanks, I've put a lot of effort to push it out of the door
<jackdaniel>
first 90% was easy :)
<jackdaniel>
elderK: I don't think I did, perhaps I've been lurking for some time
<ixelp>
metis/utils.lisp at b0333ff1b8d1502891ce8cb5839a8ca8ab589f10 · ober/metis · GitHub
<ober>
uiop:run-program "zcat ~A" was pretty damn quick.
cage has joined #commonlisp
jeosol has joined #commonlisp
masinter has quit [Ping timeout: 252 seconds]
masinter has joined #commonlisp
pranavats has joined #commonlisp
Guest63 has quit [Quit: Client closed]
qhong_ is now known as qhong
kevingal has joined #commonlisp
elderK has quit [Quit: Connection closed for inactivity]
ebrasca has quit [Remote host closed the connection]
_cymew_ has quit [Ping timeout: 260 seconds]
varjag has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
bjorkintosh has quit [Quit: Leaving]
inline__ has quit [Ping timeout: 256 seconds]
<qhong>
Is there an "unload" operation for ASDF, and if not, is there any difficulty?
<qhong>
There's already UPWARD-OPERATION, which I think can be used to implement an UNLOAD-OP?
zxcvz has quit [Quit: zxcvz]
Lycurgus has joined #commonlisp
karlosz has joined #commonlisp
Lycurgus has quit [Quit: Exeunt: personae.ai-integration.biz]
<yitzi>
qhong: You can clear systems as I recall, but that only removes ASDF's system instance from the central registry. It won't delete packages, etc.
<NotThatRPG>
There's no way to remove arbitrary code from a Lisp image, so there never will be an unload operation.
<jackdaniel>
technically speaking unloading is possible assuming we can clean up references
<jackdaniel>
(but of course no implementation has such a feature, just talking hypothetically)
<jackdaniel>
ecl for instance when loading a fasl calls underneath dlopen, so the module in question even has a handler that you could call dlclose on, however when it is loaded numerous side effects take place
<jackdaniel>
for example new packages are created and whatnot, so truly unloading it would require undoing these side effects what is reather unfeasible
<jackdaniel>
(or cutting short relevant references), so basically you would need to remove the environment too (perhaps first class global environments could help with that)
<jackdaniel>
but then (if you can dereference all objects loaded with the module), do you even need to unload it manually? it will get garbage collected anyway
rgherdt_ has quit [Remote host closed the connection]
<qhong>
NotThatRPG: there's way for the author of a particular code to write an unload specification
<qhong>
NotThatRPG: there's no way to build arbitrary code either, right? That's why we need DEFSYSTEM
<NotThatRPG>
You could create a list of all functions, methods, variables, and classes and then try to make them all unbound. I'm not sure, but my guess is that would have to be done extremely carefully, and could still go wrong, since a system could set properties on arbitrary symbols, etc. etc.
<Bike>
in most cases i imagine an unload could be written. most systems just consist of a bunch of global definitions, after all, and those are easy to tear down. but you'd have to do it manually and you'd have to keep things in sync
<NotThatRPG>
The CL spec *does* tell us how to build arbitrary code, and defsystem can build some subset of all buildable CL code. But unload would be excruciatingly difficult, and I can't imagine that the trouble one would put into it would every bey off.
<NotThatRPG>
s/bey/pay/
<qhong>
Emacs Lisp's unload-feature does it by logging all definitions during loading a feature, and also provide a custom *-unload-function hook
<qhong>
I'm thinking in a bigger context of a forever-running Lisp image. Only able to add system is not sustainable. Nowadays people are just used to a underlying Unix taking care of persistent state management and restart the Lisp process, sure
<qhong>
Bike: in fact for those systems, I think DELETE-PACKAGE already does a pretty good job
<White_Flame>
in many cases, a system contains more than one package
<White_Flame>
plus, if loading a system installed hooks somewhere, then just trying to delete the system still has all the registrations intact
<pjb>
fmakunbound
<White_Flame>
*delete the package
<qhong>
White_Flame: either a custom unload hook for doing it manually, or the underlying hook system can provide support for it, which can be fully automatic
<qhong>
if they're using one of the hook facility, say nhooks
<White_Flame>
which mean software has to intentionally have extra code to "play nice" in order to be uninstalled, and any other random code wont'
<qhong>
which is sort of the Unix status quo as well? I don't know much about Unix, that's my impression
dcb has joined #commonlisp
<White_Flame>
consider things like registering new method on existing generic functions
<qhong>
ah maybe no... *make* uninstall don't usually work, but *package_manager* uninstall almost always work
<White_Flame>
unix is just process separation and buffers/streams of bytes; it doesn't "know" much
<qhong>
I think maybe this concern could be assigned to distributor rather than authors
<qhong>
A "Lisp distro" author may curate a list of packages, and add missing unload code
<White_Flame>
that's a lot of work (eg a cartesian) for a small community with a lot of libs
<qhong>
White_Flame: or the package manager (I think it's a better assignee comparing the build system) could provide a mechanism for adding patches. So that the user can easily write their own patch, or someone can publish a repo of patches, before they get merged by upstream
<qhong>
Most functional package manager seem to support that, e.g. Guix and straight.el
cage has quit [Quit: rcirc on GNU Emacs 28.2]
<qhong>
speaking about this, when will we have a functional package manager in CL...
rtoy has joined #commonlisp
green_ has quit [Ping timeout: 252 seconds]
SenFache is now known as Sauvin
eddof13 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<NotThatRPG>
qhong: The late Drew McDermott had a build system that could do fine-grained loading and updates. If you would like to see what might be involved in unloading, that might be helpful. I don't believe there's an obvious way to automate unloading. You would have to be able to automatically detect the named entities that are added to the lisp image when you add a system.
kevingal has quit [Ping timeout: 260 seconds]
<NotThatRPG>
I suppose if you could find all the packages before loading a system and cache this information. Then you would find all the packages after loading the system. then you would have to grovel for changes, which might mean having to cache the full state of each of the packages before and after.
<NotThatRPG>
Then you would have to figure out how you want to handle the dependencies of a system when unloading it. Presumably you unload the systems it loaded, but NOT those systems that were already loaded (because those provide dependencies to other systems).
<NotThatRPG>
I encourage you to pseudo code an algorithm for this...
random-nick has quit [Ping timeout: 255 seconds]
morganw has quit [Remote host closed the connection]