<aeth>
In a sense, the whole file boundary thing is a big issue even outside of languages like CL. I think in the LLVM/GCC world this is the issue of "LTO" or "link time optimization" that is a hard problem to do right.
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
<aeth>
karlosz: SBCL can make more inferences about standard CL package functions because it has a package lock on them so they can't be redefined, and it might even have type declarations on them, I'm not sure.
<karlosz>
aeth: SBCL does not infer dynamic extentness pass function boundaries
<karlosz>
yes, that's correct
cosimone has quit [Ping timeout: 260 seconds]
jamzattack has left #lisp ["ERC (IRC client for Emacs 28.0.50)"]
<aeth>
karlosz: ah, okay, you're probably right, because it would always be problematic even without (safety 0)
terpri has quit [Remote host closed the connection]
decent-username has quit [Quit: ERC (IRC client for Emacs 26.3)]
random-nick has quit [Ping timeout: 260 seconds]
Jeanne-Kamikaze has joined #lisp
<emaczen>
Did the bounty for passing and returning c structs in SBCL get solved?
holycow has quit [Quit: Lost terminal]
jack_rabbit has quit [Ping timeout: 265 seconds]
turona_ has joined #lisp
turona has quit [Ping timeout: 272 seconds]
xkapastel has joined #lisp
holycow has joined #lisp
varjag has quit [Ping timeout: 272 seconds]
<Jeanne-Kamikaze>
Hi, can someone help me getting started? I am trying to run the example on this website: http://wookie.lyonbros.com/ I have installed sbcl, quicklisp and spacemacs with slime. When I load the example into slime, or when I run sbcl --script myfile.lisp, I get an error: 'The name "WOOKIE" does not designate any package'. I have installed the package with (ql:quickload "wookie"), but it seems that sbcl on its own won't find it. What am I missing
<Jeanne-Kamikaze>
here? Thanks.
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
<_death>
you need to quickload it every time the script runs, or you can save an image with it loaded
<_death>
you can also write a system definition for your project saying it depends on wookie, and quickload that or save an image with that
marusich has joined #lisp
karlosz has quit [Quit: karlosz]
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 258 seconds]
harovali has joined #lisp
Necktwi has quit [Ping timeout: 268 seconds]
Oladon has quit [Quit: Leaving.]
Necktwi has joined #lisp
hsaziz has joined #lisp
z147 has quit [Quit: z147]
slyrus__ has joined #lisp
Kaisyu72 has joined #lisp
Kaisyu7 has quit [Ping timeout: 265 seconds]
slyrus_ has quit [Ping timeout: 258 seconds]
terpri has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
raghavgururajan has joined #lisp
asdf_asdf_asdf has quit [Quit: asdf_asdf_asdf]
gko_ has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
econdudeawesome has quit [Quit: leaving]
jack_rabbit has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
ahungry has joined #lisp
<Jeanne-Kamikaze>
Thanks _death, will try that out.
jack_rabbit has quit [Ping timeout: 265 seconds]
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
flazh has quit [Ping timeout: 258 seconds]
terpri has quit [Quit: Leaving]
Oladon has joined #lisp
hifitim has joined #lisp
ebzzry has quit [Read error: Connection reset by peer]
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hifitim_ has joined #lisp
hifitim has quit [Ping timeout: 268 seconds]
Domaldel has joined #lisp
Domaldel has quit [Remote host closed the connection]
Lycurgus has joined #lisp
milanj has joined #lisp
hifitim_ has quit [Ping timeout: 260 seconds]
Odin- has quit [Ping timeout: 272 seconds]
Josh_2 has quit [Ping timeout: 240 seconds]
Nilby has quit [Read error: Connection reset by peer]
clothespin has joined #lisp
ebrasca has quit [Remote host closed the connection]
Oladon has quit [Quit: Leaving.]
Lycurgus has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 252 seconds]
dddddd has quit [Remote host closed the connection]
Ekho- is now known as Ekho
Oladon has joined #lisp
nullman has quit [Ping timeout: 268 seconds]
karlosz has joined #lisp
gravicappa has joined #lisp
ljavorsk_ has joined #lisp
smokeink has joined #lisp
zdm has joined #lisp
Jeanne-Kamikaze has quit [Ping timeout: 258 seconds]
Bike has quit [Quit: Lost terminal]
<smokeink>
setting file position on a stream of type SB-INT:FORM-TRACKING-STREAM i.e. by doing: (file-position stream 50) give this error: "#<SB-INT:FORM-TRACKING-STREAM for ... {DC08F051}> is not positionable" what's the proper way to set the position for such a stream, or is it impossible?
<smokeink>
*gives
Oladon has quit [Read error: Connection reset by peer]
<smokeink>
I have some reader macros which set the position back into the stream, depending on the form they encounter when (read)ing
Oladon has joined #lisp
hsaziz has quit [Quit: hsaziz]
ljavorsk_ has quit [Ping timeout: 265 seconds]
<smokeink>
they work fine, but sbcl's (load ) fails with that error when reading forms with such dispatching macro characters, because it uses SB-INT:FORM-TRACKING-STREAM instead of a normal stream
<beach>
Good morning everyone!
ggole has joined #lisp
vlatkoB has joined #lisp
<smokeink>
good morning!
ebzzry has joined #lisp
narimiran has joined #lisp
akoana has quit [Quit: leaving]
harovali1 has joined #lisp
harovali has quit [Ping timeout: 260 seconds]
shangul has joined #lisp
akoana has joined #lisp
<smokeink>
I'll try repeated calls to (unread-char ) instead of (file-position ); it should work
<pjb>
smokeink: file-position only works on file-streams. That's why it's called FILE-position, and not STREAM-position or something…
<pjb>
smokeink: you can load from non-file-streams.
<pjb>
smokeink: therefore your macro, to be able to "read" back, can only do it if it has saved the input in case of a non-file-stream.
<aeth>
I suppose if you need to unread e.g. three times, you could write your own buffer for read/unread. As in, even if the character is no longer in the stream, it can be in *your* buffer.
<aeth>
You could even use trivial-gray-streams if you wanted to do this using your own stream
<pjb>
aeth: exactly. Have a look at the COM.INFORMATIMAGO.COMMON-LISP.CESARUM.PEEK-STREAM package.
<pjb>
Or indeed, you could wrap it in a gray-streams.
epony has quit [Quit: upgrades]
bilegeek has quit [Quit: Leaving]
orivej has quit [Ping timeout: 272 seconds]
nowhere_man has joined #lisp
ebzzry has quit [Ping timeout: 260 seconds]
karlosz has quit [Quit: karlosz]
nullman has quit [Ping timeout: 265 seconds]
epony has joined #lisp
epony has quit [Max SendQ exceeded]
epony has joined #lisp
narimiran has quit [Quit: leaving]
dale has quit [Quit: My computer has gone to sleep]
epony has quit [Quit: QUIT]
milanj has quit [Quit: This computer has gone to sleep]
<smokeink>
aeth, pjb: thank you
epony has joined #lisp
raghavgururajan has quit [Remote host closed the connection]
dnaeon has joined #lisp
zaquest has joined #lisp
dnaeon has quit [Ping timeout: 265 seconds]
Lycurgus has joined #lisp
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
dnaeon has joined #lisp
Lord_of_Life has joined #lisp
dnaeon has quit [Ping timeout: 268 seconds]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
jonatack has joined #lisp
varjag has joined #lisp
dnaeon has joined #lisp
Lord_of_Life has quit [Read error: Connection reset by peer]
cmatei has quit [Remote host closed the connection]
dnaeon has quit [Ping timeout: 272 seconds]
rippa has joined #lisp
Lord_of_Life has joined #lisp
nowhere_man has quit [Ping timeout: 272 seconds]
jonatack has quit [Ping timeout: 260 seconds]
nullman has joined #lisp
gko_ has quit [Ping timeout: 258 seconds]
dnaeon has joined #lisp
random-nick has joined #lisp
nullman has quit [Ping timeout: 258 seconds]
dnaeon has quit [Ping timeout: 260 seconds]
cl-arthur has quit [Read error: Connection reset by peer]
akoana has left #lisp ["Leaving"]
brown121407 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
Lycurgus has quit [Remote host closed the connection]
<seok>
should i store hash tables as text or lisp object files?
dnaeon has joined #lisp
xuxuru has joined #lisp
dnaeon has quit [Ping timeout: 240 seconds]
<beach>
seok: It would be hard to store it as a Lisp object.
<luis>
emaczen: did you know you can do that with CFFI?
<beach>
smokeink: The function name can be (SETF <mumble>)
<smokeink>
as it is there, we can't do #M(compose #'+ #'1+)
<smokeink>
(function (setf car)) hmm
<smokeink>
can it be anything other than (setf <mumble>) and (lambda (...)...) ?
<smokeink>
if not , then maybe setf should be treated as a special case
dnaeon has joined #lisp
milanj has joined #lisp
trittweiler_ has quit [Remote host closed the connection]
xkapastel has quit [Quit: Connection closed for inactivity]
<beach>
smokeink: It looks like this function only takes names of functions as its second argument, not function objects.
Inline has quit [Quit: Leaving]
<smokeink>
right, but isn't this an unnecessary limitation?
<beach>
I don't know. I don't see the purpose of the function in the first place.
dnaeon has quit [Ping timeout: 258 seconds]
cl-arthur has joined #lisp
<smokeink>
with that #M dispatch macro, instead of (MAP-FN 'T (COMPOSE #'1+ #'1+) (SCAN `(1 2))) , one can do (#M(compose #'1+ #'1+) (scan `(1 2))) - but compose won't work with the code as it's there, and it looks to me like it's just an unnecessary limitation ; it's not the only such crappy limitation ... "why should init be a function" https://www.reddit.com/r/lisp/comments/7rsfyn/testing_the_series_common_lisp_package/
<smokeink>
==> #Z(3 4)
Inline has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
dnaeon has joined #lisp
xuxuru has quit [Ping timeout: 240 seconds]
dnaeon has quit [Ping timeout: 265 seconds]
mangul has joined #lisp
<seok>
beach: so storing them as bytes is not a good idea?
shangul has quit [Ping timeout: 268 seconds]
xuxuru has joined #lisp
cmatei has joined #lisp
mangul has quit [Ping timeout: 268 seconds]
cosimone has joined #lisp
dnaeon has joined #lisp
dnaeon has quit [Ping timeout: 268 seconds]
dnaeon has joined #lisp
bars0 has quit [Quit: leaving]
bars0 has joined #lisp
Odin- has joined #lisp
nullman has joined #lisp
xuxuru has quit [Quit: xuxuru]
smokeink has quit [Quit: Leaving]
hiroaki has joined #lisp
jmercouris has joined #lisp
<beach>
seok: What representation would you use?
dddddd has joined #lisp
cosimone has quit [Quit: Terminated!]
orivej has joined #lisp
<beach>
seok: Tell me how you would save a hash table as bytes in a file, and I'll tell you whether it is a good idea or not.
<seok>
beach: i thought there were some libraries, are they not commonly used?
<beach>
seok: How would such a library work?
<seok>
I don't know, I have just remembered seeing some libraries before which lets you store CLOS objects as files. Imagined hashes would be simpler
scymtym has joined #lisp
cl-arthur has quit [Read error: Connection reset by peer]
klltkr has joined #lisp
cl-arthur has joined #lisp
<p_l>
some implementations have ways around it (I think there was low-level access in some to generate a FASL file containing specific lisp objects)
<p_l>
for CLOS, you have the advantage of Meta Object Protocol allowing easy implementation of serialization
Bike has joined #lisp
gigetoo has quit [Ping timeout: 258 seconds]
ebzzry has joined #lisp
gigetoo has joined #lisp
<p_l>
seok: a pretty easy way would be to store the hash table as plist or alist, and use code like (with-open-file (*hashtable-file* "hashtable.file" :direction :read) (alexandria:plist-hash-table (read *hashtable-file*)))
<beach>
seok: Either way, these libraries will not store the object itself. There is always some transformation involved like serialization. That is why I told you that saving it as a Lisp object would be hard.
<seok>
cool, isn't that just saving as string and reading it back?
z147 has joined #lisp
<tfb>
seok: there are only strings (well, sequences of bytes) on disk (at least in (almost all?) modern filesystems), so *something* is always doing that. It really depends on whether you have to do it or something does it for you.
gabiruh has quit [Ping timeout: 260 seconds]
<tfb>
LispWorks has support for dumping forms (like hashtables &c) to FASL files FWIW
<tfb>
So it does the work for you in this case
developernotes has joined #lisp
developernotes has quit [Client Quit]
<pjb>
minion: memo for smokeink: there still a difference writing (function (lambda …)) instead of (lambda …). In the later case, the lambda macro will have to be expanded, and therefore *macroexpand-hook* will be called. In the former case, no such thing occurs. So there may be different side effects.
<minion>
Remembered. I'll tell smokeink when he/she/it next speaks.
gko_ has joined #lisp
<pjb>
minion: memo for smokeink: there may also be a big difference if function is not cl:function. I note in this source that they use cl:defun, perhaps function is shadowed too. Check the package definition!
<minion>
Remembered. I'll tell smokeink when he/she/it next speaks.
<boeg>
Is there a function in sly (or slime) thats like sldb-show-frame-source/sldb-show-source, but where it jumps to the place in my local source code where the bug in *my* code is so I can fix it?
<p_l>
seok: the problem is that there's no standard textual representation for some objects
<p_l>
seok: so not everything can be "written" like most forms
<pjb>
boeg: how is this not what it does already?
<pjb>
<p_l>
it's even not the case that hashtables are blocking it, but lack of standard serialization for things like classes - because hashtables can accept anything as key so long as sxhash works on it
lucasb has joined #lisp
<boeg>
pjb: well, right now I introduced a bug where I use the wrong keyword parameter with make-instance, so when I run sldb-show-frame-source it jumps into the sbcl codebase where the code is run (i'm guessing), not into the place in my source code where i typed ":accessor" wrong. Does that make sense?
<p_l>
so it's easy to serialize a hashtable that uses a primitive type as keys (as most people think of hashtables), except common lisp hashtables (and actually hashtables in many other languages) support arbitrary keys
<pjb>
boeg: yep. In the sldb window you get a stack of frames, so you need to look down the first user function and type v to jump on it.
<pjb>
boeg: I guess you could write an emacs command to lookup for each frame if the source is in or outside some specific directory.
<pjb>
Serializing hash-table requires serializing the hash-table attributes, and then to initialize the deserialized table with them. It's feasible. At least we don't have the difficulty as with displaced arrays.
<boeg>
pjb: yes thanks
<Odin->
p_l: Couldn't you define a serialisation for a hash table which barfs if printing readably and the key is bad?
<pjb>
You may still have to deal with circular structures…
<p_l>
Odin-: yes, but it wouldn't be as universal as the types that do print readably
<Odin->
p_l: That's true.
<pjb>
I guess it's because of those additionnal attributes that there is no default printer/reader for hash-tables. Note that for arrays, the reader won't create arrays of the same types, or with fill pointers, or displaced, etc. The printer writes a projection. For a hash-table you would need at least :test otherwise the new table would be useless.
<Odin->
Doesn't Clojure have to solve similar issues with its maps, though?
<pjb>
Perhaps it doesn't have different :test?
<Odin->
That might be it.
<Odin->
I think it relies on some JVM stuff for that.
<Odin->
Each object defining the hash value.
<p_l>
Odin-: I think they might have YOLO'd it a bit
ljavorsk_ has quit [Ping timeout: 258 seconds]
<Odin->
There's also that.
<jmercouris>
so, circular structures are only an issue during traversal right? so the problem is that we have to traverse the structure to persist it to disk?
xuxuru has joined #lisp
<flip214>
luis: why is 6-hex-digit as a length weird?
<flip214>
luis: did you start allowing JSON on the wire?
impaktor has joined #lisp
impaktor has left #lisp ["ERC (IRC client for Emacs 26.1)"]
<p_l>
Odin-: also, not interning symbols help there, IMO
<dnaeon>
hey all, what would be the idiomatic way to access nested alist values as returned by cl-json when using some nested JSON object? is there a library I'm missing, or should I just write my own function instead? This seems something that should already be provided by a library, but I haven't seen such.
<dnaeon>
currently I'm using my own util function, which simply REDUCEs the alist with the given key-path, but I was wondering whether there's such thing already?
FreeBirdLjj has joined #lisp
<_death>
dnaeon: afaik everybody writes their own
cosimone has joined #lisp
znc_jme has joined #lisp
znc_jme has quit [Client Quit]
<beach>
jmercouris: There is no problem what so ever in serializing a hash table to disk. The circularity "problem" can be solved with another hash table. But there is no standard way of doing it.
<beach>
jmercouris: Also, seok seems to think that the object itself can be saved to disk, but there is always going to be some conversion to an external representation.
<dnaeon>
_death: got it, thanks.
<jmercouris>
beach: oh I see, what if you took the contents into ram and literally piped them onto a disk
<beach>
jmercouris: Yes, and then the GC moves the objects so that their addresses no longer correspond to what you wrote on disk.
<jmercouris>
beach: true true...
<beach>
jmercouris: Or, you lose the reference to it in RAM, so the GC recycles the memory.
<beach>
jmercouris: You would need an operating system in which RAM is just a cache for secondary memory for it to work. Like CLOSOS for instance.
znc_jme has joined #lisp
znc_jme has quit [Client Quit]
<jmercouris>
beach: what if we just dumped the lisp image, couldn't that be effectively persisting the hash table?
<jmercouris>
I mean, it is really overkill, but it counts no?
<beach>
Sure, if you dump the entire image.
znc_jme has joined #lisp
<p_l>
there was an extension to SBCL that allowed dumping partial images, so long as the image that loaded the resulting file was the same image that generated it
<p_l>
it essentially allowed you to do a dump of memory region and then reload it, but it did none of the stuff that FASLs do for relocation et al, so you had to use the same base image
znc_jme has quit [Read error: Connection timed out]
znc_jme has joined #lisp
dnaeon has quit [Ping timeout: 265 seconds]
xuxuru has quit [Quit: xuxuru]
dnaeon has joined #lisp
<flip214>
I've got a (make-hash-table :test #'equalp); is there a way to get structures or class instances recognized as (equal) keys?
<flip214>
I guess that for structures :TYPE vector or :TYPE list might achieve that, but that has a few disadvantages...
<flip214>
is there a way to get EQUALP work for my class instances?
<jmercouris>
flip214: I've been down that road, not a good time
<jmercouris>
I remember trying to get keymaps to respond to equal instead of equalp...
<flip214>
there's no GF that is used to get some hashable value from class instances, right?
<flip214>
Perhaps SB-EXT:DEFINE-HASH-TABLE-TEST will help me?
<pjb>
flip214: all objects can be compares with eql equal or equalp, so there's no way to say this object can only be compared with equal.
<Posterdati>
hi
<Posterdati>
please I'd like to submit some fixes for cffi and iolib for OpenBSD, is there anyone who can help me? Thanks
<flip214>
pjb: but "equality" (however defined) isn't recognized by default, unless they're EQ
dnaeon has quit [Ping timeout: 240 seconds]
ljavorsk has joined #lisp
<flip214>
perhaps the easiest way is to not use structures or classes but lists starting with some symbol
<pjb>
flip214: the point is that it may be meaningful to use either test function on whatever type of keys you have.
<pjb>
It's a semantic question.
xuxuru has joined #lisp
dnaeon has joined #lisp
<flip214>
basically I need to deduplicate lists of symbols, for space reasons
<flip214>
thanks!
narimiran has joined #lisp
xuxuru has quit [Ping timeout: 240 seconds]
<jmercouris>
flip214: I ended up going to lists
<pjb>
flip214: yep, but is (|FOO|) the same as (|foo|) or (|Foo|) ?
<pjb>
flip214: what about (bar:foo) vs. (quux:foo) ?
<jmercouris>
|FOO| is not the same as |foo|
<pjb>
says you.
<jmercouris>
that's true, I did say that :-D
<pjb>
It could be considered the same in some implementation.
<jmercouris>
I see
<pjb>
now, for symbols eql equal and equalp are the same, but for string keys it would be different.
<pjb>
And often users want case insensitivity…
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jmercouris>
I'm all about case insensitivity, some people turn off upcasing of symbols
<pfdietz>
Autoloading systems when packages are found? Nice.
<pfdietz>
This would work well with package-defined-system
random-nick has joined #lisp
<_death>
yep
<_death>
likely came up with it because of Jeanne-Kamikaze's issue yesterday
dnaeon has joined #lisp
<_death>
though it's aimed at repl use.. many times I want to call something and then go, oh, need to load that system first.. there could also be a slime repl shortcut I guess (i.e. something like ,load-system)
dnaeon has quit [Ping timeout: 272 seconds]
gioyik has joined #lisp
dnaeon has joined #lisp
random-nick has quit [Ping timeout: 258 seconds]
z147x has joined #lisp
jonatack has quit [Ping timeout: 260 seconds]
z147 has quit [Ping timeout: 240 seconds]
drdo has left #lisp ["ERC (IRC client for Emacs 26.1)"]
z147x has quit [Client Quit]
ljavorsk has quit [Ping timeout: 268 seconds]
random-nick has joined #lisp
atgreen has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
kajo has joined #lisp
gko_ has quit [Ping timeout: 268 seconds]
dnaeon has quit [Ping timeout: 258 seconds]
klltkr has joined #lisp
dnaeon has joined #lisp
flazh has joined #lisp
dnaeon has quit [Ping timeout: 258 seconds]
cosimone has quit [Quit: Quit.]
FreeBirdLjj has quit [Remote host closed the connection]
cosimone has joined #lisp
zxcvz has quit [Quit: Leaving]
cl-arthur has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
cosimone has quit [Remote host closed the connection]
karlosz has joined #lisp
cosimone has joined #lisp
dnaeon has joined #lisp
rwcom has quit [Ping timeout: 268 seconds]
rwcom has joined #lisp
karlosz has quit [Quit: karlosz]
brown121407 has quit [Ping timeout: 268 seconds]
clothespin has joined #lisp
<pfdietz>
Hmm, that uses a restart that was only recently added to SBCL. Nice to see it has another use.
brown121407 has joined #lisp
dnaeon has quit [Ping timeout: 268 seconds]
<_death>
what was the original use case?
<pfdietz>
I was slurping in large amounts of lisp code to act as fodder for random input generation for testing the compiler, and didn't want to have to have all the packages defined.
<pfdietz>
So if I came across FOO::BAR and FOO wasn't a package I wanted an API to turn that into something else.
<pfdietz>
The reading did not have to be faithful, just mostly ok, because the forms were then shuffled and hacked up anyway.
dddddd has quit [Ping timeout: 272 seconds]
phoe has joined #lisp
<_death>
I see.. btw a coverage-guided fuzzer doesn't seem that far-fetched given the existence sb-cover, right?
<pfdietz>
Or COVER, which is perhaps better for that.
<_death>
the old portable one?.. hmm
<pfdietz>
Yes.
<_death>
does speed not matter that much?
<pfdietz>
It does not.
<pfdietz>
I had a proof of principle using cover at one point, but not now for IP reasons.
<pfdietz>
Idea was to hack the point data structure to be more general, and provide a version that allows checkpointing and rollback. When an input is found that increases coverage, add it to the pot. The rollback is for test minimization.
<pfdietz>
What it did not do is use local structure of code to guide search, like some fuzzers now do. But one could imagine doing that too.
<_death>
the naive one seems good for many fuzzers
<|3b|>
cl-opengl users please test https://github.com/3b/cl-opengl/tree/dev with your code, needs more feedback to decide if recent changes are safe enough to release to quicklisp
<|3b|>
in particular looking for errors like `:foo is not defined as a keyword for enum type #<...>.`, found a few in the examples already, so a bit wary of releasing it
rumbler31 has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
EvW has joined #lisp
tiwEllien has quit [Ping timeout: 268 seconds]
cosimone_ has joined #lisp
tiwEllien has joined #lisp
rumbler31 has joined #lisp
cosimone_ has quit [Client Quit]
cosimone has quit [Ping timeout: 252 seconds]
cosimone has joined #lisp
clothespin_ has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
clothespin has quit [Ping timeout: 260 seconds]
tiwEllien has quit [Ping timeout: 258 seconds]
cosimone has quit [Quit: Quit.]
v88m has joined #lisp
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
tiwEllien has joined #lisp
brown121408 has quit [Read error: Connection reset by peer]
troydm has joined #lisp
brown121408 has joined #lisp
notzmv has quit [Remote host closed the connection]
emys has quit [Ping timeout: 268 seconds]
tiwEllien has quit [Ping timeout: 240 seconds]
trafaret1 has joined #lisp
tiwEllien has joined #lisp
rwcom has quit [Ping timeout: 265 seconds]
rwcom has joined #lisp
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
torbo has joined #lisp
notzmv has joined #lisp
xuxuru has quit [Quit: xuxuru]
EvW has quit [Ping timeout: 248 seconds]
xuxuru has joined #lisp
emys has joined #lisp
<Shinmera>
|3b|: I'll try to remember to do a test tomorrow.
malfort has joined #lisp
emys has quit [Ping timeout: 268 seconds]
klltkr has joined #lisp
gravicappa has quit [Ping timeout: 240 seconds]
pfdietz has joined #lisp
zdm has quit [Quit: WeeChat 2.7]
zdm has joined #lisp
cosimone has joined #lisp
asdf_asdf_asdf has joined #lisp
EvW1 has joined #lisp
karlosz has quit [Remote host closed the connection]
bilegeek has joined #lisp
narimiran has quit [Ping timeout: 260 seconds]
vaporatorius has quit [Read error: Connection reset by peer]
vaporatorius has joined #lisp
cl-arthur has joined #lisp
karlosz has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
Oladon has quit [Quit: Leaving.]
xuxuru has quit [Quit: xuxuru]
lucasb has quit [Quit: Connection closed for inactivity]
trafaret1 has quit [Quit: ERC (IRC client for Emacs 26.1)]
gxt has quit [Quit: WeeChat 2.7]
dnaeon has joined #lisp
Jeanne-Kamikaze has joined #lisp
<LdBeth>
does SBCL support dumping incremental update to heap image?
dnaeon has quit [Quit: WeeChat 2.7]
pjb` has joined #lisp
pjb has quit [Ping timeout: 272 seconds]
slyrus has joined #lisp
<Shinmera>
what does that mean?
X-Scale` has joined #lisp
jmercouris has quit [Remote host closed the connection]
jmercouris has joined #lisp
X-Scale has quit [Ping timeout: 272 seconds]
X-Scale` is now known as X-Scale
slyrus__ has quit [Ping timeout: 265 seconds]
Nilby has quit [Ping timeout: 265 seconds]
sjl has joined #lisp
nowhere_man has joined #lisp
<LdBeth>
Shinmera: save only the difference between the old and new image instead of a standalone new image
<Shinmera>
it cannot do that.
bendersteed has joined #lisp
clothespin_ has quit [Ping timeout: 260 seconds]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
<harovali>
beach: thanks for your answer on McCLIM
<harovali>
I downloaded McCLIM in sbcl , and started trying the example suits
<harovali>
I liked the examples very much
<harovali>
While trying, some aparent normal uses yielded some conditions, I wonder how to handle that
<harovali>
I know I'm not showinf enough information
<harovali>
But maybe people already know what I'm talking about
<LdBeth>
I see why SBCL can't do so "The system expects to be loaded into a fixed-at-compile-time location in virtual memory"
<_death>
LdBeth: you could easily do that.. I saved a core to file "one", then ran sbcl --core one and save a core to file "two".. ran bsdiff one two one-to-two ... this created a 900K diff file.. the only issue is that it takes a bit of time
<LdBeth>
_death: and apply patches when loading :P
<_death>
yes
X-Scale` has joined #lisp
cl-arthur has quit [Quit: Lost terminal]
<phoe>
LdBeth: it supports dumping incremental updates to heap image, except they are called FASLs
<phoe>
and I know, this is not the answer that you were looking for
<XachX>
There was a project called steeldump
<XachX>
It was faster than fasls but needed a patched sbcl
X-Scale has quit [Ping timeout: 240 seconds]
X-Scale` is now known as X-Scale
dale has joined #lisp
torbo has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 272 seconds]
bitmapper has joined #lisp
quazimodo has joined #lisp
pjb` has quit [Quit: renaming]
pjb has joined #lisp
random-nick has quit [Ping timeout: 268 seconds]
orivej has quit [Ping timeout: 268 seconds]
harovali has quit [Ping timeout: 268 seconds]
shifty has joined #lisp
gabiruh has quit [Read error: Connection reset by peer]
tiwEllien has quit [Ping timeout: 240 seconds]
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]