<Josh_2>
I have mine set to safety 3, debug 3, space 1 and speed 0 :sunglasses:
<Josh_2>
maximum slowness, maximum safe
<thuna`>
:boom:
<aeth>
not sure why slot type checks in standard classes should be disabled by default in SBCL
<aeth>
that goes against the rest of the implementation, which basically checks everything else unless (safety 0) and probably breaks user expectations
<aeth>
besides that one area, SBCL is the one that most consistently checks
random-nick has quit [Ping timeout: 256 seconds]
<mfiano>
That's not true.
<mfiano>
There are things that it checks even if safety is high but speed is higher.
<mfiano>
err, does not check
<aeth>
this kind of represents a flaw in the language, these vague categories, instead of what you really want, e.g. (checking 3)
<aeth>
shows up even more when people rely on TCO without having a DECLARE-based way to actually force it on
<Bike>
sbcl does more or less that internally, and i've adopted it for clasp
<Bike>
would need some standardization though
<mfiano>
These features are usually not wanted by the common user, and conveniently can be opted in to those who do. Which is why I petitioned for the slot name issue to be fixed too. How annoying.
<Josh_2>
What issue mfiano?
Inline_ has joined #commonlisp
<aeth>
Bike: To be more specific, it would be nice to have something like type-checking, tail-call, bounds-checking, etc., override the standard behavior inside of DECLARE. Especially since (SAFETY 0) in SBCL turns off both type-checking and bounds-checking (afaik) while someone might only want it to turn off bounds checking (i.e. when you know, but the compiler doesn't, that you can't go out of bounds)
<mfiano>
SBCL would, without any way to disable it, emit a STYLE-WARNING whenever a class contained a slot with different symbols having the same SYMBOL-NAME. This is very annoying, and such a common thing to want to be able to do without this hand-holding (it comes up a lot with mixin classes, and is actually expected)
lisper29 has joined #commonlisp
Inline__ has quit [Ping timeout: 268 seconds]
<aeth>
SBCL does have a lot of annoying, useless verbosity... e.g. when doing a TYPECASE on single-float, double-float, and float, it will say deleting unreachable code... well, yes, but only in SBCL
<aeth>
but that's nothing compared to (speed 3) telling you to literally change your problem because it can't optimize /
<aeth>
why, yes, if I had a nicer number to divide by, it would be faster, wouldn't it?
ryanbw has quit [Ping timeout: 260 seconds]
<mfiano>
I would find it more annoying that I missed the E weeks later if ever :)
<Bike>
aeth: right, i mean that on sbcl you can do (declare (optimize (sb-c::type-check 0))) to turn off type checking without affecting tail calls or whatever
<mfiano>
It's very verbose, but CCL is very strict. It will yell at you if you forget to define a make-load-form that is needed (SBCL doesn't care), it will error when C-N-M arguments change the CPL (SBCL invokes UB), etc.
<mfiano>
actually, not UB it seems, but difference in default safety levels (CCL is 3 by default)
<Bike>
sbcl doesn't care about a missing make-load-form method?
<Bike>
in safe code, c-n-m arguments changing the effective method is actually defined as an error
<Bike>
maybe you mean something else with CPL though
<mfiano>
You have a struct instance you want available at compile time for use it in defconstant binding
<mfiano>
use in a*
<Bike>
if sbcl lets you dump a struct without a m-l-f method i think that's technically a standard violation. the m-l-f on structure objects is defined to signal an error.
<mfiano>
Bike: Yes, I know it is an error now. That's why I corrected myself. SBCL's default levels make it not a anything.
<mfiano>
Interesting. I'll have to play around with that and report it if it still is a thing when it was a year or 2 ago.
Inline__ has joined #commonlisp
<mfiano>
I started with CL back when it was the only thing really available on ARM. It taught me a lot. When I code CL, I use SBCL, and I usually test with CCL. SBCL without even a style warning will often error in CCL, so it's a nice safety net.
<mfiano>
started with CCL*
Oladon has joined #commonlisp
Inline_ has quit [Ping timeout: 256 seconds]
ym has joined #commonlisp
thuna` has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
ryanbw has joined #commonlisp
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 260 seconds]
Inline__ has joined #commonlisp
NotThatRPG_away is now known as NotThatRPG
Inline_ has quit [Ping timeout: 260 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 260 seconds]
vibs29 has joined #commonlisp
vibs29 is now known as Guest9334
lisper29 has quit [Ping timeout: 260 seconds]
Guest9334 is now known as lisper29
Inline__ has joined #commonlisp
anticomputer_ has joined #commonlisp
anticomputer has quit [Ping timeout: 255 seconds]
ec has quit [Ping timeout: 255 seconds]
ec has joined #commonlisp
Inline_ has quit [Ping timeout: 256 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 256 seconds]
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 256 seconds]
pdietz has joined #commonlisp
<pdietz>
clhs place
<specbot>
Couldn't find anything for place.
Inline__ has quit [Ping timeout: 260 seconds]
<pdietz>
Hmm.
<Bike>
i don't think it does the glossary, or you have to indicate it
<Bike>
clhs place/g
<specbot>
Couldn't find anything for place/g.
<Bike>
bah
<NotThatRPG>
Anyone here a CLIM user?
azimut has joined #commonlisp
anticomputer_ has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
anticomputer has quit [Ping timeout: 255 seconds]
waleee has quit [Ping timeout: 260 seconds]
anticomputer has joined #commonlisp
jeosol has joined #commonlisp
lisper29 has quit [Quit: Leaving]
waleee has joined #commonlisp
attila_lendvai has quit [Ping timeout: 268 seconds]
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
euandreh has quit [Ping timeout: 256 seconds]
euandreh has joined #commonlisp
ym has quit [Ping timeout: 268 seconds]
euandreh has quit [Remote host closed the connection]
euandreh has joined #commonlisp
ebrasca has quit [Remote host closed the connection]
anticomputer has quit [Remote host closed the connection]
<Bike>
usually i try to avoid complicated conditionals like that in loop. i think you could do "for next-start = 0 then (1+ delimiter-position) for delimiter-position = ... collect (cond ...) while delimiter-position"
<Bike>
oh, and as written this will just return the string if the delimiter doesn't appear, right? having just one string instead of a list of one string could be a little confusing
Inline_ has joined #commonlisp
<Nilby>
smlckz: Nice use of loop. I like big powerful loops. But also since split-sequence and ppcre:split are top 5 quicklisp libraries, you'll probably have one loaded if you use other software in quicklisp. The most immediate improvements might be to omit empty sequences, support test and key functions and use a set of delimiters.
Inline__ has quit [Ping timeout: 268 seconds]
Inline__ has joined #commonlisp
* Nilby
wishes split-sequence could simd and utf8 byte.
dipper has joined #commonlisp
Inline_ has quit [Ping timeout: 256 seconds]
waleee has quit [Ping timeout: 260 seconds]
Inline_ has joined #commonlisp
Oladon has quit [Quit: Leaving.]
Inline__ has quit [Ping timeout: 256 seconds]
Lord_of_Life has quit [Ping timeout: 268 seconds]
Inline__ has joined #commonlisp
euandreh has joined #commonlisp
Inline_ has quit [Ping timeout: 260 seconds]
Lord_of_Life has joined #commonlisp
Inline_ has joined #commonlisp
easye` has joined #commonlisp
Inline__ has quit [Ping timeout: 268 seconds]
easye has quit [Ping timeout: 255 seconds]
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 268 seconds]
Inline_ has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
Inline__ has quit [Ping timeout: 268 seconds]
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 260 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 240 seconds]
Inline__ has joined #commonlisp
tibfulv has quit [Remote host closed the connection]
Inline_ has quit [Ping timeout: 256 seconds]
tibfulv has joined #commonlisp
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
skeemer__ has quit [Remote host closed the connection]
Brucio-61 has quit [Read error: Connection reset by peer]
Inline_ has quit [Ping timeout: 268 seconds]
scymtym has quit [Ping timeout: 256 seconds]
Brucio-61 has joined #commonlisp
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 268 seconds]
epony has quit [Remote host closed the connection]
mingus has joined #commonlisp
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 256 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 240 seconds]
lisp1234 has joined #commonlisp
Inline__ has joined #commonlisp
rgherdt has joined #commonlisp
Inline_ has quit [Ping timeout: 268 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 260 seconds]
euandreh has quit [Remote host closed the connection]
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 260 seconds]
Inline_ has joined #commonlisp
frgo has quit [Ping timeout: 256 seconds]
Inline__ has quit [Ping timeout: 256 seconds]
<phoe>
Nilby: feel free to teach it to. (Although utf-8 would be complicated because you'd need to operate on raw data vectors rather than CL strings.)
<Nilby>
phoe: It's strange, but perhaps I'd have to feel "unfree" to do it. If only my boss would make me do it, or my mom would take away my steam account. But seriously, split-sequence already works on byte vectors, just not utf8 characters in them.
<Nilby>
Someday perhaps I'll finish the utf8 string class which will work with my generic splitter. Then the hard part is to make it use some of those vacant cores.
<phoe>
oh right :D
<phoe>
for whatever reason I didn't realize that a utf8 string, in Lisp, is already representable as a byte vector
<phoe>
time for more tea because my dots are not connecting today yet
lisp1234 has quit [Read error: Connection reset by peer]
<Nilby>
I only know since one day I got performance jealous and studied the tricks that python and other langauges use, mostly in C, to get their string operations fast.
<Nilby>
Also I get a little sad when looking at raw Lisp memory and see vast fields of useless zeros.
easye` has quit [Remote host closed the connection]
cosimone has joined #commonlisp
Brucio-61 has quit [Ping timeout: 260 seconds]
dipper has quit [Remote host closed the connection]
Dynom_ has joined #commonlisp
Dynom_ is now known as Guest4293
scymtym has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
mariari has quit [Remote host closed the connection]
Brucio-61 has joined #commonlisp
pve has joined #commonlisp
mariari has joined #commonlisp
lisp1234 has joined #commonlisp
Guest268987 has joined #commonlisp
sedzcat has joined #commonlisp
MajorBiscuit has joined #commonlisp
dipper has joined #commonlisp
<beach>
If they are vast enough, one would hope that the operating system is smart enough not to allocate them at all.
<beach>
... like the size of a page.
<Nilby>
In the case of characters and many other type they are nestled in the objects as the most significant bits, so unfortunately that can't happen.
<beach>
I don't understand. Either there are vast fields of zeros or there aren't, no?
morganw has joined #commonlisp
<jackdaniel>
beach: non-base strings may be implemented as arrays of 32-bit elements, while usually most characters fit in 8bits
<jackdaniel>
so that gives plenty of 0s :)
ttree has quit [Ping timeout: 268 seconds]
<Nilby>
A fallow field still has some weeds, so also these vast fields of of zero bits have a few 1's poking through.
<beach>
Sure, plenty of zeros is one thing, but I took "vast fields" to mean that they are consecutive. And then, if there are enough of them, the entire page is filled with zeros.
<Alfr>
Why not 24 bit? I mean, there are only a bit more than 2^20 code points, so they'll actually fit snugly into 21 bits.
<jackdaniel>
Alfr: ecl actually gives you different encoding options when you compile it
<Nilby>
24 bit makes everything slower and harder to code, and still wastes most of the bits
pfd has joined #commonlisp
<Alfr>
jackdaniel, oh, good to know.
<Alfr>
Nilby, but actually using utf-8 internally might incur other problems, like accessing an element wouldn't be constant time anymore.
<Nilby>
In practice it turns out the non-constant time is negligible with some annoying tricks. It would make string functions harder to code if we didn't have the great power of generic functions.
<phoe>
actually I guess that would be a fun use of extensible sequences
<phoe>
you'd just need extensible strings too which would be a little bit more complicated
mingus1 has joined #commonlisp
<Nilby>
I already mostly use generic strings, characters, and sequences. It seems to work fine, if only every implementation's loop was extensible.
mingus has quit [Ping timeout: 256 seconds]
mingus1 is now known as mingus
<Nilby>
Slow-ish generic sequences are flawed but easier, replacing/maintaining that most complex of macros seems too much for me. I'm already sailing the ship of Theseus.
<Nilby>
Shinmera: some may lament the Lisp/AI "winter", but your game makes me think that perhaps a world not having combat androids running Genera is okay :-]
<phoe>
they might be running Genera under the hood tho
pranavats has joined #commonlisp
<Alfr>
Nilby, didn't know. Mea cupla.
<Nilby>
Alfr: I haven't tried it in practice, my guess is because even performance conservative graphics formats frequently extend 24 bit pixels 32.
Lycurgus has joined #commonlisp
<Alfr>
Nilby, you lost me there.
ym has joined #commonlisp
<Nilby>
Copying/scanning a lot of 3 byte things (characters or pixels) is usually slightly harder than 32 bit things, since the 32 bit things don't have odd boundaries.
<Lycurgus>
cost of ignoring a thing
<phoe>
Lycurgus: cost of no thing?
<Lycurgus>
well ignoring is activity, not nothing; the ignored bits aren't nothing either
<Lycurgus>
to ignore a thing you first have expend energy in perceiving and (not) responding to it
<Lycurgus>
instant dismissal is probably as low as it goes plus unaccounted costs
<Lycurgus>
even thinking about 1 ignored octet out four seems ... .
euandreh has joined #commonlisp
euandreh has quit [Remote host closed the connection]
euandreh has joined #commonlisp
jello_pudding has quit [Ping timeout: 256 seconds]
<mfiano>
Are prices available for just the soundtrack? I might have some extra holiday money around then to support Shirakumo's efforts, because I don't really game. Also is it good? ;)
Bung has joined #commonlisp
<Shinmera>
Imo the soundtrack is the best thing about the game, but I'm biased
<mfiano>
"Est. Shipping: 11/2022". Might want to update that.
<Shinmera>
Oh yeah, thanks
<Alfr>
Nilby, ah. :)
<Shinmera>
A single of the soundtrack will release today. If all goes well it should be out when the trailer premieres, too. Should be on all the streaming sites and whatnot.
<lisp1234>
who made the soundtrack?
<Shinmera>
A fella by the name Mikel Dale
<lisp1234>
Nice
<lisp1234>
How did you find him?
<Shinmera>
Anyway, I shant speak more offtopic here for now. (though if you want to chat more #shirakumo always exists)
semz has quit [Quit: ZNC 1.8.2+deb2build5 - https://znc.in]
<Shinmera>
To bring it back around to lisp, I'm still working on documenting more of the engine, and will probably need some more people to look at modding and such before long (meaning: in 1-2 months).
<dipper>
hi
<phoe>
henlo
dipper has quit [Remote host closed the connection]
pranavats has left #commonlisp [Error from remote client]
<morganw>
Shinmera: I think this is a lisp question so is OK to ask here... Did you have to effectively remove any reason for the garbage collector to run at unknown times? I guess that would mean trying to design the engine to be non-consing within a scene?
semz has joined #commonlisp
<Shinmera>
Nope
<Shinmera>
I *did* refactor some smaller parts to cons less when I noticed the GC triggering a bit more often than I'd like
<Shinmera>
But the game runs perfectly smooth and I haven't had to fret too much about it.
<Shinmera>
Naturally consing less is nice, but I'm not going out of my way to engineer things in that way.
<morganw>
Great to hear. Thanks!
<Shinmera>
sprof is also a godsend for diagnosing both consing and runtime issues.
<Nilby>
morganw: It seems like a weirdly persisent myth that you can't have GC in games. Many popular games and engines have GC languages like C# and lua, etc.
<Shinmera>
I *do* wish it was easier to stack-allocate stuff.
<Shinmera>
But I understand why it isn't.
<morganw>
I did some simple tests in Guile and found there was a significant difference when I went out of my way to generate new "render specification" lists on every frame, but to get to the point where it affected the frame rate I had to be doing it excessively.
<Shinmera>
Maybe with hayley's work the SBCL GC will be even less of a problem soon :)
<morganw>
I guess I can summarise as, both were fine, the cons-ing version failed earlier when gradually increasing the load.
<|3b|>
and at the other side of the argument, when GC does turn out to be too expensive, people frequently think manual memory management is too expensive too, and in both cases the answer is just don't allocate things in general :p
pranavats has joined #commonlisp
lisp1234 has quit [Ping timeout: 260 seconds]
semz has quit [Quit: ZNC 1.8.2+deb2build5 - https://znc.in]
<_death>
if a game is in the "soft realtime" category and the gc triggering times and collection durations are not easy to predict/bound, I can see how it could be a concern.. it's possible that the game is not so much computationally demanding that there's ample time for gcs and no bad effect is detected in practice
semz has joined #commonlisp
euandreh has quit [Quit: euandreh]
euandreh2 has joined #commonlisp
<mfiano>
I have a lot to frustrating things to say on the matter I'd rather not, but it tldr's down to yeah, it depends on the game.
<mfiano>
lot of*
euandreh2 is now known as euandreh
<mfiano>
Even a large game with dozens of developers and a good budget has to carefully find the right balance between the CPU and GPU, and managing the sharing of resources between them. Doesn't that count as memory management?
semz has quit [Quit: ZNC 1.8.2+deb2build5 - https://znc.in]
semz has joined #commonlisp
ec has quit [Remote host closed the connection]
ec has joined #commonlisp
<_death>
I've seen recently that there's some work on arenas in sbcl.. maybe that could also be relevant to such games
Guest268987 has quit [Ping timeout: 256 seconds]
<mfiano>
Oh, interesting.
pranavats has left #commonlisp [Error from remote client]
tyson2 has joined #commonlisp
semz has quit [Quit: ZNC 1.8.2+deb2build5 - https://znc.in]
semz has joined #commonlisp
ec has quit [Ping timeout: 255 seconds]
ec has joined #commonlisp
pdietz has joined #commonlisp
gxt has quit [Remote host closed the connection]
prokhor__ has joined #commonlisp
pranavats has joined #commonlisp
attila_lendvai has joined #commonlisp
gxt has joined #commonlisp
attila_lendvai has quit [Ping timeout: 268 seconds]
random-nick has joined #commonlisp
ym has quit [Ping timeout: 260 seconds]
pdietz has quit [Ping timeout: 260 seconds]
azimut has quit [Ping timeout: 255 seconds]
doyougnu has joined #commonlisp
azimut has joined #commonlisp
ioa has quit [Ping timeout: 246 seconds]
ioa has joined #commonlisp
<Josh_2>
What is an arena? Other than that place you go to have a fight :sunglasses:
<Nilby>
It's where Lisp objects go to fight for their lives before being ultimately defeated by the kernel :just-normal-glasses:
Bung has quit [Quit: Leaving]
epony has joined #commonlisp
azimut has quit [Remote host closed the connection]
sedzcat1 has joined #commonlisp
sedzcat has quit [Ping timeout: 256 seconds]
sedzcat1 is now known as sedzcat
azimut has joined #commonlisp
rgherdt has quit [Remote host closed the connection]
<Shinmera>
The basic idea is: if you know the lifetime of objects better than the gc, you can avoid triggering a slow global gc by instead telling it to allocate stuff in an arena, which is just discarded when you know all the objects are dead in it.
<pjb>
Oh, so like pools in NeXTstep/OpenStep/Cocoa.
eta has joined #commonlisp
<jackdaniel>
does the system assist in proving that the memory can be discared or it takes it at face value and crashes horribly?
<pjb>
Was it worth inventing a new term?
erickisos has joined #commonlisp
<White_Flame>
jackdaniel: pretty sure it's the latter, though it might have mitigations
ldb has joined #commonlisp
<jackdaniel>
I see, thanks
<White_Flame>
in terms of sane memory errors instead of just blowupage
Guest268987 has joined #commonlisp
<White_Flame>
allocate inside a region, then decide when to throw it away
<White_Flame>
in bulk
<Bike>
there's manual regions and there's also region inference, but i have only heard of the latter in languages like ML
<jackdaniel>
perhaps not allowing to reference the memory in the area from the global heap would solve the issue
<Shinmera>
I guess Rust is region based.
<jackdaniel>
then you'd need a tag to identify the allocation pool
<Shinmera>
jackdaniel: I think it's fine as a "heres' a footgun" kind of feature that leaves things up to you, like safety 0.
<White_Flame>
regarding references and scanning, i don't think there need be that much difference between a region and a memory generation
<jackdaniel>
sure, but if it would be possible to make it safe at the same time then it would be a win, wouldn't it?
<scymtym>
SBCL has a tool for finding heap -> arena pointers. it is most similar to the root tracing tool, not about proving anything statically at all
<ldb>
Rust is more or less like ARC(auto reference counting)
<jackdaniel>
I don't really enjoy dynamic-extent in sbcl crashing the system ,)
<Shinmera>
jackdaniel: depends on the cost implications of said safety :)
<Shinmera>
the point of pools is to have very fast allocation and freeing operations. compromising that for safety may not be desired.
<ldb>
with most reference counting done at compile time if possible
<jackdaniel>
well, provable fast allocation and freeing operations still sounds better! but sure, I understand that not all things can be nice and fluffy
<Nilby>
Postscript had save and restore operators that did effectively that, but made backpointers impossible by making all mutation copy on write. It was very effective for reducing GC.
<ldb>
by using a fifo/stack as much as possible, yes it reduces GC a lot
<_death>
pjb: I think I first read about arenas in Stroustrup's D&E book, which is from 1994.. so not a new term
<jackdaniel>
areas are basically stacks (but disconnected from the call stack)
<White_Flame>
Shinmera: did genera perform local gc within regions?
<Shinmera>
Anyhoo, arenas are used a lot in games because there's some pretty obvious allocation borders
<Shinmera>
White_Flame: I have no idea about genera
<ldb>
genera has "make-area" function, and the gc is programmable
<_death>
pjb: with pools the usage is often to grab a resource and later return it.. with arenas it's allocate allocate allocate then free everything at once
<Bike>
with region inference, the inference is done at compile time, so i don't think it would involve runtime overhead to make things safe. buuuuuut i know very little about it
karlosz has joined #commonlisp
<jackdaniel>
I guess that it is sometimes hard to prove that something does not escape at compile time (i.e you may redefine a function that is not inlined)
<ldb>
^programmers make guarantees
<ldb>
that's how things worked in cl, isn't it
<White_Flame>
programmers make guarantees => runtime blows up ;0
<jackdaniel>
I don't trust these lazy bastards ;]
<Bike>
sure, but it's nice if a broken guarantee means an error instead of an explosion.
<Shinmera>
one problem with stuff like dynamic-extent is that it breaks as soon as the object to allocate is allocated in another function. So eg (let ((vector (v+ other-vec 1))) ...) can't be d-xed, but it could be done via arenas.
<Bike>
with invalid dynamic-extent you're kind of in explosion territory.
<Shinmera>
I've been trying to come up with a way to rewrite 3d-vectors/etc to mitigate that issue
<Shinmera>
but maybe if arenas land in sbcl I won't even bother :)
thuna` has joined #commonlisp
<Bike>
dynamic-extent inference is on my todo list for cleavir. i have some of the infrastructure done but not the actual analysis. region inference i'd also like to look at, but i know much less about that
<Shinmera>
What would help a lot with region inference is purity markers on functions
<Bike>
Shinmera: i kind of figured to do that you'd write a vector+ that writes into a result vector rather than allocating anything itself, but i guess that kind of makes your code worse.
<Shinmera>
yes
<Shinmera>
that was one of the ideas for the rewrite
<Shinmera>
and then some macro funkery to make it less of a pain to use.
<Bike>
mm.
<ldb>
fortran style call by name
<Bike>
as to purity markers, heisig recently put https://github.com/marcoheisig/Typo on ql. i haven't looked at it in depth yet, but i am very interested in it as a way to indicate things like that
<Bike>
(the define-fndb-record macro, which is probably based on the fndb in sbcl)
<Shinmera>
Anyway, exciting times to be a lisper imo :)
ldb has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
pdietz has joined #commonlisp
easyme has joined #commonlisp
easyme has left #commonlisp [#commonlisp]
Inline has joined #commonlisp
Inline is now known as Guest347
Guest347 is now known as Inline
prokhor_ has joined #commonlisp
prokhor__ has quit [Ping timeout: 240 seconds]
MajorBiscuit has quit [Ping timeout: 268 seconds]
<NotThatRPG>
eta: You should be able to fork repositories on cl.net, as long as you have an account.
<NotThatRPG>
Well, huh. I didn't realize that there was a limit. Looks like a bug to me
KaitoDaumoto has joined #commonlisp
Sauvin has quit [Ping timeout: 240 seconds]
ttree has joined #commonlisp
saura has quit [Ping timeout: 260 seconds]
<NotThatRPG>
eta: Try #common-lisp.net
Sauvin has joined #commonlisp
NotThatRPG is now known as NotThatRPG_away
saura has joined #commonlisp
doyougnu has quit [Remote host closed the connection]
jeosol has quit [Quit: Client closed]
cage has joined #commonlisp
jmdaemon has joined #commonlisp
Inline has quit [Quit: Leaving]
pdietz has quit [Ping timeout: 260 seconds]
lisper29 has joined #commonlisp
sunset_NOVA has joined #commonlisp
<dbotton>
Is there any presence for common lisp at FOSDEM?
<jackdaniel>
I'm considering going at fosdem2023
<jackdaniel>
it'd be cool to have a common lisp devroom
<jackdaniel>
(too late for that though, 18oct was a deadline apparentl to propose these)
<dbotton>
ya, this year was tougher to get a dev room also
<dbotton>
If I can keep on track I'd like to do
<dbotton>
next year something
<jackdaniel>
we can crash in rust devroom and play dumb that 'lisp is an acceptable rust' or something
<dbotton>
In many ways Lisp is the start of FOSS
<dbotton>
lol
<dbotton>
if can't do dev, maybe a stand
<dbotton>
wonder what costs involved
pdietz has joined #commonlisp
prokhor_ has quit [Ping timeout: 268 seconds]
<dbotton>
Pharo has one, we should :)
<dbotton>
(had last year)
<dbotton>
virtual
pfd has quit [Quit: Client closed]
Jach has joined #commonlisp
attila_lendvai has joined #commonlisp
igemnace has quit [Remote host closed the connection]
<NotThatRPG_away>
For SLIME/SLY is there any way to take a value you get from evaluating an expression in the debugger and throw it into the inspector?
attila_lendvai has quit [Ping timeout: 268 seconds]
androclus has joined #commonlisp
<thuna`>
NotThatRPG: Do you mean C-c C-v TAB (slime-inspect-presentation-at-point) or something else?
sbenitezb has joined #commonlisp
<NotThatRPG>
thuna`: I was looking for evaluate an expression in the debugger context and inspect the results. At least in the sly debugger, that can be done using `i` (as opposed to `e`, which just evaluates the expression and shows it in the minibuffer)
Oladon has joined #commonlisp
<thuna`>
Oh. Hmm
<thuna`>
NotThatRPG: The same thing seems to work in slime as well
jeosol has joined #commonlisp
sedzcat has quit [Quit: sedzcat]
Inline has joined #commonlisp
Inline is now known as Guest8992
prokhor has quit [Remote host closed the connection]
Guest8992 is now known as Inline
vibs29 has joined #commonlisp
vibs29 is now known as Guest4935
lisper29 has quit [Ping timeout: 268 seconds]
Guest4935 is now known as lisper29`
lisper29` is now known as lisper29
rgherdt has joined #commonlisp
pdietz has quit [Quit: Client closed]
waleee has joined #commonlisp
rainthree has quit [Ping timeout: 240 seconds]
prokhor_ has joined #commonlisp
jeosol has quit [Quit: Client closed]
random-jellyfish has joined #commonlisp
jeosol has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
androclus has quit [Quit: Leaving]
frgo has joined #commonlisp
<NotThatRPG>
@thuna`: good!
Brucio-61 has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 256 seconds]
tibfulv has quit [Read error: Connection reset by peer]
tibfulv has joined #commonlisp
prokhor__ has joined #commonlisp
prokhor_ has quit [Ping timeout: 260 seconds]
Brucio-61 has joined #commonlisp
waleee has quit [Ping timeout: 260 seconds]
waleee has joined #commonlisp
tyson2 has joined #commonlisp
pve has quit [Quit: leaving]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
Guest4293 has quit [Quit: WeeChat 3.7.1]
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pdietz has joined #commonlisp
pranavats has joined #commonlisp
rgherdt has quit [Remote host closed the connection]
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
sunset_NOVA has quit [Quit: Leaving]
tyson2 has quit [Remote host closed the connection]
akoana has joined #commonlisp
tyson2 has joined #commonlisp
rendar_ has joined #commonlisp
rendar has quit [Ping timeout: 260 seconds]
Guest268987 has quit [Ping timeout: 240 seconds]
cosimone has quit [Remote host closed the connection]
Guest268987 has joined #commonlisp
thuna` has quit [Remote host closed the connection]
pdietz has quit [Ping timeout: 260 seconds]
jeosol has quit [Quit: Client closed]
Lycurgus has joined #commonlisp
shka has quit [Ping timeout: 260 seconds]
tyson2 has quit [Remote host closed the connection]
random-jellyfish has quit [Quit: Client closed]
attila_lendvai has joined #commonlisp
mister_m has quit [Read error: Connection reset by peer]