<beach>
So in this case, a call looks like (foo <x> <y> :a <a> :b <b> ...)
<beach>
Since I don't know ltk, you also need to tell me the lambda list of MAKE-CANVAS.
<beach>
It looks like there must be a required argument missing.
<not_a_seagull>
Idk. I don't know LTK either.
<beach>
So why are you using it?
<not_a_seagull>
It's the first GUI library I found, and it uses TK
<not_a_seagull>
What else should I use?
physpi has quit [Ping timeout: 256 seconds]
fowlduck has quit [Ping timeout: 260 seconds]
<beach>
I think it is a horrible idea to use a foreign library if you are a Common Lisp newbie. You are going to run into all kinds of trouble. In fact, it's a bad idea to start learning Common Lisp by attempting a GUI application.
<beach>
However, since you are using it...
physpi has joined #lisp
<beach>
You made a call (ltk:make-canvas ..). You must have seen somewhere the definition of the function make-canvas, or you would not have typed that code. No?
fowlduck has joined #lisp
<not_a_seagull>
Well, I tried to use "make-instance" because that's what all the documentation I could find says to use
<not_a_seagull>
But it turns out "make-instance" doesn't exist anymore
aaaaaa has quit [Quit: leaving]
<not_a_seagull>
So I look in the source code
<not_a_seagull>
And I see that "make-canvas" is exported
<beach>
MAKE-INSTANCE is a standard Common Lisp function, so it won't go away.
<not_a_seagull>
Oh, it's not an LTK thing?
<beach>
Again, it is a horrible idea to learn Common Lisp this way.
<not_a_seagull>
Yeah that seems to work. Thank you for your help.
<beach>
Using a GUI library, and especially one based on foreign code, is going to require some knowledge about the language itself.
<Oladon>
not_a_seagull: before you continue to reject beach's wise advice, consider well that by doing so you're essentially concluding that somehow, you know better than a veteran Lisper what is and is not a good way to learn Lisp.
<Oladon>
not_a_seagull: I recommend picking up a copy of the book Land of Lisp, and starting with that, and _then_ attempting your GUI application.
kleptoflora has quit [Read error: Connection reset by peer]
kleptoflora has joined #lisp
<not_a_seagull>
Oladon: alright, I guess I'm being rash. I've been looking through Pratical Common Lisp, is that a good book?
<Oladon>
not_a_seagull: It is, but in my opinion it's not as good for beginners to the language as Land of Lisp is.
<Oladon>
beach: How long've you been practicing Lisp?
<Oladon>
not_a_seagull: Also Land of Lisp was written by a genius and has cartoons
<beach>
Oladon: Let's see, since 1977 or so.
<Oladon>
not_a_seagull: Cough cough ^
<not_a_seagull>
Alright, I'll put a bookmark in Practical Common Lisp and pick up Land of Lisp.
<Oladon>
(On a side note, show me another language that anyone actually still enjoys after that long...)
<not_a_seagull>
Fortran?
<beach>
I recently watched an animated video on YouTube showing the evolution in popularity of different programming languages. It was amusing. I mean the definition of "popularity" is probably bogus.
<beach>
But the interesting part was how languages come and go.
<Oladon>
beach: It's generally considered on such a short scale, nods
<Oladon>
I guess it has to be because of that fact
<beach>
Like Ruby was SO HOT just a few years back and now it seems dead.
<Oladon>
Yep
<not_a_seagull>
I haven't been programming for long but I remember ASP.NET from a while back.
<Oladon>
I still get candidates whose entire coding experience (of 3-5 years) is in Ruby... not interested.
<not_a_seagull>
Now it's mostly replaced by Blazor IIRC
<beach>
not_a_seagull: Also note that there is #clschool for truly basic Common Lisp questions.
<Oladon>
beach: I laughed to myself as I typed the initial parenthetical because 90% of languages with "known" names nowadays weren't even _around_ in '77.
<not_a_seagull>
beach: thank you, I'll keep that in mind
tristero has quit [Ping timeout: 240 seconds]
<beach>
Oladon: Yeah, people go to a lot of trouble to avoid learning Common Lisp. In particular, they keep inventing new languages that don't even come close.
<Oladon>
Indeed.
<not_a_seagull>
That's why I'm coming to Lisp, to be honest. I feel like it's something I should've learned when I first started.
<beach>
That, I agree with. But it is never too late.
<Oladon>
Or they "invent" this Great New Feature and release a new version of their language of choice (because their language of choice requires releasing a new version to add a feature...)... and the Lispers are like "?? We've had that since '59..."
<beach>
Exactly!
<beach>
Plus, we don't need a new release to add new syntax. We have macros and we have the compiler available at run-time.
<Oladon>
Right, that was the ellipsis there :)
<beach>
Ah, OK.
<not_a_seagull>
I read in practical lisp that the first iteration of object orientation was a library rather than a compiler update
<beach>
Correct.
<beach>
And the compiler is still not much involved in the object system.
<Oladon>
not_a_seagull: Which reminds me... as you begin to discover Lisp, you'll run into library repositories that haven't been updated in 8-10 years. Be not afraid; they're probably just done and don't need updates.
<not_a_seagull>
Oladon: I've seen a couple. I figure that, if anything isn't modern enough, it shouldn't be excruciatingly hard to do a pull request or fork.
<Oladon>
Heh.
<Oladon>
There's very little "aging" in Lisp code the way you're used to.
<not_a_seagull>
How often does lisp code really age?
<Oladon>
Core Lisp? Basically never.
<beach>
not_a_seagull: The Common Lisp Object System is a wonderful example of software design, and a wonderful example of what Common Lisp can do.
<Oladon>
nodnod
<Oladon>
I'm in awe of the CLOS.
<not_a_seagull>
That's cool. I have JS code from six months ago that's already considered aged.
<Oladon>
That's what I mean. :)
<not_a_seagull>
That being said, are there any considerations I should keep in mind when using packages from quicklisp?
<Oladon>
Not really; Xach does an excellent job weeding out anything that doesn't build.
<not_a_seagull>
Nice
<Oladon>
Quicklisp != npm
<beach>
Oladon: Do you mean (/= Quicklisp npm)? :)
<not_a_seagull>
ha3
* Oladon
kowtows in apology
<not_a_seagull>
I mostly say because I've been dabbling in Rust for the past few months, and sometimes there will be a package that has security vulnerabilities
avalos` has joined #lisp
<beach>
Common Lisp code could certainly contain malware, but I think it would be discovered fairly quickly, and then Xach would remove it from Quicklisp.
<not_a_seagull>
Cool beans
<beach>
Standard Common Lisp code can not have security vulnerabilities of the kind you get in low-level languages like C, but it is certainly possible for some library code to alter the code generator of the compiler by using some implementation-specific functionality.
<avalos`>
Why cannot?
<beach>
Well, "can not" is a bit too strong I guess. If you use (safety 0) it is up to the implementation.
<not_a_seagull>
Lisp has a safety check? rad
<beach>
avalos`: Common Lisp code does not have access to arbitrary addresses, and that includes the stack.
xrash has quit [Read error: Connection reset by peer]
<avalos`>
Yeah, but I think that "sandboxing" can be cracked somehow.
<avalos`>
Just like Meltdown and Spectre were not thought to even be possible.
<xristos>
there is no sandbox in CL
<beach>
not_a_seagull: The standard is actually pretty fuzzy about stuff like that. Many situations represent undefined behavior. Luckily, all major implementations are safe when the SAFETY optimize quality is high.
<xristos>
if you evaluate 3rd party Lisp code, it's game over
<avalos`>
xristos: That's why I used "quotes", because not having access to memory can be a way of sandboxing.
<xristos>
and you can have memory corruption in CL, with full safety
<xristos>
if you use foreign functions
<avalos`>
xristos: Exactly!
<beach>
... or if you modify the code generator of the compiler.
<beach>
That is one reason I invented first-class global environments.
<avalos`>
Are standard CL implementations interpreted?
<beach>
avalos`: Not the modern ones, no.
<not_a_seagull>
Doesn't SBCL compile down to machine code?
<beach>
Yes.
<avalos`>
Oh.
<avalos`>
Well, then it depends on how secure is the generated code, I guess.
<beach>
avalos`: There is a tendency to confuse "interactive" and "interpreted".
<not_a_seagull>
Is SBCL like PyPy where it only compiles after the function is run a certain number of times?
<beach>
People with insufficient CS knowledge who see an interactive programming system often assume that it is interpreted.
<avalos`>
beach: It's a bit confusing how "interactive" works without "interpreted", though, at least to me.
<avalos`>
beach: But I'm aware about the differences.
<beach>
avalos`: The code is compiled on the fly and then executed. That's all there is to it.
narimiran has quit [Ping timeout: 246 seconds]
<xristos>
it's not like PyPy (JIT), SBCL does ahead-of-time compilation
<avalos`>
JIT.
<not_a_seagull>
Oh it compiles on the fly? Cool.
<avalos`>
xristos: Oh.
<xristos>
you could have a CL implementation use a JIT compiler (clisp?)
<xristos>
but SBCL (and CCL) are AOT compilers
<beach>
But since a typical Common Lisp implementation, including SBCL, gives the user full access to the code, it is perfectly possible for some user code to modify the code generator, and then the code is obviously no longer safe.
<avalos`>
So, then, yeah, how secure a CL program is can be up to the impl, probably.
<not_a_seagull>
Is SBCL reasonably secure?
<xristos>
.. and -mainly- the program itself
<avalos`>
I don't think it's perfect.
<avalos`>
Nothing is perfect.
<avalos`>
It depends.
<xristos>
SBCL won't save you if you manually manage foreign memory
<xristos>
you can still have race conditions
<xristos>
you can still have all sorts of filesystem and permission issues
<avalos`>
Yeah, that's what I mean.
<xristos>
does it make it easier to avoid certain classes of security issues? yes
<beach>
not_a_seagull: It does a lot of run-time checks, so you get pretty good feedback when you make mistakes. So in that respect it is pretty secure. But, again, if you load arbitrary external code, all bets are off.
<avalos`>
xristos: Yeah, that's for sure.
<not_a_seagull>
I see
<not_a_seagull>
It's like that one google engineer said
<avalos`>
beach: Is it similar to Rust?
<not_a_seagull>
"The minute you load an attacker's code, it's over"
<beach>
avalos`: I don't see any similarities between Common Lisp and Rust.
<avalos`>
I mean, the run-time checks.
akoana has quit [Quit: leaving]
<not_a_seagull>
Doesn't Rust do compile-time checks?
<avalos`>
Yes.
<avalos`>
A lot.
<avalos`>
I've tried Rust only few times, but the compiler is indeed strict.
<beach>
avalos`: The semantics of Common Lisp include dynamic typing, so there is a limit to how much can be verified at compile time.
<avalos`>
That's a trade off for flexibility, but still, I imagine it has tools to avoid some sort of mistakes.
<avalos`>
I know little about CL, I haven't even used it, but I've learned a lot of Scheme, which shares a lot of concepts with CL.
<beach>
Again, I don't see many similarities between Common Lisp and Rust. In fact, Rust seems to be based on the false idea that garbage collection must be slower than manual memory management. At last according to an important member of the group that manages the Rust specification.
<avalos`>
beach: Well, it can be. It depends.
<avalos`>
Sometimes, manual memory management can give you a lot of performance.
not_a_seagull has quit [Quit: WeeChat 1.9.1]
<avalos`>
Garbage collection works for most stuff, but still, there are cases where you want more control over memory and extra efficiency.
<avalos`>
The Linux kernel was never really rewritten in C++, because of those reasons.
<avalos`>
Well, C++ is not garbage collected (afaik), but still, it does a lot of things behind the curtains.
<beach>
And Lisp, on the other hand, was based on what Paul Wilson later characterized as "liveness is a global property", so that it is essentially impossible to write a correct program with manual memory management, that is both modular and fast. Now, granted, you don't always need modularity and you don't always need performance.
<avalos`>
Interesting.
<avalos`>
But still, I think it depends on what you mean by "manual".
<avalos`>
And what you mean by "modularity" and "performance".
<beach>
To make modularity possible, people using languages with manual memory management often introduce things like smart pointers or reference counters. And then they take a factor 50 or more performance hit compared to garbage collection.
<beach>
avalos`: I mean if you pass an object to a module, modularity dictates that you shouldn't need to know whether that module keeps a reference to your object, so that it is still alive, or whether it does not, so you need to deallocate the space taken up by it.
<avalos`>
Good point.
<beach>
So you have two choices...
<beach>
1. Know what the module does internally, so your code is no longer modular.
<beach>
2. Copy the object, or use reference counters. Then your code is no longer fast.
OpenZen has quit [Ping timeout: 240 seconds]
<avalos`>
What if you don't need too many checks? Garbage collection can be a bit too much, especially when you perform expensive IO operation or else.
<beach>
That is a case when modularity is not so much needed.
<avalos`>
True.
<beach>
But people using languages without automatic memory management often believe that their code is fast, just because the compiler is "known to produce fast code". But then they ruin the performance by replacing a register move by a function call, a test, and several memory accesses.
<beach>
However, since they never compare the performance of their code to a similar code written in a language with automatic memory management, they feel safe in their belief that their code is fast.
<xristos>
note that you have the option for manual memory management (with some constraints) in CL
<beach>
So we have huge amounts of code written by hordes of programmers who think that "we need all the speed we can get", but that code is not particularly fast in the first place. Plus, they took an order of magnitude more time to produce that code, and the result is full of security vulnerabilities. That's the sad state of software production these days.
orivej has joined #lisp
Jeanne-Kamikaze has quit [Ping timeout: 256 seconds]
<markasoftware>
I'm today learning about format's conditionals and loops, it's pretty crazy
<markasoftware>
i wish the same people who designed (format) got to design regex
_whitelogger has joined #lisp
bsd4me has joined #lisp
gravicappa has joined #lisp
anatrope has joined #lisp
kleptoflora has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 264 seconds]
Oladon has quit [Quit: Leaving.]
gravicappa has quit [Ping timeout: 256 seconds]
gigetoo has quit [Ping timeout: 258 seconds]
karlosz has joined #lisp
gigetoo has joined #lisp
vutral has quit [Quit: Connection closed for inactivity]
gravicappa has joined #lisp
bocaneri has joined #lisp
ggole has joined #lisp
_whitelogger has joined #lisp
kmeow has quit [Remote host closed the connection]
kmeow has joined #lisp
bsd4me has quit [Quit: Leaving]
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 258 seconds]
_whitelogger has joined #lisp
rabbit_05 has joined #lisp
heisig has joined #lisp
Oladon has joined #lisp
technobean has joined #lisp
space_otter has joined #lisp
brown121407 has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
younder has quit [Quit: Leaving]
MichaelRaskin has joined #lisp
ahungry has quit [Remote host closed the connection]
zooey has quit [Remote host closed the connection]
<phoe>
vseloved's Programming Algorithms book will also get an Apress edition
<phoe>
hey beach
<beach>
Nice! That one still needs a lot of work.
<beach>
I gave up after a while.
h11 has quit [Ping timeout: 265 seconds]
h11 has joined #lisp
glamas has joined #lisp
narimiran has joined #lisp
brown121407 has quit [Remote host closed the connection]
<phoe>
you might want to contact vseloved in order to be a technical reviewer for it
<phoe>
I know too little about algorithms to be able to make any sane reviews
avalos` has quit [Remote host closed the connection]
terpri_ has joined #lisp
terpri has quit [Ping timeout: 260 seconds]
<beach>
I don't think I will. Too many times he disagreed with my remarks and didn't take them into account. Plus, a lot of the problem are still related to the English language.
<beach>
The algorithms themselves are probably fine.
<beach>
He's the expert after all.
<phoe>
I see
<contrapunctus>
beach, xristos: re: this performance paradox, is there any writeup which explores this phenomenon in detail?
<beach>
But the code and the text both need a lot of work to be acceptable, and he basically doesn't agree.
glamas has quit [Ping timeout: 264 seconds]
<beach>
contrapunctus: I don't think so, no.
h11 has quit [Ping timeout: 256 seconds]
<beach>
contrapunctus: There is very little work done in the domain of comparison between programming languages. And for good reasons. The cost of such an investigation would be huge, if it is to be scientifically valid.
<contrapunctus>
It'd be nice to have something of the sort, to make an attempt to educate people. Many may not know about the manual memory management in CL, either, which would be a welcome addition to such a writeup.
<beach>
People just won't believe you unless you can point to hard evidence, and maybe not even then. The manual memory management in Common Lisp would be highly specific to an implementation.
<contrapunctus>
The other day someone (who had written some CL packages and programs) mentioned not having used CL for ages, and using C++ instead, because they weren't satisfied with the performance in the case of games.
<beach>
I mean, every C++ programmer who were to read the paper by Hudak and Jones, would instantly convert to Haskell if they believed it.
<contrapunctus>
(Which makes me wonder if they knew what you speak of.)
pve has joined #lisp
<beach>
Performance is not so much a language issue as it is an implementation issue. But there is also the problem that most people do not understand that code that looks similar in two different languages have different semantics.
paulbarrett has quit [Quit: paulbarrett]
glamas has joined #lisp
<beach>
So if you translate (say) addition from C++ to Common Lisp, and you don't realize that C++ implements modulo arithmetic and Common Lisp has bignums, then you may very well get it wrong.
<beach>
In other words, if you compare a safe and slow program to an unsafe and fast one in a different language, you are comparing apples and oranges.
<beach>
And, again, if you don't care about modularity, you might get faster code with manual memory management. My impression is that game development falls into that category.
<beach>
Another factor is that most existing Common Lisp implementations were implemented several decades ago, and are probably still not using techniques for memory management that were invented since then. So, if you take a Common Lisp implementation with a stop-the-world garbage collector you are not going to see good real-time performance for example.
aaaaaa has joined #lisp
<contrapunctus>
Yow.
shka_ has joined #lisp
Oladon has quit [Quit: Leaving.]
notzmv has quit [Ping timeout: 264 seconds]
fanta1 has joined #lisp
space_otter has quit [Remote host closed the connection]
space_otter has joined #lisp
<jackdaniel>
programming tao 15: performance is not a trait of the language but the implementation.. but don't expect python to be fast
iissaacc has joined #lisp
<iissaacc>
sup my gs
<beach>
?
<iissaacc>
its a greeting my g
<beach>
May I suggest you do M-x set-global-abbrev<RET>gs<RET>whatever gs means<RET>
orivej has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
space_otter has quit [Remote host closed the connection]
orivej has joined #lisp
space_otter has joined #lisp
space_otter has quit [Remote host closed the connection]
edgar-rft has joined #lisp
space_otter has joined #lisp
rabbit_05 has quit [Ping timeout: 256 seconds]
brown121407 has joined #lisp
<eta>
beach, :D
<eta>
beach, have you considered writing some elisp to query Urban Dictionary
<beach>
After considering for a few seconds, I decided against it.
<flip214>
phoe: jackdaniel: sure, just make a MR. Although "collect" as a name might conflict with LOOP and ITERATE, so is there an alternative?
<beach>
Using silly abbreviations like that shows one or more of several things: 1. Your typing skills are not that great. 2. You don't master your tools, in particular not your abbrev processor. 3. You assume that everybody has read up on the urban dictionary.
<phoe>
flip214: it won't really conflict with LOOP
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
<flip214>
I guess that's a list with an end pointer for efficient appending... is there something to clear the list in-between, or to append multiple values at once? (like Perl's PUSH ARRAY, ELEMENTS...)
<jackdaniel>
flip214: collect macro (as defined in cmucl) allows supplying your own collectors
<jackdaniel>
so in principle it is possible to manipulate any object
<beach>
I hate it that SLIME ruins my Emacs tags-search command by hijacking M-.
<jackdaniel>
and adding multiple elements is supported if the collector operator supports multiple arguments (in case of default list collector it does)
<flip214>
well, yeah, I needed something like that in the past, so I definitely can see the use case
<jackdaniel>
one drawback, as note by lukego, is that the collector binding is not a function - it is a macro
<jackdaniel>
s/note/noted/
space_otter has quit [Remote host closed the connection]
<lukego>
beach: Emacs should really have some framework for combining multiple tags-like things. I wonder if it does these days? I'm still getting my head around all the new stuff like company/ivy/helm (can't even remember which is which yet...)
<beach>
Sure, that would be good.
<jackdaniel>
flip214: another useful utility from cmu utilities is with-clean-symbols
space_otter has joined #lisp
<jackdaniel>
which is kind-of like gensym, but instead of creating variable with a gensymed symbol, it replaces all occurances of the symbol in the body with a gensym
<jackdaniel>
i.e (with-clean-symbols (foo) (test (defclass foo () ()) (make-instance 'foo)))) ;-> each execution of this block will define a class of a different name
<lukego>
beach: I wonder if abbrevs would be a good solution for typing a lambda character. I've been a nerd and defined unicode lambda as a macro for LAMBDA but haven't solved the easy inputting problem yet.
<beach>
That would certainly work.
<beach>
I use it for correcting some recurring typos I make. Like my fingers seem unable to type "the". They always come up with "teh" instead. So I use abbrevs to correct.
orivej has quit [Read error: Connection reset by peer]
orivej has joined #lisp
<flip214>
jackdaniel: well, bring' it on!
* jackdaniel
looks carefully in his pocket for some spare time -- empty :)
<jackdaniel>
because it would be absurd if I had some antimatter in my pocket, right?
<beach>
It wouldn't be around for very long.
<jackdaniel>
heh
<phoe>
neither would his pocket
orivej has quit [Quit: No Ping reply in 180 seconds.]
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
orivej has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
<beach>
Yeah.
brown121407 has joined #lisp
space_otter has quit [Remote host closed the connection]
<jackdaniel>
one way to continue this joke would be rehashing the phrase, that there is no /spare time/, so /not very long/ would be a meaningless term ,)
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
kmeow has quit [Ping timeout: 260 seconds]
space_otter has joined #lisp
bhartrihari has joined #lisp
<flip214>
jackdaniel: next time you're waiting for the dentist you might find too much "spare time" on your hands, so be sure to save it somewhere safe!
kelamir[m] has quit [Quit: authenticating]
kelamir[m] has joined #lisp
<jackdaniel>
is it some kind of elaborate way of saying, that you'd rather had my packet exploded? ;p
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
random-nick has joined #lisp
boeg has quit [Quit: Connection closed for inactivity]
space_otter has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
markoong has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
kaftejiman has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
brown121407 has quit [Remote host closed the connection]
dddddd has quit [Ping timeout: 240 seconds]
cranes has quit [Remote host closed the connection]
<lukego>
why didn't ITERATE win over LOOP?
<shka_>
lukego: loop is standard, iterate is not
<shka_>
also, iterate uses code walking that produces some ugly problems sometimes
<shka_>
for instance
<lukego>
I'm noticing serapeum for the first time now too, looks like a worthy addition to the toolbox
<shka_>
(iterate (for elt in list) (sum (count 0 elt)))
<shka_>
and honestly, extending iteratate is not that good
<shka_>
i like iterate personally, but i must admit that it has problems
<shka_>
serapeum is cool
<flip214>
shka_: I think the dwim.hu version doesn't code walk
toorevitimirp has joined #lisp
<shka_>
i don't know this version
<shka_>
oh, and there is this code moving in iterate that can bite your ass
<shka_>
and let me reiterate: I LIKE ITERATE despite those issues
<shka_>
;-)
<flip214>
yeah, I use it too
<shka_>
^5
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
<flip214>
I just wished that CL-WHO would include ITERATE support by default
heisig has quit [Quit: Leaving]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 258 seconds]
Lord_of_Life_ is now known as Lord_of_Life
RedMallet has joined #lisp
bhartrihari has left #lisp ["Disconnected: Broken pipe"]
<nirved>
(iterate (for elt in list) (sum (cl:count 0 elt)))
<nirved>
maybe a version of iterate with only keywords accepted would be better: (iterate (:for elt :in list) (:sum (count 0 elt)))
orivej has quit [Ping timeout: 265 seconds]
bhartrihari has joined #lisp
<contrapunctus>
Would it help people if Serapeum was listed in awesome-cl?
jonathanschlink has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
flip214 has quit [Ping timeout: 246 seconds]
flip214 has joined #lisp
<lukego>
contrapunctus: it is, that's where I discovered it just now
lerax has joined #lisp
<contrapunctus>
Oh, odd, okay.
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
<pve>
Hi, do you guys know if it is possible to tell Slime to use a different indentation function inside, say, square brackets [ ... ]?
Retropikzel_ has joined #lisp
Retropikzel has quit [Ping timeout: 260 seconds]
ralt has joined #lisp
<lukego>
defclass-std looks nice. I have a hard time with the verbosity of defclass forms. seems like an easy fix.
<beach>
All attempts I have seen to "simplify" DEFCLASS are wrong it at least one way.
<beach>
Some use the same slot names as accessor names.
<beach>
Some always define an accessor for every slot.
<beach>
Some have only one possible accessor for each slot.
<beach>
Some don't allow you to omit the initform.
<beach>
Some don't allow :DEFAULT-INITARGS.
<shka_>
is defclass even worth simplifying?
<lukego>
Maybe the best is the enemy of the good though? defclass can do everything, but I never use it because it's so verbose, and I just stick with defstruct.
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
<beach>
And people who claim that their needs correspond exactly to what one such simplification provides usually need to rethink their ideas about protocol design.
gaqwas has quit [Remote host closed the connection]
<pve>
lukego: I have an elisp skeleton function that queries me for the class name and its slots, and then inserts a defclass form with all the goodies. Just as an alternative solution..
<shka_>
honestly, defclass is not even all that verbose
<beach>
It is not verbose because each piece of information it requires is orthogonal to each other piece.
<shka_>
it is "precise"
anatrope has quit [Remote host closed the connection]
<shka_>
anyway, i am working on readme for my data frame system. Grammar is horrible (i will correct it after i have all of the content) but i wonder what you think about the overall approach https://github.com/sirherrbatka/vellum
philadendrite has joined #lisp
aaaaaa has quit [Quit: leaving]
<lukego>
I suppose it's a mindset thing. Most of the time when I'm tempted to use DEFCLASS I'm defining a data structure and not designing a protocol. Maybe I should just stick with defstruct.
<beach>
DEFSTRUCT has its own problems. It is undefined behavior to redefine an existing structure type.
lerax has quit [Remote host closed the connection]
<shka_>
well, what helped me is to define your generic functions before even starting to think about specific classes
<beach>
Totally true.
<lukego>
shka_: It'd help to have a bit more about the motivation and intended applications for the data frame. Motivation - why use it instead of simple lists and vectors? Intended applications - how much is this likely to grow and in what direction? also related work, good to mention pandas but does it also relate to e.g. R packages like dplyr or data.table?
<shka_>
after i have defined functions, classes come more naturally
<shka_>
lukego: all good points, thank you
gigetoo has quit [Ping timeout: 264 seconds]
notzmv has joined #lisp
<lukego>
(also how does it relate to existing lisp data frame packages of which I think there are a few)
gigetoo has joined #lisp
<beach>
lukego: Even classes used to implement a data type often have variations as to whether you want an initform, a slot reader only, a slot accessor with the same name as the reader, a different slot-writer altogether, some :default-initargs, etc.
<shka_>
unfortunately dplyr clone in CL is one of very few things that are not quite feasible to implement
<pve>
but is it really so bad to simplify defclass to suit one's own requirements, as long as it's kept private?
<lukego>
I have a love/hate relationship with dplyr. I love the finished code but I hate debugging all that fexpr bullshit.
<shka_>
pve: it is very little gained for introducing extra syntax sugar
<shka_>
even after disregarding what beach said
<shka_>
lukego: yeah, i feel you
<jackdaniel>
a simplified approach with calsses as a "bags with slots + accessors" probably suits a lot of use cases, and it is possible to redefine the standard class (unlike the structure class), so I think that there is place for that in some projects
polaris has joined #lisp
<shka_>
lukego: check out transform function, that's how i wanted to get close to dplyr style of code
<shka_>
and also annoys every singe person trying to read your code
ayuce has joined #lisp
whiteline has quit [Read error: Connection reset by peer]
whiteline has joined #lisp
<lukego>
shka_: hard to form an opinion on the data frame api. I'm not yet writing that code of code in Lisp. I have a bit of a preference for concrete rather than abstract representations personally so I'd probably want to ride a simple ((COLUMN-NAME . DATA-VECTOR) ...) list for a while before getting into something more serious.
<lukego>
didn't Tony Rossini have a data frame library for Lisp? I think I saw one recently but not sure
ayuce has quit [Remote host closed the connection]
Retropikzel_ has quit [Quit: Konversation terminated!]
Retropikzel_ has joined #lisp
<shka_>
lukego: i have seen two other data frame libs up to this point
<shka_>
one was using list of lists (which is nope for me because of memory) and the other one is teddy
ayuce has joined #lisp
<shka_>
teddy started after i started vellum and honestly it tries to be pandas
<shka_>
which is not a good thing to be in CL
<shka_>
also, i seriously need sparse data frames
<shka_>
memory requirements dictate a lot of design choices in vellum actually
luna_is_here has quit [Ping timeout: 258 seconds]
<shka_>
i think that adding "why i wrote vellum" to readme is a good idea
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<lukego>
shka_: I'll come back to this eventually. I've started reading _Rethinking Statistics_ with the intention to do the exercises in CL instead of R. Just now transforming data frames isn't something I need because I don't have code that consumes the new data frames e.g. relevant statistical methods
<shka_>
ok
<shka_>
check readme in the future, i will add info about aggregation functions from cl-ds
<lukego>
Going back into caveman mode, maybe another compromise would be a list of ((COLUMN-NAME . VECTOR-OBJECT) ...) where VECTOR-OBJECT is not literally a vector but something that obeys a vectorey protocol e.g. could be a sparse table or just a plain vector underneath
<lukego>
but that's just thinking aloud about how I'd probably take my first baby steps in growing a data table structure one step at a time
<shka_>
well, you could design data frames with interface passing style
<lukego>
interface passing style?
<shka_>
that's what jackdaniel did actually
<shka_>
yeah
<lukego>
I'm not familiar with the term
* jackdaniel
neither
<shka_>
ok, let me explain
<jackdaniel>
but I'm glad I did that, sounds cool
<jackdaniel>
(like continuations)
<shka_>
yaeh, it is this LIL thing
<shka_>
you know what
<jackdaniel>
afaik I've just defined protocols which each object must implement if it is about to be treated as a data frame
<shka_>
anyway, the gist of it is to separate interface from the data type
<shka_>
so the end result is that all functions in the protocol accept both interface object and data object
<shka_>
and data type is de-encapsulated
gravicappa has joined #lisp
<Josh_2>
afternoon all
<Josh_2>
generally programming question, whats the goto way to solve a problem where you have many inputs and various combinations of these inputs map to different results
<Josh_2>
think like a polcompass test as an example
<shka_>
Josh_2: i would use generic function :-)
<shka_>
but this can be an overkill depending on the use case
<Josh_2>
hows that gonna work, say you have 100 buttons, 10 of these map to 1 answer, a generic function doesn't seem very specific xD
<shka_>
well, i don't get it
<shka_>
sorry
<Josh_2>
don't worry :P
gaqwas has quit [Remote host closed the connection]
brown121407 has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
toorevitimirp has quit [Ping timeout: 240 seconds]
toorevitimirp has joined #lisp
lucasb has joined #lisp
iissaacc has quit [Ping timeout: 260 seconds]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
entel has quit [Quit: Connection closed for inactivity]
<lukego>
Coming from R I don't immediately understand the appeal of having elaborate protocols for data frame column implementations. Just make them immutable vectors of double-floats and get on with the real work ;-)
contrapunctus has joined #lisp
vornth has joined #lisp
<jackdaniel>
lukego: does R copy whole dataframe when you select its slice?
<lukego>
I think so but I haven't really looked under the hood. Can you can reference columns separately as their own objects.
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<lukego>
I'm really intrigued by this idea that 99% of statistics is just historical baggage and keen to try and learn "new school" approaches. seems like this computer-heavy Bayesian approach of statistical rethinking gets rave reviews. curious also about the specialized probablistic programming language like Stan but haven't dug deep yet
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
Bike has joined #lisp
EvW has joined #lisp
iissaacc has joined #lisp
kmeow has joined #lisp
iissaacc has quit [Ping timeout: 246 seconds]
bsd4me has joined #lisp
TwoNotes has joined #lisp
<TwoNotes>
What is the syntax to (declare) a function parameter to be a vector of single-float?
<shka_>
lukego: well, if you think about it protocol is nothing more then set of operations
<shka_>
and one can argue that vector is not just piece of memory, but set of operations as well
<shka_>
and because without those operations, you cant access the memory you can stretch to say that vector is a protocol
<shka_>
regardless, i got sick of dealing with just pure vectors, that's why vellum exists
jw4 has quit [Read error: Connection reset by peer]
jw4 has joined #lisp
<TwoNotes>
This is a buffer of data returned from a CFFI so I have no choice about that
<TwoNotes>
audio samples
<beach>
What made you say that?
<beach>
TwoNotes: I think shka_ was talking to lukego.
<TwoNotes>
oh
brown121407 has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
<shka_>
correct
bitmapper has joined #lisp
<Demosthenex>
so in slime, i have a multiline lisp fragment i pulled from history. how do i "abort" and clear that quickly instead of having to remove the text back to the repl prompt? in a shell i'd just hit control-c to start a fresh prompt :P
TwoNotes has quit [Quit: Leaving]
markoong has quit [Ping timeout: 240 seconds]
markong has joined #lisp
<contrapunctus>
Demosthenex: kill-sexp, with a negative argument if it's behind point.
<Demosthenex>
that's the thing, being at EOL of a multiline code fragment. i could do M-a and C-k. C-c C-c unfortunatley tries to interrupt the interpreter. i just wanted to clear the line and get a new prompt
<nirved>
Demosthenex: this will help you search for it: C-h b C-x o C-s kill
<contrapunctus>
If you use Boon, `dj` or `d;`; Evil probably has something similar. Bind it to something short and it's no problem...unless...oh, getting to the start/end of a sexp could be an extra step.
<Josh_2>
phoe: I fixed it.. it was all those unwind protects xD
<Josh_2>
nice, now It's all working :D
orivej_ has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
random-nick has quit [Read error: Connection timed out]
random-nick has joined #lisp
iissaacc has joined #lisp
<paule32>
assume, i have WA1, and WB1 - W stands for wire A, and B for the port end, and the 1 should be the wire 1, so WA2,WB2 stands for wire 2
<paule32>
how can i get the these elements by a loop from the *grid* ?
<paule32>
either horizontal, and/or vertical
<paule32>
not diagonal
<phoe>
what do you mean, get?
<phoe>
(loop for i from 0 below 20 do (print (aref *grid* i 2))) is going to print everything from column 2
<paule32>
get the list item
<phoe>
there's no list there
<phoe>
this is a 2D array, not a list
<paule32>
'(1 0)
<paule32>
as item from the 2d array
Retropikzel_ has quit [Quit: Konversation terminated!]
<phoe>
oh, you want to retrieve it?
<phoe>
use AREF with the proper indices
Retropikzel_ has joined #lisp
Retropikzel_ has quit [Client Quit]
Retropikzel_ has joined #lisp
Retropikzel_ has quit [Client Quit]
iissaacc has quit [Ping timeout: 240 seconds]
Retropikzel_ has joined #lisp
toorevitimirp has quit [Ping timeout: 256 seconds]
toorevitimirp has joined #lisp
kmeow has quit [Remote host closed the connection]
<paule32>
so, last but not least, how can i check the item at the given row, if it contains WA1 or WB1 ?
toorevitimirp has quit [Remote host closed the connection]
<phoe>
use AREF with the proper indices, then check the datum that you got
<paule32>
ok, thx
<paule32>
pizza time ...
orivej has joined #lisp
<lukego>
Hey random Q but has anyone ever done a hack to support propertized text (a la Emacs) in Lisp/SBCL? i.e. strings having essentially a property list of (START-INDEX END-INDEX KEY VALUE) properties e.g. containing formatting information or other metadata
orivej_ has quit [Ping timeout: 258 seconds]
cosimone has joined #lisp
Guest9274 has quit [Ping timeout: 264 seconds]
cosimone has quit [Client Quit]
cosimone has joined #lisp
bmansurov has joined #lisp
bmansurov is now known as Guest90000
* lukego
is spending a very pleasant afternoon reading serapeum function reference... lots of unfamiliar idioms here
<tychoish>
lukego: I'm not even familar with this in emacs :)
<loke>
lukego: You cannot add this to the STRING type.
<loke>
You'd have to implement it as a separate class, and if you use the SBCL extension functions to extend SEQUENCE, you can get pretty close.
<loke>
But the only reason you'd want to do this is if you're implementing an Emacs in CL.
<pve>
could the string properties be stored in a weak hash table?
<loke>
pve: The problem is that every existing function that deals with strings would ignore it. So if you do, say, (FORMAT NIL "~a" propertiszed-string) you'd lose the properties.
<pve>
right
<lukego>
loke: the use case I had in mind is writing Lisp code that produces strings with extra information for Emacs e.g. references to objects that hte SLIME inspector can chase
<loke>
So if you want to use this design in a CL-based editor, you'd have to work with "special strings" or something like that, and the editor's functions coudl be made to accept either type.
<loke>
It wouldn't be too bad.
Retropikzel_ has quit [Quit: Konversation terminated!]
notzmv has quit [Ping timeout: 240 seconds]
whiteline has quit [Read error: Connection reset by peer]
kaun_ has joined #lisp
Retropikzel has joined #lisp
notzmv has joined #lisp
bhartrihari has joined #lisp
gaqwas has quit [Remote host closed the connection]
whiteline has joined #lisp
dominic34 has joined #lisp
<lukego>
loke: I'd like for that FORMAT to preserve properties. Emacs Lisp works like this, all the normal string manipulation functions copy properties as if they are attached to the characters themselves. If you don't want the properties you need to strip them manually.
<lukego>
Maybe it's better to think of it that way i.e. property lists on characters rather than property ranges on strings. I wonder if that could be done in SBCL.
v88m has joined #lisp
srji has joined #lisp
<kaun_>
lukego? of distel fame?
jibanes has quit [Ping timeout: 264 seconds]
whiteline has quit [Remote host closed the connection]
whiteline has joined #lisp
kaun_ has left #lisp ["chalo"]
kaun_ has joined #lisp
jibanes has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
luna_is_here has joined #lisp
jonatack has quit [Quit: jonatack]
<Josh_2>
Is there a library to discover my machines IP address? saves the user having to enter in manually in my program, although I could make a nice McCLim interface for this program
<phoe>
Josh_2: which one? there can be plentyu
<Josh_2>
Yes exactly
jonatack has joined #lisp
<Josh_2>
just listing IP's for each interface would do
<Josh_2>
Then the user can select when they start my program
orivej has quit [Read error: Connection reset by peer]
<Josh_2>
with cross platform compatibility, pretty awesome
kaun_ has left #lisp ["chalo"]
OpenZen has joined #lisp
Jeanne-Kamikaze has joined #lisp
dominic34 has quit [Ping timeout: 240 seconds]
<Josh_2>
thanks phoe works just great
<phoe>
<3
Oladon has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
<Josh_2>
I think I will attempt to make a mcclim interface for this app
orivej has joined #lisp
dominic34 has joined #lisp
seok has joined #lisp
karlosz has joined #lisp
<seok>
which autocomplete does portacle ship with?
<seok>
I want to force C-x C-f to create a file, it opens a file with similar name
bsd4me has quit [Remote host closed the connection]
<loke>
seok: I don't know which one that is, but it's horrible. Yes.
roze has quit [Quit: Leaving]
polaris has quit [Quit: WeeChat 2.8]
orivej_ has joined #lisp
orivej has quit [Read error: Connection reset by peer]
<ggole>
If that's ido, C-f falls back to the non-completing version iirc
scymtym has quit [Ping timeout: 264 seconds]
jibanes has quit [Ping timeout: 240 seconds]
jibanes has joined #lisp
ralt has quit [Quit: Connection closed for inactivity]
<seok>
ggole: this works! tyvm
ralt has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
kaftejiman has quit [Remote host closed the connection]
<paule32>
hello
<paule32>
how can i concate 2 items ?
<paule32>
(defvar wa 0)
<paule32>
(setf (aref *grid* 5 4) '(wa1 0))
<paule32>
(concatenate 'list wa 1)
<paule32>
don't work
<phoe>
paule32: (setf wa (append wa '(1)))
<phoe>
or (nconc wa (lis 1))
<paule32>
thx
iissaacc has joined #lisp
lerax has joined #lisp
iissaacc has quit [Ping timeout: 240 seconds]
EvW1 has quit [Ping timeout: 260 seconds]
orivej_ has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
<seok>
Is there a way to persist connection with postmodern?
<seok>
Ah there are connection pools
<seok>
nvm
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
specbot has quit [Ping timeout: 240 seconds]
minion has quit [Ping timeout: 240 seconds]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
orivej has joined #lisp
minion has joined #lisp
markoong has joined #lisp
markong has quit [Ping timeout: 256 seconds]
specbot has joined #lisp
dominic34 has quit [Ping timeout: 246 seconds]
cosimone has quit [Remote host closed the connection]
<Oladon>
Anyone around with experience in parser combinators? I'm trying to do two things with bbcode-tag (L90): 1) make it work, and 2) make it recursive. https://pastebin.com/an96mFSK White_Flame: I'm sure you'd have some thoughts, if you're around
<Oladon>
I'm pretty new to the concept of parser combinators, so I suspect I'm missing something fairly obvious.
karlosz has quit [Quit: karlosz]
ckonstanski has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
lnostdal has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
narimiran has quit [Ping timeout: 240 seconds]
bhartrihari has joined #lisp
<Demosthenex>
hrm. the common lisp cookbook completely breaks keyboard scrolling. i have to touch the rodent.
<Demosthenex>
how odd
luna_is_here_ has joined #lisp
paule32 has quit [Quit: Leaving]
luna_is_here has quit [Quit: luna_is_here]
tristero has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
whiteline has quit [Ping timeout: 240 seconds]
terpri__ has joined #lisp
terpri_ has quit [Ping timeout: 260 seconds]
dvdmuckle has quit [Quit: Bouncer Surgery]
dvdmuckle has joined #lisp
<lukego>
SBCL seems to represent characters as 32-bit and with three spare bits to play with...
stepnem has quit [Ping timeout: 240 seconds]
<lukego>
are there any "invisible" characters that can be present in strings but will be skipped in visible formatted output (rendered as if not there) and won't be counted e.g. towards pretty-printer column number? Thinking about sneaking "escape" characters into strings discretely
zigpaw has quit [Ping timeout: 240 seconds]
johntalent has joined #lisp
<p_l>
lukego: combining characters, especially various zero-width whitespace, though it depends what shows the output
zigpaw has joined #lisp
<p_l>
And SBCL characters are iirc 21 bit, exactly as specified in Unicode
<lukego>
right, but it says in memory they are 32-bits of space of which 29 are used (eight for sbcl type tag and 21 for unicode character code)
<p_l>
Ahh, this way, yes
<p_l>
(I didn't know about the tag bits used)
<lukego>
but three bits isn't much if you still want to have a character in the low bits. So sounds more promising to look for alternatives
karlosz has joined #lisp
<lukego>
I'll look at these "combining characters", thanks for the keyword
<lukego>
just an idle thought at the moment but it would be neat to have a little "CLIM lite" in Emacs with presentations inlined into ordinary formatted output
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
elosant has joined #lisp
FreeBirdLjj has joined #lisp
<lukego>
hey serapeum already has a powerset function :)
stepnem has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
elosant has quit [Quit: WeeChat 2.8]
dominic34 has joined #lisp
<edgar-rft>
powerset sounds like teleshopping :-)
gravicappa has quit [Ping timeout: 256 seconds]
iissaacc has joined #lisp
grewal has joined #lisp
gravicappa has joined #lisp
iissaacc has quit [Ping timeout: 260 seconds]
whiteline has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
orivej_ has joined #lisp
dominic34 has quit [Ping timeout: 256 seconds]
<shka_>
lukego: yup, serapeum is a nice lib
<shka_>
i use it a lot
bhartrihari has joined #lisp
kaftejiman has joined #lisp
<shka_>
i like how it pulls stuff from other programing languages
mankaev has quit []
<shka_>
clojures take/drop/threading macros, APL like scan
mankaev has joined #lisp
fanta1 has quit [Quit: fanta1]
johnjay has quit [Ping timeout: 246 seconds]
orivej_ has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
rixard has joined #lisp
Jesin has joined #lisp
ralt has quit [Quit: Connection closed for inactivity]