tyson2 has quit [Remote host closed the connection]
dra_ has joined #commonlisp
dra has quit [Ping timeout: 240 seconds]
Everything has quit [Quit: leaving]
igemnace has joined #commonlisp
<remexre>
is there a standard way to "expand" a derived type specifier?
<rotateq>
remexre: typexpand, but it's not in the standard
<remexre>
rotateq: ah, thanks; I guess it working on SBCL is probably good enough, since it's only needed in one of the tests
<rotateq>
yes it's in the CL-USER package
<remexre>
SB-EXT too, looks like
<rotateq>
ah okay
<rotateq>
i learned recently there's sb-ext:truly-the which SBCL trusts :D
tyson2 has joined #commonlisp
taiju has quit [Ping timeout: 240 seconds]
<rotateq>
remexre: yes then the CL-USER imports it from sb-ext in SBCL
amb007 has quit [Ping timeout: 256 seconds]
yewscion has quit [Ping timeout: 240 seconds]
VincentV` has quit [Remote host closed the connection]
waleee has quit [Ping timeout: 240 seconds]
nij- has joined #commonlisp
dra_ has quit [Ping timeout: 240 seconds]
jstoddard has quit [Ping timeout: 240 seconds]
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]
<rotateq>
Sorry but this nij person gets on my nerves discreetly, seems really basic things do not understand, but means already and that yes the others do not. Then there's this abstract-"modern" math gobbledygook.
<Bike>
where did that come from?
<rotateq>
And I never do this or even think it so harsh, but it drives me really crazy! sorry
<rotateq>
it was also some months ago, I can't talk to this person. sad but true
<rotateq>
yes Bike that's the big question
jstoddard has joined #commonlisp
<rotateq>
okay I know it sounds rude and impolite now, as not at all
<Bike>
well, this channel is publicly logged, so you can talk about it with them next time they come online, i guess
Lycurgus has joined #commonlisp
<rotateq>
i tried, and yes you're right of course. but i can't find the right words, nothing has effect
<rotateq>
Okay I'll do next time, better than not. me feelings broke a bit out with all that *breathing out*
<rotateq>
s/me/my
<rotateq>
And now the last drop to the barrel surely did come from query in the last hour of course.
<Lycurgus>
"abstract modern math gobbeldygook" is that like vs the times tables and the goesintas
<Lycurgus>
?
<rotateq>
hm no
<Lycurgus>
there is a branch of modern math that openly calls itself abstract nonsense
<rotateq>
"No PAIP doesn't interest me, we don't need symbolic computing for math."
<rotateq>
or other stuff
<Lycurgus>
nij said that?
<rotateq>
i could give you the newer query log but yes, one of the things
<rotateq>
he wants doing a "modern" CAS
<Lycurgus>
from some perspective that's right as symbolic vs quantitative/math is a going dichotomy
<rotateq>
I just got in touch superficial (by reading) in November 2020, but it gives me slight hexstream feelings.
<rotateq>
yes okay, but it can't be ignored, especially not when doing maths for computer science or physics
<Lycurgus>
it's an AI axis/dimension like neat vs scruffy
<rotateq>
yeah okay
<rotateq>
So whatever, people have meanings. Next time I'll clearly say I don't see a correspondence in any way further.
asarch has joined #commonlisp
<Lycurgus>
agree though doing a 'modern' CAS, assuming that means like in contrast to macsyma or whatever seems less than a contribution
<Lycurgus>
unless there are real advances that would make it better than the plethora of existing one
<Lycurgus>
*ones
<Lycurgus>
i.e. bundled in various products/pkgs such as mathematica
<Lycurgus>
or standalone pkgs
<Lycurgus>
also CAS is all about the symbols
winning-luser has quit [Quit: Leaving]
<rotateq>
Yes.
<rotateq>
symbols are power :)
<Lycurgus>
well i'd say that was knowledge but algebra is definitely about symbols
<rotateq>
yes that was one of my points, but whatever
<rotateq>
You people here now know me some time (as I'm also lotuseater) and how I really am. I apologize that it has overcome me and hope we can keep on as it's very important to me.
<Lycurgus>
lotuseater? only familiar with that in the sybarite context, does it have a lisp association?
<rotateq>
Lycurgus: no, but a mathematical one and with greek mythology :) the newer one i use now was also for having a lispier nickname in petto
<Lycurgus>
ah
winning-luser has joined #commonlisp
<rotateq>
and my love for number theory and concrete(!) mathematics :)
asarch has quit [Quit: leaving]
Lycurgus has quit [Quit: Exeunt]
panji has joined #commonlisp
<panji>
Hello, is there any system support uuencode and uudecode?
<rotateq>
Maybe you want READ-FILE-INTO-BYTE-VECTOR and WRITE-BYTE-VECTOR-INTO-FILE from alexandria.
<rotateq>
With associating the bytes with their fitting chars of course. :)
panji has quit [Ping timeout: 268 seconds]
Oladon has joined #commonlisp
Bike has quit [Quit: Lost terminal]
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
panji has joined #commonlisp
* panji
wonder if disconnection made my reply lost?
<rotateq>
Yes sorry. :/
<rotateq>
If you're on mobile it can be not so stable.
<panji>
rotateq: my connection is bad. :/
<panji>
rotateq: The specs said "Files can be attached to scripts and are stored as plain text. The method used is a form of UUEncoding." I don't want to implement it myself, or should i wait the specs change to BASE64... :)
<rotateq>
Ah don't worry.
<rotateq>
Oh okay, but I think I don't get yet what you want to achive.
<rotateq>
Fun is always important in programming and life. :)
<rotateq>
With peeking at some files, looks like you're a very advanced (or more) user already.
<opalvaults[m]>
Hopefuly I'm not interrupting anything. I'm having trouble with the homoiconicity of Lisps and was wondering if anyone had a similar experience, and what helped them finally start to read past the intermingling of data and code?
<rotateq>
No you're not opalvaults[m] I would say, but I should sleep finally.
<hayley>
I haven't found it to be a problem. Usually it is evident when you have data or code.
<rotateq>
opalvaults[m]: That's a very big question. :)
<hayley>
It's useful to use data as code (e.g. pass it to COMPILE or EVAL) but usually you don't, and so you can tell if something is used as data, or used as code.
<rotateq>
hayley: Maybe it's kind of being used to another way of thinking.
<hayley>
...and it's also to process code as data, but again that's the exception to the norm.
<hayley>
rotateq: I don't think there is really a new way of thinking, and that's just something Paul Graham acolytes say to make Lisp sound cool. Or maybe I internalised it. Who knows.
<rotateq>
hayley: I mean for the person who asked right now.
panji has quit [Ping timeout: 256 seconds]
<rotateq>
Oh in 5 minutes some other person will show up by high chance.
<opalvaults[m]>
For background, I work with Python mostly. And having had much use for strong typing so it's usually not a problem of what the data is ie vectors, tuples, etc.
<opalvaults[m]>
let me see if I can find a good example
<beach>
Good morning everyone!
<rotateq>
Yes no problem opalvaults[m].
<rotateq>
beach: Faster than I predicted. Good morning.
<hayley>
I mean, in a typed language you could just have a "code" type (e.g. Scala, F♯), and there would be protocol functions on code objects. But still that's just data until you EVAL or COMPILE.
<opalvaults[m]>
Here's a particular example I'm trying to refactor a little if possible, to remove :source potentially so that users can mroe easily decide what source they would like to show up first (in this case, it's Global history, URLS, etc. boring stuff.
<opalvaults[m]>
Anyways the point is
<opalvaults[m]>
I get lost in that let expression almost immediately as it nests further and further.
<hayley>
What does it have to do with code and data looking the same?
<opalvaults[m]>
Hm, maybe I'm not explaining myself very well.
<hayley>
You could use LET* instead of LET and break up the value form for ACTIONS.
<opalvaults[m]>
If we only take the let expression from there, and we travel down to:
<opalvaults[m]>
By this point I've completely lost track of what data is supposed to be in suggestion and suggestion-values.
<opalvaults[m]>
And why it's being mapcar'ed into a lambda expression
<opalvaults[m]>
not that I'm asking anyone to figure it out for me
<opalvaults[m]>
It was more a general question towards other questions about when does the homoiconicity become a bit easier to digest. If think if I showed that to any developer who wasn't familiar they'd feel as if they didn't know what data was coming in and out of this procedure as you get further nested into this let.
<opalvaults[m]>
towards other users**
<beach>
opalvaults[m]: "homoiconicity" means that data and code look the same. Your problem is unrelated to homoiconicity.
<opalvaults[m]>
I hope that's a bit more clear.
<opalvaults[m]>
is it not to do with the fact that "buffer-load (url (first suggestion-values))))" are all arbitrary syntactic sugar?
<beach>
opalvaults[m]: You can use LET* as hayley suggests, and you can break up the code into functions the way you do with other languages.
<opalvaults[m]>
oops, took a chunk out of the beginning
<rotateq>
Maybe look how MAKE-COMMAND is defined.
<hayley>
You could make such sugar less arbitrary then. e.g. people are very familliar with macros of the form (DEFINE-<something> <name> <arguments> <body>)
taiju has joined #commonlisp
notzmv has quit [Ping timeout: 240 seconds]
<rotateq>
opalvaults[m]: And for what beach said, you can see LISP programs/expressions as being their own abstract syntax trees at the same time.
taiju has quit [Read error: Connection reset by peer]
panji has joined #commonlisp
taiju has joined #commonlisp
* panji
lost connection again, i should stop and just read logs. :/
<rotateq>
Oh panji, sorry to hear that.
<panji>
rotateq: Don't worry. Anyway, i am not advanced user.
taiju has quit [Ping timeout: 268 seconds]
<rotateq>
Okay, I may believe you.
<opalvaults[m]>
Hmm. okay. Well that's certainly something to think about. I think others have a lot easier time grasping at the syntactic sugar of Lisp than I do. When I see:
<opalvaults[m]>
y = lambda k, v : k + v
<opalvaults[m]>
It becomes immediately obvious to me what is the syntax and what is the data, especially if I've declared it explicitly. I don't get the same sense of obviousness which leads to sprawling blocks of code becoming a bit difficult to grok.
<opalvaults[m]>
print(y(5, 6))
semz has quit [Ping timeout: 252 seconds]
<opalvaults[m]>
in CL thus far*
<opalvaults[m]>
it's getting late and I'm hitting Return to early lol
<hayley>
Also, may I ask, do you have a list of "actions" or a list of "commands"?
<opalvaults[m]>
thankfully it's Nyxt, so the variables and procedures(functions?) are only a describe key-chord away
<opalvaults[m]>
So to answer more directly, yes. Much in the same way as Elisp, the behavior is defined beforehand (although it's a bit sprawling as you can imagine).
<opalvaults[m]>
Cool, I'll give that a read!
<hayley>
Such a form looks almost identical to DEFUN, and you could imagine that it is like an annotation in Python, e.g. @command def buffer_load(...): ...
<opalvaults[m]>
But really I'm just trying to have an equivalent to (setq source-for-set-url 'bookmarks) or some such
<opalvaults[m]>
It's obvious I just need more practice. This isn't Python, and I just need to slow down it seems. It's a bit jarring to go from knowing exactly how to express a problem to being in bewilderment. No fault to Common Lisp. Just stuck in a particular mindset.
<opalvaults[m]>
Thanks again! Off to study I suppose
semz has joined #commonlisp
Oladon has quit [Quit: Leaving.]
taiju has joined #commonlisp
jealousmonk has quit [Quit: ERC (IRC client for Emacs 27.1)]
jstoddard has quit [Quit: Goodnight]
tyson2 has quit [Remote host closed the connection]
stacksmith has joined #commonlisp
myrrh has joined #commonlisp
alfonsox has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
miique has joined #commonlisp
karlosz has quit [Quit: karlosz]
yewscion has joined #commonlisp
yewscion has quit [Quit: Quit.]
karlosz has joined #commonlisp
notzmv has joined #commonlisp
taiju has quit [Ping timeout: 240 seconds]
karlosz has quit [Quit: karlosz]
Jing has joined #commonlisp
shka has joined #commonlisp
s-liao has quit [Quit: Client closed]
lisp123 has joined #commonlisp
gaqwas has joined #commonlisp
taiju has joined #commonlisp
aartaka has joined #commonlisp
karlosz has joined #commonlisp
winning-luser has quit [Quit: Leaving]
<lisp123>
Do current compilers do ANY optimisations for generic functions, or would I have to use fast-generic-functions / wait for some of SICL technologies to filter into production?
<jackdaniel>
they do
<lisp123>
jackdaniel: *phew* good to hear. Do you think they do some sort of sealing?
<jackdaniel>
fast generic functions, fast generic function dispatch (and other) are recent improvements over existing technologies, but it is not that existing ones had no optimizations
<jackdaniel>
ecl (for instance) allows sealing; that said if you are sure that functions won't change, then you could use a library trivial-generic-functions
<jackdaniel>
s/trivial/inlined/
<lisp123>
I am most worried about representing lists that I will use very often as their own class, so that instead of (car list) I would do (first my-class) and that way I can replace lists for arrays down the track (similarly I would implement generic functions for iteration)
<jackdaniel>
this library defines a generic function metaclass that allows inlining them and that greatly improves the performance (at cost of some runtime flexibility)
<lisp123>
Great, I will use that
<lisp123>
Thanks
<jackdaniel>
I believe that FIRST is already taken (at least in CL package:)
karlosz has quit [Quit: karlosz]
<lisp123>
(shadowing ;))
<lisp123>
(and implementing methods for (defmethod first ((obj sequence))) as well)
<beach>
lisp123: I find that designing good algorithms and data structures is much more important than low-level considerations like that.
<lisp123>
Iteration is quite annoying actually. For example the loop macro is relatively different between lists and arrays
<beach>
lisp123: Use (loop for x = ... then ... do...)
<lisp123>
beach: Yes, I agree. I just have one section of my code where I am doing permutations & combinations on lists, so that's the only place I was a bit hesistant
<lisp123>
beach: Thanks! That will prove very helpful
rgherdt has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
random-nick has joined #commonlisp
Algernon69 has joined #commonlisp
Algernon91 has joined #commonlisp
Algernon69 has quit [Ping timeout: 240 seconds]
lisp123 has quit [Remote host closed the connection]
cage has joined #commonlisp
pve has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
gaqwas has quit [Remote host closed the connection]
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
igemnace has quit [Remote host closed the connection]
Algernon91 has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
lisp123 has joined #commonlisp
gaqwas has joined #commonlisp
lisp123 has quit [Ping timeout: 240 seconds]
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
Algernon91 has joined #commonlisp
<phoe>
I would like to compose a PNG image from pieces. I have a set of PNG image parts that I would like to rotate, translate, and layer on top of one another to produce a flattened final image. I think I can use PNGLOAD for reading PNG files, but what library should I use for actually generating the image?
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life_ is now known as Lord_of_Life
amb007 has quit [Ping timeout: 256 seconds]
Algernon91 has quit [Ping timeout: 268 seconds]
VincentVega has joined #commonlisp
s-liao has joined #commonlisp
amb007 has joined #commonlisp
Algernon91 has joined #commonlisp
alcaeus has joined #commonlisp
<alcaeus>
Anyone home?
<hayley>
Is there anybody in there?
<phoe>
well, I'm working in home
<phoe>
s/in/from/
<phoe>
so it kinda counts I guess!?
<madnificent>
phoe: I vaguely recall uzing zpng a long time ago for a ray tracer.
<phoe>
madnificent: OK I can write PNG images using ZPNG; then I'm only looking for a library that will allow me to compose them
<phoe>
so, like, pngload → ??? → zpng
s-liao has quit [Quit: Ping timeout (120 seconds)]
s-liao has joined #commonlisp
rito_ has joined #commonlisp
<hayley>
It'd be a fun hack in Petalisp, except for rotation (unless you constrain yourself to multiples of 90°).
<madnificent>
phoe: I didn't spend too much time on the writing part. I started from a 2d vector. Combination of images would be filling the vector at the desired spots with the desired pixel values...
<hayley>
Resizing could also be tricky perhaps.
<madnificent>
phoe: What sort of transformations are you looking for? Many common transformations are expressed as matrix multiplication.
<phoe>
madnificent: rotations, scaling, layering of RGBA images
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
<phoe>
nothing too heavy on maths or logic I think, just assembling larger images from smaller pieces
<phoe>
hayley: hmm, that's an idea
winning-luser has joined #commonlisp
<madnificent>
phoe: The sources of the ray tracer are sadly long gone, however I do recall there being much value in first working on a larger color space before converting the image to the effective PNG. In the case of the raytracer that helped with over- and undersaturation.
<phoe>
sure, that's something I don't care about - my images fit within RGB
<madnificent>
I hadded an extra average depth dimension to each pixel which also helped in adding a background. Perhaps such a trick could come in handy too.
<phoe>
probably not something I need either - my images are all flat :D
<madnificent>
phoe: yeah. If you stagger images on top of each other, you may want to either multiply or add, or ...
<phoe>
I think the only thing that comes into play is the alpha channel - 0 alpha is 100% the bottom image, 1 alpha is 100% the top image, whereas 0.5 alpha is an average of the two images
<madnificent>
If you're jotting something together, it may be hande to foresee such extra dimension for use during playing. Unless you're literally composing and not staggering, which is also fine.
<phoe>
I don't need more advanced image processing modes, thankfully :D
<hayley>
phoe announces GIMP 2
<madnificent>
If you run into undesired artifacts, check out blending modes. Good shot you don't want raw addition/removal. But could be!
<semz>
And again it's written in CL first. Curious.
<madnificent>
On a different note: I didn't oversee any well-rounded EBNF parsers, right?
<madnificent>
*overlook
amb007 has quit [Ping timeout: 240 seconds]
<phoe>
hayley: gimp 2.99.8 is something I have on my machine right now to be honest
amb007 has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
Inline has quit [Remote host closed the connection]
myrrh has quit [Ping timeout: 268 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
lisp123 has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
alcaeus has quit [Ping timeout: 268 seconds]
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
s-liao has joined #commonlisp
winning-luser has quit [Quit: Leaving]
shka has quit [Quit: Konversation terminated!]
Algernon91 has quit [Read error: Network is unreachable]
<Xach>
_death: thanks. i can't reach it from my home connection for some reason. but the server is not in distress and you can reach it, so I don't know what's up.
* Xach
will wait and check it later
<_death>
try traceroute
<Xach>
yeah, seems like a routing problem in he.net. I will wait it out I guess.
ldb has quit [Ping timeout: 252 seconds]
gaqwas has quit [Remote host closed the connection]
ldb has joined #commonlisp
<rotateq>
522 MB/s ?!
<_death>
statistics and lies
ldb has quit [Ping timeout: 250 seconds]
<rotateq>
ah right, never trust statistics :D
<_death>
statistics is fine, never trust the statistician ;)
<rotateq>
even more right, mathematics is key to see above our intuition
ldb has joined #commonlisp
<ns12>
rotateq: The number tends to be inaccurate for small files.
<rotateq>
^^
rain3 has joined #commonlisp
<ns12>
rotateq: What's your typical speed?
<rotateq>
ehm I think around .. 5MB/s ?
BerntH has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
Bike has joined #commonlisp
amb007 has joined #commonlisp
igemnace has joined #commonlisp
nij- has joined #commonlisp
<nij->
Is there a printed little schemer but for CL?
dra_ has joined #commonlisp
<nij->
(Or maybe someone should write one?)
Bike has quit [Quit: Connection closed]
Krystof has joined #commonlisp
Bike has joined #commonlisp
treflip has joined #commonlisp
dra_ has quit [Quit: Leaving]
dra has joined #commonlisp
<edgar-rft>
nij-: I've never read the little schemer books (just because it's not CL) so I have no idea about the style of that books, but the standard recommenation for an introuctionary CL book is -> https://gigamonkeys.com/book/
<edgar-rft>
*introductionary
<ldb>
nij-: there was an older version of that book called "little lisper"
<yitzi>
I think it was still LISP-1 in that incarnation.
<nij->
Yeah. I'm trying to hook some of my friends into CL.
<nij->
Kinda hard cuz they don't even use emacs.
<nij->
Not even vim.. or not even the terminal :(
<ldb>
why should they?
<nij->
But I'm sure they are capable of learning. Just to need some tricks to trick them in.
<nij->
ldb should they?
<edgar-rft>
you don't necessarily *need* emacs for lisp programming, but it helps a lot :-)
<nij->
Yeah..
<ldb>
If they want to be cool kids, they should already googled "the best text editor" and installed VSCode (well, when I did that it turns out to be Vim)
<edgar-rft>
I already wrote Lisp code on Windows using notepad.exe but I don't really reommend that for a beginners :-)
<sm2n>
iirc the little schemer has footnotes describing how to run things on CL
<sm2n>
so it shouldn't be much of a hurdle
<ldb>
^ true
mjoerg has joined #commonlisp
<ldb>
edgar-rft: it seem many experienced programmers I know don't use highlighting and completion at all.
igemnace has quit [Quit: WeeChat 3.4]
* ldb
except for Java programmers?
<rotateq>
ldb: and is that now good or bad behavior?
<ldb>
rotateq: that depends on the languages of their choice, if it is Java, meh. if it is CL, good. for APL, Supercalifragilisticexpialidocious
<rotateq>
i like APL too :) you can use the april compiler
pdietz has quit [Ping timeout: 256 seconds]
<semz>
How would APL completion even look like?
<rotateq>
and yes, i saw it for people starting with things, those newer IDEs often complete too much and it's not good for learning
<rotateq>
semz: that is a good question :D you don't need it anyway
<rotateq>
or better: it hinders you more falling into such a trap
lisp123 has quit [Remote host closed the connection]
Xach has quit [Ping timeout: 252 seconds]
Xach has joined #commonlisp
mjoerg has left #commonlisp [ERC 5.4.1 (IRC client for GNU Emacs 27.2)]
waleee has joined #commonlisp
attila_lendvai_ has quit [Ping timeout: 268 seconds]
theBlackDragon has quit [Ping timeout: 240 seconds]
nature has joined #commonlisp
s-liao has quit [Quit: Client closed]
theBlackDragon has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
aartaka has joined #commonlisp
ldb has quit [Quit: ERC (IRC client for Emacs 27.2)]
VincentV` has joined #commonlisp
VincentVega has quit [Ping timeout: 268 seconds]
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]
tyson2 has quit [Remote host closed the connection]
Algernon69 has joined #commonlisp
rogersm has quit [Read error: Connection reset by peer]
rogersm has joined #commonlisp
lisp123 has joined #commonlisp
<ns12>
ldb: "... don't use highlighting and completion" - What text editors do they use? BSD vi? MicroEmacs?
<lisp123>
I don't use highlighting for Lisp with the exception of doc strings, much more enjoyable actually
<ns12>
It's a pain to write lisp using BSD vi (nvi) because it doesn't implement lisp mode ("set lisp").
<lisp123>
All the other "IDE" features are a must though
<ns12>
lisp123: Example? Automatic closing of parentheses?
<lisp123>
Yes, of course, that's essential. Covered by Paredit
<White_Flame>
for me, highlighting for comments is probably the most important highlight
<lisp123>
Then slime has quite a few useful features
<lisp123>
White_Flame: Actually, yes, I need to correct myself. I only have highlighting for doc strings and comments
<lisp123>
I use a slightly modified version of the "monotropic" theme, if anyone wants to try a monochrome setup
anticomputer has quit [Remote host closed the connection]
gxt has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
gxt has joined #commonlisp
jealousmonk has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
<edgar-rft>
Using Emacs for Lisp programming helps a lot (not only a bit), but for people who have never worked with Lisp before it's a bit hard to learn Common Lisp *and* Emacs simultaneously. But on the other hand I really don't know anything better than Emacs for Lisp.
Algernon69 has joined #commonlisp
Algernon91 has joined #commonlisp
<rotateq>
for me it was (and still is) spacemacs a good decision, as i learned vim before
<rotateq>
edgar-rft: yes a bit similar i saw a few times at people from math faculty at university: never used or even know LaTeX, then the bachelor thesis comes up and too much for some
SAL9000 has quit [Ping timeout: 252 seconds]
Algernon69 has quit [Ping timeout: 250 seconds]
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
<VincentV`>
mfiano: Hey, I have a mind for using vectors with rational numbers, and I am going to use origin for that. I see there's ehh some code duplication eg diff on dvec2 and vec2 only gives differences on 0.0 vs 0d0 f32 f64 and such, so I am gonna pull out some macrology, but I think adding rationals shouldn't be too big of a problem, right? Plus some structs like circle should have a typed version as well I guess (radius f32 is hardcoded for
<VincentV`>
instance). Conversion utilites between all the stuff is another thing. I am also thinking of a better convention like point2d/f for f32, circle/r (r for rational), d for double. Any tips/gotchas/wishes you could give for my macro gun please?
VincentV` is now known as VincentVega
amb007 has quit [Read error: Connection reset by peer]
Catie has joined #commonlisp
gaqwas has joined #commonlisp
amb007 has joined #commonlisp
ajoberstar has joined #commonlisp
xsperry has joined #commonlisp
gioyik has joined #commonlisp
<yitzi>
::notify phoe I saw in your trivial-package-local-nicknames test suite that one of the tests locked a package and then verified that adding nicknames would fail while the package was locked. I've added a WITH-LOCKED-PACKAGES macro to trivial-package-locks that may help for that use case.
<Colleen>
yitzi: Got it. I'll let phoe know as soon as possible.
dra has quit [Quit: Leaving]
waleee has quit [Ping timeout: 250 seconds]
VincentVega has quit [Remote host closed the connection]
<phoe>
yitzi: thanks! I'll make an issue to use that.
<Colleen>
phoe: yitzi said 5 minutes, 6 seconds ago: I saw in your trivial-package-local-nicknames test suite that one of the tests locked a package and then verified that adding nicknames would fail while the package was locked. I've added a WITH-LOCKED-PACKAGES macro to trivial-package-locks that may help for that use case.
<yitzi>
Great!
VincentVega has joined #commonlisp
JoshYoshi has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
Algernon666 has joined #commonlisp
amb007 has joined #commonlisp
SAL9000 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<madnificent>
Ah, so it wasn't there for PNG which is probably why we missed it.
waleee has joined #commonlisp
amb007 has quit [Ping timeout: 256 seconds]
<madnificent>
If the readme is anything to judge on, it looks really nice.
<phoe>
no rotations
<madnificent>
As they say: always judge a book by its cover.
<phoe>
I might need to add those myself
<madnificent>
There are array operations, so that should be little more than constructing a target array and matrix-multiplication.
amb007 has joined #commonlisp
<phoe>
yes
lisp123 has joined #commonlisp
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
lisp123 has quit [Ping timeout: 268 seconds]
karlosz has joined #commonlisp
tyson2 has joined #commonlisp
gaqwas has quit [Remote host closed the connection]
gioyik has quit [Ping timeout: 276 seconds]
<VincentVega>
mfiano: OK, thanks!
Everything has joined #commonlisp
gioyik has joined #commonlisp
attila_lendvai_ has joined #commonlisp
gioyik has quit [Ping timeout: 276 seconds]
treflip has quit [Quit: bb]
gioyik has joined #commonlisp
gioyik has quit [Ping timeout: 276 seconds]
Algernon666 has quit [Read error: Network is unreachable]
fmakuncertain has joined #commonlisp
gaqwas has joined #commonlisp
gioyik has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Client Quit]
rain3 has quit [Ping timeout: 252 seconds]
gioyik has quit [Ping timeout: 276 seconds]
Inline has joined #commonlisp
amb007 has quit [Ping timeout: 268 seconds]
amb007 has joined #commonlisp
Inline has left #commonlisp [#commonlisp]
Inline has joined #commonlisp
gioyik has joined #commonlisp
<VincentVega>
mfiano: I like how gfxmath is more approachable/compact, and I am looking to do a generic interface anyway. I think I will just adapt geometry parts I need from origin to gfxmath. Say, what would it take to add rationals to gfxmath? The simple way, I guess, would be to replace everything double to rational (which would be fine for me short term), but how hard would it be to allow using either float or double or rational as COMPONENTS of
<VincentVega>
MATH-OBJECT?
miique has quit [Ping timeout: 240 seconds]
fmakuncertain has quit [Ping timeout: 240 seconds]
rogersm has quit [Read error: Connection reset by peer]
Colt has quit [Remote host closed the connection]
Colt has joined #commonlisp
Colt has quit [Read error: Connection reset by peer]
miique has joined #commonlisp
xaltsc has quit [Quit: WeeChat 3.3]
varjag has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
xaltsc has joined #commonlisp
aartaka has quit [Ping timeout: 260 seconds]
xaltsc has quit [Quit: WeeChat 3.3]
xaltsc has joined #commonlisp
ajoberstar has quit [Ping timeout: 260 seconds]
rito_ has quit [Quit: Leaving]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
tyson2 has quit [Remote host closed the connection]
Xach has quit [Changing host]
Xach has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
ajoberstar has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
attila_lendvai_ is now known as attila_lendvai
jpl01 has joined #commonlisp
_73 has joined #commonlisp
varjag has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
gaqwas has quit [Remote host closed the connection]
Algernon666 has joined #commonlisp
nature has quit [Ping timeout: 250 seconds]
xaltsc has quit [Quit: WeeChat 3.3]
Alfr has quit [Remote host closed the connection]
Alfr has joined #commonlisp
gaqwas has joined #commonlisp
Bike has quit [Quit: Lost terminal]
gaqwas has quit [Ping timeout: 240 seconds]
<mfiano>
VincentVega: I haven't really considered it, and I'm not sure it would be a good idea, as the numerator/denominator could end up very large and thus be consed as a bignum for all the intermediate calculations in a chain of operations.
<mfiano>
Plus, GPU's expect floating point arrays, particularly composed of single-floats, since double-floats are a serious performance trap for GPU calculations.
tyson2 has joined #commonlisp
<mfiano>
I would also be surprised of specialized rational arrays were not upgraded to T on every implementation
<mfiano>
s/of/if/
<mfiano>
Performance aside, I don't think it would be very difficult to add with this generic protocol.
cosimone has quit [Ping timeout: 256 seconds]
<madnificent>
I'm seeing some behaviour I don't grok. I have a parameter containing a hash-table. I create a bunch of scanners using #'cl-ppcre:create-scanner for later use at runtime and I try to store them in that hash-table. When doing so, I'm exhausting the heap. It's a dolist with a (setf gethash). How would this land on the heap?
<hayley>
The hash table is allowed to resize. And CL-PPCRE creates a chain of closures which allocates.
<madnificent>
hayley: The heap contains all closures and I'm exhausting space for any function definition?
<madnificent>
These are fixed, so if I could define them another way, that'd work too.
<hayley>
"the heap" being all memory Lisp is allowed to use for storing objects?
<mfiano>
You can use (room t) to see the breakdown of dynamic space usage by type on SBCL at least.
<mfiano>
and the default heap size is very low on SBCL at least
<madnificent>
mfiano: good point
<hayley>
You are aware that April fool's day is in April?
<mfiano>
Note that, even specifying a heap size of all of your RAM, that isn't going to be allocated unless it needs it. I typically use 3/4 or so
<mfiano>
(SBCL that is)
<White_Flame>
hayley: no it's not, that's just an april fool's joke
<hayley>
:<
<madnificent>
Somewhat before creating too many scanners, I'm at 500Mb dynamic space. Almost all of that are simple-array-fixnum objects (only 74 of them?)
<hayley>
What kinds of REs are you compiling?
<madnificent>
hayley: I first compile a bunch of more complex ones (everything is fine there though). It starts failing when creating many case-insensitive word matches, basically.
<madnificent>
okay. Let's read the docs for *use-bmh-matchers* again and for (setf *optimize-char-classes* :charmap). Disabling those two makes sbcl happy.
<madnificent>
Well, *use-bmh-matchers* kind-of says it: use the (fast but large) Boyer-Moore-Horspool matchers.
<madnificent>
Still confused as to why it crashes with under 700Mb of used space.
<hayley>
Ah yeah, those would give you large fixnum tables.
<madnificent>
Oh right, staring at the numbers again, I must have overlooked that. That's 971Mb of simple-array-fixnum content.
<madnificent>
Thank you all for the help. Glad to be seeing some lisp again.
<mfiano>
Sure enjoy, and yeah definitely bump up your heap size if you have more than 2G of RAM or so :)
<madnificent>
Ah, for the scrollback: we're running these things on machines with 256Gb of ram. There's some wiggle room for sure :P
<hayley>
gigabits?
<mfiano>
Well 256Gb is only 32G :P
<madnificent>
you're right, but wrong too. Hmmmm.... it's GB.
miique has quit [Ping timeout: 240 seconds]
<madnificent>
though there's wiggle room with 32GB too! :P
<mfiano>
You I have 64 on this machine and heap at 48G, though usually never even 1/8 of that used
<mfiano>
But on ocassion I create incredibly large arrays and don't want to lose my image
<madnificent>
Looking at the earlier discussion on GPUs: I recall "doing" deep learning on a CPU with Common Lisp somewhere 2006-2010 and it was terrible for various reasons (most being me). Is GPU support (preferably AMD) here now for these cases? Is that a pipe dream?
<mfiano>
I don't do too much GPGPU stuff, nor have I used an AMD. |3b| might be one to ask.
<hayley>
eazy-opencl usually doesn't blow up on me™, and GPGPU on AMD works fine.
* |3b|
hasn't done any gpgpu outside graphics in a long time (and not even much of that lately), so hands the question to hayley
<mfiano>
:)
attila_lendvai has quit [Ping timeout: 240 seconds]
ajoberstar has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
<madnificent>
Oh, that would be a good case to test my graphics card on.
<VincentVega>
mfiano: I was entertaining the idea of an infinite sheet and a relatively small amount of objects, so it's not really for immediate gpu consumption. I haven't yet decided how badly I want infinity though... But yeah, I am getting the hang of the codebase so far, I think.
<mfiano>
VincentVega: Great. I am sort of on break this week, so I can't be of much help unfortunately. But if you come up with something, send a PR or open issues or whatever. I'd love to see what you come up with.
<|3b|>
VincentVega: trying to use rationals in generic graphics code is probably not going to work well even without considering the size problems, too many operations require irrationals :/
<mfiano>
That is also a good point
<VincentVega>
3b: yeah, true! But an occasional irrational doesn't take away the infinity...
<|3b|>
it does if a double-float in a transform matrix infects everything else :)
<VincentVega>
mfiano: cool, thank you, if I come up with something good, I will make sure to send a PR
<VincentVega>
3b: yeah that would take some care or type coercion to avoid I guess
<VincentVega>
hell, infinity is hard
<|3b|>
nah, infinity isn't actually that hard
<|3b|>
just need to respecify it as finite regions around and infinite grid
<|3b|>
subtract out the infinity and dump that in a bignum, then do the rest in single-floats or whatever
<mfiano>
is this for the ray tracer?
<mfiano>
or was that someone else?
<VincentVega>
nah, it can be pretty hard, man, I took real analysis and everything there is about screwing around with infinity in some way
<VincentVega>
mfiano: gui
* |3b|
meant "computer graphics infinity" not "math infinity" :p
<mfiano>
ah
<VincentVega>
3b: I understand : )
<|3b|>
though i guess there is also the question of whether you want infinitesimal in addition to infinite, that's a bit more work than just chopping off the bignum part
<|3b|>
gui is possibly in an easier subset of "graphics" for using rationals though, can do a lot of gui without rotations for example
<VincentVega>
3b: I guess so, yeah. The edge cases, huh.
<VincentVega>
3b: gui isn't supposed to be very hard or anything, sure