<copec>
Julia is implementation defined, and changes at times :-(
waleee has quit [Ping timeout: 268 seconds]
asarch has joined #commonlisp
waleee has joined #commonlisp
<asarch>
Any IRC client that is viewed in the web browser?
<asarch>
Just like Perl's Alice?
CrashTestDummy2 has joined #commonlisp
CrashTestDummy has quit [Ping timeout: 252 seconds]
paule32 has quit [Read error: Connection reset by peer]
nature has quit [Ping timeout: 265 seconds]
zazzerino has quit [Remote host closed the connection]
akoana has left #commonlisp [Leaving]
prxq has quit [Ping timeout: 252 seconds]
zazzerino has joined #commonlisp
prxq has joined #commonlisp
peterhil has quit [Ping timeout: 252 seconds]
semz has quit [Ping timeout: 252 seconds]
semz has joined #commonlisp
beach` is now known as beach
<asarch>
beach, what is your native language?
<beach>
Good morning everyone!
<beach>
asarch: Assuming by "native language", you mean the literal meaning, i.e., the one I was born into, then it is Swedish. But my "primary" language is English.
<beach>
asarch: But since I live in France, I am also a fluent speaker of French.
<beach>
Well, I guess that doesn't automatically follow, but it's true.
semz has quit [Ping timeout: 252 seconds]
<asarch>
?
Spawns_Carpeting has joined #commonlisp
<asarch>
Oh, that's great!
<beach>
Person P lives in country C doesn't automatically imply that P speaks the official language of C.
<asarch>
The same language of Bjarne Stroustrup then
<beach>
WOW, HOLD ON! Finnish is in a completely different language family.
<beach>
asarch: I wouldn't say "Spanish, Portuguese, Hungarian", now would I?
<asarch>
I didn't know
<beach>
Either way, it's off topic. Now, my primary (but not "native") programming language is Common Lisp.
<asarch>
What other programming languages do you know?
<beach>
asarch: Also, you should turn on your spell checker. It would have caught your typos in two of the languages you listed.
<beach>
asarch: I have been exposed to quite a few, but whether I still "know" them, is a different story. Not important either way.
abrantesasf has quit [Remote host closed the connection]
<beach>
I have been using Common Lisp almost exclusively for more than 2 decades, and the languages I used before that have evolved.
<asarch>
*Danish, *Swedish
<beach>
Good!
<asarch>
My mistake
tyson2 has quit [Remote host closed the connection]
<asarch>
What operating system do you use?
<beach>
Only GNU/Linux. Unfortunately there is nothing better.
semz has joined #commonlisp
<beach>
... but I am working on it, of course.
srhm has quit [Read error: Connection reset by peer]
srhm has joined #commonlisp
<Spawns_Carpeting>
are there are "must have" cl libraries for basic things like strings, lists, file handling, etc? I am thinking something like dash and s for elisp for example
<asarch>
What distro?
<Spawns_Carpeting>
elisp actually doesn't make a terrible general purpose language using those libs and cl-lib
<beach>
Spawns_Carpeting: If, instead of referring to Emacs Lisp, you describe what it is you want, you might get better answers. That said, Alexandria is a general-purpose library for many things that are useful additions to basic Common Lisp.
<beach>
Spawns_Carpeting: I am not going to read up on dash and s to answer your question, is what I am trying to say.
<beach>
Spawns_Carpeting: Emacs Lisp is not a "programming language" in my vocabulary, but a "programming system". For something to be considered a "programming language" I require it to have a specification established by an "organization" that is separate from any of the suppliers of implementations of that language.
<beach>
Spawns_Carpeting: This features is essential for industrial use, because there must be some kind of guarantee that the interface does not change arbitrarily over time, thereby requiring clients to catch up with changes to the programming system.
<Spawns_Carpeting>
right beach I understand. dash is a library that adds many highly useful utility functions for lists. Examples are map, filter, remove, take, slice, reduce, min, max, some, any, split
<beach>
Spawns_Carpeting: That's why, in my talks to industry, I emphasize the importance of choosing languages with an independent standard, published by some credible standards organization, like ISO, ANSI, IEEE, etc.
<beach>
Spawns_Carpeting: All those are in standard Common Lisp, or can be had with a small amount of code.
<beach>
I am pretty sure Alexandria supplies most of the "missing" ones.
<Spawns_Carpeting>
there are probably 100s of functions that dash provides but those are just the ones I could think of. s is basically the same idea but for strings. common lisps string handling felt a little weak when I used it
<beach>
I don't know what to say to such a statement.
<beach>
It sounds to me like you think you would be better off using Emacs Lisp.
saturn3 is now known as saturn2
<Spawns_Carpeting>
I didn't mean to offend lol!
<beach>
Oh, I am not offended.
<White_Flame>
Spawns_Carpeting: everything in the sequences dictionary in the spec also applies to strings
<White_Flame>
as strings are vectors of chars, which are sequences
<Spawns_Carpeting>
how can you check if a string only contains uppercase letters in cl? or what about checking if it starts or ends with a given substring?
<White_Flame>
(every #'predicate string)
<hayley>
(notany #'lower-case-p string) ; assuming you're okay with non-alphabetic characters too
<White_Flame>
alexandria has string prefix & suffix functions
<beach>
Spawns_Carpeting: I know Alexandria has STARTS-WITH. Probably also ENDS-WITH.
<Spawns_Carpeting>
better example, set the first letter of every word to an upper case
<White_Flame>
although subseq + string= does it manually
<Spawns_Carpeting>
yeah alexandria sounds like what I am talking about. also uiop gives many helpful functions
<beach>
Spawns_Carpeting: This looks like an exercise it trying to find a function that Common Lisp doesn't have but that exists i s.
<White_Flame>
that example sounds more regexy
zazzerino has quit [Ping timeout: 252 seconds]
<Spawns_Carpeting>
my only point was that cl's built in string handling is a tad weaker than what you would get with say... python
<White_Flame>
yes
<White_Flame>
it's also much older
<Spawns_Carpeting>
though I agree many of them are trivial to roll on your own
<White_Flame>
but, alexandria, split-sequence, etc libs bring things up to reasonable par
<White_Flame>
and yes, people tend to make their own library of one-liners for stuff like this, tuned to whatever they happen to need for their project
<beach>
Spawns_Carpeting: (mapc #'nstring-capitalize <strings>) or something like that.
<White_Flame>
you'll also find CL to have more of a mindfulness to using fewer resources, so for instance splitting & rejoining many temporary substrings isn't something normally done in the standard stuff
<White_Flame>
although easy enough to do with mapping operations
<White_Flame>
python pushes for convenience of small things
<Spawns_Carpeting>
oh yeah there is certainly a different philosophy which is not a bad thing
<Spawns_Carpeting>
fwiw I like lisp and moreso common lisp a lot. I don't want to be banished to elisp forever! lol
<Spawns_Carpeting>
Alexandria is in the gentoo repo as well which is highly convenient
<White_Flame>
you should use quicklisp for pulling down lisp libraries
<White_Flame>
it manages downloading & loading dependencies
<Spawns_Carpeting>
is there any vetting of libraries in the quicklisp repo?
<Spawns_Carpeting>
i doubt that lisp libraries are an extremely common source of malware but you never know
<White_Flame>
I believe the only testing that is done is that all tests it includes must pass, and combinations of loads must work
<White_Flame>
QL has a laundry list of wishlist advancements
<White_Flame>
however, CL in general is distributed in source form, and I haven't seen any obfuscated stuff in the wild. So it relies by default on openness in this security regard
<jcowan>
beach: It's not clear to me that C# is significantly less risky than Java, even though C# has a standard (ISO 23270) and Java does not.
<beach>
jcowan: In case it wasn't clear, I meant that a standard is a necessary (but not sufficient) condition.
<waleee>
2003 C# was a very different beast compared to what ms is pushing now
<White_Flame>
well, a standard can't really do anything about library ecosystem malware anyway
<hayley>
I'd have to check the overlap between Java specifiers and Java implementors, but I suspect there is no overlap in people (but there would be an overlap in Sun/Oracle funding both).
<beach>
hayley: But by having the specification owned by a company means that they can attempt to sue people who use it in ways they don't like, as Google has experienced.
<hayley>
The Java 17 specification has James Gosling, Bill Joy, Guy Steele, Gilad Bracha, Alex Buckley, Daniel Smith and Gavin Bierman. I know the first four wouldn't have touched JVM source - yes, true.
<Spawns_Carpeting>
I am actually not a huge fan of official standards wrt programming languages. I do think it's useful for truly industrial software though
<beach>
hayley: Of course if you are Google, you have enough means to fight it, but if you are a small company or an individual, there is no hope.
<hayley>
Right.
<Spawns_Carpeting>
but thankfully my hobby projects aren't industrial ;)
<waleee>
beach: what are your thoughs on the recent foundation "owned" languages?
<hayley>
I think there is a catch-22 though; how do you get users, if the language should not be used until it is standardised? I assume that you won't bother standardising untill you have users.
semz has joined #commonlisp
<waleee>
by the amount of cash ISO et al wants for a copy of a standard I assume you also dont bother because of financial reasons
<beach>
waleee: I am unaware of that recent tendency.
<Spawns_Carpeting>
that's one of the reasons I am not a fan of standardizing languages waleee. it also makes it much more difficult for common people to actually contribute to the standard
<beach>
Spawns_Carpeting: Oh, but you don't want "common people" to contribute to a language definition. They just don't have the knowledge of language design or compiler technology to understand the consequences of their "contributions".
<beach>
Spawns_Carpeting: We see attempts here pretty much every week of "common people" wanting to revise the Common Lisp standard, and often in ways that would then make it impossible for the compiler to generate efficient code.
<hayley>
Having some kinds of contributions, no matter the experience of the author, is still in conflict with having a standard which doesn't change.
<beach>
That too.
<waleee>
beach: risking haleys ire, the rust foundation and some less high profile languages
<hayley>
👀
<jcowan>
ISLisp, ST, and some other languages solved that problem by producing a pre-standard in the public domain
<beach>
Spawns_Carpeting: Maybe your projects are just a hobby, but Common Lisp is designed to be industrially viable.
<Spawns_Carpeting>
yeah I do see your point beach, but I am not advocating for introducing every random idea that a person comes up with either! I am a fan of how python handles this with "PEPs"
<beach>
waleee: I mean, what is the purpose of this tendency? Just to have an independent organization in charge of the language specification?
<White_Flame>
as long as there is a cut & published standard, as opposed to an arbirarily changing webpage, a spec is a spec
<beach>
Spawns_Carpeting: You just gave a fantastic example of a language that basically can't have a compiler that generates efficient code. I would definitely not want that for Common Lisp.
<Spawns_Carpeting>
there must be some minimum level of quality no matter what the case is, otherwise it's going to become a joke really fast
<Spawns_Carpeting>
yeah but I don't think that's because of it not having an official standard beach
<Spawns_Carpeting>
I hate to be the rust dude, but rust has a similar system where people can create rfcs on github, and the team decides whether they are worth considering or not
<beach>
Spawns_Carpeting: Sure it is. The official standard would preferably be established by a bunch of people who have knowledge and experience in language design and compiler technology. When you have "common people" establishing a specification, that's when you get aberrations like Python.
<waleee>
in the case of the rust foundation it seems unclear, they (by comments of different core developer groups) apparently isn't directly involved in the work
<Spawns_Carpeting>
the language devs and maintainers are still the "gatekeepers" in regards to quality, they just aren't "official" like legal standards committees are
<White_Flame>
Spawns_Carpeting: one unique thing about CL is that libraries can fundamentally change the language, without needing extra support from standard implementations for those features
kakuhen has quit [Remote host closed the connection]
<beach>
Spawns_Carpeting: The problem here is selecting the people who are capable of screening proposals. Apparently, for Python this is not done in a way that would be acceptable to Common Lisp, since they accept design that is impossible to implement efficiently.
kakuhen has joined #commonlisp
<Spawns_Carpeting>
yup I agree 100% beach, screening is good, but I am not sure ISO standard committees are the best method of screening for talent
<hayley>
waleee: I recall Steve Klabnik found an article claiming that Rust followed principles used at Amazon, said that was definitely not the case, then some time later, he decided to ditch his book-writing efforts.
<hayley>
So I'm...not comfortable with the idea of having a group of large companies fund a language any more than I'd be with just one company. Though the funding isn't supposed to affect language decisions on paper.
<beach>
Spawns_Carpeting: I think you have an incorrect idea of how ISO (or ANSI) standard committees are created.
<Spawns_Carpeting>
I know it costs a non-trivial amount of money which is a non-starter for a large amount of the world
<jcowan>
It's only a historical accident that CL has a stable standard: most standards have a definite lifecycle
<waleee>
hayley: yeah, I saw that debacle, but there was some other rust teams that claimed that this wasn't the case, with varying degrees of plausability
<waleee>
(ie being employed by amazon etc)
<Spawns_Carpeting>
though participation I guess doesn't cost (or does it?), but I imagine it still requires traveling which is also not possible for everyone. I could be wrong about these things though and am welcome to being corrected :)
<beach>
jcowan: I am extremely grateful for that historical accident, and it is a large part of the reason it is my preferred language.
<jcowan>
I'm not sure when Fortran 66 features were actually removed from the standard
kakuhen has quit [Ping timeout: 252 seconds]
<jcowan>
Fortran 95, apparently
waleee has quit [Ping timeout: 268 seconds]
jealousmonk has quit [Quit: ERC (IRC client for Emacs 27.1)]
abraham has joined #commonlisp
wyrd has quit [Remote host closed the connection]
wyrd has joined #commonlisp
Bike has quit [Quit: Lost terminal]
kakuhen has joined #commonlisp
kakuhen has quit [Ping timeout: 252 seconds]
<akater[m]>
beach: Is there a collection of examples of Python features that prevent compiling it to efficient code, preferably with explanations? A blog entry, a book, an article, anything?
<beach>
I don't know. But I know that the one that allows you to add a slot to an instance is very problematic.
Guest-liao has quit [Quit: Client closed]
kakuhen has joined #commonlisp
kakuhen has quit [Ping timeout: 252 seconds]
<beach>
I haven't looked at Python for a while, but as I recall, their "list" data type allows for insertion and deletion of elements at arbitrary positions, thereby changing the number of elements. Not sure if they introduced a more low-level sequence type since then.
<beach>
But that kind of "feature" makes the complexity of element access at least O(log n) worst-case.
<beach>
Or, rather, either the insert/delete operations take O(n) time in which case access can be O(1), or insert/delete/access all take O(log n) at least.
<Spawns_Carpeting>
do you mean the list which is pretty much a vector or the actual list
<Spawns_Carpeting>
can't remember if there is a more conventional non-contiguous list
<hayley>
A vector.
<hayley>
I remember the lecturer thought a Python list was a linked list and said "Ah, it's like Lisp..."
<Spawns_Carpeting>
don't all vectors allow for insertion into arbitrary locations? that would be weird to not support
<Spawns_Carpeting>
ofc you have to shift elements to insert like that, but that's just how vectors work
<Alfr>
Spawns_Carpeting, usually replacing something at a position, insertion not so much.
gaqwas has joined #commonlisp
<Spawns_Carpeting>
i know c++ allows the same thing at least
<Alfr>
Spawns_Carpeting, is it possible? Certainly, you just described how, but worst case it costs O(n^2) to insert n elements.
<Spawns_Carpeting>
yeah of course, but you don't have to use it if you don't need it
<akater[m]>
I don't get this example. Lisp lists also allow arbitrary insertion and deletion, and random access is expensive. So this doesn't explain how Lisp design was better than that of Python's.
<Spawns_Carpeting>
that's what I was wondering as well akater[m]
srhm has quit [Read error: Connection reset by peer]
<Alfr>
akater[m], does Python really not have something like linked lists?
srhm has joined #commonlisp
kakuhen has joined #commonlisp
asarch has quit [Quit: alice.]
Spawns_Carpeting has quit [Ping timeout: 252 seconds]
kakuhen has quit [Ping timeout: 252 seconds]
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
kakuhen has joined #commonlisp
kakuhen has quit [Remote host closed the connection]
kdlv6 has joined #commonlisp
kakuhen has joined #commonlisp
sgithens_ has joined #commonlisp
kdlv has quit [Ping timeout: 245 seconds]
sgithens_ is now known as sgithens
kdlv6 is now known as kdlv
lisp123 has joined #commonlisp
ggoes has joined #commonlisp
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
Cymew has joined #commonlisp
<akater[m]>
Alfr: I know ≈nothing about Python. Only wrote a single Python script in my life. I was just wondering about language design principles.
<akater[m]>
I know it has explicit return, distinguishes between statements and expressions, makes it hard to write lambdas, one guy can change something in it in a breaking way, and it's extremely popular. In other words, I only know very bad things about it so I'm biased. Oh, and during my system updates, Python is the only source of trouble.
cranium has joined #commonlisp
<lisp123>
Did I just read Emacs Lisp, Python, Rust, all in one log on Common Lisp?
amb007 has quit [Ping timeout: 245 seconds]
amb007 has joined #commonlisp
makomo_ has joined #commonlisp
selwyn_ has joined #commonlisp
<lisp123>
Spawns* (can't get an automcomplete) - Check out Cl-PPCRE: CL-PPCRE is a high-performance regular expression library written on COMMON LISP. Benchmarks suggest that for most regular expressions CL-PPCRE is roughly twice as fast as Perl, often much faster. And Perl has one of the fastest non-lisp regular expression engines around: a highly optimised engine written in C. How is this possible? Surely Perl's low-level implementation should have
<lisp123>
a performance edge over anything written in a high-level language like lisp.
selwyn_ has quit [Remote host closed the connection]
<hayley>
lisp123: The answer is "compilation"; olde PCRE would interpret something to do with the regular expression, but CL-PPCRE would "compile" it to a chain of closures. It works okay, but now new PCRE with its own compiler is faster.
<akater[m]>
It has since lost the speed advantage, hasn't it?
<lisp123>
hayley: Oh nice, very cool. Will check it out
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<hayley>
As the README suggests, it can be up to 28× as fast on SBCL, and even up to 202× as fast on ECL (as it doesn't seem to do fast function calls, but the C compiler loves DFAs).
amb007 has joined #commonlisp
<lisp123>
hayley: Nice. And it has to compile for each term searched?
pve has joined #commonlisp
<hayley>
Sort of. Each pair of <regular expression × string type> has to be compiled, but it's cached. And, if runtime speed is less important than compile-time speed, I plan on implementing a "interpreter" which should still be faster than walking an NFA as CL-PPCRE does.
<jackdaniel>
high level languages may easily outperform low level ones when the task complexity raises -- less high-level code is easier to optimize by the programmer and high level constructs may hold more meaning to the compiler then a long list of separate instructions
amb007 has quit [Read error: Connection reset by peer]
peterhil has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
<lisp123>
Very cool stuff. It's like rocket science to get things that fast :D
<jackdaniel>
a cute example of that is format ~r, the task of printing numbers as names on some of code golf sites shows taht lisp is very fast with it (because it is part of the standard)
<jackdaniel>
while solutions written in c or other languages are slower (perhaps they could be on par, but that would require considerable amount of code)
<hayley>
It's a combination of things. gilberth gave me an algorithm to convert tagged regular expressions to DFAs, I then wrote a code generator, and then tweaked it until the assembly looked better.
<jackdaniel>
hayley: what is "break even after"?
<hayley>
The number of characters for which compilation + runtime of this engine is equal to that of cl-ppcre (assuming cl-ppcre compilation is free, which is approximately true).
<hayley>
Though I've now implemented the same LOAD-TIME-VALUE trick that CL-PPCRE uses, so it is irrelevant for constant regular expressions.
<jackdaniel>
I see, thanks
<hayley>
lisp123: It's quite simple to make a half-decent compiler for a DFA though; just write a PROG form (also, hence the name), label each state, and have a CASE form which GOes to the next state.
<lisp123>
hayley: Interesting, thanks for the info. I will dip my toes into learning more on it in due course
heisig has joined #commonlisp
cosimone has joined #commonlisp
<hayley>
Eventually I want to get a bit more performance by using SIMD instructions for constant strings, and heisig has kindly added the necessary functions to SB-SIMD to make that work.
<beach>
akater[m]: The more "primitive" type in Common Lisp would be a vector. And in Common Lisp you can obviously easily use built-in functions to extend the size of a vector and move elements around.
<beach>
My point is that the programming language should contain implementations of the primitive types and then different libraries can make different compromises with respect to complexity of operations.
* hayley
has had two kernel panics while trying to send that message, so lisp123 better read it.
<beach>
It should not be up to the language designer to have opinions on whether access should be O(1) and insertion/deletion O(n), or whether all operations should be O(log n).
<hayley>
No idea why. I mean, I get crashes every so often, but not two in the space of five minutes.
<jackdaniel>
great performance comes at a cost! ,-)
<hayley>
Well...
Guest-liao has joined #commonlisp
Mandus has quit [Quit: WeeChat 3.3]
Mandus has joined #commonlisp
hendursa1 has joined #commonlisp
hendursaga has quit [Ping timeout: 276 seconds]
<hayley>
(I think I've almost gone full circle, as kingcons's excellent articles on compiling in cl-6502 motivated me to mess around with compiling on the fly, and he starred my repository today.)
<hayley>
(Maybe full circle would be to compile to 6502 assembly, then compile that to Common Lisp :)
Mandus has quit [Ping timeout: 252 seconds]
kakuhen has quit [Remote host closed the connection]
Mandus has joined #commonlisp
kakuhen has joined #commonlisp
rotateq has joined #commonlisp
kakuhen has quit [Ping timeout: 252 seconds]
dec0d3r has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 246 seconds]
<ulfvonbelow>
so I know for iterating over an arbitrary sequence (list or vector) I can use (map nil function seq1 ...), is there a standard way to iterate over a particular subsequence? So like (map nil ...) but with :start and :end arguments?
<Shinmera>
ulfvonbelow: you could abuse FIND-IF for that.
Guest-liao has joined #commonlisp
<Shinmera>
Though I can't say I ever had to use something like that.
selwyn_ has joined #commonlisp
<heisig>
Shinmera: Did you really just develop another build system :D
<Shinmera>
well, not "just" but yes
<heisig>
You are a legend :)
<Shinmera>
still needs a bunch more work to be useful.
<heisig>
What is the rationale behind forge? Is it to overcome some problems of ASDF, and if so, which ones?
selwyn_ has quit [Ping timeout: 265 seconds]
selwyn_ has joined #commonlisp
<Shinmera>
ASDF doesn't deal with version constraints, is by necessity in-process, can't distribute the build, and can only deal with Lisp, not other languages. It also has some other design problems that I don't like.
<heisig>
I agree with almost all these points. Except the one that ASDF can only deal with Lisp. I cheerfully build my C libraries with ASDF :)
<heisig>
But having parallel or even distributed builds for CL would be great.
<Shinmera>
Well, I tried to make ASDF work well for C and gave up.
<Shinmera>
the design, especially it forcing the cache of operation objects, is just not meant for it
<heisig>
If Forge is somewhat language agnostic, it would make an excellent replacement for CMake and the like. C++ is in dire need of a non-broken build system.
<heisig>
I guess building Kandria is one of the intended use-cases, right?
lisp123 has joined #commonlisp
<Shinmera>
Not Kandria itself, but its mods.
<Shinmera>
I mean, eventually I'd like it to do everything, but we'll have to first see whether it scales at all
<heisig>
Ooh, there will be mods? That sounds awesome. Good luck with everything - I hear writing a reasonable build system is a breeze :)
<Shinmera>
yeah....
<jackdaniel>
"Wow it works!" is encouraging commit message ,)
<Shinmera>
My commit messages are always full of confidence
kakuhen has quit [Ping timeout: 252 seconds]
Qwnavery has joined #commonlisp
attila_lendvai has joined #commonlisp
<hayley>
As long as the README doesn't consist of screaming, it's probably fine.
<Shinmera>
If anyone wants to follow development / get involved, #shirakumo is there :)
<Shinmera>
hayley: oh right I should fix that
<Qwnavery>
Shinmera: is this what I think it is?
<Shinmera>
I don't know, what do you think what is?
dec0d3r has quit [Remote host closed the connection]
<jackdaniel>
warcraft 3 pre-mod pirated version?
<hayley>
(By the way, I took another stab at optimizing the table and it's within 15% or so of Java. But one of the things is to declare (safety 0), and I'd rather see what I need to remove from (safety 1) to make it safer.)
<Shinmera>
hayley: cool! I'm assuming you're eliminating GC as the cause of the 15%?
<hayley>
(No, I still don't have a proper way of testing tables, and I think my permission to use university servers is gone.)
<jackdaniel>
that would explain the smoke the other day
<hayley>
I...have not factored in such a thing, but hypothetically it shouldn't cons unless resizing, and I don't think the benchmark provided with NBHM causes resizes that often?
lisp123 has quit [Ping timeout: 252 seconds]
<Shinmera>
Well, Java definitely has an edge on SBCL in terms of GC performance, so
<Qwnavery>
Wait you're the person who made portacle?? o_O
<Shinmera>
Sadly, yea
<Qwnavery>
Erm, what
<hayley>
Yes, right. And the Java compiler probably is a bit smarter when it warms up. FWIW I had to disable bounds checks on 42nd-at-threadmill, as SBCL didn't spot that (LOGAND INDEX (1- LENGTH)) closes INDEX under LENGTH.
<Qwnavery>
*what's that supposed to mean?
<Shinmera>
Portacle is a project that has caused me a lot of pain, and I no longer have the mental strength to sustain more of it, so it stands unmaintained.
<Shinmera>
hayley: might be worth reporting that to #sbcl.
selwyn_ has quit [Quit: Leaving]
<hayley>
I'm not aware of what bounds checking elimination SBCL can do, admittedly.
<Shinmera>
Well, I'd hope it can do at least some :)
<Qwnavery>
Shinmera: my mind has been just blown
<Shinmera>
Why?
<Qwnavery>
I didn't even know you existed until now and your presence in the lisp community is huge. :/
<Shinmera>
Is it? I don't really know how to evaluate that kinda thing myself.
<Shinmera>
I know I used to be more active years ago.
<Qwnavery>
._. I'm just blind lol
<hayley>
You get to meet a lot of cool people on #commonlisp.
wyrd has quit [Ping timeout: 276 seconds]
<Shinmera>
Plenty of implementation maintainers around here.
<Shinmera>
Personally I think that's a far more impressive thing than the stuff I clobber together :)
<Qwnavery>
Your game looks really cool aswell
<Shinmera>
Thanks!
<Qwnavery>
:D
<hayley>
Shinmera: From someone who was told not to be so hard on themselves yesterday: don't be so hard on yourself.
* hayley
continues the chain
<jackdaniel>
as much as I agree with all the praise Shinmera receives, I feel obligated to remind about the channel topic
<Qwnavery>
jackdaniel: ofcourse, apologies
<ulfvonbelow>
wow! THE jackdaniel? The ECL maintainer and McCLIM developer???
<jackdaniel>
no, that's someone else. topic people, topic.
<heisig>
Praising Shinmera is very much on topic for this channel, isn't it? Then again, we can also carry our praises to #shirakumo :)
<Qwnavery>
>_> wait a minute... what. are you telling me...
<hayley>
(:
<heisig>
And if you want to praise jackdaniels, you can head over to to #ecl or #clim :)
<Shinmera>
hayley: Actually I'm fairly certain SBCL does do bounds check elimination in some cases, eg when the vector length and index bounds are known.
* Qwnavery
's mind implodes
<Shinmera>
hayley: Too lazy to actually check with a disassemble though :v
<hayley>
Wow! MaRcO hEiSiG from Petalisp?!?!?!
<Qwnavery>
okok I get the idea. I'll stop.
* heisig
blushes :)
<beach>
Unlikely!
Mandus has quit [Ping timeout: 245 seconds]
wyrd has joined #commonlisp
Mandus has joined #commonlisp
tyson2 has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 265 seconds]
Guest-liao has quit [Ping timeout: 256 seconds]
cage has joined #commonlisp
Guest-liao has joined #commonlisp
kakuhen has joined #commonlisp
Mandus has quit [Ping timeout: 260 seconds]
Mandus has joined #commonlisp
Inline has quit [Quit: Leaving]
kakuhen has quit [Ping timeout: 245 seconds]
Tomte has joined #commonlisp
Tomte has quit [Client Quit]
srhm has quit [Read error: Connection reset by peer]
srhm has joined #commonlisp
Guest-liao has quit [Quit: Client closed]
Guest-liao has joined #commonlisp
Mandus has quit [Ping timeout: 265 seconds]
Mandus has joined #commonlisp
attila_lendvai_ has joined #commonlisp
Guest-liao has quit [Ping timeout: 256 seconds]
amb007 has quit [Ping timeout: 252 seconds]
random-nick has joined #commonlisp
<akater[m]>
dolist and other similar constructs are wrapped into (block nil ..). Why not (block dolist ..) ?
<akater[m]>
I'm asking because I write similar macros and I tend to use specific names. But I also want to follow conventions. Anything wrong with (block dolist ..) and such?
amb007 has joined #commonlisp
<jackdaniel>
nothing, but this provides little utility
<jackdaniel>
if you do (do-akater (…) (do-akater (…) …)) you shadow the scope anyway
makomo_ has quit [Ping timeout: 252 seconds]
makomo_ has joined #commonlisp
<jackdaniel>
also (reason-wise) DO is the basic lisp iteration construct, so if you build your own iteration macros they will likely expand to do
<jackdaniel>
and do already introduces a block nil scope, adding one on top of that is of course a possiblity but quite unnecessary
<jackdaniel>
otoh loop allows you to name the block
<jackdaniel>
does it make sense?
<heisig>
And nothing prevents you from wrapping another named block around dolist.
<heisig>
The implicit (block nil ...) convention is just to have RETURN do the 'obvious' thing.
Inline has joined #commonlisp
<akater[m]>
At least when loops have different names, it's better to have distinct block names. So overall it's marginally better to have them rather than not. And I don't expand to do (never actually learned it, and have very little motivation to). I expand to block-let-tagbody — to prog, basically.
<jackdaniel>
the fun fact is that what you manually do is what do does
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<akater[m]>
Given that block-let-tagbody is prog, it is certain that I do what prog does. Meanwhile,
<akater[m]>
> do iterates over a group of statements while a test condition holds.
<akater[m]>
— That doesn't sound like what prog does. But anyway, I just don't find do intuitive.
<akater[m]>
BTW does anybody know of an implementation of a “cons tree” walker that detects cycles and offers implicit tagbody? I couldn't find any and wrote one but I have a hard time believing it's not there already.
<jackdaniel>
I mean taht it expands to block let tagbody *and* go to ensure iteration :)
<jackdaniel>
(and stop condition)
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
Guest-liao has joined #commonlisp
edgar-rft has joined #commonlisp
attila_lendvai_ has quit [Ping timeout: 252 seconds]
tyson2 has quit [Remote host closed the connection]
<pjb>
akater[m]: note that blocks are lexical, ie. compilation-time constructs; normally (block foo (block bar (block nil (something (return-from bar result))))) should cost the same as (block bar (something (return-from bar result))); using block nil let us use (return result) instead of the more verbose (return-from name result).
<pjb>
akater[m]: in your own macros, you can let the user specify the name of the block. cf (loop named foo do (return-from foo))
Guest-liao has quit [Ping timeout: 256 seconds]
peterhil has joined #commonlisp
<akater[m]>
pjb: “named” syntax is not present in standard dosmth macros the interface of which my stuff mimics most often.
<jackdaniel>
I've found only defmacro to mention "parameter variables" from quick glance
makomo_ has quit [Ping timeout: 260 seconds]
makomo_ has joined #commonlisp
kakuhen has joined #commonlisp
Jach has joined #commonlisp
kakuhen has quit [Ping timeout: 252 seconds]
igemnace has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
xaotuk has quit [Ping timeout: 252 seconds]
lisp123 has quit [Ping timeout: 268 seconds]
xaotuk has joined #commonlisp
Bike has joined #commonlisp
selwyn_ has joined #commonlisp
selwyn_ has quit [Remote host closed the connection]
nature has joined #commonlisp
Guest-liao has joined #commonlisp
<drmeister>
Where do we post job openings for Common Lisp programmers?
<jackdaniel>
reddit, blog post, lispjobs.com, lisp professionals mailing list
<hayley>
Here?
<jackdaniel>
and irc of course (:
X-Scale has joined #commonlisp
<mfiano>
I was going to say to my inbox, but those are probably better options.
<jackdaniel>
right, you may also spam individual developers if you know them
<yitzi>
I don't think lispjobs.com exists anymore
<jackdaniel>
oh
<jackdaniel>
it is true, thanks
<yitzi>
np
<jackdaniel>
hm, it was lispjobs.wordpress.com; last post is from 2018 though
<yitzi>
Ah.
<_death>
ordinary job posting sites would be nice as well.. so that if I search "lisp" I get at least one posting :)
igemnace has joined #commonlisp
* mfiano
would like to search (and "lisp" (not "clojure"))
* jackdaniel
expects of some brave lisp hacker developing 90%-feature-complete job posting and browsing engine after reading this exchange
* rotateq
is curious
kakuhen has joined #commonlisp
attila_lendvai has quit [Ping timeout: 245 seconds]
kakuhen has quit [Ping timeout: 252 seconds]
jealousmonk has joined #commonlisp
<etimmons>
Shinmera: Very nice :). If you're going where I think you're going with the list of module names passed to define-project I'm very excited.
<etimmons>
Shinmera: ASDF's single :class argument has annoyed me a couple times in the past.
<Shinmera>
parsing is still done by the first listed module, but yes you can list several. one extra module I already have is to allow specifying versions based on git repo state.
<etimmons>
Yeah, I saw a git module in the repo! It currently looks like any module but the first does nothing (other than being loaded), but I figured that's because it's still being developed
<Shinmera>
I wouldn't know how to combine the parse behaviours.
JeromeLon has quit [Ping timeout: 265 seconds]
<madnificent>
Is there any good infrastructure for managing processes? Thinking of moving some heavy-hit components from Elixir to Common Lisp due to processing constraints on the former.
<etimmons>
Yeah, I imagine that's tricky. But I was referring to the full list of modules not being attached to the project instance. Or are they and I'm missing something?
<jackdaniel>
madnificent: lparallel gives you some nice concurrency constructs
<Shinmera>
madnificent: you mean processes in the erlang sense? As in green-thread-y things?
<Shinmera>
etimmons: I don't know what you mean by 'attached'
<etimmons>
Because ensure-version has EQL specializers
<jackdaniel>
sure
rotateq has quit [Remote host closed the connection]
<Shinmera>
etimmons: right. auxiliar modules so far were intended to provide extensions somewhere in the system that don't directly affect project parse behaviour.
<mfiano>
Shinmera, etimmons: Is there a reason you both are independently developing similar tools? Do the ideas not overlap in many ways or something? I just thought it might be better to create a suite of tools like the SICL project that can be used by anyone wishing to create a build tool.
<Shinmera>
mfiano: we're not, though.
<etimmons>
Shinmera: I was assuming those methods would be specialized on the project class and you would do some sort of dynamic mixins stuff to have all the modules influence the project class
<madnificent>
Shinmera: yeah, more something like that.
zazzerino has joined #commonlisp
<Shinmera>
madnificent: unfortunately to my knowledge there's no current implementation with support for lightweight threads, and doing it manually is a pain.
<madnificent>
jackdaniel: Looking for higher abstractions like asynchronous messenger abstractions.
<Shinmera>
I know there are libraries implementing mailboxes and queues and such.
<mfiano>
Shinmera: You fooled me then
<jackdaniel>
Shinmera: I think that cmucl has (had?) green threads
<Shinmera>
hm!
<Shinmera>
mfiano: etimmons is working on a ql replacement. I'm working on an ASDF replacement. We're already talking about integrating the two.
<jackdaniel>
ecl had (until 2010) and will have (since 2022) green threads as well
<madnificent>
Shinmera: Perhaps I got dragged away with it being closer than jackdaniel's idea. We can work with worker pools. We currently process ~5k queries per second. The many threads in the BEAM VM have their cost for our type of workloads in terms of immutable data structures anyway. We probably don't need over 20k open connections anyhow so I think we should be able to work with dedicated threads if need be.
<Shinmera>
jackdaniel: Nice, I was going to ask when that was expected to be completed
<mfiano>
Shinmera: I see!
<jackdaniel>
well, there are many things going at the same time, so they are moving slowly
* jackdaniel
smiles wryly
<madnificent>
We certainly need multithreading for the processing load. We currently scale 24cores with 48threads very linearly and I don't see why we wouldn't be able to replicate that in Lisp when I look at the workload.
<Shinmera>
madnificent: Good luck! I rewrote my chat server thing in elixir since I couldn't get it stable in Lisp, but that's saying more about me than anything I imagine :)
<Shinmera>
jackdaniel: All too familiar with that myself
<mfiano>
I've been using CLPM for a couple months and have been happy. Having an ASDF alternative too would be even more welcome :)
<etimmons>
mfiano: Yeah, I'm pretty excited about Forge. Both it and CLPM take the approach of doing the heavy lifting outside of the development image.
<jackdaniel>
oh, now I'm getting excited
<jackdaniel>
I'm quite disappointed that asdf wants to assert itself into every final build
<etimmons>
jackdaniel: You're not the only one
lisp123 has joined #commonlisp
<mfiano>
Exciting times in Lisp's future.
<Shinmera>
One of Forge's main goals is to allow building in the current image with no trace left behind of the build operation itself.
<mfiano>
And to think there was talk about CL dying just a little while ago in #lisp
<Xach>
No deader than usual
<Shinmera>
CL is dying, after all, have you heard when its last standard was written????
<mfiano>
A software eternity ago. I must jump to Python in time for the 4.x compatibility disaster
<jackdaniel>
Shinmera: I had a sour exchange on #lisp a few minutes ago about that ,) either way, time for me - laters
<etimmons>
jackdaniel: I had no idea about esdf, I'll take a look at it!
<jackdaniel>
etimmons: dont' take it too seriously, it didn't pass to a "usable" stage and my projects are already time-starved as they are
<etimmons>
Yeah, it's always fun to see others' thoughts on these things, though
lisp123 has quit [Ping timeout: 268 seconds]
<etimmons>
Xach: Total change of subject, but can you make sure Planet Lisp is pulling its feed from https://www.timmons.dev/tag/common-lisp-rss.xml ? Some day I'll probably blog about something other than Common Lisp :)
<Xach>
ok
<madnificent>
Shinmera: problem with Elixir is that you can't mutate objects. We parse and transform SPARQL queries and the AST becomes fairly large. Transforming that means transforming many tiny things. I am a bit in doubt as the BEAM knows it can throw away a thread, where the Lisp runtime has to execute GC across threads once everything has been processed.
<madnificent>
Shinmera: Do you know of good queues and/or mailboxes libraries? If anything has a good name, I'd love to know about it.
<Shinmera>
yeah
<Shinmera>
uuuh
<Shinmera>
Haven't used anything myself so I can't say, I just remember hearing of Erlang-inspired libraries.
<Shinmera>
doing a search on quickdocs for erlang ought to find things.
<mfiano>
I remember sykopomp wrote a couchdb client in Lisp way back in the day
<etimmons>
Xach: Thanks! Also, not sure if you saw, but I did open a PR for a compressing stream in salza2.
<Xach>
etimmons: thanks for the reminder
<etimmons>
Xach: I also opened a PR on QL controller to try and improve dependency extraction for package-inferred-systems
<madnificent>
mfiano: I paired on that and wrote jsown for it at the time. Fun times.
<madnificent>
Shinmera: good idea!
makomo_ has quit [Ping timeout: 252 seconds]
lottaquestions has joined #commonlisp
<mfiano>
madnificent: I remember. Though sexml is the library of yours I used the most back then :)
* mfiano
<-- axion
Guest-liao has quit [Ping timeout: 256 seconds]
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #commonlisp
lottaquestions has quit [Quit: Konversation terminated!]
lottaquestions has joined #commonlisp
Guest-liao has joined #commonlisp
Guest-liao has quit [Client Quit]
waleee has joined #commonlisp
lisp123_ has quit [Remote host closed the connection]
lisp123_ has joined #commonlisp
Josh_2 has joined #commonlisp
<Josh_2>
Hi hi
<beach>
Hello Josh_2.
<Josh_2>
Okay MOP question. I have a library that heavily relies on a metaclass I have made, however when I first load the library I have to make an instance of a class that uses my metaclass 3 times before the slots are initialize properly
<Josh_2>
What method call am I missing?
Cymew has quit [Ping timeout: 252 seconds]
<Josh_2>
Man I get some weird behaviour with MOP until I go and recompile that specific class
<scymtym>
C2MOP:ENSURE-FINALIZED?
<Josh_2>
That might be it
<Josh_2>
I'll check
igemnace has quit [Remote host closed the connection]
<madnificent>
mfiano: axion! Yay! Hello!
<mfiano>
Hello :)
<Josh_2>
scymtym: I think that worked, thanks
<scymtym>
Josh_2: sure
aartaka has joined #commonlisp
aeth has quit [Ping timeout: 252 seconds]
waleee has quit [Ping timeout: 265 seconds]
aeth has joined #commonlisp
waleee has joined #commonlisp
<Josh_2>
hmm
kakuhen has joined #commonlisp
makomo_ has joined #commonlisp
kevingal has joined #commonlisp
<Josh_2>
Okay now I'm really confused. When I make-instance my my repl and check the slot-values in its superclass they all look how I expect them
<Josh_2>
however when I make an instance of the same class within a function call none of the slot-values exist
<Josh_2>
they are all nil
<Josh_2>
after 2/3 attempts at calling the function it works
kakuhen has quit [Ping timeout: 260 seconds]
lisp123_ has quit [Quit: Leaving...]
<Josh_2>
well my execution function is getting double called, I'll have to figure that one out
<madnificent>
Any benchmark comparisons including Common Lisp (SBCL preferably) containing many threads and if possible containing GC intensive workloads?
<Josh_2>
or not :(
Nilby has quit [Ping timeout: 245 seconds]
makomo has joined #commonlisp
cranium has quit [Quit: Leaving]
heisig has quit [Ping timeout: 265 seconds]
raeda_ has quit [Quit: Leaving]
rogersm has joined #commonlisp
<Shinmera>
madnificent: hayley might have some stuff from her work on lockless hash tables.
<madnificent>
Related to netfarm perhaps? Anything is welcome hayley and I should see DMs arrive too.
<Shinmera>
I don't know the broader context. I wrote the initial lockless hash table implementation, and she's been hammering away at it for a while.
JeromeLon has joined #commonlisp
zazzerino has quit [Ping timeout: 268 seconds]
<madnificent>
Shinmera: was that incompatible with later SBCL releases? I checked something about it but dismissed it for some reason.
<Shinmera>
? not to my knowledge?
JeromeLon has quit [Ping timeout: 265 seconds]
<Shinmera>
I didn't end up using it myself, so it's not on ql yet.
Catie has left #commonlisp [Killed buffer]
JeromeLon has joined #commonlisp
Catie has joined #commonlisp
JeromeLon has quit [Ping timeout: 264 seconds]
JeromeLon has joined #commonlisp
lisp123 has joined #commonlisp
JeromeLon has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<Gnuxie>
she will explain it when she wakes up, but as i understand it Threadmill only works with older versions of SBCL, and she doesn't recommend her portable hash table library over luckless yet.
amb007 has quit [Read error: Connection reset by peer]
JeromeLon has joined #commonlisp
amb007 has joined #commonlisp
<Shinmera>
If anyone wants to pick up the slack and document the library + add some more small useful primitives like a queue and a stack, that would be great
<Shinmera>
*the library being Luckless.
waleee has quit [Ping timeout: 245 seconds]
<Shinmera>
lockless vector would also be great
<Shinmera>
(though probably as difficult as the hash table, so)
selwyn_ has joined #commonlisp
selwyn_ has quit [Client Quit]
JeromeLon has quit [Ping timeout: 252 seconds]
<Gnuxie>
Also madnificent, if you need a portable mailbox and queue library "safe-queue" by deadtrickster is good, but it isn't lockless or anything fancy iirc.
<Josh_2>
I am trying to (setf (slot-value <instance with my own superclass> 'txn) 0) and I keep getting the condition that slot is missing. I have checked both the direct and effective slots
<Josh_2>
its not missing. Do I have to provide a method for something like slot-value-using-class?
<drmeister>
jackdaniel, hayley, pjb - thank you.
<White_Flame>
Josh_2: package problem with 'txn?
ec has joined #commonlisp
<Josh_2>
ha yeh it was
<pjb>
Josh_2: possibly. Do you mean <instance of a class of your own metaclass> ?
<pjb>
Otherwise, indeed, package.
<Josh_2>
It was the package
<Josh_2>
I thought I'd broken something, fortunately not :)
makomo_ has quit [Ping timeout: 268 seconds]
ec has quit [Ping timeout: 276 seconds]
Qwnavery has quit [Quit: WeeChat 3.3]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
CrashTestDummy3 has joined #commonlisp
ec has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
Qwnavery has joined #commonlisp
waleee has joined #commonlisp
waleee has quit [Ping timeout: 245 seconds]
pve has quit [Quit: leaving]
lisp123 has joined #commonlisp
jasom has joined #commonlisp
paule32 has joined #commonlisp
dec0d3r has joined #commonlisp
dec0d3r has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 265 seconds]
aartaka has joined #commonlisp
khrbt has quit [Ping timeout: 265 seconds]
khrbt has joined #commonlisp
aartaka has quit [Ping timeout: 245 seconds]
lisp123 has quit [Remote host closed the connection]
heisig has joined #commonlisp
heisig has quit [Client Quit]
lisp123 has joined #commonlisp
tyson2 has joined #commonlisp
lisp123 has quit [Ping timeout: 265 seconds]
aartaka has joined #commonlisp
cosimone has quit [Quit: ERC (IRC client for Emacs 27.1)]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<Josh_2>
Is it possible to garbage collect keywords?
waleee has joined #commonlisp
<semz>
The only way I can think of is to unintern it and make it inaccessible (latter probably not a big concern for keywords), but that probably causes all kinds of problems unless you know a lot about how the keyword came to be and will be used.
<semz>
Or hm, the inaccessibility part might actually be key
<Josh_2>
That was my thinking
aartaka has quit [Read error: Connection reset by peer]
lisp123 has joined #commonlisp
<Josh_2>
Seems all the symbols I would be interested in garbage collecting start with a $ sign
<semz>
Is it possible to just keep them uninterned and work with that?
<Josh_2>
Well its jojo thats interning them
<Josh_2>
Okay word of advice, dont unintern all symbols starting with & :joy:
<semz>
RIP
lisp123 has quit [Ping timeout: 252 seconds]
<Josh_2>
Is 14k keywords gonna take up much space?
<Josh_2>
Just gonna keep using jojo, seems that if I *really* want to clean up the keywords package I can just unintern symbols starting with & that are exactly 44 long
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
Skyfire has quit [Quit: WeeChat 3.3]
<White_Flame>
44 chars * 8 bytes per char worst case * 14000 keywords = "only" 4.7MB of raw string text
<hayley>
madnificent: Well, some of the decentralise2 benchmarks are CPU and GC heavy (particuarly network simulations).
lad has joined #commonlisp
<Josh_2>
Thats what I thought
<Josh_2>
White_Flame:
lisp123 has joined #commonlisp
<hayley>
What's funny is that hash table benchmarks tend to try really hard to _not_ allocate. But my code is evil and hammers on some mailboxes and even deletes from hash tables (gasp!), which tends to give the GC a bad time.
<hayley>
I believe safe-queue is lockless on SBCL, but otherwise it falls back to lparallel which might or might not lock.
<hayley>
And I don't recommend Threadmill because it only seems to work well on UMA machines with < 40 threads or so. Else the SIMD lookup becomes a problem.
<hayley>
In testing, it also very rarely drops messages (1 in 10 million-ish) so I've apparently done something wrong.
<hayley>
Josh_2: cons harder, git gud skrub
igemnace has joined #commonlisp
<hayley>
(Oh, and Threadmill works on newer versions of SBCL, I just had problems w.r.t fixing a bug in how AVX instructions are assembled. But I found SSE2 to be no slower, and heisig fixed that recently, so it should be unnecessary.)
nature has quit [Ping timeout: 252 seconds]
Skyfire has joined #commonlisp
lisp123 has quit [Ping timeout: 264 seconds]
kevingal has joined #commonlisp
waleee has quit [Ping timeout: 260 seconds]
akoana_ has joined #commonlisp
rgherdt has quit [Ping timeout: 264 seconds]
akoana_ has quit [Client Quit]
akoana has joined #commonlisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 27.1)]