anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
even4void has joined #commonlisp
thuna` has quit [Remote host closed the connection]
mixotricha has joined #commonlisp
bilegeek has joined #commonlisp
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
even4void has quit [Ping timeout: 268 seconds]
atgreen has quit [Ping timeout: 264 seconds]
orestarod has quit [Ping timeout: 268 seconds]
even4void has joined #commonlisp
atgreen has joined #commonlisp
atgreen has quit [Quit: Leaving]
jin has joined #commonlisp
jin is now known as nij
nij is now known as nijj
nijj has quit [Remote host closed the connection]
akoana has quit [Quit: leaving]
jeffrey has quit [Ping timeout: 246 seconds]
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 255 seconds]
tyson2 has quit [Remote host closed the connection]
igemnace has joined #commonlisp
igemnace has quit [Remote host closed the connection]
igemnace has joined #commonlisp
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
Bike has quit [Quit: Lost terminal]
ahlk has quit [Remote host closed the connection]
causal has joined #commonlisp
mon_aaraj has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
kathe has joined #commonlisp
<kathe>
good morning everyone. :)
<beach>
Hello kathe.
<kathe>
does anyone know of how to analyse performance of a code under 'sbcl'?
<kathe>
i mean, is there any tool like linux's "perf" for native binaries?
<beach>
You can use the statistical profiler.
<kathe>
beach! :)
<kathe>
beach: thanks for that one. didn't know it even existed. :)
<beach>
Pleasure! Good luck!
<kathe>
beach: isn't it a bit too early for you to be here?
<beach>
No, it is 5:30 here, and I am usually here before 5.
<kathe>
ah. cool. have a good day ahead. :)
kathe has quit [Quit: Leaving]
<hayley>
Time is late instead, beach is up on...time.
mrcom has quit [Remote host closed the connection]
mrcom has joined #commonlisp
saura has joined #commonlisp
saura has quit [Ping timeout: 268 seconds]
fitzsim has quit [Read error: Connection reset by peer]
fitzsim has joined #commonlisp
hineios7 has joined #commonlisp
hineios has quit [Ping timeout: 272 seconds]
hineios7 is now known as hineios
mon_aaraj has quit [Ping timeout: 246 seconds]
mon_aaraj has joined #commonlisp
igemnace has quit [Remote host closed the connection]
igemnace has joined #commonlisp
igemnace has quit [Remote host closed the connection]
igemnace has joined #commonlisp
saura has joined #commonlisp
saura has quit [Ping timeout: 246 seconds]
leeb has quit [Ping timeout: 264 seconds]
leeb has joined #commonlisp
igemnace has quit [Remote host closed the connection]
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
azimut has joined #commonlisp
dBc has joined #commonlisp
<contrapunctus>
Hm...I could use some design suggestions.
saura has joined #commonlisp
saura has quit [Remote host closed the connection]
mrcom has quit [Read error: Connection reset by peer]
saura has joined #commonlisp
mrcom has joined #commonlisp
saura has quit [Ping timeout: 246 seconds]
<contrapunctus>
I'm working on a code browser which displays code as trees, which have directories, files, and top-level Lisp forms as nodes.
<contrapunctus>
Currently, the constructor for file nodes takes a pathname and checks whether the file type is supported, by calling `(compute-applicable-methods #'parse-file (list pathname ... <file extension as a keyword>))` ...but I'm not sure I like this approach.
yauhsien has joined #commonlisp
<beach>
Why not just call PARSE-FILE?
<contrapunctus>
Probably because it would error if there is no applicable method, and I haven't yet figured out how to add a method to `no-applicable-method`...
<beach>
I suggest you figure that out.
<contrapunctus>
Okay.
yauhsien has quit [Ping timeout: 255 seconds]
dra_ has joined #commonlisp
Dynom has joined #commonlisp
pve has joined #commonlisp
lisp123 has joined #commonlisp
bilegeek has quit [Quit: Leaving]
<lisp123>
I have an interesting puzzle for this group
<lisp123>
Haven't thought of the answer yet, but will try myself shortly
<lisp123>
Is there a way to represent the position of items in a list numerically
<lisp123>
so that A in (+ 1 (+ A B)) has a particular number. And then 1 has its own number
<pjb>
Sure. of course.
<lisp123>
and the subtraction of these two numbers will give you the direction to go from 1 to A
<lisp123>
and from A to 1 (if negative)
<lisp123>
And subtraction may not achieve this, but any sort of binary operation can be used in its place
<pjb>
what about division?
<lisp123>
sure
<pjb>
a trivial representation is to use the product of powers of prime numbers.
<pjb>
powers of 2 for position in the toplevel list. Powers of 3 for positions in sublists of level 1. Powers of 5 for positions in sublists of level 2, etc.
<pjb>
So 1 is 2^2 (starting from 1), and A is 2^3*3^2
<lisp123>
Simply. Genius.
<pjb>
1 to A is 2^3*3^2/2^2 = 2^1*3^2
cosimone has quit [Read error: Connection reset by peer]
<beach>
Gödel invented that.
<lisp123>
Is this something that has been used before?
<beach>
He used it in his proof of the incompleteness theorem.
<beach>
Or something similar, anyway.
<pjb>
A to 1 is 2^2/(2^3*3^2) = 2^-1*3^-2 = go back 2, go up, go back 1.
<lisp123>
beach: Interesting to know. Seems like he would've liked Lisp if he was in this era
<lisp123>
pjb: Have you ever used this in your own code or seen it somewhere in lisp code as a way to navigate within lists?
<lisp123>
I was thinking more of the Zipper algorithm (which represents the path from the top to the final element), so something like DRDR or DRR (where d = down, r = right)
<rotateq>
lisp123: And he wasn't far discovering it himself around 1930.
<lisp123>
And was seeing if I could convert this 'string' view of element positions into a numerical equivalent
<lisp123>
rotateq: Connections like this between (C)Lisp and mathematical concepts really does seem to drive home the point that Lisp is the most natural language
lisp123 has quit [Remote host closed the connection]
ttree has quit [Ping timeout: 272 seconds]
jeffrey has joined #commonlisp
azimut has quit [Remote host closed the connection]
cosimone has joined #commonlisp
kpoeck has joined #commonlisp
azimut has joined #commonlisp
opcode has quit [Quit: hopefully not k:lined]
dra_ has quit [Ping timeout: 268 seconds]
X-Scale` has joined #commonlisp
dBc has quit [Quit: Lost terminal]
X-Scale has quit [Ping timeout: 264 seconds]
X-Scale` is now known as X-Scale
yauhsien has joined #commonlisp
nijj has joined #commonlisp
yauhsien has quit [Ping timeout: 246 seconds]
random-nick has joined #commonlisp
anticomputer has quit [Quit: quit]
waleee has joined #commonlisp
anticomputer has joined #commonlisp
atgreen has joined #commonlisp
yauhsien has joined #commonlisp
mon_aaraj has quit [Read error: Connection reset by peer]
kpoeck has quit [Quit: Client closed]
mon_aaraj has joined #commonlisp
Oddity has quit [Ping timeout: 264 seconds]
nijj has left #commonlisp [ERC 5.4 (IRC client for GNU Emacs 28.1)]
orestarod has joined #commonlisp
dra has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
kpoeck has joined #commonlisp
lisp123 has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
pranavats has joined #commonlisp
vassenn has joined #commonlisp
cage has joined #commonlisp
rotateq has quit [Ping timeout: 268 seconds]
tyson2 has joined #commonlisp
mon_aaraj has quit [Ping timeout: 246 seconds]
mon_aaraj has joined #commonlisp
X-Scale` has joined #commonlisp
X-Scale has quit [Ping timeout: 268 seconds]
X-Scale` is now known as X-Scale
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
dra has quit [Ping timeout: 272 seconds]
rodicm has joined #commonlisp
<lisp123>
contrapunctus: re code browser, why worry about directories and files? better do based on packages and how functions depend on other functions
<lisp123>
an object browser for CLOS objects would be good - believe its already implemented in various forms, but worthwhile adding to any 'code browser'
<lisp123>
then it would be good to see the current values of any special variables
<lisp123>
it would be good to read a function and automatically browser to the applicable method
<lisp123>
then it would be good to have a documentation browser and potentially some type inference
<lisp123>
these are some thoughts :) easier to type than to do, but some food for thought!
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
vassenn has quit [Remote host closed the connection]
lisp123 has quit [Remote host closed the connection]
<contrapunctus>
«better do based on packages and how functions depend on other functions» I'm working on a view which does something similar, but using system definitions rather than packages.
<contrapunctus>
«it would be good to have a documentation browser» One part of this will be done when I implement source comment display. Another aspect is customizable views of source code, e.g. displaying any combination of code, [and wherever applicable] definition name, definition type, docstring, arglists, etc...the parsing for this is in place, but needs a UI.
leeb has quit [Ping timeout: 268 seconds]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 246 seconds]
<jeosol>
Good morning all
<jeosol>
I am using SBCL primarily and currently investigating two different representation options for some data. Is there a function to find out (in the repl) the size of the object created?
<beach>
I don't think so, but you can make an educated guess. Are you sure your application requires you to optimize for space?
<jeosol>
To give some context, I am trying to refactor some code that does binary genetic algorithm and I have to store the genes as array of the bits #(1 0 1 0 ...). I am thinking of saving it in the objects as str "1010..." then blow it up when I need to use it for GA operations (crossover and mutation), but it's probably too much work as I'll need those
<jeosol>
other encode and decode functions
<_death>
one simple approximation is to traverse the object, summing the sizes of sub-objects.. for the size of "primitive" objects you can use sb-ext:primitive-object-size
<beach>
jeosol: Arrays with bits take up less room that strings.
<jeosol>
beach: Good point. I am just thinking about it, I don't think so. It's seem it will just be too much work. I am trying to see if I can store things compactly and see how things the time and space tradeoffs
<jeosol>
beach: Thanks for that. That resolves my problem. Using array of bits is my current implementation but had someone suggest if I have looked into compressing them.
<beach>
jeosol: The standard requires the existence of bit vectors, and I am pretty sure SBCL stores a single bit for each element in that case.
<beach>
You could possibly do better if your arrays are sparse.
<jeosol>
beach: That's good to know. Thanks as always
<jeosol>
The arrays are usually sparse. It will contain lots of 0's and 1's. But usually, I am not looking at massive datasets. I do use a some compression elsewhere but for storing things in a file where I store things as 4*1 4*0 5*1 with the first number indicating the count of the second number. It's not related to my bits question but I do process some
<jeosol>
large arrays in a 3d-grid that are mostly just 1's (have property there) or 0's (property is not there)
leeb has joined #commonlisp
<hayley>
It is worth noting that SBCL can do SIMD-within-a-register for sequence operations on bit vectors, which may be faster than writing out the loop by hand.
<jeosol>
hayley: thanks, that it is worth looking into.
<hayley>
Some time ago I had mentioned that I got marked down substantially for using Lisp/ML-ish pseudocode on an assignment; but I got full marks for writing an algorithm which used such bit vector tricks, so it evened out. I'd highly recommend trying to use such operations.
<jeosol>
beach: to your question of optimizing for space. I normally sacrifice space for convenience of implementation and clear code - so I often may create more variables especially if I need to track them, than perform computations to get the variables when needed.
<jeosol>
beach: I think the boosting computation speed is a better use of my time. So I search for bottle necks and see where I can replace some code with better algorithms and/or use appropriate data structures
<beach>
I see, yes.
<jeosol>
hayley: thanks I will look into it
Everything has joined #commonlisp
<hayley>
Oh, and speaking of SIMD, I got a new processor recently, and all the vectorised scanning stuff in one-more-re-nightmare is much faster than I had anticipated; as the new (Zen 3) processor has a 256-bit ALU and the older processor has a 128-bit ALU. Scanning at 16GB/s with submatches is quite fun.
<jeosol>
I will try to create a version of the code so I can track the speedup as I make the improvements
<jeosol>
hayley: wow, that's very nice. I might self will look to get a machine later on, but I have to do some research, since I do some machine learning, thinking of something with GPU
<hayley>
I see. Last time I checked, the GPU market was in bad shape, but the Ethereum price went down recently, so hopefully fewer miners will inflate demand these days.
<jeosol>
hayley: good point. I have seen several posts on reddit that said the GPU prices have crashed due to crash in BTC and related coin prices
<jeosol>
This was the reason cited for the price reductions
<jeosol>
I am not sure what can of boost I will get
saura has joined #commonlisp
<hayley>
Long ago I had decided to only replace computer parts after they've been used for 5 years. The result is that I can't waste too much money at once, and hopefully I would partake in producing less e-waste too. But I decided to spend more money than usual on a CPU, as the cost is amortised over 5 years. That information might or might not help with picking a machine.
<hayley>
But this might be more relevant for #lispcafe.
saura has quit [Ping timeout: 255 seconds]
<jeosol>
hayley: that's lofty
<hayley>
On topic, I do a fair amount of model checking and fuzzing of my code, to help find bugs; there usually are a few bugs before I run a fuzzer for the first time. That sort of workload is embarrassingly parallel, so I decided throwing money at a nice CPU would improve my productivity enough to justify the cost.
<jeosol>
Doing something similar now - my code mostly runs but there are some code paths that will result in problems every now are then. I am running stochastic optimizations so something some situations may arise and I have not accounted for nor written protective code around
szkl has quit [Quit: Connection closed for inactivity]
<hayley>
Pratchett once said that "real stupidity beats artificial intelligence every time", but often artificial stupidity beats my intelligence ):
<jeosol>
beach: On the timing and performance issue, is there some resource (or may be there needs to be one) that emphasizes CL style for better performant code. Perhaps some of the Lisp guides and/or some repos have this. Like for python, because of multiple ways of doing things, some looping constructs run slower and others that use C underneat or
<jeosol>
vectorized operation run faster.
<jeosol>
I haven't looked at Vseloved's(?) book see if he touches on this area
<beach>
I am unaware of any such resource. Also, I imagine that for Python, it's for a single implementation, whereas for Common Lisp, the recommendations might vary a lot between implementations.
<TMA>
jeosol: the name is Vsevolod
<jeosol>
my bad, I am sorry, but butchering the name. I get confused, not sure if I have seen the other spelling somewhere or my mind is playing tricks on me
<hayley>
I always thought the rule for Python was to just use a C module, or to hope PyPy fares better.
<jeosol>
beach: good point beach. I was even thing of say things like organize let forms, loop macro constructs that are performance, albeit slightly, etc. But I do agree that will definitely vary my implementation.
<hayley>
The instructor didn't like my sense of humour for some submitted work; we had to produce an algorithm that ran quickly, which was to be written in Python, so I made a C module which did the computation. (Better yet, we were allowed external libraries, and those often use C as well.)
<jeosol>
hayley: I don't claim to be a python expert, and don't know the language fully, just use it to get some things (in the ML/AI space) done
<jeosol>
hayley: yes, for serious computation, it was recommended to use a C module or libs with C modules behind
<hayley>
Later he had admitted that my submission was fast even for a C program; perhaps I could have done it in Python properly. But I searched how to perform a count-trailing-zeroes operation in Python, and was told to make a string and search for a '0' character in the string, which scared me.
<yitzi>
Trailing zeros in the decimal representation of a number?
<hayley>
As for an optimisation guide for Common Lisp, I think one might be tempted to write too much about optimising for SBCL. (Though it might be good advice to recommend you try hacking on the compiler of your favourite implementation, too.]
<hayley>
Oh, it was searching for the '1' in the binary representation, which isn't much better. Ideally this operation would just use the BSF instruction on x86, I think.
<hayley>
(Arguably I didn't write my code in C, as I used a GCC intrinsic function to perform count trailing/leading zeroes though.)
<hayley>
Common Lisp is quite good for bit munging, in comparison. LDB is already amazing, INTEGER-LENGTH is find-last-set(?) and LOGCOUNT is Hamming weight.
<TMA>
jeosol: it is his e-mail address (and twitter handle), but not his name, so...
kpoeck has quit [Quit: Client closed]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 268 seconds]
rodicm has quit [Ping timeout: 272 seconds]
<jeosol>
TMA: that's where I have seen that then. I was confused when I saw it and then saw his name later on. Good to know
saura has joined #commonlisp
cosimone has quit [Remote host closed the connection]
thuna` has joined #commonlisp
rodicm has joined #commonlisp
saura has quit [Ping timeout: 268 seconds]
cosimone has joined #commonlisp
saura has joined #commonlisp
saura has quit [Ping timeout: 255 seconds]
rotateq has joined #commonlisp
saura has joined #commonlisp
saura has quit [Ping timeout: 255 seconds]
surabax has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
yauhsien has quit [Remote host closed the connection]
semz has joined #commonlisp
notzmv has quit [Ping timeout: 264 seconds]
<phantomics>
Hey, quick question, are there any libraries for CL that optimize integer division, i.e. (floor), like libdivide for C/C++?
<pjb>
phantomics: (/ 1 3) #| --> 1/3 |# what do you mean?
<pjb>
If you find your CL implementation doesn't divide fast enough, then report a bug!
<pjb>
(floor 1 3) #| --> 0 ; 1 |#
<pjb>
(time (floor 903128712708418 12312)) #| --> 73353534170 ; 7378 |# took 4 microseconds (0.000004 seconds) to run.
<pjb>
Well, with slime repl, anything takes 4 µs…
<phantomics>
The naive implementation of floor can be improved on a bit, libdivide uses some strategic bit shifts and other techniques to make it faster
<jackdaniel>
a bottleneck!
<phantomics>
And April's row-major-index based array transformations do a lot of (floor)ing to convert indices
<pjb>
Yes. Again, you can report a bug asking vendors to use libdivide or better in their cl:floor implementation.
kpoeck has joined #commonlisp
yauhsien has joined #commonlisp
<jeosol>
I recall seeing that PLN is not in SBCL a while back. What is the current status? I tried in many moons ago and got some errors.
<jeosol>
thanks
<phantomics>
Or just FFI it directly in April, but that would be inelegant, although it appears that some recent processors have much faster int division, like M1 and Ryzen
<jackdaniel>
jeosol: it works at least on abcl, ccl, ecl and sbcl
<jackdaniel>
afair commercial implementations either picked changes up, or will do that, but that would need a confirmation
<jackdaniel>
I think that Shinmera had some fancy page that summarizes support for various extensions
<jeosol>
jackdaniel: thanks, I only use SBCL, I tried it a while ago and remember seeing something that asdf for SBCL didn't update something (i don't remember exactly)
<jeosol>
jackdaniel: I think I recall my error. I was trying to use PLN with uiop:define-package, that's why I wasn't able to get it to work, not plain defpackage
makomo has quit [Quit: WeeChat 3.5]
makomo has joined #commonlisp
<jackdaniel>
I agree taht using uiop:define-package is an error :) /jk
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 255 seconds]
specbot has quit [Ping timeout: 246 seconds]
minion has quit [Ping timeout: 256 seconds]
minion has joined #commonlisp
specbot has joined #commonlisp
notzmv has quit [Ping timeout: 268 seconds]
kpoeck has joined #commonlisp
<Shinmera>
jeosol: PLNs originated in SBCL.
<jeosol>
Shinmera: thanks for that. It seems there is some issue using it with uiop:define-package
<Shinmera>
anyway, what jackdaniel said but without the /jk
<jeosol>
jackdaniel: did you confirm that it gives an error too, or that I shouldn't be using it that way
<jeosol>
Shinmera: ok, thanks, that resolves it then
<Shinmera>
you need a recent asdf to add support for it
<Shinmera>
I just do not like depending on asdf in my code unless absolutely necessary.
<jeosol>
Shinmera: interesting. So it means I'd have to update manually because I am using latest SBCL
<jeosol>
Good point
<jeosol>
I am not using PLN now per se, but trying to make things more maintainable, so looking at options
jmes has quit [Ping timeout: 264 seconds]
<Shinmera>
I've been using PLNs in all my libraries published since 2019 and it's been great.
notzmv has joined #commonlisp
<jeosol>
You use SBCL or what implementation
<Shinmera>
primarily, but my libraries are portable.
<jeosol>
you point about dependence about is to use plain defpackage instead of uiop:define-package
<Josh_2>
PLN?
<random-nick>
Josh_2: package local nicknames
<Josh_2>
Oh
<Josh_2>
Makes sense
tyson2 has joined #commonlisp
citizenandrew has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
citizenandrew has quit [Remote host closed the connection]
citizenandrew has joined #commonlisp
<mfiano>
Shinmera: Well PLNs didn't really originate in SBCL, but it was the first implementation of the external specification
<jackdaniel>
the specification was written by nsivola for sbcl with intent to propose it as CDR after some user feedback
citizenandrew has quit [Remote host closed the connection]
citizenandrew has joined #commonlisp
<mfiano>
It's pretty amazing how that feature caught like wildfire in the world of opinionated Lispers.
ttree has joined #commonlisp
<mfiano>
What a great thing to have, and what a great thing we all agree on.
citizenandrew has quit [Remote host closed the connection]
kpoeck has quit [Quit: Client closed]
citizenandrew has joined #commonlisp
citizenandrew has quit [Remote host closed the connection]
citizenandrew has joined #commonlisp
tyson2 has joined #commonlisp
citizenandrew has quit [Remote host closed the connection]
citizenandrew has joined #commonlisp
tyson2 has quit [Read error: Connection reset by peer]
citizenandrew has quit [Remote host closed the connection]
citizenandrew has joined #commonlisp
snits has quit [Ping timeout: 268 seconds]
snits has joined #commonlisp
citizenandrew has quit [Remote host closed the connection]
Bike has joined #commonlisp
tyson2 has joined #commonlisp
<Bike>
phantomics: sbcl optimizes division by small constants into shifts+etc already https://github.com/sbcl/sbcl/blob/master/src/compiler/srctran.lisp#L3093-L3119. if you want to do something like libdivide you could call compile? like use (compile nil `(lambda (x) (truncate x ,d))) where libdivide has libdivide::divider<int>;
<Bike>
if the function call overhead is too much, you could probably leverage sbcl internals to produce appropriate forms yourself and rely on the modular arithmetic optimizations
Bike has quit [Client Quit]
ttree has quit [Ping timeout: 255 seconds]
even4void has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 27.1]
dra has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
<phantomics>
Thanks Bike
kpoeck has joined #commonlisp
<phantomics>
By small constants does it have to be expressed as a constant in the code, like (floor x 3)? Will it work with for example (floor x (aref v y)), where v is a vector of positive integers?
saura has joined #commonlisp
saura has quit [Ping timeout: 268 seconds]
opcode has joined #commonlisp
Everything has quit [Quit: leaving]
makomo has quit [Quit: WeeChat 3.5]
Oddity has joined #commonlisp
azimut has quit [Ping timeout: 268 seconds]
livoreno has quit [Ping timeout: 248 seconds]
matt` has joined #commonlisp
tyson2 has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
rodicm has quit [Quit: Leaving]
Dynom has quit [Quit: WeeChat 3.5]
akoana has joined #commonlisp
kpoeck has quit [Quit: Client closed]
jmes has joined #commonlisp
yauhsien has joined #commonlisp
irc_user has joined #commonlisp
yauhsien has quit [Ping timeout: 268 seconds]
triffid has joined #commonlisp
waleee has joined #commonlisp
lisp123 has joined #commonlisp
contrapunctus has quit [Ping timeout: 240 seconds]
pranavats has quit [Ping timeout: 244 seconds]
alaa has quit [Quit: Leaving]
matt` has quit [Remote host closed the connection]
jack_rabbit has joined #commonlisp
knusbaum has quit [Ping timeout: 268 seconds]
pve has quit [Quit: leaving]
aartaka has joined #commonlisp
Guest8247 has quit [Quit: bye]
krjst has joined #commonlisp
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #commonlisp
aartaka has quit [Ping timeout: 246 seconds]
aartaka has joined #commonlisp
lottaquestions has quit [Quit: Konversation terminated!]
dra_ has joined #commonlisp
dra has quit [Ping timeout: 248 seconds]
lisp123 has quit [Remote host closed the connection]