keep_learning_M has quit [Quit: This computer has gone to sleep]
<leedleLoo>
good evening!
dale is now known as ale
ale is now known as dale
torbo has joined #lisp
keep_learning_M has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
dacoda has joined #lisp
torbo has quit [Remote host closed the connection]
uplime is now known as ^
^ has quit [Disconnected by services]
uplime has joined #lisp
<leedleLoo>
I'm not sure if there are any folks with gitlab persmissions for asdf on here, but I ran into a typo in the uiop:run-program docstring awhile ago: https://gitlab.common-lisp.net/asdf/asdf/blob/master/uiop/run-program.lisp#L550 I had an awkward registration experience for the gitlab instance so figured I'd post it here instead
ltriant has quit [Ping timeout: 248 seconds]
uplime is now known as ^
dddddd has quit [Remote host closed the connection]
<moldybits>
i'm probably really dumb here but this confuses me: (defparameter x 1) (defun a (x) (lambda () x)) (funcall (a 2)) ; => 1
<no-defun-allowed>
No, you're not dumb, the reason is that DEFPARAMETER and DEFVAR use dynamic scoping instead of static.
<|3b|>
DEFPARAMETER globally declaims the variable it defines as special (= dynamic scope), which applies to any use of that variable name, including function arguments
<jonh>
beach: sort of, pop in and out every few weeks and mostly lurk ;p
<no-defun-allowed>
(This is why you usually see the names surrounded in stars, so it's obvious they're dynamic and so they don't collide with any other names.)
<no-defun-allowed>
It's weird, but basically it allows something like (defvar *x*) (defun f (*x*) (g)) (defun g () (1+ *x*)) (f 3) ; => 4
<beach>
jonh: I see.
<no-defun-allowed>
This is useful for getting some code to output to a file instead of the terminal (rebinding *standard-output*) and setting print parameters (like *print-base*)
<jonh>
but i think its sleepy time now
<no-defun-allowed>
So, in a way, the bindings pass through function calls, but the downside is they can't be closed over since functions don't capture them.
Xach has quit [Ping timeout: 258 seconds]
Xach has joined #lisp
<moldybits>
i've never seen earmuffs on a parameter before ...
ltriant has joined #lisp
leedleLoo has left #lisp [#lisp]
<no-defun-allowed>
That's very odd, all special variables in the CL package use that style.
<moldybits>
sorry, i meant function parameter :)
<|3b|>
it isn't too common, but can be useful
<no-defun-allowed>
Oh, it's possible, and it does what you would expect.
<moldybits>
yeah, it makes sense now that is see it, haha
<loke>
/,e never uses it. I'd rather write (defun foo (s) (let ((*standard-output* s)) ...))
<LdBeth>
Special variable can be used effectively to eliminate call back hell
<moldybits>
you mean having to pass a handler down the stack?
<moldybits>
loke: yeah, i thought that was the only way
<moldybits>
no-defun-allowed, |3b|: thanks.
<LdBeth>
moldybits: yes.
<White_Flame>
also for thread-local contexts
<White_Flame>
I use such bindings a lot
Arcaelyx has quit [Ping timeout: 246 seconds]
Necktwi has quit [Ping timeout: 244 seconds]
nanoz has quit [Ping timeout: 245 seconds]
q9929t has joined #lisp
Necktwi has joined #lisp
trn has quit [Quit: quit]
vlatkoB has joined #lisp
akoana has left #lisp [#lisp]
Misha_B has quit [Read error: Connection reset by peer]
wigust has quit [Read error: Connection reset by peer]
wigust has joined #lisp
Arcaelyx has joined #lisp
q9929t has quit [Quit: q9929t]
^ is now known as [
[ has quit [Disconnected by services]
uplime has joined #lisp
froggey has quit [Ping timeout: 272 seconds]
froggey has joined #lisp
Inline has quit [Quit: Leaving]
uplime is now known as ^
^ is now known as [
keep_learning_M has quit [Quit: This computer has gone to sleep]
sauvin has joined #lisp
mfiano has joined #lisp
dacoda has quit [Ping timeout: 258 seconds]
<dmiles>
i cant count the number of timeas a say i want to write: MY-PACKAGE:(LIST 'READ-FROM-MAY-PACKAGE 'AND-THIS-TO)
<dmiles>
times a day
keep_learning_M has joined #lisp
keep_learning_M has quit [Client Quit]
<ck_>
<|3b|>
dmiles: doesn't that work on some implementations?
<|3b|>
dmiles: my-package::(list 'a 'b) seems to work on sbcl at least
<dmiles>
|3b| oh awesome, ok adding it to my LarKC_CL's reader then.. i was sort of bringing it up to see how terrible it would be had i added it
<dmiles>
also i do like that using :: better than :
* |3b|
thinks they copied it from one of the commercial implementations, but can't remember specifics
<mfiano>
allegro
Kundry_Wag has joined #lisp
JohnMS_WORK has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
varjag has joined #lisp
<emacsomancer>
has anyone here played with 'snek' (generative art) ?
jprajzne has joined #lisp
varjag has quit [Ping timeout: 245 seconds]
trn has joined #lisp
donotturnoff has joined #lisp
varjag has joined #lisp
dale has quit [Quit: dale]
varjag has quit [Ping timeout: 252 seconds]
zmyrgel has joined #lisp
<zmyrgel>
I need to generate 400.000 8-digit unique random 'checkcodes' but my current methods seems to choke up sbcl defaults
<zmyrgel>
the 7-digit version works but the sbcl chokes on the 8-digit version
<loke>
zmyrgel: You have to explain what the actual problem is.
<zmyrgel>
i'm making a raffle and I need unique seven and eight digit length check codes for each raffle ticket
ebrasca has joined #lisp
<loke>
yes, but you never explained what error you're seeing
<zmyrgel>
heap exhaustion I think as sbcl ends up in ldb
<loke>
So allocate more memory for the heap then?
<mfiano>
Well, one optimization worth pursuing is `subseq` conses a new piece of memory each time
<loke>
mfiano: That'll not make it run out of memory. This seems to be more related to the fact that he creates a list of N conses. I'd recommend creating the array outright and fill it instead of going via a huge list.
<mfiano>
Aye, I was getting to that. First it's important to understand why it's running out of memory. There are a few reasons
<no-defun-allowed>
You could also save quite a few bytes by only formatting strings after you've shuffled them.
<mfiano>
Considering he is doing destructive operations elsewhere, I believe he was trying not to cons at runtime
<loke>
He's creating a list of 100 million conses. That'll be almost 2 GB of space.
<loke>
He's just running out of heap creating the list.
<no-defun-allowed>
I imagine that strings have some overhead, whereas using fixnums (good to at least 9 digits with 28-bit fixnums) would be a lot tighter
<loke>
he's only generating the strings after shiffling
<zmyrgel>
first version did the format within the loop, that wasn't great idea
<no-defun-allowed>
Oh, very good then.
<loke>
zmyrgel: Just work with arrays all the time instead of going back and forth between lists and arrays
<loke>
that'll sove the problem
<zmyrgel>
yeah, I'll try that
<loke>
also, there is a brief period in your function that converts back and forth where TWO copies of the list + the array is keps in memory at the same time
<loke>
At like 11 to be precise. The original list, the array and th enew list are all on heap at the same time.
<loke>
s/like/line/
<loke>
that'll eat multiple GB of RAM
<White_Flame>
why not just make linear raffle numbers, and add a 32-bit hash of each to it?
<White_Flame>
that's 8 digits
<loke>
White_Flame: hashes are not guaranteed to be unique
<loke>
and I presume you don't want the sequence to be reversible
<no-defun-allowed>
The author is supposed to write a Knuth shuffle.
<White_Flame>
I know, but it's incredibly unlikely. Plus if you have both the sequence and the "checkcode" required, it doesn't matter if there's a collision
<no-defun-allowed>
The raffle thing is just a demonstration.
<White_Flame>
no-defun-allowed: yeah, that's quite a possibility as well
<White_Flame>
just offering a different approach to the original problem
mingus has quit [Remote host closed the connection]
ltriant has quit [Quit: leaving]
<loke>
White_Flame: Far too many people believe hashes are some kind of magical things that never (almost never) collide. We're supposed to be logical people here, and "almost" isn't the same as "never". Also, a hash in this case is no different from just a random number. And adding a random number to any number yields a random number. So your idea can simply be reduced to: "just use a random number, it's unlikely there will be a collision"
<White_Flame>
yeah, I uses hashes a ton, I know their bounds
<White_Flame>
bu tyeah, this particular case does reduce to a random set of numbers, but collisions would hurt there
<White_Flame>
that's why I said sequence + hash of sequence would not collide, and would not be predictable if the hash had a secret salt as well
<zmyrgel>
original program used just random integers but there we're some duplicates in the results
<White_Flame>
just fill a hash table with random keys until the size of the hash table reaches your desired count. That would automatically dedup
<White_Flame>
if that's too big for RAM, use the filesystem by touching files named randomly
<White_Flame>
(assuming the practical effect is what's desired, and not a classroom assignment)
<zmyrgel>
that seems to work as well
<White_Flame>
there ou go
<zmyrgel>
if the requirements change yet again I think I'll try the stuffing checksums in hash method
mSSM has joined #lisp
<zmyrgel>
like the checksum can/must include letters
<White_Flame>
yep, :test #'equal
<White_Flame>
it doesn't sound like speed is of the utmost priority, just ensuring it doesn't blow RAM
<zmyrgel>
yeah, it just needs to be fast enough
Folkol has quit [Ping timeout: 258 seconds]
Folkol has joined #lisp
scymtym has joined #lisp
random-nick has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
linli has joined #lisp
keep_learning_M has joined #lisp
Kundry_Wag has joined #lisp
linli has quit [Ping timeout: 245 seconds]
keep_learning_M has quit [Client Quit]
orivej has joined #lisp
salva has joined #lisp
hhdave has joined #lisp
Kundry_Wag has quit [Ping timeout: 248 seconds]
shrdlu68 has joined #lisp
Kundry_Wag has joined #lisp
quazimodo has quit [Quit: leaving]
Kundry_Wag has quit [Ping timeout: 252 seconds]
[ is now known as ^
libertyprime has quit [Ping timeout: 245 seconds]
bendersteed has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
vxe has quit [Remote host closed the connection]
zagura has quit [Ping timeout: 272 seconds]
zagura has joined #lisp
seok has quit [Remote host closed the connection]
manualcrank has quit [Quit: WeeChat 1.9.1]
v88m has quit [Read error: Connection reset by peer]
quazimodo has joined #lisp
quazimodo has quit [Client Quit]
quazimodo has joined #lisp
v88m has joined #lisp
quazimodo has quit [Quit: leaving]
bendersteed has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
Oddity has quit [Ping timeout: 258 seconds]
v88m has quit [Read error: Connection reset by peer]
Necktwi has quit [Ping timeout: 258 seconds]
josemanuel has joined #lisp
v88m has joined #lisp
Oddity has joined #lisp
cosimone has joined #lisp
JohnMS_WORK has quit [Read error: Connection reset by peer]
JohnMS_WORK has joined #lisp
keep_learning_M has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
dddddd has joined #lisp
linli has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
linli has quit [Ping timeout: 245 seconds]
mSSM has left #lisp ["WeeChat 2.5"]
xkapastel has joined #lisp
m00natic has joined #lisp
hackware has quit [Remote host closed the connection]
Necktwi has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
papachan has joined #lisp
jmercouris has joined #lisp
jmercouris has quit [Ping timeout: 244 seconds]
amerlyq has joined #lisp
keep_learning_M has joined #lisp
flazh has quit [Ping timeout: 248 seconds]
edgar-rft has joined #lisp
jprajzne has quit [Quit: Leaving.]
Misha_B has joined #lisp
v88m has quit [Ping timeout: 244 seconds]
jprajzne has joined #lisp
hackware has joined #lisp
zmyrgel has quit [Remote host closed the connection]
lnostdal has quit [Quit: "Fascism, Nazism, Communism and Socialism are only superficial variations of the same monstrous theme—collectivism." -- Ayn Rand]
Kundry_Wag has quit [Remote host closed the connection]
jprajzne has quit [Quit: Leaving.]
linli has quit [Read error: Connection reset by peer]
varjag has joined #lisp
mindCrime has joined #lisp
smazga has joined #lisp
Arcaelyx has quit [Read error: Connection reset by peer]
Arcaelyx has joined #lisp
xkapastel has joined #lisp
Arcaelyx has quit [Read error: Connection reset by peer]
lnostdal has joined #lisp
actuallybatman has joined #lisp
atgreen has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
Arcaelyx has joined #lisp
Arcaelyx has quit [Read error: Connection reset by peer]
bendersteed has joined #lisp
Arcaelyx has joined #lisp
igemnace has joined #lisp
Arcaelyx has quit [Read error: Connection reset by peer]
smazga has quit [Ping timeout: 258 seconds]
Arcaelyx has joined #lisp
smazga has joined #lisp
sjl has joined #lisp
mindCrime_ has joined #lisp
scymtym has joined #lisp
cosimone has joined #lisp
mindCrime_ has quit [Ping timeout: 248 seconds]
Arcaelyx has quit [Ping timeout: 248 seconds]
anewuser has joined #lisp
v88m has joined #lisp
sjl has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
cosimone has joined #lisp
sjl has joined #lisp
rippa has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 272 seconds]
Kundry_Wag has quit [Remote host closed the connection]
hhdave has quit [Quit: hhdave]
Kundry_Wag has joined #lisp
Necktwi has quit [Ping timeout: 245 seconds]
Necktwi has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
atgreen has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
bendersteed has quit [Remote host closed the connection]
atgreen has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
q3d has joined #lisp
anewuser has quit [Quit: anewuser]
<jackdaniel>
mutexes and bordeaux-threads question: how would you deal with a situation, where condition-variable returns prematurely without re-taking lock when whole thing is wrapped in with-recursive-lock-held?
<jackdaniel>
I could put (ignore-errors (release-recursive-lock rlock)) after condition-wait, other than that I don't have ideas (because there is no lock-taken-p in bt api)
<aeth>
carmack: CLISP has essentially three advantages over SBCL. It has an arbitrary-precision long-float. It has much lower memory usage because it uses a bytecode interpreter instead of native compilation. It has readline at the terminal without using something like rlwrap (but almost no one uses a REPL directly in the terminal these days).
<aeth>
Well, I guess its compilation times are faster, too, since it doesn't really compile to native code.
<aeth>
For literally everything else, SBCL is better.
<aeth>
Faster, more recently updated, more features, more helpful error messages, larger community (so better library support), etc.
dvdmuckle has joined #lisp
<pfdietz>
clisp can be built from scratch without a lisp. It's used to build sbcl in the debian build process, isn't it? Or at least it was.
<aeth>
I think ECL has taken a lot of CLISP's niches lately since they really are in the same space for a lot of things and ECL is way more actively developed.
<aeth>
CLISP was traditionally used for bootstrapping a new Lisp, but I think ECL might be usable now, I'm not sure.
<pfdietz>
ECL can't run the random tester very long before dying, so I am prejudiced against it. :)
hiroaki has joined #lisp
<carmack>
I'll try sbcl first. I have more experience with that. All my trying was failed, i hope was lucky now :)
<jackdaniel>
ECL is officially bugfree™ since 1989 ,)
mindCrime has quit [Ping timeout: 258 seconds]
<aeth>
carmack: Generally, I would recommend trying SBCL, then CCL, then ECL in that order, because that seems to roughly be in order of popularity and performance, at least on IRC. Then stuff like ABCL (runs on the JVM) or CLISP (it still might useful to have a tiny-in-RAM interpreter) fit niches.
rippa has quit [Ping timeout: 245 seconds]
<carmack>
aeth: ok thx, i'll try
rippa has joined #lisp
<carmack>
I didn't expect this kind of activity.
<carmack>
I prepared myself to wait for an answer.
notzmv has joined #lisp
<aeth>
CCL is kind of the balanced middle ground. It's natively compiled, but not as optimized as SBCL, so its compilation times are faster, but the resulting code is slower. You can usually see this fairly directly by using DISASSEMBLE on the same function in both implementations. It will generally be larger on CCL. CCL might have better macOS integration.
<aeth>
carmack: The Lisp IRC channels are incredibly active. Except #lispweb
atgreen has quit [Ping timeout: 252 seconds]
jlarocco has joined #lisp
sauvin has quit [Ping timeout: 252 seconds]
milanj has quit [Quit: This computer has gone to sleep]
linli has joined #lisp
<mfiano>
aeth: Where do you get the number 3 from? I can think of more advantages than that.
<aeth>
mfiano: I said 3 and then listed 4
<aeth>
that was just off the top of my head
<aeth>
There are lots of related advantages to the ones I gave, like simpler output of its disassemble since it's not x86-64 asm
<mfiano>
And you also said for literally everything else, SBCL is better. While that is technically true, because "better" is a subjective term, it is not so "literal".
linli has quit [Ping timeout: 245 seconds]
<aeth>
no one uses literally literally anymore
<mfiano>
As an example, #'room for example gives much better information about memory use on CLISP. I've used it to find memory leaks SBCL had no idea about before.
<scymtym>
literally literally means figuratively now
cosimone has joined #lisp
<aeth>
For SBCL I usually just do (optimize (speed 3)) and sb-profile and disassemble to catch surprise allocations. One good thing SBCL does is that it comments (almost?) all of its allocations in disassemble. Really, the disassembly itself there isn't the point. Maybe there's a way just to get a list of the allocations.
<aeth>
As for memory leaks, what exactly do you mean?
<pfdietz>
Holding on to things you didn't realize you were holding on to.
<aeth>
Ah. Personally, I do the preallocated object pool pattern in my game engine, which is the only place where I really care about allocations. It sacrifices startup time and memory, but then shifts the whole memory process to detecting allocations and moving them to before the game loop.
<aeth>
s/memory process/memory part of the development workflow/
hiroaki has quit [Ping timeout: 252 seconds]
cosimone has quit [Quit: WeeChat 2.3]
<aeth>
Actually, I wouldn't be surprised if some of the early data before the loop starts is accidentally kept because I've never looked.
sz0 has joined #lisp
<ck_>
carmack: when did you have this experience, trying quicklisp on sbcl unsuccessfully?
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
grumble has quit [Quit: and some kind of madness has started to evolve]
grumble has joined #lisp
ebrasca has joined #lisp
milanj has joined #lisp
<carmack>
ck_: in 2018
<ck_>
o_O
<ebrasca>
Can I ask about lem here?
<pfdietz>
You can, but I don't know if anyone can answer.
<Bike>
like, the author, or
<hackware>
lem=blue...
cosimone has joined #lisp
<ebrasca>
Is it hard to add McCLIM frondend to it?
josemanuel has quit [Ping timeout: 245 seconds]
cosimone has quit [Ping timeout: 252 seconds]
Misha_B has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
lnostdal has quit [Quit: "Fascism, Nazism, Communism and Socialism are only superficial variations of the same monstrous theme—collectivism." -- Ayn Rand]
milanj has quit [Ping timeout: 272 seconds]
cpape has joined #lisp
shka_ has quit [Ping timeout: 268 seconds]
linli has joined #lisp
josemanuel has joined #lisp
linli has quit [Ping timeout: 252 seconds]
kushal has quit [Ping timeout: 260 seconds]
kushal has joined #lisp
[6502] has joined #lisp
amerlyq has quit [Quit: amerlyq]
scymtym has quit [Ping timeout: 252 seconds]
APic has quit [Ping timeout: 245 seconds]
vlatkoB has quit [Remote host closed the connection]
dvdmuckle has quit [Quit: Bouncer Surgery]
dvdmuckle has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
donotturnoff has quit [Ping timeout: 268 seconds]
nowhereman has joined #lisp
APic has joined #lisp
nowhereman has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
<hackware>
my lisp is better than yer lisp, cuz ya cants hear my lisp in a dark room... ;-)
q3d has quit [Remote host closed the connection]
byronkatz has joined #lisp
aindilis has quit [Ping timeout: 244 seconds]
Kundry_Wag has joined #lisp
dale has quit [Max SendQ exceeded]
mindCrime_ has joined #lisp
cosimone has quit [Ping timeout: 250 seconds]
dale has joined #lisp
cosimone has joined #lisp
pfdietz has quit [Remote host closed the connection]
Nikotiini has quit [Ping timeout: 245 seconds]
powerbit has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Remote host closed the connection]
mindCrime_ has quit [Ping timeout: 248 seconds]
Lycurgus has joined #lisp
<hackware>
well, i b newbie... i can see where it can speak "pjb-last-message", but not where original is sourced...
akoana has joined #lisp
<hackware>
speak off counter...?
<hackware>
file --> format "%s/speak-%d.txt"
<hackware>
only book i've recieved so far is lisp recipes...
<hackware>
i'm missing invocation basics...
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
Kundry_Wag has joined #lisp
<pjb>
hackware: (speak "Hello world") speak binds file to some file name returned by (pjb-speak-file) -> "/tmp/emacs501/speak-3.txt" for example.
seok has quit [Remote host closed the connection]
<pjb>
hackware: with-current-buffer switches to a new temporary buffer created by get-buffer-create, invisible, since it's name starts with a space " *speak text*"
<hackware>
learned long time ago, dos finger poken with out know'n d rite poken = bad things...
<pjb>
hackware: (erase-buffer) erases it. (in case, ther was already a buffer named " *speak text*": we reuse the same buffer each time).
<pjb>
hackware: (insert message) inserts the parameter string in that buffer. So we have "Hello world" in it.
<pjb>
hackware: (setf *pjb-speak-last-message* message) stores this parameter strinrg in the global variable.
<pjb>
hackware: (write-region (point-min) (point-max) file) writes the buffer from start to end, to the file named file.
<pjb>
hackware: then we bind command to a speak command using that file.
<pjb>
hackware: (message "%S" command) logs the command in *Messages*
<pjb>
hackware: (shell-command command) run this command in a shell.
<pjb>
hackware: (say "Understood?")
<pjb>
hackware: say is an alias of speak.
josemanuel has quit [Quit: leaving]
Kundry_Wag has quit [Ping timeout: 245 seconds]
<pjb>
hackware: Well, don't say your lisp is better when you're a newbie!
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Bike has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
hackware has quit [Remote host closed the connection]
nckx has joined #lisp
jonh has left #lisp ["WeeChat 1.9.1"]
[6502] has quit [Remote host closed the connection]
<bexx>
anyone has tried sly the fork of slime?
Necktwi has quit [Ping timeout: 245 seconds]
ltriant has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
xkapastel has quit [Quit: Connection closed for inactivity]
t58 has joined #lisp
hiroaki has joined #lisp
hackware has joined #lisp
keep_learning_M has joined #lisp
Kundry_Wag has joined #lisp
saravia has quit [Remote host closed the connection]
Necktwi has joined #lisp
Kundry_Wag has quit [Ping timeout: 258 seconds]
igemnace has quit [Quit: WeeChat 2.5]
antonv has joined #lisp
<antonv>
on CCL, if my program hangs (in some network call I believe), is there a way to check the backtrace of the hanging thread to see where exactly it hangs?
smazga has quit [Quit: leaving]
sjl has quit [Ping timeout: 252 seconds]
keep_learning_M has quit [Quit: This computer has gone to sleep]