<rotateq>
i saw at a linux from scratch site that it says to compile CLISP, it's very portable and smaller, isn't it? not that my linux skills would now be good enough to do LFS, but one day maybe ^^
amb007 has quit [Ping timeout: 268 seconds]
<hayley>
I never found a version of libsigsegv that CLISP would build with, so I just bootstrap using ECL.
sloanr` has quit [Remote host closed the connection]
sloanr` has joined #commonlisp
<rotateq>
it even ran on Atari ST ^^
srhm has quit [Remote host closed the connection]
<rotateq>
hayley: oh
<rotateq>
good point of course
<hayley>
...once I got ECL bootstrapped on a new RISC-V machine that you could SSH into. But I couldn't compile SBCL as it'd run out of memory building Unicode tables.
srhm has joined #commonlisp
<rotateq>
nice
<rotateq>
oh damn
<rotateq>
hayley: or maybe you write another kernel with Ru5t :D
<hayley>
Something like 768MB of memory, and someone else was running rustc at the same time. While it would have been funny to start a pkill cold war, I decided against it.
fmakuncertain has quit [Ping timeout: 268 seconds]
<rotateq>
yes it often needs many crates, time and resources to even compile simple applications with many dependencies
waleee has quit [Ping timeout: 240 seconds]
xsperry has quit [Ping timeout: 268 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
Alfr has quit [Remote host closed the connection]
Alfr has joined #commonlisp
notzmv has quit [Ping timeout: 252 seconds]
rotateq has quit [Ping timeout: 252 seconds]
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
VincentV` has quit [Remote host closed the connection]
rotateq has joined #commonlisp
fmakuncertain has joined #commonlisp
Everything has joined #commonlisp
<fiddlerwoaroof>
rotateq: LFS is a good way to build linux skills :)
<fiddlerwoaroof>
Work through it in a VM and google the problems you run into along the way
<fiddlerwoaroof>
Anyways, does anyone here use sbcl from nix?
<rotateq>
fiddlerwoaroof: yes! much more than just following stupid gentoo instructions
<rotateq>
i did on the NixOS machine, why?
<rotateq>
fiddlerwoaroof: i should try starting Mezzano again in kvm too again. aroung two years ago everything compiled, then i started the image, nothing to see and when i clicked in it it crashed my xmonad
<rotateq>
what also could be very interesting, building a raw operating system really from scratch in assembly and c
<fiddlerwoaroof>
I'm running into issues with loading libraries using nix on Debian
<rotateq>
oh hm
<rotateq>
what does it say?
<fiddlerwoaroof>
nix basically rewrites the paths programs search for libraries in, from what I can tell and I'm wondering if anyone has encountered this and figured out a workaround.
<fiddlerwoaroof>
From their matrix channel: "Yes, we set the interpreter path and the rpath of the binaries to Nix store paths"
<rotateq>
i often had problems when lib had to load shared object files that it can't find cause some important paths are else arranged
<rotateq>
I'm honest, even to today I didn't really deeply get how to do nix things on my own.
<fiddlerwoaroof>
I guess I could setup LD_LIBRARY_PATH with a shell script to make system libraries available again, but that's sort of annoying
<rotateq>
good old shell scripting :P
fmakuncertain has quit [Ping timeout: 240 seconds]
Jing has quit [Remote host closed the connection]
Jing has joined #commonlisp
KvL has joined #commonlisp
fmakuncertain has joined #commonlisp
Oladon has joined #commonlisp
<rotateq>
do you also have issues now loading the STR system?
aartaka has quit [Ping timeout: 240 seconds]
<rotateq>
it signals me an error "Failed to find TRUENAME of /usr/share/common-lisp/source/cl-ppcre/cl-ppcre-unicode/packages.lisp"
aartaka has joined #commonlisp
<Xach>
rotateq: sounds like you have some things installed by the os package system
s-liao has quit [Ping timeout: 256 seconds]
<rotateq>
yes of course, it's about me again :)
<rotateq>
maybe trying to just remove that
fmakuncertain has quit [Ping timeout: 240 seconds]
fmakuncertain has joined #commonlisp
fmakuncertain has quit [Quit: disconnected]
sloanr` has quit [Remote host closed the connection]
sloanr` has joined #commonlisp
s-liao has joined #commonlisp
Oladon has quit [Quit: Leaving.]
sloanr` has quit [Remote host closed the connection]
s-liao has quit [Quit: Ping timeout (120 seconds)]
sloanr` has joined #commonlisp
s-liao has joined #commonlisp
sloanr`` has joined #commonlisp
sloanr` has quit [Ping timeout: 240 seconds]
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
epolanski has quit [Quit: Connection closed for inactivity]
notzmv has joined #commonlisp
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
fmakuncertain has joined #commonlisp
Guest74 has quit [Ping timeout: 240 seconds]
sloanr`` has quit [Ping timeout: 240 seconds]
john__ has joined #commonlisp
srhm has quit [Remote host closed the connection]
sloanr`` has joined #commonlisp
srhm has joined #commonlisp
gaqwas has quit [Ping timeout: 256 seconds]
rotateq has quit [Ping timeout: 260 seconds]
fmakuncertain has quit [Ping timeout: 240 seconds]
<Spawns>
what are the variables after the function call part of the syntax called? parameter would be for functions, but what about if its for macros or let bindings for example
<Spawns>
(x y z) <- what are y and z called
<Spawns>
may be a dumb question but it's bothered me a bit
<hayley>
The HyperSpec includes names for syntactical elements.
<hayley>
e.g. LET has "var"iables, "declaration"s and a "body".
fmakuncertain has joined #commonlisp
<Spawns>
maybe body is what I am thinking of. i am making a little tiny compiler and don't know what to name the method. for compiling, i take each list, and look at the first element and determine the type of expression (funcall, let, if, etc), then I handle any special cases, then I compile the rest of the elements in a much more generic way
<Spawns>
the rest of them just use a basic visitor pattern type thing, most things emit constants, symbols get replaced with local and global vars, and new lists start the whole process again recursively
<Spawns>
so I named the generic compile thing compile_values() but that name is not very good. it might seem silly to go through a bunch of trouble just for a function name, but I honestly can't think of a good name for it
igemnace has quit [Remote host closed the connection]
terrorjack has joined #commonlisp
<Spawns>
very neat
<Spawns>
i don't have macros yet, or really much of anything actually
<Spawns>
my goal for now is to just get local vars and basic operations like + - / * and print finished
<Spawns>
once the internal lisp can actually do something semiuseful i will rewrite what I can in the language! I want to even do read macros in the language itself, if possible
<hayley>
Hypothetically, basic operations should just fall out if you can call foreign functions.
<Spawns>
what do you mean by fall out?
fmakuncertain has quit [Ping timeout: 240 seconds]
<hayley>
I mean having a way to call functions in the host language would mean you don't have to handle +, -, /, *, and print specially.
<Spawns>
right right, I was wondering about that
<Spawns>
how hard is it to setup basic ffi? I am using rust but it can expose a C ffi
<Spawns>
i'll have to do a lot of research on this
<hayley>
It's not "FFI" per se.
<hayley>
You'd have some sort of foreign function object, and the evaluator (probably in your apply[] function) would know how to call a foreign function.
<Spawns>
and it would call the + method in the host language?
<Spawns>
or something roughly like that
<hayley>
Right.
notzmv has quit [Ping timeout: 268 seconds]
Everything has quit [Quit: leaving]
<beach>
Good morning everyone!
<beach>
Spawns: The variables in the definition of a function are called "parameters", and the forms (which are not necessarily variables) following the function name in a function call are called "arguments".
<beach>
engblom: When you say things like "and it is using push now instead of rewriting the whole list", it sounds like you have a fundamental misunderstanding of how Common Lisp works. In what way does ACONS "rewrite the whole list"?
<beach>
engblom: And in what way does PUSH not do the exact same thing as ACONS + SETF?
<Spawns>
thank you beach, i think I was overthinking this
<beach>
Oh? In what way?
taiju has quit [Ping timeout: 240 seconds]
Lycurgus has joined #commonlisp
<Spawns>
i should have just called it compile_parameters() and called it a day
<Spawns>
that is descriptive enough to let a reader understand roughly whats going on
<Spawns>
human reader >.<
<beach>
I think that's exactly the opposite of what I just said, no?
<hayley>
Well, stupid thought, why does it take multiple parameters? Are the semantics different to compiling each parameter individually in your implementation?
<beach>
The "parameters" are the variables you find in the function *definition*, not in the function *call*.
<Spawns>
oh my I see now
<Spawns>
yes you are right
<Lycurgus>
anybody know when the mccarthy thinking allowed interview/episode was filmed?
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
taiju has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
aartaka has joined #commonlisp
<Lycurgus>
also beach, while you and i find it deplorable, 'guys' is now commonly accepted to be unisex
<Lycurgus>
but not "dudes"
<beach>
I understand. Thanks.
cjb has quit [Quit: rcirc on GNU Emacs 29.0.50]
semz has quit [Ping timeout: 252 seconds]
john__ has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
semz has joined #commonlisp
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
notzmv has joined #commonlisp
Bike has quit [Quit: Lost terminal]
sloanr`` has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<fiddlerwoaroof>
It's sort of amusing the errors you run into when you mess with printing
<fiddlerwoaroof>
doing things like using set-pprint-dispatch to override pretty printing for standard types or changing *print-case* break a lot of libraries
<fiddlerwoaroof>
especially libraries that try to make symbols out of strings without turning off *print-pretty*
Lycurgus has joined #commonlisp
* Lycurgus
c. '97 implicitly by reference to deep blue vs kasparov
Lycurgus has quit [Quit: Exeunt]
amb007 has quit [Ping timeout: 256 seconds]
sloanr has quit [Ping timeout: 240 seconds]
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
sloanr has joined #commonlisp
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
Guest74 has joined #commonlisp
Fare has joined #commonlisp
spiaggia has joined #commonlisp
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
engblom has quit [Read error: Connection reset by peer]
Guest74 has quit [Quit: Ping timeout (120 seconds)]
treflip has joined #commonlisp
engblom has joined #commonlisp
<spiaggia>
engblom: Are you around?
robin has quit [Quit: Leaving]
Krystof has quit [Ping timeout: 240 seconds]
robin has joined #commonlisp
Cymew has joined #commonlisp
Algernon69 has joined #commonlisp
sloanr has quit [Ping timeout: 240 seconds]
Algernon91 has joined #commonlisp
unixlisp has joined #commonlisp
Guest74 has joined #commonlisp
Algernon69 has quit [Ping timeout: 240 seconds]
<unixlisp>
scymtym: "Produce new specifications without legal complications" bzflag.bz/~starseeker/Project_FreeSpec dpANS copyright is not clear (whatever leave it alone)
shka has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
s-liao has quit [Quit: Client closed]
contrapunctus has joined #commonlisp
KvL has quit [Quit: KvL]
lisp123 has joined #commonlisp
<lisp123>
(theoretical question) Is there a way to control the order of :around methods being applied via call-next-method?
<lisp123>
it may just be a stupid idea, I was just reading how it works so was curious
<flip214>
> The default order for the primary methods is :most-specific-first. However, the order can be reversed by supplying :most-specific-last as the second argument to the :method-combination option.
<flip214>
and you can reorder your parent classes as well
<lisp123>
flip214: I was wondering if its possible to do without reordering the parent classes
<lisp123>
flip214: Thanks for the link and info, I didn't know about :most-specific-last
<spiaggia>
As I recall, the standard method combination does not take any arguments.
<spiaggia>
flip214: Where did you see that the standard method combination takes an argument?
<flip214>
spiaggia: right, for the simple method combinations only
spiaggia has quit [Quit: ERC (IRC client for Emacs 26.3)]
s-liao has quit [Quit: Client closed]
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
<engblom>
beach: I might have misunderstood something. What I imagine would happen with setf + acons is that acons create a new list (thus a copy of the whole list) and then when I "overwrite" the old list with setf, the reference is changed to the new list and the old list ends up in GC.
<engblom>
beach: I imagined that no new list would be made with push, but instead a new element is linked in to the old list
<hayley>
You aren't overwriting the list though; you are just overwriting the value in the relevant binding.
<hayley>
Suppose that you had another variable bound to the list; if you "overwrote" the list, it would be expected that the updates would be visible through the other variable.
<engblom>
hayley: Yes, it would because there is still a reference to it then, so nothing for GC to take care of. I know "overwrite" was the wrong term as the refence is just updated to point to a new list.
<hayley>
For the most part, you can think of object identity as the answers to a set of "what would happen if I did this destructive operation?" questions. So, suggesting that different effects occur by a particular operation implies that the identities are different.
<hayley>
By definition, the GC doesn't do anything that you can observe, as it only reclaims dead objects, so we don't need to talk about it. (This ignores the existence of finalizers, and effects on program execution relative to physical time and memory, but I don't think any languages say anything about real time and memory guarantees.)
<engblom>
The original question was whatever it is better to use (setf ... (acons ...)) or (push (cons ...) ...)
makomo has quit [Ping timeout: 240 seconds]
<hayley>
Tricky one, that. I would say the former, as it is more apparent that you are working on an alist to me.
<hayley>
(But if you are not working on an alist, use the latter then :)
<engblom>
I was thinking that as acons creates a new list with the cons linked in, that it would be slower than operating directly on the list with push.
attila_lendvai has joined #commonlisp
<engblom>
Yes, it is alists that I working on. I wrote a function that recursively converts nested plists to alists.
<unixlisp>
engblom: equivalent. but PUSH nice.
<beach>
engblom: Common Lisp never implicitly copies anything. That's what I feared you were thinking, and it is not the case.
<unixlisp>
acons DO create a new list, shared with old list (not copy it)
<beach>
engblom: In both cases, as I pointed out yesterday (UTC+1) a new CONS cell is created and prepended to the existing list.
<engblom>
Now I understand! Thank you!
<beach>
Sure. It is important to understand stuff like this, because it is the very basis of the "uniform reference semantics" of Common Lisp.
<engblom>
beach: If you would use append, and then want to use setf to update the reference, what is then happening?
<beach>
engblom: APPEND copies all lists except the last one.
<engblom>
beach: OK, then I guessed right about that one
<beach>
But it is not "implicit". The dictionary entry for APPEND states this fact explicitly.
<beach>
The destructive version of APPEND is NCONC. It modifies the CDR of the last CONS cell of all list except the last one. [I hope that's right]
<engblom>
Is it better to use nconc rather than what I am doing now. I am pushing one cons at the time and then when all are pushed I do reverse on the result so the plist-to-alist function I created maintain the original order.
<beach>
PUSH and then reverse at the end is more efficient.
<beach>
Each PUSH is O(1) and reverse is O(n).
<engblom>
Yep
<mfiano>
Or nreverse
<beach>
So the entire operation is O(n).
<mfiano>
But why create such a function when one already exists?
<engblom>
mfiano: I do not know about any such function that does it recursively. The one in alexandria does only do it for one level
<engblom>
The plist-alist from alexandria
Krystof has joined #commonlisp
<engblom>
imagine that you have (:a 1 :b (:c 2 :d (:e 3 :f 4)))
<mfiano>
I see, yes, that I'm not aware of, because most people would use proper data structures for that purpose.
<unixlisp>
engblom: use (loop ... collect...) without reverse or nreverse seems more efficient at sbcl
<mfiano>
It's still O(n) keeping references
<unixlisp>
SB-LOOP::LOOP-COLLECT-RPLACD efficient
<mfiano>
Right, keeping references
<unixlisp>
keep tail
<engblom>
mfiano: In this case I have some quite big configuration files that is supposed to be hand edited. As plists are easy to edit by hand I use them. They are not even proper plists as I use strings for keys, thus I need to convert them to something else. Alists allows to set test to equalp so I convert the "plist" to alist.
<engblom>
I was converting them to hash-tables, but while developing alists are easier to handle as they are human readable too.
<engblom>
Ah, ok. I am not at my computer at home, where I do lisp development so I never tested the function you pasted.
<flip214>
engblom: YAML is kind-of-nice to read and edit as well.
peterhil_ has joined #commonlisp
<mfiano>
Personally I would parse the structure into standard-objects to make use of generic protocols.
<mfiano>
Nested primitive structures are not very flexible.
Jing has quit [Remote host closed the connection]
peterhil has quit [Ping timeout: 240 seconds]
Jing has joined #commonlisp
<unixlisp>
transparent
<mfiano>
unixlisp: Can you use complete sentences?
<unixlisp>
sorry. nested primitive structures are transparent
<mfiano>
That wasn't my argument.
<unixlisp>
yeah. your argument is right.
igemnace has joined #commonlisp
Lord_Nightmare has quit [Ping timeout: 260 seconds]
pve has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
pranavats has joined #commonlisp
Fare has quit [Ping timeout: 240 seconds]
unixlisp has left #commonlisp [#commonlisp]
s-liao has joined #commonlisp
aeth has quit [Ping timeout: 252 seconds]
cage has joined #commonlisp
aeth has joined #commonlisp
<phantomics>
A question if anyone knows: I was using SBCL 2.0.2 for a long time, then upgraded to 2.1.7 recently. Both were built from source on my computer. In 2.0.2 the array-rank-limit was 65529 (2^16-7), and in 2.1.7 the limit is 256. Does anyone know why? I don't know how often anyone uses such super-dimensional arrays, did they turn out to cause problems?
<flip214>
was 10 in the meantime, then got bumped up again
s-liao has quit [Ping timeout: 256 seconds]
<phantomics>
It seems they just reduced it to 129
<phantomics>
In the latest version, and it was moved from src/code/early-array.lisp to early-vm.lisp
lisp123 has quit [Quit: Leaving...]
* rogersm
is intrigued to know how phantomics discovered the change
<rotateq>
hi phantomics :) good to see lines of you again
<phantomics>
I just entered array-rank-limit on a whim
<phantomics>
Hey rotateq, good to hear from you
<rotateq>
thank you :) didn't want to interrupt
<rogersm>
oh! I though you had some 'interesting' code that required tens of thousands of dimensions.
<jackdaniel>
ccl has 4096, ecl has 64
<jackdaniel>
for comparison
s-liao has joined #commonlisp
<phantomics>
Here is the rationale for 129 from SBCL: Since the array rank is stored as rank-1 in the array header, having it stop at 128 ensures that adding 1 produces an unsigned result.
<phantomics>
Does anyone know the rationales for 4096, 256 and 64? Different preferences for width of the rank value?
<phantomics>
Also the current version of Clasp has just 8, the ANSI minimum
<phantomics>
I'd be interested to hear of any use cases for really high-rank arrays, I heard some ML techniques can use dozens of dimensions but not hundreds
<hayley>
I think high-rank arrays appear in representing Markov chains, though most values are zero and thus you usually use a sparse representation.
<phantomics>
I.e. 0 0 0 0 ... 0 0 0 0⍴something? With a few nonzeroes thrown in?
<hayley>
If you had a language with N words, and wanted a chain of degree(?) C, then you would have (C⍴N)⍴something
<hayley>
...or something like that. Each transition of a Markov chain is defined by mapping the last N words to a mapping of next words -> probability.
<hayley>
...and hence why people use sparse representations, since almost all probabilities are zero.
<phantomics>
neat
* rotateq
didn't understand really yet the deeper difference of shape and rank in APL
<rotateq>
or even on their own :)
Fare has quit [Quit: Leaving]
<phantomics>
how is the difference between shape and rank unclear?
<rotateq>
phantomics: for YOU all these concepts are clear now :)
<phantomics>
what do you see as unclear about it?
<rotateq>
that i first have to remember. but it would be for query
<phantomics>
Like you mean fetching elements of an array, giving the coordinates?
<rotateq>
öhm maybe? :D
<phantomics>
In terms of implementation, all arrays are really just vectors in funny suits
<rotateq>
sure
<rotateq>
or displaced arrays in other arrays ^^
<phantomics>
For an n-dimensional array, you take the coordinates for an element, multiply each coordinate by a set of factors determined by the array's dimensions, and then add the products to get the row-major index
<phantomics>
This is how (aref) works under the hood if you check out its source
<phantomics>
Every (aref) is really a (row-major-aref) in disguise
<rotateq>
again I would say not soo on-topic here :) but maybe in terms of how CL (implementations) handle arrays
<phantomics>
Although it would be interesting if there were some kind of exotic RAM that had a hardware-accelerated implementation of matrices or even 3D arrays... perhaps that would allow you to iterate over a given column index in the rows of a row-major matrix as quickly as you could iterate over each column index in a row
<jackdaniel>
phantomics: not necessarily true; in principle implementation could incorporate conformal displacement
cosimone has joined #commonlisp
<jackdaniel>
then there are some additional computations to compute the "real" index
<rotateq>
phantomics: maybe possible to build with FPGA, who knows :D
<rotateq>
jackdaniel: uii
<phantomics>
Cool, thanks
<jackdaniel>
sure
<hayley>
phantomics: Pedantically DRAM is addressed as a 2D array of...some unit that I forgot, but it has "columns" and "rows". But, of course, those units are provided by the hardware manufacturer.
<phantomics>
That's natural given the structure of the semiconductor. I don't know if an array in memory could be aligned with that structure to give some kind of advantage in access time
ldb has joined #commonlisp
omr has joined #commonlisp
waleee has joined #commonlisp
<hayley>
I haven't heard of such a technique, but it could work. At the least, I think reducing the number of "commands" to step en the major index would improve performance.
ldb has quit [Ping timeout: 240 seconds]
ldb has joined #commonlisp
OlCe has joined #commonlisp
ldb has quit [Ping timeout: 240 seconds]
Lycurgus has joined #commonlisp
<Lycurgus>
unixlisp pointed out that Thinking Allowed had posted that the mccarthy interview was recorded in March 1989
<Lycurgus>
he (mccarthy) only says 'grand master' and not world champion and the actual first defeat of a high ranking player was in '87 with deep thought
random-nick has joined #commonlisp
<Lycurgus>
also the difference between his appearance there and the '07 oral history where he's interviewed by nils nilson is more consistent with 20 than 10 years
<jackdaniel>
hello aver my old friend, dword and qword are not equal size again! :)
<Lycurgus>
that doesn't look different from the tarball posted on hotz's homepage
<Lycurgus>
except that it's incomplete and doesn't for example include the asdf defined test sys
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
<unixlisp>
(make-array 1 :weak t ...) in objectstore.lisp sbcl do not support :weat keyword.
<Lycurgus>
if you're referring to netclos, it's acl dependent
<Lycurgus>
jackdaniel, aver?
<jackdaniel>
that's an internal consistency check in sbcl
<Lycurgus>
ah
<Lycurgus>
sounds like a 32bit dingleberry
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
<unixlisp>
so netclos may not work well in sbcl?
amb007 has quit [Read error: Connection reset by peer]
<Lycurgus>
i'm not actually sure everything in my working dir for netclos came from the tarball but there's a lot more than has made it to that github repo
amb007 has joined #commonlisp
<Lycurgus>
no, netclos won't work with sbcl without a lot of work and maybe not at all
<unixlisp>
ah. regret.
<Lycurgus>
btw is there any better implementation independence thing than roswell et. al.?
<Lycurgus>
working with a lot of ad hoc things at present
<Lycurgus>
otoh it will work with acl 10.1
<Lycurgus>
also you need the Chaco lib
<Lycurgus>
(maintained by sandia labs)
<unixlisp>
acl express version?
<rotateq>
unixlisp: weat xD
<Lycurgus>
unixlisp, yes
Bike has joined #commonlisp
<unixlisp>
Lycurgus: good news
ebrasca has joined #commonlisp
aartaka has quit [Ping timeout: 268 seconds]
s-liao has quit [Quit: Client closed]
<Lycurgus>
sfaik, unlike lw, the only restriction in acl express is the binary expiry and ofc you can't distribute it
<Lycurgus>
as far as base ACL
<unixlisp>
Chaco is c lib!
<Lycurgus>
s/maybe not at all/,more than you're likely up to/ since both things in question are fully open source
<Lycurgus>
yeah it's unproblematic, buildwise
<Lycurgus>
cl-actors is way simpler and more recently maintained but netclos is more consistent with the grandiosity of cl
<Lycurgus>
and i'm guessin lparallel is actually to most used
<Lycurgus>
*the most
omr has quit [Quit: WeeChat 3.3]
<unixlisp>
yeah. just wonder how CL faces parallel and concurrency.
<unixlisp>
cl-actors: It's implemented on top of Bordeaux-Threads
<Lycurgus>
yeah all 3 are solid pkgs, netclos is maybe over the top
<Lycurgus>
as well as being stale, unmaintained
<Lycurgus>
from a set of fortran subroutines to here: journey
<Lycurgus>
well all the thoughtless parallelism u prolly should want is already in modern hardware and base OS
miique has quit [Ping timeout: 245 seconds]
s-liao has joined #commonlisp
<unixlisp>
do not need on the level of programming language?
tyson2 has joined #commonlisp
<Bike>
i have a sort of draft specification for atomic operation semantics, but it would need implementation buy-in to go anywhere
taiju has quit [Remote host closed the connection]
<Bike>
(implementations do have atomics already, just not in any uniform way)
taiju has joined #commonlisp
<unixlisp>
good advance
<Lycurgus>
unixlisp, no I meant that the level where you think about wether you need or can benefit from parallelism at all and then how is operative
<unixlisp>
that is, CL needs not fundamentally change?
<Bike>
no, i think you would need changes. bordeaux is already halfway to being a language extension.
<Lycurgus>
i dunno it's not a static lang
<Lycurgus>
at some point it might be addressed as seriously as the object system was
<Lycurgus>
or conditons or whatever
<Lycurgus>
inevitable maybe if cl lasts another 30 y
<Bike>
somebody has to put in the effort to do such "inevitable" things.
<unixlisp>
bordeaux more like on top of lisp, need not change spec.
<jackdaniel>
that's inevitable that someone will ! ;)
<Bike>
well, adding to a specification counts as a change in my book
<Lycurgus>
everything sags under the weight of the price system's senescence process, it's amazing how fast things moved in the so called golden age of capitalism
<Bike>
if you mean, would a parallelism extension entail changes to the uniprocessor language that already exist, probably not
<Bike>
exists
<Bike>
some of the semantics of it might need to be rewritten to accomodate concurrency, but i don't see any reason to break existing code that doesn't use concurrency
<unixlisp>
keeping compatibility is a big feature of CL. hope CL keeping peaceful with concurrency and parallel.
unixlisp has left #commonlisp [#commonlisp]
Lycurgus has quit [Quit: Exeunt]
s-liao has quit [Quit: Client closed]
s-liao has joined #commonlisp
igemnace has quit [Remote host closed the connection]
aartaka has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
Alfr has quit [Ping timeout: 268 seconds]
amb007 has joined #commonlisp
Alfr has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
sloanr has joined #commonlisp
s-liao has quit [Quit: Client closed]
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
srhm has quit [Remote host closed the connection]
srhm has joined #commonlisp
igemnace has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
euandreh has quit [Ping timeout: 240 seconds]
aartaka has quit [Ping timeout: 256 seconds]
srhm has quit [Ping timeout: 260 seconds]
aartaka has joined #commonlisp
nitrowheels has joined #commonlisp
<aeth>
to be fair, the only way you break compatibility in CL is if you mess with the reader in some way
<aeth>
because otherwise, even if you did release a new version of CL every year with 'breaking' changes, you could just version them behind CL2022, CL2023, CL2024, etc., packages.
<aeth>
implementation maintainers would hate you, though
<rotateq>
aeth: yes :D
<Bike>
i think that is an optimistic take on how well versioning works.
<rotateq>
i had such funny situation from time to time
<aeth>
oh, sorry, the reader or DEFPACKAGE, unfortunately
<aeth>
since DEFPACKAGE isn't the greatest
<rotateq>
implementation would fork you, but then with real forks in their hands xD
<aeth>
I guess you could just replace DEFPACKAGE, though
<rotateq>
ah right defpackage
aartaka has quit [Ping timeout: 260 seconds]
Algernon666 has joined #commonlisp
Algernon91 has quit [Read error: Connection reset by peer]
Algernon91 has joined #commonlisp
Algernon666 has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Algernon91 has quit [Ping timeout: 240 seconds]
tyson2 has quit [Remote host closed the connection]
Algernon91 has joined #commonlisp
sloanr has quit [Ping timeout: 256 seconds]
Algernon666 has joined #commonlisp
Algernon91 has quit [Ping timeout: 252 seconds]
convexferret has joined #commonlisp
euandreh has joined #commonlisp
convexferret has quit [Remote host closed the connection]
VincentVega has joined #commonlisp
makomo has joined #commonlisp
ajoberstar has joined #commonlisp
<White_Flame>
aeth: still just CL:DEFPACKAGE vs CL2022:DEFPACKAGE etc
<jackdaniel>
at a procedure that eliminates branches from the generic function dispatch tree
treflip has quit [Remote host closed the connection]
treflip has joined #commonlisp
<aeth>
White_Flame: yes, but...
<aeth>
White_Flame: you need DEFPACKAGE to do this. Or IN-PACKAGE, I guess
<aeth>
So it's slightly circular and what the expected default FOO:DEFPACKAGE is will determine what people will put in there (e.g. package local nicknames)
<White_Flame>
you start off in a package. If your default package is CL-USER, which USEs CL, vs CL2022-USER, which USEs CL2022...
<aeth>
I do have to say, though, that it's a good thing that people didn't decide to do this this year or they may have chosen CL21
<jackdaniel>
columns marked "split" show the decision point
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Algernon91 has joined #commonlisp
Catie has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
lottaquestions has quit [Ping timeout: 240 seconds]
Algernon666 has quit [Ping timeout: 252 seconds]
peterhil_ has quit [Remote host closed the connection]
peterhil_ has joined #commonlisp
epolanski has joined #commonlisp
asarch has joined #commonlisp
thomaslewis has joined #commonlisp
Oladon has joined #commonlisp
gaqwas has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
aartaka has joined #commonlisp
karlosz has joined #commonlisp
karlosz has quit [Quit: karlosz]
treflip has quit [Quit: good night ✨]
Guest74 has quit [Quit: Connection closed]
<Josh_2>
With bknr is there a general consensus for how often one should snapshot?
Algernon91 has quit [Read error: Connection reset by peer]
<Josh_2>
ANONYMOUS-TRANSACTION-IN-TRANSACTION :( I am getting this condition inconsistently
<Josh_2>
from what I can see there are no nested transactions
waleee has quit [Ping timeout: 252 seconds]
waleee has joined #commonlisp
<Josh_2>
Oops
<Josh_2>
I figured it out
yewscion_ has joined #commonlisp
igemnace has quit [Quit: WeeChat 3.3]
ajoberstar has quit [Ping timeout: 268 seconds]
marcoxa has joined #commonlisp
Lord_Nightmare has joined #commonlisp
nitrowheels has quit [Quit: Leaving]
notzmv has quit [Ping timeout: 268 seconds]
VincentV` has joined #commonlisp
VincentVega has quit [Ping timeout: 240 seconds]
tyson2 has quit [Remote host closed the connection]
loskutak has joined #commonlisp
Guest74 has joined #commonlisp
epolanski has quit [Quit: Connection closed for inactivity]
aartaka has quit [Ping timeout: 256 seconds]
aartaka has joined #commonlisp
cjb has joined #commonlisp
Algernon91 has joined #commonlisp
utis has joined #commonlisp
<utis>
ahoy-hoy
<utis>
how does one find the hash-function used for strings?
<utis>
i wanted to use #'string-equal as the test, but i'm not sure what hash function to specify
amb007 has quit [Read error: Connection reset by peer]
poselyqualityles has joined #commonlisp
<Josh_2>
use equal
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<Bike>
utis: for standard hash tables you don't specify a hash function. are you using a library or extension?
<marcoxa>
utis: hash-tables (unfortunately) only accept EQ, EQL (the default), EQUAL and EQUALP. These four cover most cases, including strings and Josh_2 ponted out.
<marcoxa>
Weeeeeel... maybe no so "unfortunately".
<fiddlerwoaroof>
I wonder how many implementations extend hash tables here
<fiddlerwoaroof>
SBCL has sb-ext:define-hash-table-test
<Bike>
that said, string-equal and equalp coincide on strings anyway
<fiddlerwoaroof>
Probably don't use that, though :)
<fiddlerwoaroof>
At least, don't use it if the default set of tests works
<semz>
I don't really get the design of this library. Why codewalking?
<utis>
well, i want to use symbols, but that gets me into trouble when i try to supply the symbols from another package
<semz>
You can specify a package, e.g. 'foo:sym, 'bar:sym instead of 'sym
<utis>
if i understood weitz, it's possible to use a custom test if one also supplies a hash function?
<semz>
Or keywords
tyson2 has joined #commonlisp
<marcoxa>
utis: in general you need to supply a test AND a hash function; they go together. However, in CL you do not have control over SXHASH. Implementations (I'll name the sin, but not the sinner) have been known t returns something like ... 42 upon calls to (SXHASH some-random-struct).
<marcoxa>
As an example, Java is very clear about how you should specialize hashCode() and equals() methods together.
cage has quit [Quit: rcirc on GNU Emacs 27.1]
aeth has quit [Ping timeout: 252 seconds]
shka has quit [Ping timeout: 240 seconds]
aeth has joined #commonlisp
<Nilby>
utisor you could use the symbol-name as the key if that's what you want, then you don't have to use a non-standard solution
aartaka has quit [Ping timeout: 268 seconds]
poselyqualityles has quit [Ping timeout: 240 seconds]
<utis>
Nilby: do you mean i could use strings instead of symbols? i just find symbols so much neater . .
sander has quit [Read error: Connection reset by peer]
<Xach>
utis: that is not what is meant.
<Xach>
utis: the suggestion is to use a part of the symbol that does not change when the package of a symbol is different
ajoberstar has joined #commonlisp
<Xach>
but it's hard to tell what suggestion is best without a little more info about the problem
sander has joined #commonlisp
aartaka has joined #commonlisp
<Xach>
utis: what are you doing that you find symbols so appealing?
<Nilby>
utis: I just mean using (gethash (symbol-name symbol) table) instead of (gethash symbol table) . That way you can use an #'equal test and the standard tables.
peterhil_ has quit [Remote host closed the connection]
<utis>
i just find it annoying to type double quotation marks, and i also find them a bit ugly to look at
<Xach>
utis: but that is not what is suggested
<utis>
all right, it think i understand. thanks!
<Nilby>
I prefer symbols too. If you wrap the access in a few functions everthing else can just see symbols.
<Nilby>
Like when I'm loading a 100GB CSV, symbols make it much smaller, but then the table view can just pretend it's strings for search and sorting.
Algernon91 has quit [Ping timeout: 268 seconds]
<Guest74>
100GB csv?
<Nilby>
yes, or frequently bigger, is surprisingly common in some places
<Guest74>
for what out of curiousity?
<pjb>
datasets.
<Guest74>
really?
<Nilby>
database dumps, financial transactions, server logs, goverenment data, etc. Even sometimes crap from excel
<rotateq>
Nilby: excel :D
aartaka has quit [Ping timeout: 256 seconds]
<Nilby>
If you store it compressed, stream load into symbols, which depending on dataset, removes a lot of entropy, I can sometimes even just view it from memory on a typical laptop. It's usually better in you throw in a disk database for real work.
<Nilby>
100GB is actually very tiny for modern datasets, nowhere near planet scale
<rotateq>
phew
<rotateq>
or the sizes they have at CERN
<Nilby>
ya, physics data gets very chunky. It's usualy not in csv, but in some only very slightly more efficent physics formats
attila_lendvai has quit [Ping timeout: 268 seconds]
<Nilby>
one time lisp beat out the python and c++ entries in a cern data analsys contest
<Guest74>
Is there a function to remove a specific position from a sequence?
<Bike>
nope. there are some ways one can hack it up
<Guest74>
yeah, i'm using start and end, but just wondering.
<_death>
(remove-if (constantly t) '(a b c d e) :start 2 :end 3)
<Guest74>
my goto is if-not #'null
<Bike>
unlike deaths, that is sensitive to the actual contents of the sequence, isn't it?
<Bike>
if you have nil at that position it wouldn't actually be removed.
<Guest74>
I'm not sure I've ever used nil in a sequence. and i tend to only use it when I have odd stuff in the sequence.
<Nilby>
The constantly version also seems to get optimized quite well.
<Bike>
does it?
<Bike>
doesn't really look like anything special to me on sbcl
sloanr has joined #commonlisp
<Nilby>
Hmmm. It went fast, but disassemble doesn't look as good as I expected
<Guest74>
seems pretty much the same.
<Guest74>
except #'null is handed to it.
<Bike>
no matter what you're going to be allocating a new sequence of variable length and copying into it
<Nilby>
I was expecting it could just do the list splice, but I guess not
<Bike>
i don't believe remove is permitted to have its result share structure with the input
<Bike>
oh, no, it can
<_death>
Bike: it does?
<Bike>
huh
<Bike>
what?
<_death>
Bike: I meant, it does.. that's one advantage (sometimes) of using a nondestructive operator
<Bike>
oh, yeah. i mean i checked after i said that, the standard says as much
<_death>
if you want to avoid allocations you can use replace.. for vectors maybe have a fill pointer
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<mfiano>
for lists just walk to n+1 and rplacd n-1 as n+1 ?
<_death>
yeah
<mfiano>
if array order is not important just swap last element
<mfiano>
and add a tombstone
<_death>
mfiano: with a fill pointer you can swap and vector-pop
<mfiano>
true
<Guest74>
I guess if i didn't care about the order I could rotatef and use a fill pointer.
<mfiano>
just (setf (aref array n) (vector-pop array))
<_death>
that means you need to handle some edge cases
<mfiano>
yes
miique has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<mfiano>
I implement a few custom data structures that do this, but keeping old data in a freelist to be reclaimed instead of incrementing new counters towards positive infinity for a custom allocator.
<_death>
if the sequence is very large (e.g., an editor's character buffer) there are other data structures
cosimone has quit [Ping timeout: 252 seconds]
<mfiano>
like a rope or gap buffer
poselyqualityles has joined #commonlisp
<jeosol>
VincentVega: hmmm#vb%otd$-mp!
<jeosol>
Good morning guys
<jeosol>
VincentVega: please ignore that gibberish
<rotateq>
ohai jeosol
<jeosol>
rotateq: doing well
<rotateq>
yes hope you too
s-liao has joined #commonlisp
Jing has quit [Remote host closed the connection]
Jing has joined #commonlisp
ajoberstar has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]