kevingal has quit [Remote host closed the connection]
namasteaks has joined #commonlisp
cosimone has quit [Ping timeout: 260 seconds]
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life_ is now known as Lord_of_Life
taiju has quit [Ping timeout: 264 seconds]
Inline has quit [Ping timeout: 268 seconds]
psi[m] has joined #commonlisp
Guest74 has joined #commonlisp
notzmv has quit [Ping timeout: 268 seconds]
taiju has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.3]
perrierjouet has joined #commonlisp
notzmv has joined #commonlisp
holycow has quit [Quit: leaving]
CrashTestDummy2 has quit [Quit: Leaving]
psi[m] has left #commonlisp [#commonlisp]
pjb has quit [Read error: Connection reset by peer]
<jcowan>
But variable bindings were implemented with alists, so they are the same age.
pillton has joined #commonlisp
akoana has quit [Quit: leaving]
namasteaks has quit [Ping timeout: 268 seconds]
john__ has joined #commonlisp
karlosz has joined #commonlisp
gaqwas has quit [Ping timeout: 256 seconds]
karlosz has quit [Client Quit]
Bike has quit [Quit: Connection closed]
namasteaks has joined #commonlisp
mingus_ has joined #commonlisp
CrashTestDummy has joined #commonlisp
namasteaks has quit [Ping timeout: 244 seconds]
mingus_ has quit [Ping timeout: 244 seconds]
namasteaks has joined #commonlisp
taiju has quit [Ping timeout: 245 seconds]
splittist has quit [Ping timeout: 268 seconds]
alanz has quit [Ping timeout: 268 seconds]
jmercouris has quit [Ping timeout: 268 seconds]
gendl has quit [Ping timeout: 268 seconds]
servytor has quit [Ping timeout: 268 seconds]
IUSR has quit [Ping timeout: 264 seconds]
hubvu has quit [Ping timeout: 264 seconds]
hubvu has joined #commonlisp
ullbeking has quit [Ping timeout: 268 seconds]
splittist has joined #commonlisp
elderK has quit [Ping timeout: 268 seconds]
alanz has joined #commonlisp
ullbeking has joined #commonlisp
servytor has joined #commonlisp
gendl has joined #commonlisp
IUSR has joined #commonlisp
elderK has joined #commonlisp
drmeister has quit [Read error: Connection reset by peer]
jcowan has quit [Read error: Connection reset by peer]
pranavats has joined #commonlisp
dec0d3r has quit [Remote host closed the connection]
dec0d3r has joined #commonlisp
ullbeking has quit [Ping timeout: 256 seconds]
mfiano has quit [Remote host closed the connection]
mfiano has joined #commonlisp
jmercouris has joined #commonlisp
drmeister has joined #commonlisp
ullbeking has joined #commonlisp
jcowan has joined #commonlisp
dec0d3r_ has joined #commonlisp
dec0d3r has quit [Ping timeout: 260 seconds]
jealousmonk has quit [Quit: ERC (IRC client for Emacs 27.1)]
dec0d3r__ has joined #commonlisp
jcowan has quit [Ping timeout: 268 seconds]
ullbeking has quit [Ping timeout: 268 seconds]
dec0d3r_ has quit [Ping timeout: 268 seconds]
drmeister has quit [Ping timeout: 264 seconds]
ullbeking has joined #commonlisp
jcowan has joined #commonlisp
drmeister has joined #commonlisp
gaqwas has joined #commonlisp
john__ has quit [Ping timeout: 244 seconds]
waleee has quit [Ping timeout: 264 seconds]
taiju has joined #commonlisp
aartaka has joined #commonlisp
yodudd has left #commonlisp [#commonlisp]
yodudd has joined #commonlisp
Guest74 has quit [Ping timeout: 260 seconds]
taiju has quit [Ping timeout: 264 seconds]
karlosz has joined #commonlisp
taiju has joined #commonlisp
Alfr has quit [Quit: Leaving]
<beach>
Good morning everyone!
aartaka has quit [Ping timeout: 264 seconds]
elderK has quit [Ping timeout: 244 seconds]
gendl has quit [Ping timeout: 244 seconds]
conjunctive has quit [Ping timeout: 245 seconds]
drmeister has quit [Ping timeout: 256 seconds]
splittist has quit [Ping timeout: 256 seconds]
dbotton has quit [Ping timeout: 260 seconds]
jcowan has quit [Ping timeout: 268 seconds]
pl has quit [Ping timeout: 268 seconds]
jsatk has quit [Ping timeout: 268 seconds]
victor has quit [Ping timeout: 260 seconds]
jmercouris has quit [Ping timeout: 256 seconds]
alanz has quit [Ping timeout: 256 seconds]
travv0 has quit [Ping timeout: 260 seconds]
splittist has joined #commonlisp
ullbeking has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
servytor has quit [Ping timeout: 256 seconds]
drmeister has joined #commonlisp
sgithens has quit [Ping timeout: 268 seconds]
conjunctive has joined #commonlisp
hubvu has quit [Ping timeout: 260 seconds]
griffinmb has quit [Ping timeout: 245 seconds]
elderK has joined #commonlisp
IUSR has quit [Ping timeout: 256 seconds]
d_run has quit [Ping timeout: 256 seconds]
gendl has joined #commonlisp
victor has joined #commonlisp
dbotton has joined #commonlisp
IUSR has joined #commonlisp
jsatk has joined #commonlisp
servytor has joined #commonlisp
sgithens has joined #commonlisp
griffinmb has joined #commonlisp
jmercouris has joined #commonlisp
d_run has joined #commonlisp
jcowan has joined #commonlisp
alanz has joined #commonlisp
ullbeking has joined #commonlisp
hubvu has joined #commonlisp
pl has joined #commonlisp
semz has quit [Ping timeout: 268 seconds]
aartaka has quit [Ping timeout: 244 seconds]
Bike has joined #commonlisp
aartaka has joined #commonlisp
travv0 has joined #commonlisp
semz has joined #commonlisp
asarch has joined #commonlisp
namasteaks has quit [Read error: Connection reset by peer]
s-liao has quit [Ping timeout: 256 seconds]
cjb has quit []
tales74 has joined #commonlisp
<asarch>
With (g-signal-connect the-button "click" (lambda (msg) (declare (ignore msg)) (format t "Hello!~%"))), every time the user clicks on the button, you get the message "Hello!".
nature has quit [Ping timeout: 256 seconds]
<tales74>
Hi, I'd like to know if SBCL has something like Lispworks' find-object-size.
<asarch>
So, if you had an array of ten buttons (let's say from 0 to 9) with (loop for x from 0 to 9 do (g-signal-connect … (lambda (msg) … (foo x)))) you could call (foo) with the correct number value like: (foo 0) … (foo 9)
<asarch>
However, it only uses the 10 value for that: Hello!: 10 … Hello!: 10
<asarch>
Why is that?
<beach>
asarch: Because you are using the same x every time. LOOP is not required to create a new lexical variable in each iterations.
<beach>
asarch: Try (loop for x... do (let ((x x)) (g-signal...)))
<asarch>
If I load a file and it is loading the ~60% of the file and something is wrong and I select "0: [ABORT ] Abort loading file …", what happen with this 60%? Is it keep or the evaluator discards it?
<beach>
If it is a source file, then top-level forms in the first 60% are evaluated.
<asarch>
I see
s-liao has joined #commonlisp
<tales74>
beach: Bike: Thank you!
Bike has quit [Quit: Connection closed]
rain3 has joined #commonlisp
Jing has quit [Remote host closed the connection]
Jing has joined #commonlisp
<beach>
tales74: Sure, good luck!
tales74 has left #commonlisp [#commonlisp]
dre has quit [Remote host closed the connection]
happy-dude has quit [*.net *.split]
froggey has quit [*.net *.split]
les has quit [*.net *.split]
luis has quit [*.net *.split]
mikko has quit [*.net *.split]
les has joined #commonlisp
froggey has joined #commonlisp
luis has joined #commonlisp
mikko has joined #commonlisp
happy-dude has joined #commonlisp
enzuru has joined #commonlisp
jasom has quit [*.net *.split]
danirukun[m] has quit [*.net *.split]
bitspook[m] has quit [*.net *.split]
zagura has quit [*.net *.split]
etimmons has quit [*.net *.split]
zups has quit [*.net *.split]
light has quit [*.net *.split]
ck_ has quit [*.net *.split]
Colleen has quit [*.net *.split]
zephyr has quit [*.net *.split]
jfb4 has quit [*.net *.split]
skn has quit [*.net *.split]
ck_ has joined #commonlisp
light has joined #commonlisp
zagura has joined #commonlisp
zups has joined #commonlisp
Colleen has joined #commonlisp
jasom has joined #commonlisp
skn has joined #commonlisp
zephyr has joined #commonlisp
jfb4 has joined #commonlisp
mingus_ has joined #commonlisp
etimmons has joined #commonlisp
danirukun[m] has joined #commonlisp
Alfr has joined #commonlisp
<pillton>
What would you call the macro F where (macroexpand '(F place)) is (lambda (#:var) (push #:var place))?
<beach>
PUSHER maybe?
mingus_ has quit [Ping timeout: 250 seconds]
bitspook[m] has joined #commonlisp
VincentVega has joined #commonlisp
yodudd has left #commonlisp [#commonlisp]
<pillton>
beach: Thanks.
Cymew has joined #commonlisp
<guthur>
pillton is that just something for learning?
yodudd has joined #commonlisp
pve has joined #commonlisp
<guthur>
because it feels like `(defun F (place) (lambda (x) (push x place)))` would be more appropriate
rain3 has quit [Remote host closed the connection]
rain3 has joined #commonlisp
<beach>
guthur: Places are not first-class objects in Common Lisp.
<pillton>
No it isn't for learning. I was going to add it to a library of combinators (though I think this macro isn't really a combinator).
<beach>
guthur: That function would just modify the variable in the argument.
<beach>
pillton: Nice use case.
<guthur>
beach ok, fair. Apologies my bad pillton
<pillton>
No dramas. It is why I am asking the question. Part of me thinks "place" or the suffix "f" should be in the name to warn the reader.
<beach>
I guess PLACE-PUSHER would fulfill that requirement, but PUSHER already suggests that a place is involved.
dre has joined #commonlisp
<pillton>
It works with APPENDER and NCONCER too. NCONCER is funny.
<beach>
Sure is.
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
dec0d3r__ has quit [Remote host closed the connection]
spiaggia has joined #commonlisp
frgo has quit [Ping timeout: 268 seconds]
pjb has joined #commonlisp
<spiaggia>
In "Let over Lambda" page 28, isn't that an error to quote the lambda expression inside a FUNCTION special form?
<spiaggia>
This book uses CLISP as I recall. Maybe CLISP accepts it this way?
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
<White_Flame>
like what, (function '(lambda () 3))?
<spiaggia>
(function '(lambda (x) (+ 1 x))) to be precise.
<White_Flame>
yeah, sbcl certainly doesn't like it. I wonder if it's undefined or illegal behavior
<spiaggia>
I don't think I have ever seen any remarks about it, which would make it illegal. But then, I could have missed something.
<White_Flame>
it doesn't explicitly say that the NAME parameter of the FUNCTION special form is unevaluated, but it's hard to justify the quote being reasonable there I'd think
<spiaggia>
Yeah, this is the first time I see something like this.
<pillton>
"For special operators and macros, their arguments are not evaluated unless it is explicitly stated in their descriptions that they are evaluated."
<White_Flame>
CLISP doesn't accept (function '(lambda () 3)), so it might be a typo in the book
<White_Flame>
ah, k
<spiaggia>
Thanks. Yes, a typo then. But a strange one, I would have thought the same text to be used for testing and for typesetting,
<pillton>
I doubt it.
<spiaggia>
Hmm. That's the way I write books. :)
shka has joined #commonlisp
<pillton>
What do you use to do literate programming? I hated it the last time I tried it. Version control is a pain. Sharing "the code" with others.
<pillton>
(I have to go. I'll check the logs tomorrow.)
pillton has quit [Quit: ERC (IRC client for Emacs 27.2)]
rotateq has joined #commonlisp
<spiaggia>
I really should start that "book reviews" web page I have threatened to start in the past. It seems every time I open a book using Common Lisp, I find tons of errors.
MumblyFoo has quit [Ping timeout: 260 seconds]
<rotateq>
spiaggia: which one for example?
<spiaggia>
Right now I am reading "Let over Lambda", and it is not too bad, but there are still many errors. But in the past, I started reading "Land of Lisp" and it is very badly written.
<rotateq>
ah this one
<rotateq>
hm why do you think so? i mean beside the "tons of errors"
<spiaggia>
That's irritating enough that I get upset reading it.
<rotateq>
but that's then about YOU :)
<spiaggia>
It is strange to me that it was allowed to be published in this state,
<spiaggia>
rotateq: I hardly ever consider myself unique. If it irritates me, I am convinced there are lots of others out there who share those feelings.
rgherdt has joined #commonlisp
<spiaggia>
"Land of Lisp" is a book meant for newbies, and it is full of incorrect terminology. That's sending a very bad message to those newbies.
<Cymew>
Is it? I read it ages ago and I do not remember getting stuck on weird terminology.
<spiaggia>
I don't have the book handy, but I remember that it uses "command" and I think also "statement" when it means "form", and it is not even consistent.
<rotateq>
it's a not too technical resource, cause programming is also about fun
<spiaggia>
Still, there is no excuse for teaching incorrect and inconsistent terminology.
<spiaggia>
It doesn't hurt anyone to do it right. It doesn't make it more fun to be incorrect.
<Cymew>
I would not say calling a form a "statement" is incorrect.
<spiaggia>
There are only a few places where the standard uses that terminology, and I can remember only one of them now, and that's in the TAGBODY form.
<spiaggia>
Basically, it is used to mean a form that is not evaluated for its return value(s).
<spiaggia>
So if the value of a form is needed, I consider it incorrect to call it a "statement".
<Cymew>
It might be a bit colloquial, but if you think deviating from the terms in the standard, I think you are way to harsh in your judgement.
<spiaggia>
Also, the use of "statement" this way is consistent with how other languages use it.
<spiaggia>
Cymew: Then I prefer being harsh when it comes to published books, especially those meant for newbies.
<Cymew>
s/terms in the standard/terms in the standard is all wrong/
<spiaggia>
Anyway, that's just one point of a large number. I'll start the page and show it when I have made some progress.
VincentV` has joined #commonlisp
<Cymew>
Please do. It could be quite useful, even if I personally think you are wrong about how to write newbie friendly texts.
<spiaggia>
So you think it is a good thing to be inconsistent in such texts? What would the purpose be?
<spiaggia>
Like I said, it doesn't make it more fun that way.
VincentVega has quit [Ping timeout: 244 seconds]
<Cymew>
Inconsistencies are bad, but I see nothing wrong with colloquialism. Stricly following the terminology in a standard is not something of a goal in itself.
<spiaggia>
If you say so,
<spiaggia>
.
* spiaggia
is again allowed to enter his office, so he will abandon his Italian alter ego now.
spiaggia has left #commonlisp [ERC Version 5.3 (IRC client for Emacs)]
<rotateq>
:)
<Cymew>
Ah, so you have different nicks depending on location?
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<Cymew>
Personally I use the same nick with _ in front or suchlike. Makes it easier to see that it's the same person.
asarch_ has quit [Quit: Leaving]
notzmv has quit [Ping timeout: 268 seconds]
<beach>
I think it's more fun to use different languages.
<beach>
My nicks are not meant for newbies.
<Cymew>
You seem to have a conflicted relationship to newbies.
<Cymew>
But, I suppor the idea of using more languages online. We should not always assume the world runs on English.
frgo has joined #commonlisp
<beach>
I care deeply about newbies, and I feel sorry for them when authors confuse them by inconsistent and incorrect terminology. I am often a newbie myself with respect to many topics, and I much prefer to be presented with consistent and correct terminology.
<beach>
And, again, I rarely consider myself unique, so I am sure many others feel the same. Also, again, using consistent and correct terminology doesn't hurt any others.
frgo has quit [Ping timeout: 240 seconds]
aartaka has quit [Remote host closed the connection]
frgo has joined #commonlisp
random-nick has joined #commonlisp
BottomType has joined #commonlisp
<hayley>
I barely slept last night, as the specification for the last assignment (which was due yesterday) at university was poorly worded, and I was told that my solution was not allowed two days ago. After asking again, I was told that it was allowed. Can't say I enjoyed it.
<hayley>
(Any poor wording on my behalf is clearly due to a lack of sleep.)
<lisp123w>
Writing well and precise always is better. But its a considerably challenging task
<lisp123w>
I used to just type stuff out, but as I got more (hopefully?) experienced in Lisp, I'm much more cautious on writing anything. Ignorance was bliss in the early days. I have quite a few notes on Macros but its been 1.5 months and nowhere close to a reasonable article
<beach>
Sure, but that's why there are reviewers. For example, Apress has hired experienced Common Lisp programmers to review their Lisp books.
<beach>
Clearly, Land of Lisp was not reviewed by an experienced Common Lisp programmer, if it was reviewed at all.
<lisp123w>
No, I'm agreeing with you on why using 'form' and 'statement' correctly matters (even subliminally). Just noting its quite a hard process
<beach>
Of course. Writing books requires training and experience, in addition to reviewers. But it seems that many people don't think so and just go ahead and write any crap.
<beach>
I guess, that's just like programming now that I think about it.
OlCe has joined #commonlisp
<lisp123w>
I guess. Boils down to Human Nature, 'if it gets the job done (today) its good enough'
<rotateq>
There are many crap books from newer times, eg those with "Learn FOO in 24 hours".
<lisp123w>
rotateq: Especially on the internet. First page of google is terrible
<rotateq>
and it blends especially young people in terms of understanding vs just using something (Dunning-Kruger effect)
<lisp123w>
I imagine it would. Hopefully there is a counter movement the other way
<lisp123w>
I do think Land Of Lisp has great cartoons and is a lot of 'fun', I have never read the book but it has certainly energized many people into Lisp
<lisp123w>
Perhaps worth a second edition correcting some of the items
<beach>
I didn't start taking notes until chapter 3, so maybe I need to re-read the book from the start.
hirez has joined #commonlisp
<beach>
Cymew: No need for you to read it. You won't agree with anything and I already know it.
<guthur>
that pg 35 one is bizarre, how would one make the leap to data/code reader? maybe some weird concept of macros?
<beach>
The book is full of that kind of stuff.
hirez- has quit [Ping timeout: 245 seconds]
<beach>
I was trained as a scientist and as an engineer, and I was taught to be much more careful with terminology, so as to make life easier for people reading my stuff. Clearly the author didn't receive such training, or didn't pay attention when it happened.
<beach>
Though that would at least show that the evaluator was working correctly.
<rotateq>
now I get hungry but 2h till lunch :)
<hayley>
I suppose that statement _could_ be read (with very large granules of salt) to mean "the REPL of a Lisp system could print a form which constructs the resulting object from evaluation, and the resulting output would still be useful." From memory, the Racket printer does print '(pork beef chicken), though I don't see the point in it.
<hayley>
Otherwise, it's very ridiculous.
<hayley>
(Maybe someone should implement CDR coding, so that the diagram on page 38 that beach described would be even more inaccurate.)
<beach>
Anyway, I hope I am beginning to show why I think this book is very badly written. Notice that there is on the average more than one problem per page on the pages I have reviewed so far.
<shka>
well, regardless
<shka>
i am still in need of sbcl profiles visualization
<shka>
some other profiler would be fine as well
<shka>
but i need really need either call graph or flamegraph
<shka>
flamegraph preferred
<shka>
some tips please?
<jackdaniel>
" Page 39. "(cons 'chicken ())". This use of the empty list is in direct violation of section 1.4.1.4.4 of the Common Lisp standard. " seems to hint, that it is the violation of the standard (i.e not a valid form), but 1.4.1.4.4 is about conventions as hints to the human reader
<jackdaniel>
in other words it is bad style, but it is not wrong (unlike other statements pointed out on that page)
<beach>
Fair enough. I'll clarify.
<jackdaniel>
conventions listed in 1.4 are conventions used in the standard, not something that could be violated elsewhere
<jackdaniel>
I haven't read land of lisp, but a few people I've talked with had some warm remarks about it
<jackdaniel>
and a sharp criticism that it uses clisp afair
<Cymew>
beach: Thanks for the link. Looks good. Good resource.
<shka>
and I think that it would be possible to produce json for the chrome to visualize, from metering
<beach>
Cymew: Thanks.
<shka>
jackdaniel: but I need some kind of interface to access collected samples
<pve>
Hi, I have a class I currently call "document-store" that supports operations like saving, deleting and looking up documents (also a class). I have other kinds of "stores" too, each associated with a class whose instances the store knows how to deal with (save, delete, look up). My question is: is there an established name for the kind of objects that come out of these stores? I've seen the term "protocol
<pve>
class", but I'm not sure if it's applicable here.
<pve>
oh, sorry about the line break, wonder how that happened..
<shka>
jackdaniel: could you please demonstrate how to get access to sampling events?
Oladon has quit [Quit: Leaving.]
MumblyFoo has joined #commonlisp
<beach>
pve: Yes, a "protocol class" is a class that is specified as being part of a protocol, together is functions (often generic) that may take instances of such a class as arguments. Sometimes the protocol class is not meant to be instantiated directly, because it is merely the root of some hierarchy of classes that are meant to be instantiated.
<beach>
together *with functions
<pve>
beach: Aha! Yeah, I'm trying to come up with a superclass name for the "document" class. The superclass of "document-store" is just "store".
<pve>
and also to make it easier to refer to these classes in comments etc
engblom has left #commonlisp [#commonlisp]
<pve>
but it sounds like "protocol class" could work here
<pve>
hmm, could "instances of protocol classes" be called simply "protocol instances" or "protocol objects"?
notzmv has joined #commonlisp
<beach>
Not really. Subclasses of protocol classes may not be protocol classes, like if client code subclasses a protocol class. But an instance of such a subclass is still an instance of the protocol class.
<beach>
And if you mean a "direct" (or is it "immediate") instance, then typically no such instance should exist if the protocol class is not meant to be instantiated, which is typically the case.
voltron has joined #commonlisp
<beach>
Oops, the "Acknowledgments" of "Land of Lisp" names a reviewer. I guess I should send my link to that person.
Devon has quit [Ping timeout: 244 seconds]
scymtym has quit [Ping timeout: 245 seconds]
<pve>
beach: Ok, thanks. I guess I have to think about this a bit more.
<beach>
Sure. Good luck!
voltron has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
voltron has joined #commonlisp
Devon has joined #commonlisp
s-liao has quit [Quit: Client closed]
s-liao has joined #commonlisp
<jackdaniel>
shka: there are no sampling events, metering collects aggregate time / cons
frgo has quit [Remote host closed the connection]
<shka>
will I be able to gather caller and form a stack?
<shka>
this would be required for making a flamegraph
<jackdaniel>
no, I don't think that metering as it is now is suitable for this
<shka>
oh :(
s-liao has quit [Quit: Client closed]
<jackdaniel>
you may hack things around of course, but you'll need to code necessary stuff yourself
<jackdaniel>
metering works by encapsulating the monitored function, so technically you may inject any code you want (the overhead is estimated) -- unless the function is inlined of course
<phantomics>
I tried defining a function to run a bunch of April tests, it takes incredibly long to compile, 70-80secs
<phantomics>
But if I just have the macro expand to run those tests, it takes only a couple seconds to compile
<shka>
jackdaniel: thanks for hints
<jackdaniel>
sure
<phantomics>
I have another function that runs the main set of tests for April and it takes a fraction of a second to compile, and it has ~976 tests as opposed to ~220 in this test set that's taking a long time
<phantomics>
Does anyone have an idea why a defun would take so long to compile compared to just running things after macroexpansion?
<shka>
perhaps it is running in interpreted mode?
<hayley>
I suspect the latter uses the interpreter of SBCL, whereas the former invokes the compiler.
<jackdaniel>
"just running things" may be minimally compiled
<jackdaniel>
while normal compilation could go through multiple passes
<hayley>
Look at the number of "forms interpreted" for either.
<jackdaniel>
Lycurgus: I've used it briefly around 2y ago and then I could affirm that it is. I don't know how much better it is now though
<Lycurgus>
>:
amb007 has quit [Ping timeout: 250 seconds]
amb007 has joined #commonlisp
<Lycurgus>
this also is not my first go but some pkgs I want to use depend on it so thought I'd give it another try
<Lycurgus>
instead gonna pass on them pkgs
<Lycurgus>
other langs can do this don't see why they couldn
pjb has quit [Read error: Connection reset by peer]
<Lycurgus>
pass or rework
<phantomics>
Defining it as a macro doesn't make the compilation any faster, and produces some strange bugs
<phantomics>
And I'm using a standard SBCL, so if the interpreter is disabled I doubt it's being interpreted
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<hayley>
It might not be interpreting entirely, but casual inspection suggests that SBCL might be compiling each form in the PROGN form separately.
<hayley>
This would presumably reduce the size of forms to compile, and thus any super-linear algorithms used in the compiler would not be as slow. (From my own observation, I think there are some algorithms which are super-linear in runtime.)
rogersm has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
<shka>
jackdaniel: i may actually do what you recommended eventually, because lack of portable flamegraph (or flamegraphs, period) is seriously annoying
<shka>
should such code be merged into metrics or is it out of scope?
<jackdaniel>
I think that you should make a separate project. I've only fixed some issues and ported the system to today implementations; I consider the project finished
<jackdaniel>
(on my part)
frgo has joined #commonlisp
<shka>
jackdaniel: got it
<shka>
but it is nice to have place to start regardless
<phantomics>
hayley: strange thing is, all the invocations in the main test set are also inside a progn, and that takes no time to compile. So the cause for the compile time is mystifying.
<jackdaniel>
when forms are inside the function then the compiler may i.e analyze whether some local functions doesn't escape the invocation dynamic extent
<jackdaniel>
and jazz like that
<hayley>
To my knowledge, it compiles A, then compiles B, then C, rather than compiling (progn A B C)
<phantomics>
Also, the April code in most of those tests is super simple, basically just "call this function on a few values." Some of the referenced functions are quite complex, but those were already compiled. Is there a reason that compiling code that references certain functions would cause those functions to be recompiled?
tyson2 has joined #commonlisp
<hayley>
Do you inline any functions?
<phantomics>
Ok, so it may be analyzing the functions to check whether they affect dynamic vars is what you're saying
<phantomics>
In the test code there are a few inline functions, but they're all quite simple
<phantomics>
Now the other thing occurring to me is that the demo test sets I'm working on are compiling outside the main April package
frgo has quit [Ping timeout: 245 seconds]
<phantomics>
They use functions from the April package to process values and call functions that are defined in another package. I don't know if that could be related
<phantomics>
Although all April code interacts with packages outside the main April package, since April creates dedicated packages to use as its workspaces
pjb has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
attila_lendvai has joined #commonlisp
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
heisig has joined #commonlisp
kadir has joined #commonlisp
didi has joined #commonlisp
<didi>
I want to define a SETF method that works like GETHASH in (incf (gethash key table 42)), i.e., I can pass a default value that will be used if no key already exists. I can define a SETF method like (defmethod (setf method) (new-value ... &optional default) ...), but the issue is that I don't use the variable `default' in my SETF method, so I have to ignore it with (declare (ignore default)). Is there another way to define a SETF method
<didi>
so I don't need to ignore the variable `default'?
<hayley>
Why doesn't (incf (gethash key table 42)) work again?
<shka>
it does
<didi>
hayley: It does.
<shka>
didi: simply use ignore, it is fine
<didi>
shka: Oh, OK. Thanks.
<didi>
I thought I was doing something wrong.
enzuru has quit [Remote host closed the connection]
enzuru has joined #commonlisp
<phantomics>
Nah, sometimes arguments are present that you don't need in which case you can ignore them, especially when doing things with macros
guthur has quit [Quit: Client closed]
* didi
nods
yewscion has joined #commonlisp
kadir has left #commonlisp [WeeChat 3.3]
Posterdati has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
s-liao has joined #commonlisp
Posterdati has joined #commonlisp
<Jing>
Hi, I encountered a problem with a package which is not available via Quicklisp: I downloaded the package cl-https-everywhere from GitHub, and then in the REPL I loaded it with asdf:load-asd. And then I try it call "(cl-https-everywhere:rewrite-uri ...)" the debugger said "Undefined function REWRITE-URI called with arguments ("...")". So I was wondering that what caused it?
<Jing>
I also called `use-package`
<jackdaniel>
Jing: are you certain that rewrite-uri is a function defined in the package cl-https-everywhere ?
<jackdaniel>
mind that the link that you gave contains only the package definition - what I see there is that rewrite-uri is indeed an exported symbol, but nothing about whether it is a function
<jackdaniel>
what is somewhat puzzling is that you've typed (cl-https-everywhere:whatever) before loading the system and it did not complain that the package doesn't exist (and it doesn't exist because you haven't loaded the system)
<Jing>
I think I may have try `(load XXX.lisp)` some time before
<Jing>
I am still trying your solution
Devon has quit [Ping timeout: 250 seconds]
Jing_ has joined #commonlisp
Jing has quit [Remote host closed the connection]
<Jing_>
@jackdaniel Thank you. I think it's working now. So to summarize, one should `asdf:load-system` with packages downloaded online in the REPL?
<jackdaniel>
the word package may be a bit misleading
<jackdaniel>
a "package" in common lisp is something like a namespace, a "system" in common lisp is like a library
<jackdaniel>
the usual term "package manager" in linux or in languages like python probably gave you that impression
nature has joined #commonlisp
<jackdaniel>
a "common lisp" equivalent would be a "system manager"
lottaquestions has quit [Quit: Konversation terminated!]
<Jing_>
Thanks. So in REPL I should use the term "system", but in `defpackage` when I use `:use` or `:import` I should treat it like a namespace?
s-liao33 has joined #commonlisp
s-liao33 has quit [Client Quit]
s-liao61 has joined #commonlisp
<jackdaniel>
in the file foobar.asd you have a form defsystem
s-liao61 has quit [Client Quit]
<jackdaniel>
this defines a library (something you load with asdf or with quicklisp)
s-liao has quit [Ping timeout: 256 seconds]
s-liao has joined #commonlisp
<jackdaniel>
in packages.lisp you may see (defpackage foobar …), that means that a package is created - you may use it in your program etc
<jackdaniel>
systems and packages are different entities. you may have multiple packages in one system
Guest55 has joined #commonlisp
Guest55 has quit [Client Quit]
<jackdaniel>
(and it is not uncommon that a system has a different name than a package)
<jackdaniel>
I know that this sounds like a mess and I wouldn't argue hard that it isn't - it is a frequent point of confusion for people learning common lisp
<Jing_>
You are right, I didn't notice "defsystem" in the asd
<Jing_>
Thank you for the clarification
<jackdaniel>
sure
<jcowan>
rotateq: On the other hand, Teach Yourself Scheme In Fixnum Days is excellent. Of course, that's a bit longer than 24 hours.
<jackdaniel>
I take that it is easier to learn scheme on 8-bit chip then
<jackdaniel>
if we tag with 2 bits then it should take little more than 2 months
Bike has joined #commonlisp
heisig has quit [Ping timeout: 240 seconds]
<jackdaniel>
and here I am, considering this joke funny ,)
* jcowan
chuckles
<jcowan>
The Scheme-79 chip had 32 bits: 24 bit value, 7 bit type, 1 mark bit. It's the direct ancestor of MIT Scheme, which even has a "microcode" directory, and is why the minimum size of a fixnum is 24 bits.
nature has quit [Quit: Lost terminal]
OlCe has quit [Ping timeout: 240 seconds]
edgar-rft has quit [Quit: Leaving]
heisig has joined #commonlisp
attila_lendvai has quit [Quit: Leaving]
<shka>
jackdaniel: it was a pretty funny
<shka>
joke
<jackdaniel>
tell me more, most of these gems encounter a deafening silence :)
<shka>
well, i usually visit this channel only when i am having problems with CL and I am looking for help
<shka>
so...
s-liao has quit [Ping timeout: 256 seconds]
s-liao has joined #commonlisp
OlCe` has joined #commonlisp
waleee has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
Inline has joined #commonlisp
s-liao has quit [Quit: Client closed]
tyson2 has joined #commonlisp
rotateq has quit [Quit: ERC (IRC client for Emacs 26.3)]
BottomType has quit [Quit: Client closed]
scymtym_ has joined #commonlisp
scymtym has quit [Ping timeout: 250 seconds]
voltron has joined #commonlisp
heisig has quit [Read error: Connection reset by peer]
nature has joined #commonlisp
edgar-rft has joined #commonlisp
<jackdaniel>
I have a constant session for the very same reason
voltron has quit [Remote host closed the connection]
frgo has joined #commonlisp
ym has joined #commonlisp
dec0d3r has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 244 seconds]
utis has quit [Ping timeout: 260 seconds]
attila_lendvai has joined #commonlisp
X-Scale has quit [Ping timeout: 260 seconds]
X-Scale` has joined #commonlisp
X-Scale` is now known as X-Scale
Bike has quit [Quit: Connection closed]
attila_lendvai has quit [Quit: Leaving]
tyson2 has quit [Remote host closed the connection]
Oladon has joined #commonlisp
frgo has quit [Remote host closed the connection]
utis has joined #commonlisp
mingus_ has joined #commonlisp
frgo has joined #commonlisp
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
frgo has quit [Remote host closed the connection]
attila_lendvai has joined #commonlisp
Jing_ has quit [Remote host closed the connection]
Jing has joined #commonlisp
tyson2 has joined #commonlisp
Bike has joined #commonlisp
scymtym_ has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
scymtym has joined #commonlisp
frgo has joined #commonlisp
frgo has quit [Ping timeout: 250 seconds]
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
<Guest74>
Is there any reason to choose a single float over a double besides ease of writing?
frgo has joined #commonlisp
<jackdaniel>
some implementations make a single float immediate value on 64bit
<jackdaniel>
double float wouldn't fit in 60 bits
<Guest74>
interesting, any idea which implementations or anyway to find that out within the system?
<jackdaniel>
of course sufficiently haha compiler will do unboxed operations when it has enough type information
<jackdaniel>
s/haha/smart/
<jackdaniel>
surely ccl, not sure about cmucl, sbcl - I think, ecl - planned
<Guest74>
Don't you wish people could give time as a present?
* edgar-rft
will write sufficiently haha code from now on only
<jackdaniel>
as a parent - I certainly do ,)
<Guest74>
and if I'm already dealing with doubles I'm guessing it's best to keep everything as doubles instead of converting to singles?
<jackdaniel>
I'd keep them without specifics and manipulate default-float-type for the reader
Catie has joined #commonlisp
<Guest74>
interesting, I'll try that out.
<Guest74>
I'm trying to decide whether to have my colour interpolators work on singles or doubles. Though not sure that will change anything about them being slow as ass.
<jackdaniel>
use fixnums
<Guest74>
for passing in a t between 0 and 1?
<jackdaniel>
scale it to some reasonably big integer
<jackdaniel>
but oh well, whatever suits you
yewscion has quit [Quit: Connection closed]
<Guest74>
I have no position on how to do it. Except having to accept values from other libraries that are between 0 and 1, whether single or double.
<White_Flame>
how many operations do your color operations go through that floating point error is a concern?
<White_Flame>
single-floats are 7-8 digits of precision, 10-bit color is barely 4 digits
<Guest74>
I'm not sure it is a concern yet, haven't done any tests for that. But dealing mainly with 16bit colours.
<White_Flame>
and 16-big color is just 5
<White_Flame>
*bit
<Guest74>
mainly concerned with speed.
<White_Flame>
on sbcl?
<Guest74>
yes
<Guest74>
mainly
<Guest74>
i mean, i should probably consider other implementations.
<White_Flame>
ok, well then just using specialized arrays will probably get you most of the way, as type inference should keep all intermediate operations in a known numeric type
<White_Flame>
sbcl is basically fastest on the block (though slow compilation time)
<Guest74>
specialized arrays? like lookup tables?
<White_Flame>
(make-array ... :element-type 'single-float) will specialize the array to hold unboxed single floats
<White_Flame>
in sbcl
<White_Flame>
and then again, accesses to that array will spread type information to your math, which should easily feed optimization
<Guest74>
I might be dumb, i'm not understanding.
<White_Flame>
if you don't specialize the array, on a 64-bit machine, then the type of each entry of the array is T (ie, holds anything). Entries in the array must have type tags to distinguish what they are
<White_Flame>
if you specialize the array, then they can hold literal smaller integers & floats without any per-element tagging
<Guest74>
but why am i putting floats in an array?
<White_Flame>
where are your colors coming from?
<White_Flame>
images? palettes? etc
voltron has joined #commonlisp
<Guest74>
my colours are 16bit integers
<White_Flame>
from where? your program only works on 1 color that the user inputs?
<Guest74>
of however many channels.
voltron has quit [Read error: Connection reset by peer]
<White_Flame>
also, even with just a single color, if you have 4 channel color, that's 4 values, and would be reasonable in an array
<White_Flame>
if you make a struct with type specified slot, I don't believe it specializes it in the same way as arrays
<White_Flame>
or class
<Guest74>
I should probably clarify that the value between 0 and 1 I am accepting or using from/for other libraries is the t value for interpolation.
Bike has quit [Quit: Connection closed]
Bike has joined #commonlisp
<White_Flame>
if you're splitting up your images/palettes/channels into separate functions handling only indiviudal numbers, then the iteration & function call overhead is probably going to be larger than any access styles
<White_Flame>
if you're talking about optimizing this, then you need to handle values in streaming batch
<Guest74>
colours are in specialized arrays of 16bit integers of however many channels.
<White_Flame>
so you're never storing the floats that you work with, but do int -> float processing -> int?
<Guest74>
granted sometimes i have to deal with 8bit. but pretty much all colour operations are 16bit.
<Guest74>
yup
<White_Flame>
I might be oldschool in thinking, but handling 16 bit int values on a 64 bit machine, I wonder if fixed point operations would be faster than float
<White_Flame>
however, I think in modern processors, the FPU might be faster than the ALU chain for some things
<Guest74>
I think the consensus is, or was, that 16bit ints are better for color accuracy for multiple operations.
<Guest74>
though that point is moot if changing to different colour spaces.
<White_Flame>
in your case, assuming your transformations are contained within a single function body, the intermediate values might just stay in registers and never hit memory anyway, regarding float sizes
<White_Flame>
whether you'd want single or float depends on how much error accumulation you have
scymtym_ has joined #commonlisp
<Guest74>
I was mainly wondering if one was more performant than the other, then I would just make palette interpolators work with that.
<Guest74>
I'm actually not too concerned with accuracy in the palette interpolators because they do dumb interpolation to match other scientific visualization tools that do dumb interpolation.
scymtym has quit [Ping timeout: 250 seconds]
<White_Flame>
double is probably slower than float, but given the pipelining width and very wide acceleration they have, who knows. It'll be a per-CPU performance characteristic
<White_Flame>
in corroboration with how your specific code happens to push it
<Guest74>
welp, I guess I'll just do the usual and implement both and set the fastest as default.
<Guest74>
probably try jd's idea since that seems interesting.
<Guest74>
as well
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
bcasiello has joined #commonlisp
Devon has joined #commonlisp
amb007 has quit [Ping timeout: 250 seconds]
amb007 has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
Lord_of_Life has quit [Excess Flood]
Lord_of_Life has joined #commonlisp
amb007 has quit [Ping timeout: 244 seconds]
amb007 has joined #commonlisp
hobo_ has joined #commonlisp
hobo has quit [Ping timeout: 268 seconds]
Alfr has quit [Killed (iridium.libera.chat (Nickname regained by services))]
Alfr has joined #commonlisp
Bike has quit [Quit: Connection closed]
amb007 has quit [Ping timeout: 244 seconds]
amb007 has joined #commonlisp
tyson2 has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
<shka>
double-floats often need to be boxed
<Guest74>
about the ears?
hobo has joined #commonlisp
hobo_ has quit [Read error: Connection reset by peer]
<shka>
Guest74: i mean, that's what jackdaniel meant about the bit size
<shka>
in practice, on the SBCL double-floats can be handled efficiently, but you will gonna need type declarations and plenty of inlines
<Guest74>
I was just making a jd joke.
<shka>
oh, ok
<shka>
and yeah, at least on ryzen, on the older version of sbcl double-floats could be actually faster then single-floats
<Guest74>
I think the initial response confirms I was successful.
<Guest74>
newer sbcl have slower doubles or faster singles?
<shka>
i don't know, but i was benchmarking like 2 years ago to say the least
<shka>
this still may the case, i don't know
<Guest74>
that's almost how long I've been out of it. just started recovering from covid.
<Guest74>
So i've forgotten lots of stuff.
<shka>
sorry to hear that
<Guest74>
thanks, it's certainly been an experience. Glad to be able to think enough to start coding again.
amb007 has quit [Ping timeout: 244 seconds]
karlosz has joined #commonlisp
amb007 has joined #commonlisp
voltron has joined #commonlisp
cosimone has quit [Remote host closed the connection]
Guest9216 has joined #commonlisp
cosimone has joined #commonlisp
Guest74 has quit [Quit: Connection closed]
VincentV` has quit [Read error: Connection reset by peer]
Guest9216 has quit [Client Quit]
<mfiano>
There is a reason cricket uses doubles, if that's what you're asking
Guest74 has joined #commonlisp
<mfiano>
There is a reason cricket uses doubles, if that's what you're asking
akoana has joined #commonlisp
Mandus_ has quit [Quit: WeeChat 3.3]
<mfiano>
You will run out of bits very quickly with single floats when procedurally generating terrain down to a usable scale.
Bike has joined #commonlisp
<mfiano>
iirc if you use doubles you could model a planet and scale in down to centimeter without data loss
<Guest74>
that's a good reason.
<mfiano>
cricket doesn't use doubles really either...well it does, but it changes the range
rain3 has quit [Ping timeout: 250 seconds]
<mfiano>
it uses 60 bit doubles
<Guest74>
but was mainly only concerned about mapping to colours for now.
Mandus has joined #commonlisp
<mfiano>
because the extra bits are almost meaningless and we didn't want to box them
<mfiano>
cricket already efficiently maps to colors
<mfiano>
it supports interpolating color gradient maps
<mfiano>
this is in the docs
<Guest74>
yes, i saw. I had a more general solution, which is not very efficient.
<Guest74>
but was easy to implement. but now I'm thinking of changing it seeing how badly it did with cricket stuff.
asarch has joined #commonlisp
BottomType has joined #commonlisp
<mfiano>
If you use crickets image map instead of your own do-pixels, it batches the scanlines on multiple threads
ym has quit [Ping timeout: 240 seconds]
<Guest74>
I'm not sure how that would work with clx. but in general I'm looking for a general solution for all my visualization use cases.
<Guest74>
So sometimes colours need to be accessed by things like symbols.