mr-rager has quit [Remote host closed the connection]
aartaka has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
gaqwas has joined #lisp
jprajzne has joined #lisp
skapata has joined #lisp
<beach>
travv0: Don't feel you have to read the paper. Here is an executive summary: I suggest a way to optimize call sites by having the callee generate the code for the call site, thereby allowing more opportunities for optimization, like avoiding indirections, avoiding optional and keyword argument parsing, etc.
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
<beach>
It has the potential to make Common Lisp function calls faster than (say) C++ function calls, at least when C++ function calls use the default calling conventions.
narimiran has joined #lisp
lowryder has quit [Ping timeout: 264 seconds]
lowryder has joined #lisp
mr-iznogud has joined #lisp
amb007 has quit [Ping timeout: 272 seconds]
<travv0>
wow, that definitely sounds interesting. and i guess silver lining with the covid stuff is I'll get to watch along with ELS presentations again this year from the US
amb007 has joined #lisp
<travv0>
i was planning on making it in person soon but i have a bit more time now
paulj has quit [Remote host closed the connection]
hjudt has joined #lisp
<beach>
Indeed.
emaczen has quit [Ping timeout: 265 seconds]
jeosol has quit [Quit: Ping timeout (120 seconds)]
rgherdt_ has joined #lisp
xanderle has joined #lisp
<flip214>
I build an application via QL and its ADSF file, then call a function to dump an image. When running that image, my main starts swank in there (to debug); but when I connect, I'm thrown in sldb - from a (LOAD "... .asd").
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
GZJ0X_ has quit [Remote host closed the connection]
random-nick has joined #lisp
attila_lendvai_ has joined #lisp
GZJ0X_ has joined #lisp
karlosz has joined #lisp
<flip214>
seems that ASDF gets triggered on the defined system _again_ .... - or still, though I'd have expected loading to complete when QL returns?!
attila_lendvai has quit [Ping timeout: 256 seconds]
mr-iznogud has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
shka_ has joined #lisp
iskander- has joined #lisp
iskander| has joined #lisp
iskander has quit [Ping timeout: 256 seconds]
aartaka_d has joined #lisp
iskander- has quit [Ping timeout: 264 seconds]
aartaka has quit [Ping timeout: 246 seconds]
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
Cymew has joined #lisp
varjag has joined #lisp
luckless_ has quit [Ping timeout: 268 seconds]
luckless_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
ralt has joined #lisp
amb007 has joined #lisp
luni has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
amb007 has joined #lisp
GZJ0X__ has joined #lisp
zerno has joined #lisp
jprajzne has quit [Ping timeout: 256 seconds]
Cymew has quit [Remote host closed the connection]
jprajzne has joined #lisp
rumbler31 has quit [Ping timeout: 265 seconds]
andreyorst`_ has joined #lisp
GZJ0X_ has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
hjudt has quit [Ping timeout: 256 seconds]
zaquest has quit [Ping timeout: 256 seconds]
andreyorst` has quit [Ping timeout: 256 seconds]
andreyorst`_ is now known as andreyorst`
amb007 has joined #lisp
hjudt has joined #lisp
zaquest has joined #lisp
Cymew has joined #lisp
zerno has quit [Client Quit]
froggey has joined #lisp
rwcom60280385034 is now known as nivet
nivet is now known as rwcom60280385034
pve has joined #lisp
liberliver has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
rme has quit [Ping timeout: 272 seconds]
rme has joined #lisp
heisig has joined #lisp
hendursa1 has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
podge has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
aartaka_d has quit [Ping timeout: 264 seconds]
galex-713 has quit [Ping timeout: 260 seconds]
mood has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
jbgg has quit [Ping timeout: 240 seconds]
jbgg has joined #lisp
Madvax has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
amb007 has joined #lisp
mood has joined #lisp
Madvax has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
galex-713 has joined #lisp
GZJ0X__ has quit [Remote host closed the connection]
mrcom_ has quit [Ping timeout: 265 seconds]
GZJ0X__ has joined #lisp
nicktick has quit [Ping timeout: 265 seconds]
zerno has joined #lisp
iskander has joined #lisp
iskander| has quit [Ping timeout: 264 seconds]
ex_nihilo has joined #lisp
zmv has joined #lisp
livoreno has quit [Ping timeout: 265 seconds]
amb007 has quit [Read error: Connection reset by peer]
villanella has joined #lisp
amb007 has joined #lisp
jello_pudding has quit [Ping timeout: 272 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
johnjay has quit [Ping timeout: 240 seconds]
johnjay has joined #lisp
zerno has quit [Quit: This computer has gone to sleep]
jello_pudding has joined #lisp
awkravchuk has joined #lisp
awkravchuk has quit [Client Quit]
awkravchuk has joined #lisp
johnjay has quit [Read error: No route to host]
johnjay has joined #lisp
rtypo has joined #lisp
aartaka has joined #lisp
zacts has joined #lisp
zacts has quit [Client Quit]
aartaka has quit [Read error: Connection reset by peer]
frodef has quit [Remote host closed the connection]
GZJ0X__ has quit [Remote host closed the connection]
GZJ0X__ has joined #lisp
luni has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
frodef has joined #lisp
perrier-jouet has quit [Quit: WeeChat 3.0]
perrier-jouet has joined #lisp
surabax has joined #lisp
frgo has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
Nilby has joined #lisp
frgo has joined #lisp
amb007 has joined #lisp
nicktick has quit [Ping timeout: 265 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
nicktick has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
liberliver has quit [Quit: liberliver]
mrcom_ has joined #lisp
<Xach>
flip214: last i checked, swank does not act like most asdf systems, but i don't know if its behavior accounts for what you see.
<flip214>
Xach: thanks.
<flip214>
looks like my swank _client_ tried to load something - causing ASDF to look at all its asd files... but I haven't fully debugged that yet.
zerno has joined #lisp
fitzsim has quit [Ping timeout: 264 seconds]
luni has quit [Quit: Connection closed]
Stanley00 has quit []
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
zulu-inuoe has quit [Read error: Connection reset by peer]
villanella has joined #lisp
jealousmonk has quit [Ping timeout: 240 seconds]
jealousmonk has joined #lisp
zerno has quit [Quit: This computer has gone to sleep]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
zerno has joined #lisp
luni has joined #lisp
awkravchuk has quit [Remote host closed the connection]
ljavorsk has quit [Remote host closed the connection]
okflo has joined #lisp
awkravchuk has joined #lisp
ljavorsk has joined #lisp
Guest11553 has quit [Remote host closed the connection]
liberliver has joined #lisp
jedii has joined #lisp
<jedii>
how goes the lisp folks?
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
GZJ0X__ has quit [Remote host closed the connection]
GZJ0X__ has joined #lisp
<Xach>
jedii: fresh and clean
kenu has quit [Ping timeout: 240 seconds]
zmv has quit [Ping timeout: 256 seconds]
torillebazar has joined #lisp
torillebazar has left #lisp ["Leaving"]
kenu has joined #lisp
euandreh has quit [Ping timeout: 264 seconds]
euandreh has joined #lisp
cage_ has joined #lisp
Bike has joined #lisp
mtd_ has quit [Ping timeout: 240 seconds]
mtd_ has joined #lisp
frgo_ has joined #lisp
liberliver has quit [Ping timeout: 265 seconds]
dbotton has joined #lisp
frgo has quit [Ping timeout: 264 seconds]
liberliver has joined #lisp
liberliver1 has joined #lisp
liberliver has quit [Ping timeout: 240 seconds]
liberliver1 is now known as liberliver
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aeth has quit [Ping timeout: 246 seconds]
mrcom_ has quit [Ping timeout: 265 seconds]
aeth has joined #lisp
caret has joined #lisp
zerno has quit [Quit: This computer has gone to sleep]
GZJ0X__ has quit [Remote host closed the connection]
GZJ0X__ has joined #lisp
GZJ0X__ has quit [Remote host closed the connection]
mmmattyx has joined #lisp
GZJ0X__ has joined #lisp
GZJ0X__ has quit [Remote host closed the connection]
GZJ0X__ has joined #lisp
GZJ0X__ has quit [Remote host closed the connection]
kenu has quit [Ping timeout: 246 seconds]
GZJ0X__ has joined #lisp
GZJ0X__ has quit [Remote host closed the connection]
zerno has joined #lisp
GZJ0X__ has joined #lisp
kenu has joined #lisp
luni has quit [Quit: Connection closed]
mrcom_ has joined #lisp
zerno has quit [Quit: This computer has gone to sleep]
zerno has joined #lisp
kenu has quit [Ping timeout: 260 seconds]
bendersteed has joined #lisp
zerno has quit [Quit: This computer has gone to sleep]
zerno has joined #lisp
ljavorsk_ has joined #lisp
ljavorsk has quit [Quit: I'm out, bye]
ljavorsk_ has quit [Client Quit]
ljavorsk has joined #lisp
cods has quit [Changing host]
cods has joined #lisp
GZJ0X__ has quit [Remote host closed the connection]
rtypo has quit [Read error: Connection reset by peer]
CrazyEddy has joined #lisp
sjl has joined #lisp
<jedii>
what are lispers using for persistance lately? postgresql? is there a driver for scylladb.com? or is there a lispy database? or simply use lisp data structures? and serialize?
totoro2021 has quit [Read error: Connection reset by peer]
zerno has quit [Quit: This computer has gone to sleep]
fitzsim has joined #lisp
totoro2021 has joined #lisp
<jackdaniel>
cl-store is a good choice for serialization
Josh_2 has joined #lisp
<phoe>
postgres + postmodern + optionally cl-yesql for using an external DB
<varjag>
we use cl-store for over-the-wire, and postmodern for storage
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
waleee-cl has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
fangyrn has joined #lisp
brandflake11 has joined #lisp
VincentVega has joined #lisp
pfdietz has joined #lisp
<Josh_2>
Ello
rumbler31 has joined #lisp
aeth has quit [Ping timeout: 246 seconds]
aeth has joined #lisp
rumbler31 has quit [Ping timeout: 264 seconds]
orivej has quit [Ping timeout: 256 seconds]
kenu has joined #lisp
ebrasca has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
mindCrime has joined #lisp
amb007 has joined #lisp
kenu has quit [Quit: Leaving]
<jmercouris>
why does uiop:define-package exist?
<jmercouris>
why would we use it instead of defpackage?
<jackdaniel>
its docstring provides differences between the two
jeosol has joined #lisp
<jmercouris>
I already clicked it
<jmercouris>
I wasn't convinced
<phoe>
jmercouris: better redefinition support, more options like :mix
<jackdaniel>
the point is that it is different from defpackage and that some people may find it more useful than defpackage
<phoe>
(defpackage #:foo (:use) (:export #:bar))
<phoe>
(defpackage #:foo (:use) (:export))
<jackdaniel>
I personally think that it is a clutter
<jmercouris>
that's another question phoe why do some people #:xyz instead of :xyz?
<phoe>
jmercouris: to avoid interning
<jmercouris>
what's the big deal
gxt has quit [Quit: WeeChat 3.0]
<jmercouris>
so what if we intern something in keyword package
amb007 has quit [Read error: Connection reset by peer]
<jmercouris>
it is not like it will clobber anything
<phoe>
basically, DEFPACKAGE is massively undefined wrt redefining packages
<jackdaniel>
same with articles, what's a big deal: add "an" or skip it whatsoever
<phoe>
because of
amb007 has joined #lisp
mindCrime has quit [Ping timeout: 264 seconds]
<phoe>
"If the new definition is at variance with the current state of that package, the consequences are undefined; an implementation might choose to modify the existing package to reflect the new definition."
<jmercouris>
phoe: redefinition is a point of contention, I will agree with that
<phoe>
AFAIK UIOP:DEFINE-PACKAGE has specified behavior for redefinition
<jmercouris>
I don't like #:xyz, seems pointless to me
<Xach>
SBCL used to do everything incrementally so if you encountered a conflict or other issue, the package system would be in a freaky state if you aborted
<phoe>
also its :REEXPORT is very useful for reexporting stuff, and MIX is like USE on steroids if you know how to use it
amb007 has quit [Read error: Connection reset by peer]
<jmercouris>
phoe: so do you personally use uiop:define-package?
amb007 has joined #lisp
<phoe>
jmercouris: yes, whenever DEFPACKAGE is not enough for me for whatever reason
<phoe>
usually because I want to redefine packages and SBCL yells at me, or I want to make use of the additional options
<jmercouris>
phoe: why not just use it by default?
<phoe>
jmercouris: dunno, force of habit I suppose
<jmercouris>
if it contains all of the functionality of defpackage and more, why not just use it by default?
* jackdaniel
uses cond for everything
<jmercouris>
jackdaniel: is this some kind of joke?
<jackdaniel>
yes
<jmercouris>
you don't ever use match?
<jackdaniel>
(cond ((test) (foo-bar))) is (when (test) (foo-bar))
amb007 has quit [Read error: Connection reset by peer]
<jmercouris>
I think comparing cond to other branching statements vs defpackage to uiop:defpackage is different
<phoe>
jmercouris: because printing readably is not a well-defined term
<Bike>
jmercouris: you can read the string at any time, including after the instance has been garbage collected, or after you restart lisp and the XYZ class isn't even defined
orivej has joined #lisp
<phoe>
should it create a new object? should it try to intern it somewhere? should it try to find it and signal an error if it does not exist? where should it look for it?
<phoe>
such stuff
<Josh_2>
This is unfortunate
<jmercouris>
phoe: I would expect it to try to find the object, otherwise error if it doesn't exist
<Josh_2>
quickref doesn't provide an easy description for libraries
<phoe>
jmercouris: what do you mean by "trying to find the object"
<jmercouris>
a unique identifier per object
<phoe>
there's no such thing in Lisp though
<jmercouris>
I don't know, shouldn't my implementation have a reference of all existing objects?
<jmercouris>
do they not have unique IDs?
<Bike>
not really, no
<phoe>
no, why would it have those?
Vultyre has joined #lisp
<jmercouris>
I don't know, why not?
<Bike>
they might have an address, but GCs often copy things around, so the address isn't constant
<phoe>
memory bloat
<jmercouris>
how does (eq) work? just compares memory address?
<Bike>
usually, yeah
<phoe>
most of the time, yes
<jmercouris>
hm
<Bike>
but that only works at the present time
<phoe>
but memory addresses can, and will, change
<Bike>
you're talking about something future-proof.
<phoe>
try to observe SBCL IDs of unreadable objects over time
<jmercouris>
that is a question I have as well
<jmercouris>
is there a way to mark a specific variable
<jmercouris>
and read its value at any time?
<Bike>
you could get every object an ID tag, but then obviously you'd need to use an extra word of storage for every single object.
<Bike>
jmercouris: mark?
<jmercouris>
or emit its value when it changes?
<phoe>
what do you mean, read its value at any time?
<jackdaniel>
yes! (setf *foo* my-object)
<jackdaniel>
and then you read it with *foo*
<Bike>
oh, like an observer. No.
<jmercouris>
Bike: yeah, I meant like that
<phoe>
you can achieve it via a symbol macro
<Bike>
Of course if you want that you can just define read and write functions that do whatever you want, and then use a symbol macro so it looks exactly the same.
<phoe>
but not via a raw variable
<jmercouris>
hm, I see
<phoe>
or what Bike said, methods would be better overall
<jmercouris>
I always thought that would be a cool slime feature
<jmercouris>
similar to sly labels
<phoe>
1) because you can't rebind them by accident, 2) because you get all the clos goodness.
<jmercouris>
are funcalls faster than method calls?
<phoe>
you mean standard functions?
<jmercouris>
if not, why do methods and functions exist? why not only methods?
<phoe>
yes, normal function calls are usually faster than generic function calls
<jmercouris>
is (defun xyz (var1)) faster than (defmethod xyz ((var1 var1)))?
<phoe>
I say usually, because beach is working on fixing this
<jmercouris>
I remember him talking about this
<jackdaniel>
jmercouris: did you consider reading a book about CL? like practical common lisp?
<jmercouris>
saying that the performance has to be incredibly fast
<jmercouris>
jackdaniel: did you consider that I have read said book?
sword865 has quit [Quit: Connection closed for inactivity]
<jackdaniel>
no, given you ask some questions that are literally answered in there
<phoe>
but, yes, normal functions do not need to do argument dispatch
<jmercouris>
jackdaniel: oh yeah, I totally forgot that chapter about implementation specific details regarding object IDs
<jmercouris>
jackdaniel: where the author goes into an explanation of why eq would use memory addresses instead
<jmercouris>
that's a good section, sorry about that
<phoe>
I assume jackdaniel meant dispatch macros and GF call overhead though
<jackdaniel>
no, I mean things like what is a difference between a method and a function
<jmercouris>
jackdaniel: oh yeah, I also forgot about the section where the author talks about dispatching method performance
<jmercouris>
that is a good section
<jmercouris>
where he explains the difference between how long a function call vs a method call takes, and why
<jmercouris>
Except for the way that literally everyone in the world uses it
<jmercouris>
when I write (xyz 123) I'm pretty sure everyone would say I am calling a method
<Bike>
no, because multiple methods might be involved, you know?
<beach>
I am sorry to hear that.
<Bike>
thanks to call-next-method and stuff
<jmercouris>
ay yai yai
<jmercouris>
IT IS EVEN IN THE NAME
<jmercouris>
CALL-NEXT-METHOD
<jmercouris>
are you kidding me
<Bike>
yes, if you use call-next-method you are calling a method.
<phoe>
> when I write (xyz 123) I'm pretty sure everyone would say I am calling a method
<phoe>
wait what
<Bike>
but if you do (xyz 123) you are calling a generic function, which may result in multiple methods being called.
<jmercouris>
Bike: it sure might
<phoe>
you're calling some sorta function, or macro, I don't know what XYZ is
<jmercouris>
... anyways
<jmercouris>
please, enough of this gaslighting
<jackdaniel>
jmercouris: my point is that you sometimes tend to ask questions that could be easily looked up, like about dispatch macro #:foo
<jmercouris>
jackdaniel: do not make such a suggestion ever again
<jmercouris>
I find it really irritating
<jmercouris>
if you want, just say "it is in book XYZ"
<jmercouris>
and leave it at that
<jackdaniel>
I'm not sure how to respond to this tone, so I'll get back to other things
<phoe>
anyway - GFs, most of the time, are slower than normal functions
<jackdaniel>
(mind, I'm not used to take orders from strangers, so I may suggest it again)
<jmercouris>
I'm asking you the couresty of not enraging me... perhaps too much to ask
<phoe>
current CLOS implementations work in a way where GFs must do runtime argument dispatch that cannot be done at compile time
<phoe>
so, first source of overhead
<phoe>
second, effective methods must be computed - second source of overhead, even if they are cached
<jmercouris>
phoe: I just don't understand, why could we not precompute ALL of this?
<phoe>
jmercouris: adding/removing methods at runtime
<jmercouris>
phoe: yes, then we must go through all objects and recompute things
<phoe>
if you want your GFs to be redefinable, then you need to take this into account
<jmercouris>
if we had a reference of all objects, then we could do so
Vultyre has quit [Read error: Connection reset by peer]
<jmercouris>
we always trade memory for runtime performance
Vultyre has joined #lisp
<jmercouris>
we could make the trade for memory in this context
<phoe>
actually lots of this stuff can be precomputed at compile-time; that's what beach is working on now
<phoe>
it's just not done in modern complete CL implementations
<jmercouris>
so you are telling me that SICL will have a really fast generic function dispatch
mmmattyx has quit [Quit: Connection closed for inactivity]
<Bike>
what you can't compute ahead of time is the actual dispatch, generally speaking. If you have one method specialized on class xyz, and one specialized on class zyx, and you call the generic function on an argument and it's not discernable at compile time that it's definitely one of those classes, the generic function has to actually check the class.
<jmercouris>
and that implementation developers will just pop that bad boy into their implementation?
<jmercouris>
Bike: I believe that you *can*
<jmercouris>
for example
<Bike>
can what?
<jmercouris>
sorry, I reread what you said
<jmercouris>
you said compile time
<jmercouris>
consider this, whenever we create an object, we give it a list of functions it can invoke
<jmercouris>
depending on the type of object this is, that list will be different
<Bike>
i'm familiar with vtables.
<phoe>
jmercouris: "just pop that bad boy into" is troublesome because different implementations do it differently
<jmercouris>
Bike: is that what I am suggesting, a vtable?
<Bike>
it sounds like it to me.
<phoe>
also vtables don't work in Lisp because methods don't belong to objects
<phoe>
they belong to GFs
<jmercouris>
phoe: I get it
<Bike>
vtables don't always work for lisp because we have multimethods, i.e. a generic function does different things depending on the classes of _multiple_ objects.
<jmercouris>
but could we not just update them?
<phoe>
so a slight modification of that is needed
<phoe>
update what exactly?
<jmercouris>
could we not store permutations
orivej has quit [Ping timeout: 256 seconds]
<jmercouris>
like a 'pseudo' class of permutation X, Y with a set of viable functions
<Bike>
How would you look up the permutation?
<jmercouris>
am I making sense?
<Bike>
Like, is this stored with the X object or the Y object or what?
<jmercouris>
well you would have some data structure in memory, I don't know
<phoe>
I think this is more or less what already happens e.g. with regard to effective method functions in SBCL
<jmercouris>
Bike: in another object
<jmercouris>
some global magical object that knows that X, Y invoke function Q
<Bike>
You could store a map from lists of classes to effective methods in the generic function
<jmercouris>
you just give it a list of objects, and it has precomputed it
<jmercouris>
Bike: or that, sure
<Bike>
that is pretty much exactly how beach's method works. however, it's still nonzero overhead compared to doing no dispatch at all
<jmercouris>
I see
<jmercouris>
and there is no faster way?
<Bike>
I mean, fundamentally the generic function is doing something the non-generic function isn't
<jmercouris>
that's true
<jmercouris>
how does the non-generic function get invoked?
<jmercouris>
we look up the symbol, and then get the function pointer or something, right?
trocado has joined #lisp
<Bike>
That's one way.
<phoe>
if you want redefinability at runtime, no, unless you literally want to recompile all of your calling code whenever you add or remove a method I guess
<Bike>
Usually there's only one or two dereferences to get a function pointer, and then you call that.
<jmercouris>
OK
<jmercouris>
so here is the idea
<jmercouris>
we take X Y right
<jmercouris>
and we know that they must invoke Q
<jmercouris>
so instead of doing a look-up
trocado has quit [Client Quit]
<jmercouris>
we make a pseudo symbol in some other package
<jmercouris>
it could be something like XY and it points to the Q function
<jmercouris>
and then we just call that, there are no extra steps here
trocado has joined #lisp
<phoe>
what's XY?
<Bike>
Okay, but I mean, you do whatever lookup at runtime still, since you don't know at compile time that the function is going to be called with objects of classes X and Y.
<phoe>
oh, these are the calling functions
<jmercouris>
XY is a combination of the class names X and Y
<Bike>
If you do know the classes ahead of time you can skip runtime dispatch sometimes kinda, but in general you don't have that information.
<jmercouris>
Bike: yeah, you do it at runtime, but you don't do it at call time
<Bike>
For example you can do like (foo (read) (read)) and then the foo function could be called with literally anything.
<Bike>
I don't understand what you mean.
<Josh_2>
I have a large collection of strings and I need to find a string that matches closest to an input string, what datastructure should I use to store my strings?
<Bike>
closest like what, hamming distance?
<phoe>
closest by what metric?
<jmercouris>
when I'm doing (salmon x y), it WILL KNOW that salmon is really supposed to be Q (Q X Y)
<jmercouris>
phoe: yeah, that is most cases though, no?
<jmercouris>
phoe: do we have metrics data about this?
<jmercouris>
otherwise we cannot define an efficient data structure, we must know the nature of the data
<jmercouris>
actually, the compiler could even be intelligent and evolve the data structure over time via usage, or via some parameters
<Bike>
yeah, it could be pretty involved indeed. pkhuong's thing here doesn't include branch prediction info iirc
<Bike>
like, if you know that some string is more common than another, you can incorporate that to speed things up a little
euandreh_ has joined #lisp
<jmercouris>
Josh_2: I think you will probably want to write your own data structure, nothing built-in will be performant enough
<jmercouris>
s/performant/suitable
<Josh_2>
thats what I was thinking
<Josh_2>
unfortunate
<jmercouris>
I would write a structure that decomposes the strings into things I can look up via partial parts
<jmercouris>
for example, if I have the string "salmon"
<Josh_2>
for testing purposes the performance isn't a problem, but if I ended up with 10000 different strings and I have to test each user input against them it would end up a problem
<jmercouris>
I would have a hash table with entries "sal" "salm" and "salmo" all pointing to salmon
euandreh has quit [Ping timeout: 260 seconds]
<jmercouris>
Josh_2: if you know some things like length of string you can resaonably decompose the search size
<jmercouris>
s/decompose/reduce the search space
<Josh_2>
10000 different strings and then the users inputs 5 for each search..
<Josh_2>
which I wont
<jmercouris>
you could also condier suffix and prefix for reducing the search space
<jmercouris>
OR, you could use another library
<jmercouris>
I would use a spell check library with a custom dictionary
<jmercouris>
I would use cl-charm or whatever, I think it is called
<jmercouris>
with a custom dictionary
<Josh_2>
yes that could work
<jmercouris>
let me find the name, one moment please
<jmercouris>
so then you will just make a dict from your source strings, and compare user input to them
<Josh_2>
I think that might be the best way to do it
<beach>
jmercouris: The reason most programmers would say that (xyz 123) is a method call is that they know only impoverished languages where a call like that invokes a single method. But Common Lisp has auxiliary methods and also different method combinations, resulting in several methods being invoked by a single call like that.
<jmercouris>
beach: yeah, I knew what you guys were getting at, I'm just being stubborn
<beach>
jmercouris: There is another reason that #:xyz is preferred to :xyz which is that you send a clear message to the person reading your code that only the *name* of the symbol is important, and not its package. Consider a call such as (f '#:xyz 234) vs (f :xyz 234). It is clear that in the first case, only the name of the symbol in important. In the second case, it can very well be a keyword argument.
<jmercouris>
hm, you are right, I never thought of that actually
<beach>
jmercouris: And it is important to write code so that the person reading the code gets as much information as possible from every element of it.
<jmercouris>
I'm not sure it matters in the context of defpackage
dbotton has quit [Quit: This computer has gone to sleep]
<beach>
jmercouris: As many software engineers point out, the compiler is not the only entity reading code. Other tools may as well. So if you use a keyword, the person reading the code might think that some other tool requires a package for the symbol.
<beach>
jmercouris: You should always be consistent with things like this.
varjag has joined #lisp
<Nilby>
Is there a portable bivalent streams library?
<phoe>
flexi-streams?
<Nilby>
Hmmm. It's close, but not exactly.
<jmercouris>
beach: I will think about this, thanks for the advice
<jmercouris>
I must go for now, dinner and then church
<phoe>
Nilby: what do you mean?
<jmercouris>
goodbye thank you for conversation phoe , beach, Bike
<beach>
Take care.
<Josh_2>
"The alien function "enchant_broker_init" is undefined." thats unfortunate :(
<Josh_2>
when trying to use enchant
<Nilby>
phoe: flexi-streams can take a byte stream and read it as a character stream, but I don't think it can take a character stream and let you do both read-char and read-byte.
<Josh_2>
rip seems enchant is broken, trying to (ql:quickload "echant-autoload") it cant find the libenchant.so despite the fact I have installed enchant
<Josh_2>
"enchant-autoload"*
dbotton has joined #lisp
<phoe>
Nilby: hmmm, I don't think that's feasible because of all the different encodings either; inserting a stray byte might break character ordering maybe
Lord_of_Life_ has joined #lisp
<shka_>
indeed
<phoe>
what's your use case with writing bytes to a char stream?
<shka_>
character can be 16 bit long
<shka_>
for instance
<phoe>
or 32, or variable
<beach>
What does it mean for a character to be x bits long?
<phoe>
when using encoding X, then the encoded representation of that character is X bits long
<phoe>
I guess a mental shortcut happened there
<beach>
As in integer-length?
Lord_of_Life has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
karlosz has joined #lisp
<phoe>
not really, more like length of a bit vector
tassleoff has joined #lisp
<phoe>
because a null character encoded in UTF-8 is not 0 bits long
<shka_>
well, i thought it's obvious
<phoe>
dealing with character encodings is sometimes anything but obvious
<beach>
Oh, UTF-8. Got it.
<shka_>
number of bits used to encode a single character is encoding obvious
<phoe>
again, not obvious in UTF-8 :D
<shka_>
unicode or utf?
<Nilby>
phoe: It's true it's troublesome. But even normal character streams with encodings have such problems.
<phoe>
shka_: in variable-length encodings in general
<beach>
Boy, that was a weird discussion on generic dispatch. I guess I am glad I was out right then.
<shka_>
anyway, if you need such stuff, simply use just bytes
<phoe>
things are easy when you have UTF-32 and every char is an (unsigned-byte 32) under the hood
aartaka has quit [Read error: Connection reset by peer]
X-Scale` has joined #lisp
varjagg has joined #lisp
X-Scale has quit [Ping timeout: 256 seconds]
amk has quit [Ping timeout: 256 seconds]
ukari has quit [Ping timeout: 256 seconds]
cyraxjoe has quit [Quit: No Ping reply in 180 seconds.]
X-Scale` is now known as X-Scale
totoro2021 has quit [Ping timeout: 256 seconds]
Bike has quit [Ping timeout: 256 seconds]
ukari has joined #lisp
totoro2021 has joined #lisp
varjag has quit [Ping timeout: 256 seconds]
jealousmonk has quit [Ping timeout: 256 seconds]
amk has joined #lisp
cyraxjoe has joined #lisp
Bike has joined #lisp
jealousmonk has joined #lisp
villanella has quit [Remote host closed the connection]
villanella has joined #lisp
kini has quit [Ping timeout: 260 seconds]
kini has joined #lisp
fangyrn has quit [Quit: Connection closed for inactivity]
random-nick has quit [Ping timeout: 256 seconds]
judson_ has joined #lisp
judson_ has quit [Client Quit]
kini has quit [Ping timeout: 260 seconds]
heisig has quit [Quit: Leaving]
pillton has joined #lisp
random-nick has joined #lisp
hnOsmium0001 has joined #lisp
kini has joined #lisp
gclv has joined #lisp
gclv has quit [Read error: Connection reset by peer]
kini has quit [Ping timeout: 264 seconds]
galex-713 has quit [Ping timeout: 240 seconds]
Aurora_v_kosmose has quit [Remote host closed the connection]
galex-713 has joined #lisp
caret has quit [Read error: Connection reset by peer]
narimiran has quit [Ping timeout: 265 seconds]
mindCrime has joined #lisp
Aurora_v_kosmose has joined #lisp
dbotton has joined #lisp
judson_ has joined #lisp
kini has joined #lisp
shka_ has quit [Ping timeout: 256 seconds]
mrcom_ has quit [Ping timeout: 265 seconds]
varjagg has quit [Ping timeout: 246 seconds]
Nilby has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
aartaka_d has quit [Read error: Connection reset by peer]
mrcom_ has joined #lisp
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
judson_ has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
attila_lendvai_ has quit [Remote host closed the connection]
F________ has joined #lisp
F________ is now known as Feldman
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
<Feldman>
Hello, is scymtym online?
<scymtym>
Feldman: sure
<Feldman>
So I was looking at Robert Strandh's paper and I wanted to implpment it as my university project. I was told on the discord that you had partial done some of it and that I should contact you.
<scymtym>
i see. by now, there are multiple implementations that are to some extent based on that technique. what i did is actually pretty far from what the paper describes. part of the reason is that i targeted SBCL
<scymtym>
as far as i know, SICL (by Robert Standh) has one, ECL has most of the required infrastructure and Clasp more or less implements what is described in the paper
<Feldman>
that's very good to hear, but SBCL doesn't have it at the moment?
<scymtym>
correct
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<Feldman>
Do you think it would still be worthwhile writing my own implementation in the SBCL code?
<scymtym>
i did everything as a separate generic function class and only as a prototype
amb007 has quit [Read error: Connection reset by peer]
<scymtym>
depends on what your goal is
bilegeek has joined #lisp
amb007 has joined #lisp
<Feldman>
Fast generic functions on SBCL
<Feldman>
a vaguely novel university project
charles` has joined #lisp
nullman has quit [Remote host closed the connection]
<scymtym>
that is worthwhile in my opinion, but i'm not sure it would make a good university project. since SBCL organizes standard instances and also other objects very differently compared to the assumptions of the paper, you would have to bridge over many gaps
<scymtym>
while that makes the project more interesting and researchy, it is also hard and requires time
<Feldman>
How does SBCL organise them?
<scymtym>
as i said, what i did is pretty far from the paper
<Feldman>
Officially the project is 300 hours of work, but in practice it ends up being more than that.
cage_ has quit [Quit: Leaving]
<scymtym>
SBCL has immediate objects with lowtags, instances with a layout, a classoid and a class, "other pointers" with a widetag
<scymtym>
(you can get a feeling for those in the video i linked)
<Feldman>
(yeah the video is still downloading)
<scymtym>
i think making something that could actually replace the dispatch part of PCL in SBCL is much more work. you could aim for a proof-of-concept, of course
<Feldman>
Hmm..., what about implementing it in CCL then? Would CCL be more amenable?
<scymtym>
you know what, i mentioned that ECL now has some of the infrastructure required for fastgf which was in fact added in order to eventually implement it. maybe as jackdaniel about adding fastgf to ECL instead
<scymtym>
*maybe ask
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Bike>
i have also implemented the thing, so you can ask me too
<Bike>
it's true that it relies on how standard objects are structured
Kingsy has joined #lisp
<Feldman>
sorry what do you mean implemented "the thing"? what thing? (infrastructre on ECL, worked on fastgf on Clasp etc)
<Bike>
i have implemented beach's fast generic dispatch in clasp
<Bike>
i mean, drmeister did it first, but i've pretty much rewritten it all a few times by now, so i'm familiar with the workings
<Feldman>
ah ok, so how difficult would it be for SBCL vs CCL vs ECL
<scymtym>
i would say ECL probably much easier than SBCL. i have no idea for CCL
surabax has quit [Quit: Leaving]
<Feldman>
My worry with ECL is that if all the "infrastructre" is there, it might not be enough to count, but SBCL does seem much harder yeah.
judson_ has joined #lisp
<scymtym>
jackdaniel is one of the maintainers of ECL. he should have a good idea of what would need to be done for ECL. he is available in this channel during European daytime most of the time
<Feldman>
Scymtym, what exactly did you mean by "infrastructure" now that I think of it? I'll make sure to contact jackdaniel as well ofc
<scymtym>
i don't know any details but i think jackdaniel changed or extended the object representation in ECL to add stamps