lemonpepper24 has quit [Ping timeout: 246 seconds]
lemonpepper24 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
grumble has quit [Read error: Connection reset by peer]
gurmble has joined #lisp
gurmble is now known as grumble
Kundry_Wag has joined #lisp
grumble has quit [Quit: Freenode looks forward to seeing you at the freenode #live conference, in Bristol on November 3rd and 4th. Check it out at https://freenode.live or join #live or read the /motd for more info!]
grumble has joined #lisp
sjl has joined #lisp
quazimodo has quit [Ping timeout: 260 seconds]
southy has joined #lisp
quazimodo has joined #lisp
southy has quit [Ping timeout: 260 seconds]
equwal has joined #lisp
nullniverse has joined #lisp
dddddd has quit [Ping timeout: 252 seconds]
equwal has quit [Ping timeout: 244 seconds]
equwal has joined #lisp
equwal has quit [Remote host closed the connection]
Oladon has joined #lisp
equwal has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
Achylles has quit [Ping timeout: 260 seconds]
Balooga_ has joined #lisp
slyrus has quit [Quit: slyrus]
slyrus has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
UNCLE_PROTON has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: No route to host]
Kundry_Wag has joined #lisp
lavaflow_ has quit [Read error: Connection reset by peer]
Roy_Fokker has quit [Read error: Connection reset by peer]
equwal has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 272 seconds]
iomonad has quit [Ping timeout: 240 seconds]
equwal has joined #lisp
lavaflow_ has joined #lisp
esrse has joined #lisp
Balooga_ has quit [Quit: Balooga_]
equwal has quit [Ping timeout: 245 seconds]
UNCLE_PROTON has quit [Quit: leaving]
shifty has joined #lisp
Kundry_Wag has joined #lisp
dale has joined #lisp
atgreen has joined #lisp
iomonad has joined #lisp
meepdeew has quit [Remote host closed the connection]
Pixel_Outlaw has joined #lisp
nullniverse has quit [Quit: Undertaking stack overflow prevention]
lagagain has quit [Quit: Connection closed for inactivity]
Kundry_Wag has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
graphene has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
jealousmonk has joined #lisp
meepdeew has joined #lisp
nanoz has joined #lisp
meepdeew has quit [Ping timeout: 252 seconds]
pierpal has joined #lisp
nanoz has quit [Ping timeout: 245 seconds]
astronavt has quit [Ping timeout: 260 seconds]
<LdBeth>
hola
<no-defun-allowed>
hey LdBeth
Kundry_Wag has joined #lisp
anewuser has quit [Read error: Connection reset by peer]
jack_rabbit has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
Balooga_ has joined #lisp
Kundry_Wag has joined #lisp
prometheus_falli has quit [Remote host closed the connection]
prometheus_falli has joined #lisp
dented42 has joined #lisp
dale has quit [Quit: dale]
dented42 has quit [Client Quit]
southy has joined #lisp
southy has quit [Ping timeout: 252 seconds]
rnmhdn has joined #lisp
Balooga_ has quit [Ping timeout: 252 seconds]
<LdBeth>
can I do someth like (defmethod method ((foo (and superclass-1 superclass-2))) ...)
Kundry_Wag has quit [Ping timeout: 240 seconds]
Pixel_Outlaw has quit [Remote host closed the connection]
<LdBeth>
I'm not sure if this is releated to method combination
nanoz has joined #lisp
dented42 has joined #lisp
<LdBeth>
or maybe I could define a new type for it
jealousmonk has quit [Quit: Leaving]
Balooga_ has joined #lisp
ealfonso has joined #lisp
ggole has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
nonlinear is now known as NB0X-Matt-CA
Kundry_Wag has joined #lisp
<Demosthenex>
_death: anything cool? =]
madrik has joined #lisp
<oni-on-ion>
LdBeth: afaik it is possible yes
Oladon has quit [Quit: Leaving.]
Balooga_ has quit [Quit: Balooga_]
<oni-on-ion>
LdBeth: the practical way is to have superclass-1 and superclass-2 come from superclass-0 then dispatch on that, i think.
igemnace has joined #lisp
beach has joined #lisp
<beach>
Good morning everyone!
<flip214>
LdBeth: you could write a SATISFIES predicate
Kundry_Wag has quit [Ping timeout: 244 seconds]
<flip214>
Good morning, beach!
<Demosthenex>
beach: top of the mornin!
eminhi has joined #lisp
<no-defun-allowed>
Morning beacu
<no-defun-allowed>
*beach
Kundry_Wag has joined #lisp
<LdBeth>
ok, got it
Kundry_Wag has quit [Read error: No route to host]
Kundry_Wag has joined #lisp
doubledup has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
jackdaniel has joined #lisp
Kundry_Wag has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
<aeth>
LdBeth: there's always the ugly, messy, hackish solution of writing a macro to generate two methods, one for superclass-1 and one for superclass-2, with the same body.
Kundry_Wag has quit [Ping timeout: 246 seconds]
<aeth>
oh wait, it's and not or, nevermind
sauvin has joined #lisp
<aeth>
You could probably still do it with a macro but it'd be even messier if you could
<aeth>
With a macro-generated approach I'd be thinking of something along the lines of this: You would need to make sure that both methods got called if both were valid, and only call the "real" method if both methods got called. Probably messier than the other two approaches.
nanoz has quit [Ping timeout: 240 seconds]
<aeth>
e.g. NIL as a member of null has two distinct parent classes (list and symbol) and you can go into both in some order via: (defmethod foobar ((foo symbol)) (format t "symbol ~S~%" foo) (when (next-method-p) (call-next-method))) (defmethod foobar ((foo list)) (format t "list ~S~%" foo) (when (next-method-p) (call-next-method)))
southy has joined #lisp
igemnace has quit [Remote host closed the connection]
frodef has joined #lisp
igemnace has joined #lisp
varjag has joined #lisp
Kundry_Wag has joined #lisp
southy has quit [Ping timeout: 272 seconds]
frgo has quit [Remote host closed the connection]
DataLinkDroid3 has quit [Ping timeout: 256 seconds]
pyx has joined #lisp
pyx has quit [Client Quit]
Kundry_Wag has quit [Ping timeout: 240 seconds]
doubledup has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
robotoad has joined #lisp
Balooga_ has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
makomo has joined #lisp
vlatkoB has joined #lisp
varjag has quit [Ping timeout: 240 seconds]
<LdBeth>
aeth: actually I find out that I could aviod it in the particular case I'm dealing
lemonpepper24 has quit [Ping timeout: 246 seconds]
Kundry_Wag has quit [Ping timeout: 245 seconds]
frgo has quit [Ping timeout: 252 seconds]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
moei has quit [Ping timeout: 252 seconds]
makomo has quit [Ping timeout: 252 seconds]
shka_ has quit [Quit: WeeChat 1.9.1]
shka_ has joined #lisp
graphene has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
graphene has joined #lisp
scymtym has quit [Ping timeout: 246 seconds]
frgo has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
shka_ has quit [Quit: WeeChat 1.9.1]
shka_ has joined #lisp
Kundry_Wag has joined #lisp
abbe has quit [Read error: Connection reset by peer]
abbe has joined #lisp
emaczen has quit [Read error: Connection reset by peer]
emaczen has joined #lisp
flamebeard has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
scymtym has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
varjag has joined #lisp
Kundry_Wag has joined #lisp
nowhereman_ has joined #lisp
graphene has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 252 seconds]
graphene has joined #lisp
shrdlu68 has joined #lisp
<shrdlu68>
pjb: It occured to me that O(log n) ought not be 10 times slower than 0(1) when n=240
t0adst00l has joined #lisp
<shrdlu68>
(the binary trees, bit vectors, hash-tables discussion) for context.
prometheus_falli has quit [Ping timeout: 256 seconds]
angavrilov has joined #lisp
Kundry_Wag has joined #lisp
<beach>
shrdlu68: Different algorithms have different overhead, so different constant factors. Having said that, I should point out that lb(256) = 8 so 10 doesn't sound strange at all.
<no-defun-allowed>
yeah O(...) doesn't include constant factors
igemnace has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 245 seconds]
igemnace has joined #lisp
<shrdlu68>
I see.
<no-defun-allowed>
so if using, say, O(n) lists and O(1) vectors, if vectors are 3 times slower (which is unlikely, just for an example), it's really O(n) and O(3)
<beach>
There is no such thing as O(3).
<no-defun-allowed>
O() just refers to the shape of the complexity if you were to plot it IMO
igemnace has quit [Remote host closed the connection]
<no-defun-allowed>
that's true, O() doesn't really use constants
<no-defun-allowed>
to rephrase that, "the relative time taken for each structure would be n and 3" i guess
Kundry_Wag has joined #lisp
<shka_>
shrdlu68: it is worth noting that hashtable have amortized constant time insert
<shka_>
but pesemistic time is linear ;-)
<shka_>
pesemistic search time
Kundry_Wag has quit [Ping timeout: 244 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
lemonpepper24 has joined #lisp
<Demosthenex>
so where do you go for lispy news? reddit's /r/common_lisp? y combinator's hacker news?
Kundry_Wag has quit [Read error: Connection reset by peer]
<shka_>
i am looking for blog post demonstrating petalisp
<adlai>
Demosthenex: no matter where i get my news, i have never encountered the journalist lispy enough to try slipping nestted parentheses by the copyeditor
<shka_>
can someone recommend me anything?
<beach>
shka_: Ask heisig.
<shka_>
hm, asking him to write it does not help :-)
<LdBeth>
beach: Seems I have a excuse for implement #= not very perfect
<beach>
What part do you think might be a bug, and do you think it might be a bug in CCL or something else?
<no-defun-allowed>
i've only done one presentation with beamer and it was a default
<no-defun-allowed>
and the teacher used the google drive pdf viewer which is all blurry and horrible cause she didn't download it either she just zoomed in the browser
<no-defun-allowed>
i only could tell beamer cause a. duh this is #lisp and b. i recognise the font
moei has joined #lisp
Kundry_Wag has joined #lisp
<shka_>
hm, petalisp looks kinda astonishing
<no-defun-allowed>
i have an idea for getting the money to go to els 2020
<no-defun-allowed>
petalisp does look very fancy
<Shinmera>
not 2019?
<no-defun-allowed>
in 2020 i'll be out of high school (probably)
<Shinmera>
2020 isn't even decided yet where it is!
<no-defun-allowed>
2019 is last week of term 1 and i'll be 18 in 2020
<no-defun-allowed>
Shinmera: it wouldn't be the ELS if it wasn't in Europe
<ggole>
Hmm, the petalisp operators remind me of star lisp a little
<beach>
Shinmera: In Europe, I would think.
<Shinmera>
beach: Well, maybe Didier will throw us for a loop!
<beach>
Maybe so.
<no-defun-allowed>
it's at least 12000km from here if it's in europe
Kundry_Wag has quit [Ping timeout: 252 seconds]
<Shinmera>
You haven't heard this from me, but 2020 might be in Zürich.
<no-defun-allowed>
(tldr: watched a security conference, saw neat presentation on wpa cracking with fpga, wondered why no one sells these things to skiddies and or pentesters)
<beach>
Shinmera: That would be fantastic!
<Shinmera>
It would.
emaczen has quit [Read error: Connection reset by peer]
<no-defun-allowed>
i've never been to europe so it'll be fantastic
emaczen has joined #lisp
Kundry_Wag has joined #lisp
<beach>
Shinmera: Would ETH support such a thing, like with free access to a lecture room?
<no-defun-allowed>
now i remember, ETH is in zurich
<no-defun-allowed>
that's the oberon people
<beach>
I think those days are over.
<no-defun-allowed>
:c
<Shinmera>
I'm still looking into that. I'm meeting with some googlers this Friday to see what we want to do. I'll try contacting the ETH secretary based on what we decide there
<no-defun-allowed>
that's a shame, oberon is rather nice
<beach>
Shinmera: Good plan. The Google people in Zürich might help as well.
francogrex has joined #lisp
<Shinmera>
Yes, fe[nl]ix won't be here to help, but I'm meeting with trittweiler and another.
<beach>
Excellent!
<beach>
When I organized it, I got help from the region and the city as well.
<francogrex>
is there a reason why when I load clsql package, SBCL 1.4.2, recompile most of the already compiled file every time!? for example all files in clsql/uffi/ and clsql/db-oracle/ compiling (IN-PACKAGE #:CLSQL-UFFI)... etc. I though when nothing is changed it just loads the already compile files?
Kundry_Wag has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
heisig has joined #lisp
<no-defun-allowed>
okay i think i figured out the cl-decentralise object system
<no-defun-allowed>
schema is usually used for documents of some kind and i think that's a more appropriate word though
longshi has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
edgar-rft has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
<phoe>
Is there a one-liner to generate a nested list?
<phoe>
Like (make-nested-list-6) ;=> (((((())))))
<phoe>
(loop repeat 3 for list = nil then (list list) finally (return list)) - OK, found it.
Kundry_Wag has quit [Ping timeout: 252 seconds]
madrik has quit [Ping timeout: 252 seconds]
<Shinmera>
phoe: (reduce 'cons (make-list 7))
<heisig>
Ah, I see people demanding more documentation for Petalisp. Well, I am working on it... but I am not willing to document an API that is still under development. Give me a few more weeks.
Kundry_Wag has joined #lisp
groovy2shoes has quit [Quit: moritura te salutat]
southy has joined #lisp
southy has quit [Ping timeout: 252 seconds]
<phoe>
Shinmera: woah, right
<Shinmera>
:)
<phoe>
(:
francogrex has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
t0adst00l has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
<razzy>
ELS in zurich would make me very happy.
<Shinmera>
razzy: Why's that?
<shrdlu68>
Ah, I failed at (reduce #'list (make-list 6))
<shka_>
heisig: it's cool, btw, can we add alias "alpha" for greek alpha?
<shka_>
and "beta" for beta?
igemnace has joined #lisp
<ggole>
(nested-funcall 7 #'list nil) would be cleaner imho, but then you need to write nested-funcall
<ggole>
There's probably one in Alexandria...
<shka_>
heisig: so people could either customize their input to include greek letters, or use pretty lambda in emacs or just stick to plain old ascii
<razzy>
Shinmera: i can hope to see zurich, eth and els at the same time :]
longshi has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 250 seconds]
<razzy>
2020 i can make it, if i plan accordingly
Kundry_Wag has joined #lisp
<heisig>
shka_: The aliases are already there! I am listening to community feedback :-)
<shka_>
heisig: oh, cool, i was checking in the quicklisp version
<shka_>
and did not find them
<shka_>
maybe this version is old
<shka_>
anyway, i think that your project looks sweeeeeeeeeet!
Kundry_Wag has quit [Ping timeout: 252 seconds]
anewuser has joined #lisp
Kundry_Wag has joined #lisp
<heisig>
shka_: Thank you! I hope I get the native code generator working again before the next Quicklisp release. At the moment, Petalisp is extremely slow.
Kundry_Wag has quit [Ping timeout: 252 seconds]
<shka_>
heisig: i hope so to!
Kundry_Wag has joined #lisp
<shka_>
heisig: btw, is GPU computation is still considered to be a future feature?
<heisig>
Yes, but the dependency chain is: 1. Fast single threaded code 2. fast multi-threaded code 3. MPI parallel code 4. A GPU backend.
<jackdaniel>
5. Oracle-based answers.
Kundry_Wag has quit [Ping timeout: 245 seconds]
t0adst00l has joined #lisp
<heisig>
The company?!? Or some machine-learning magic?
<jackdaniel>
many thesis include metaphore of oracle which always returns correct results in no time (as a means of comparison)
<jackdaniel>
I believe company name came from that
<dim>
I've seen references of “God's algorithm” in some papers too, and used that to show pgloader as the next best thing ;-)
<jackdaniel>
hueh, demi-god software incorporated
<dim>
how fast can you sort this huge vector? well if you're God, it's already sorted before you need it that way, right?
<shka_>
folks, how can i find-method but without knowing the exact class of specializers?
<dim>
in the case of pgloader it was like if you're God then your database is already running with PostgreSQL, no wonder, the next best thing is ./pgloader mysql://localhost/dbname pgsql://localhost/dbname and be done with it already; so that's what pgloader does
<dim>
anyway
<shka_>
namely (defclass foo (bar)...)
<shka_>
and i have method for bar
<dim>
was fun, the approach worked very well in the presentation: people did have a laugh and then though about it
<jackdaniel>
(c2mop:generic-function-methods …)
<beach>
shka_: What do you expect it to return if you don't know the specializers?
<shka_>
jackdaniel: well, it is about inheritance, really
<beach>
shka_: Do you want the applicable methods?
<shka_>
jackdaniel: sorry, i wanted to highlight beach
<jackdaniel>
with "thanks"? well, that certainly suprised me, yes
<shka_>
jackdaniel: with inheritance
SaganMan has quit [Ping timeout: 252 seconds]
<shka_>
beach: and what if i don't have instances of classes, but just class names?
<jackdaniel>
try expand method
<shka_>
oh, ok
<jackdaniel>
you'll get right of the bat: (c2mop:compute-applicable-methods-using-classes
<shka_>
ooooooooh, neat
<shka_>
i like how mop has those layers of functions for extra dispatch
* splittist
likes the idea of ELS ZRH too.
<razzy>
heisig: i very much liked code shattered to graph-structure you are using. forget the name
eminhi_ has joined #lisp
<razzy>
*i forgoten the name
<shka_>
jackdaniel: that works perfectly :D
<shka_>
awesome
eminhi has quit [Ping timeout: 240 seconds]
SaganMan has joined #lisp
<jackdaniel>
see, that's why I was suprised in the first place. glad it works
<jackdaniel>
btw, is it me or c2mop doesnt export compute-applicable-methods ?
<jackdaniel>
(only the variant with classes)
<jackdaniel>
ah, that's because function is part of cl package
igemnace has quit [Remote host closed the connection]
<shka_>
indeed it is
<heisig>
razzy: Treating lazy arrays as data flow graph nodes? That works well. It gets somewhat funny once you start supporting functions with multiple return values. That is what I'm working on right now.
<razzy>
heisig: how funny?
<shka_>
i think that i already seen restructuring (tau) in petalisp
<shka_>
or not
<razzy>
data flow graph nodes seem most natural of the basic-code representation
<razzy>
to me
SaganMan has quit [Ping timeout: 264 seconds]
<heisig>
razzy: Well, you get one array of all first values, one array of all second values and so on. But when several of the multiple value arrays are used in the same computation, you want to merge them back to a single call to the multiple valued function. I hope this makes sense.
<russellw>
suppose you are calling a function with a list, on which you want to apply destructuring. You can take it as a parameter, then use destructuring-bind. But is there a way to make the destructuring happen right there in the function call? A destructuring-defun, so to speak?
Kundry_Wag has joined #lisp
<heisig>
russellw: That would be a different calling convention, so no. But you can have a look at TRIVIA:DEFUN-MATCH.
<russellw>
Okay thanks
<russellw>
also to concatenate several strings, this can be done with (concatenate 'string a b c). But suppose a and b are strings but c is a list of strings, what's the best way?
igemnace has joined #lisp
<heisig>
(apply #'concatenate 'string a b c)?
<shka_>
or format
<eminhi_>
doesn't defmacro do some destructuring in lambda list?
<shka_>
yes
<russellw>
thanks!
<shka_>
but not defun
Kundry_Wag has quit [Ping timeout: 240 seconds]
eminhi_ has quit [Quit: leaving]
dddddd has joined #lisp
esrse has quit [Ping timeout: 245 seconds]
SaganMan has joined #lisp
Achylles has joined #lisp
moei has quit [Read error: Connection reset by peer]
robotoad has quit [Read error: Connection reset by peer]
moei has joined #lisp
robotoad has joined #lisp
<russellw>
to print a list of items comma-separated, (format nil "~{~a~^,~}" '(1 2 3)) can be used. but suppose instead of a hardcoded comma, the separator itself must be a parameter. Can format do this?
SaganMan has quit [Ping timeout: 240 seconds]
edgar-rft has joined #lisp
<heisig>
russellw: Since you can call arbitrary functions from a format string via ~/NAME/, the answer to "can format do this?" is always yes. The question is whether it will be aesthetically pleasing. The easiest way for you is probably to use another format call to produce the format string with a separator of choice..
Essadon has joined #lisp
anewuser has quit [Ping timeout: 252 seconds]
<russellw>
heisig, I see what you mean. Or maybe instead of overloading format that badly, there might be a reasonably elegant idiom for just doing it with LOOP
<|3b|>
(with-output-to-string (s) (loop for (i . more) on list do (format s "~a~:[~;~a~]" i more separator))) ?
<Shinmera>
razzy: Fair enough (wrt els)
<|3b|>
though might be better to just use do (format s "~a" i) when more do (format s "~a" separator)
Kundry_Wag has joined #lisp
<russellw>
|3b| I had no idea loop could do that. Thanks!
<|3b|>
latter is more obvious, and not really enough else happening in the format string to require combining them
<|3b|>
yeah, lots of useful tricks with loop destructuring and FOR .. ON
Kundry_Wag has quit [Ping timeout: 245 seconds]
<|3b|>
(i . more) in LOOP destructuring is like (i &rest more) in normal destructuring, and ON binds all of remainder of list each time, so each step gets the car of current part of list in I, and cdr in MORE
<|3b|>
(well, . also works like that in 'normal' destructuring, but i'd hope not to see it in anything but code golf or really old code :)
southy has joined #lisp
gravicappa has joined #lisp
Kundry_Wag has joined #lisp
southy has quit [Ping timeout: 252 seconds]
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
marvin2 has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
longshi has joined #lisp
Kundry_Wag has joined #lisp
russellw has quit [Ping timeout: 240 seconds]
russellw has joined #lisp
SaganMan has joined #lisp
lanu1 has joined #lisp
lanu1 is now known as lanu
<frodef>
in sbcl/slime, is there any way to inject something that will look like a stack-frame without having an actual function?
<frodef>
e.g. like (with-stack-info (..) ...)
<frodef>
..that shows up in the backtrace
zfree has quit [Quit: zfree]
<Shinmera>
with what purpose
<frodef>
having more informative backtrace
longshi has quit [Ping timeout: 252 seconds]
<Shinmera>
a local function can do that, as long as you make sure to declare it notinline.
<frodef>
sure. Just thought there might be explicit support, seems like a worthwhile mechanism to me.
<Shinmera>
the stack is for stack frames. seems weird to have support for anything else.
<frodef>
it'd just be another stack-frame feature, I suppose.
<frodef>
not unlike restarts.
<Shinmera>
just make a function call
<pfdietz>
So you could implement with-stack-info as a macro that produces a flet with a notinline declaration.
<pfdietz>
More interesting would be more standard ways of tracing such local functions.
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
<shka_>
heisig: btw, how did you made petalisp portable?
m00natic has joined #lisp
k-hos has quit [Ping timeout: 272 seconds]
<heisig>
shka_: I use CL:COMPILE to produce fast code and avoid non-Lisp dependencies.
igemnace has quit [Quit: WeeChat 2.2]
SenasOzys has quit [Ping timeout: 252 seconds]
* LdBeth
almost forget about compile
Bike has joined #lisp
<shka_>
heisig: ok, cool
Kundry_Wag has quit [Ping timeout: 240 seconds]
<shka_>
so basicly, you are generating code, compiling it then run
<shka_>
is there anything more in the loop?
<heisig>
In the loop?
<shka_>
well, in basic workflow
<heisig>
Ah, not the CL:LOOP. Yes, there is plenty of data flow graph optimization and - most importantly - normalization, so that I can cache and reuse compiled code.
<shka_>
right
Kundry_Wag has joined #lisp
<LdBeth>
sounds like what fb had recently released
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
lanu has quit [Quit: lanu]
Kundry_Wag has quit [Ping timeout: 250 seconds]
shka_ has quit [Quit: WeeChat 1.9.1]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
Oddity has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 246 seconds]
vtomole has quit [Ping timeout: 256 seconds]
Oddity has joined #lisp
Guest5800_ has joined #lisp
groovy2shoes has joined #lisp
regreg_ has joined #lisp
scroll has joined #lisp
rnmhdn has quit [Ping timeout: 240 seconds]
atgreen has quit [Ping timeout: 272 seconds]
Kundry_Wag has joined #lisp
vtomole has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
<razzy>
LdBeth: "skip what you already computed" :D awesome
warweasle has joined #lisp
<heisig>
Two red flags about Skip: "Skip achieved [efficient memoization-based caching] via a static type system ..." and "Skip is no longer under active development at Facebook".
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
thetemplar has joined #lisp
arej has quit [Ping timeout: 252 seconds]
jack_rabbit has quit [Ping timeout: 252 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
lemonpepper24 has quit [Ping timeout: 272 seconds]
pierpal has quit [Read error: Connection reset by peer]
astronavt has joined #lisp
atgreen has joined #lisp
astronavt_ has joined #lisp
astronavt has quit [Ping timeout: 252 seconds]
SenasOzys has quit [Remote host closed the connection]
igemnace has joined #lisp
SenasOzys has joined #lisp
frodef has quit [Ping timeout: 244 seconds]
FreeBirdLjj has joined #lisp
Bike has quit [Ping timeout: 256 seconds]
pierpal has joined #lisp
atgreen has quit [Remote host closed the connection]
NB0X-Matt-CA has quit [Remote host closed the connection]
NB0X-Matt-CA has joined #lisp
pierpal has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 260 seconds]
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
jkordani_ has joined #lisp
pierpal has quit [Ping timeout: 252 seconds]
nsrahmad has joined #lisp
jkordani has quit [Ping timeout: 244 seconds]
frgo has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
warweasle is now known as warweasle_bbib
FreeBirdLjj has joined #lisp
heisig has quit [Ping timeout: 252 seconds]
frgo has joined #lisp
shrdlu68 has quit [Ping timeout: 245 seconds]
FreeBirdLjj has quit [Ping timeout: 252 seconds]
regreg_ has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
frgo has quit [Ping timeout: 272 seconds]
<v0|d>
anybody know a software verification suite written in CL?
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
<dim>
yeah, I think I saw one the other day, something that's at least 30 years old and seemed to have a modern offering to it, but I can't remember any name, it was tweeted by Rainer Joswig
<v0|d>
interesting.
orivej has joined #lisp
<m00natic>
ACL2 probably
cage_ has joined #lisp
frodef has joined #lisp
gravicappa has quit [Ping timeout: 252 seconds]
southy has joined #lisp
frgo has joined #lisp
flamebeard has quit []
<v0|d>
I wonder what ppl use for white-box testing these days.
<v0|d>
for instance generating test-cases for coverage for an algo written in lang X.
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
southy has quit [Ping timeout: 244 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
astronavt_ is now known as astronavt
<gendl>
Xach: any chance of getting the planet Lisp link to google calendar of Lisp meetings working again?
<gendl>
I want to try scheduling another Detroit meetup.
varjag has joined #lisp
shka_ has joined #lisp
<shka_>
good evening
<gendl>
heisig: check out Gendl.org for an actively maintained, dynamically-typed, Lisp-based system which sounds something like Skip (plus more, also minus a bunch of stuff too I’m sure).
FreeBirdLjj has quit [Ping timeout: 272 seconds]
FreeBirdLjj has joined #lisp
<shka_>
what the heck is skip anyway?
<shka_>
scratch that, not a lisp question
NB0X-Matt-CA has quit [Remote host closed the connection]
<Blackbeard>
if anyone wants to give me some feedback I will appreciate it :)
<shka_>
Blackbeard: first of, congrats
southy has joined #lisp
scymtym has joined #lisp
<shka_>
defcommand needs progn?
<shka_>
yuck
graphene has quit [Remote host closed the connection]
<Blackbeard>
shka_: I don't know :) I just used it
graphene has joined #lisp
<shka_>
i don't understand what happens at line 83
<shka_>
i suspect some kind of mistake
<Blackbeard>
shka_: line 83?
<shka_>
uh no
<shka_>
old.lisp
<shka_>
i don't understand this function
<Blackbeard>
ohh sorry I should delete old.lisp
<Blackbeard>
I forgot that
<Blackbeard>
it is wallpapers.lisp
LiamH has joined #lisp
<shka_>
oh, ok
robotoad has quit [Quit: robotoad]
<Blackbeard>
let me delete it
<shka_>
well kill-wallpaper-timer is mystery to me
<shka_>
other then that, nothing really screams "bad" at me
<shka_>
but i am not an expert
<Blackbeard>
shka_: oh ok
<Blackbeard>
so stumpwm has a list of timers
<Blackbeard>
*timer-list*
<Blackbeard>
so I loop in the stumpwm::*timer-list*
<shka_>
and those timers are functions?
<Blackbeard>
and then I check if the function of each timer is #'set-random-wallpaper
<Blackbeard>
if it is
<Blackbeard>
I kill that timer
<shka_>
hm
<shka_>
ok
<Blackbeard>
I only kill those timers, because the user might have timers for other things
<shka_>
i think you can use eq here
<shka_>
instead of equal
<Blackbeard>
I need to kill the wallpapers timers because if you decide to change your timer the other would still run
shifty has quit [Ping timeout: 244 seconds]
<Blackbeard>
so it needs to be killed
<Blackbeard>
ohh
<Blackbeard>
ok i will do that :)
<Blackbeard>
I am a little confused and overwhelmed with all the equality functions
<Blackbeard>
haha
<shka_>
i don't know that much about stumpwm so i can't comment any further
orivej has quit [Ping timeout: 245 seconds]
<Blackbeard>
shka_: thanks :) you are the first person to check my code eer
warweasle_bbib is now known as warweasle
<shka_>
no problem man
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
southy has quit [Ping timeout: 240 seconds]
<trittweiler>
Blackbeard, the longer the name of the equivalence function, the broader its concept of equivalence is. EQ just compares by memory address, EQL additionally compares numbers and character by identity (their memory address might be different, thing of boxed numbers), equal also compares lists and arrays (including strings), case sensitively, and equalp is like equal but compares case insensitively. There are a few more details, but that's essentially i
<trittweiler>
t.
<trittweiler>
equalp also compares structures and hash-tables element-wise, though again case insensitively
dale_ has joined #lisp
<shka_>
i never understood case insensitivity here
<shka_>
just why
dale_ is now known as dale
<Blackbeard>
trittweiler: ooohhh
<Blackbeard>
that is such a great explanation
<Blackbeard>
it belongs in a book
<Blackbeard>
🤔
pierpal has joined #lisp
dale has quit [Client Quit]
dale_ has joined #lisp
<Shinmera>
Blackbeard: a similar explanation is in PCL, so your wish had been granted before you even had it
<Blackbeard>
so I don't know the details of common lisp
<Blackbeard>
or general coding conventions
<Blackbeard>
that's why I use the arrows
<Blackbeard>
I learned that in HtDP
<Blackbeard>
But I wanna code something more meaningful now
<Shinmera>
do yourself, and everyone else, a favour and read PCL
Folkol has joined #lisp
<Blackbeard>
Shinmera: ok
SenasOzys has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
<pjb>
shka_: it's random. It's just because equal and equalp are called recursively, and in the case of strings, equal is case sensitive and equalp is case insensitve.
<minion>
pjb, memo from shrdlu68: I'll give this a try, thanks!
<pjb>
shka_: again, if you're not happy with that, define your own equals methods.
Kundry_Wag has quit [Read error: No route to host]
<shka_>
hmmm
<pjb>
Common Lisp is a hybrid programming language. It's the oldest and also the most modern. It's the lowest level programming language, but also the highest level programming language thanks to the macros.
<shka_>
ok
wiselord has joined #lisp
<pjb>
It's a big ball of mud, but also the cleanest programming language (since thanks to meta-programming, you can clean it as aseptically as you wish).
<pjb>
There are no parenthesis, but you only see them.
jkordani has joined #lisp
<pjb>
There are no lists! but it's called LISt Processing!
<pjb>
Not only it's an elephant, but an alien elephant at that (you don't even recognize the parts you touch). And while it's an elephant, it's small compared to other programming languages (java, c++, r7rs, etc).
<pjb>
It has fun with you: program parameters shall be defined with defvar, global variables shall be defined with defparameter!
<pjb>
and you can have fun with it! Just write a macro!
<wiselord>
hi! help me plz, i use ccl on windows. (ql:quickload 'cl+ssl) return error: libssl32.dll or ssley32.dll unable to load, i realized what i need to install openssl, but where do i put files "ssley32.dll" and "ssleay32.dll"?
jkordani_ has quit [Ping timeout: 245 seconds]
<|3b|>
anywhere on %PATH% i think
<|3b|>
or possibly working directory would work
<pjb>
or you may specify the paths to the libraries in cffi:*<something>*.
<|3b|>
cffi:*foreign-library-directories*
<pjb>
cffi:*foreign-library-directories* yes.
<wiselord>
but where can i write it? in ccl-init.lisp?
<wiselord>
current cffi:*foreign-library-directories* NIL
<jasom>
wiselord: you can write it wherever you want. You can also copy the DLLs into the same directory as CCL, but that's kind of an ugly solution.
<pjb>
wiselord: possibly. But since you're using Common Lisp, and may use another CL implementation, I would advise to use a ~/rc/common.lisp file and load it from all the rc files.
<pjb>
(don't use my rc files, you'd be puzzled; but writing your own you may follow the model).
quazimodo has quit [Ping timeout: 272 seconds]
<wiselord>
ok, thank
qapples has quit [Ping timeout: 256 seconds]
Bike has joined #lisp
Kundry_Wag has joined #lisp
m00natic has quit [Remote host closed the connection]
Kundry_Wag has quit [Read error: Connection reset by peer]
fiddlerwoaroof has quit [Quit: Gone.]
astalla has joined #lisp
nsrahmad has quit [Remote host closed the connection]
doubledup has joined #lisp
rumbler31 has joined #lisp
<jkordani>
wiselord: actually, you're better off putting them in %path
<jkordani>
cffi uses the operating system's dll load mechanism. If any dlls loaded in this way *also* depend on other dlls, the os will attempt to find them using %path
<jkordani>
so if A.dll depends on B.sll
<jkordani>
B.dll, and you put the path to a.dll in cffi:*foreign-library-directories*, loading will still fail because B.dll will also need to be resolved.
Jesin has quit [Quit: Leaving]
<jkordani>
you can get around this by "cffi loading" dependencies first, as the os machinery will then be able to find the libraries in question, or install them all to a location in %path
<jkordani>
on 64 bit windows, sysWOW64 is where 32 bit libs go, and system32 is where 64 bit libs go
<jkordani>
ask me how I know and how long it took me to realize that
doubledup has quit [Quit: Leaving]
* |3b|
thinks they go in the msys2 bin dirs :p
rumbler31 has quit [Remote host closed the connection]
<jkordani>
whatever makes the win32 dlopen call succeed (I forget what it is at the moment)
vtomole has quit [Ping timeout: 256 seconds]
Jesin has joined #lisp
slyrus1 has joined #lisp
<jackdaniel>
dlopen is posix function for opening dynamic libraries (to find functions in them for instance)
<|3b|>
LoadLibrary() ?
<jkordani>
yea I know, can't remember the windows version names at the moment
<jkordani>
yes thank you
t0adst00l has quit [Ping timeout: 256 seconds]
<|3b|>
probably with an Ex at the end or something
<jackdaniel>
ah, OK
<jkordani>
and specifically wiselord's set of libs, there's a 3rd library that one of those two reference that isn't called out for by the cffi call in cl+sll
<|3b|>
or ExW since we don't have the C preprocessor :)
<jkordani>
since I was shipping a binary I just found all three and made explicit cffi load library calls to all 3 in the proper order and put the dlls in the local directory
Achylles has quit [Ping timeout: 260 seconds]
longshi has joined #lisp
slyrus2 has joined #lisp
longshi has quit [Client Quit]
<wiselord>
i put libs into my programm dir, and so good, thanks
trafaret1 has joined #lisp
<trafaret1>
hi there
sauvin has quit [Read error: Connection reset by peer]
<jackdaniel>
general kenobi
<jackdaniel>
\\\o///
graphene has quit [Remote host closed the connection]
<russellw>
what's the most efficient and cleanest way to write a newline as a literal string (or as close as it is possible to get to that)? #\newline is the character form, but what's the appropriate string form?
<shka_>
that would be hello there
<Bike>
you mean a string with just a newline in it?
<russellw>
yes
<jackdaniel>
russellw: (format nil "~%")
<russellw>
jackdaniel, cool, thanks
<jackdaniel>
or, even better, #.(format nil "~%")
graphene has joined #lisp
<trafaret1>
if I will learn lisp does it give me ability to make million dollars?
graphene has quit [Remote host closed the connection]
<jackdaniel>
trafaret1: you'll have approximately the same chance as without learning it
slyrus2 has quit [Ping timeout: 260 seconds]
danielxvu has quit [Remote host closed the connection]
graphene has joined #lisp
regreg_ has joined #lisp
danielxvu has joined #lisp
<pjb>
russellw: (string #\newline)
<pjb>
with #.
<russellw>
pjb, ah! thanks
<pjb>
(string #\f) #| --> "f" |#
<pjb>
trafaret1: you, I don't know. But Paul Graham made millions with CL, writing a program in clisp, and selling it to Yahoo!.
kyby64 has joined #lisp
<pjb>
trafaret1: so at least, it's possible, and since lisp is fun, you may be able to do it having fun. With C++, you'd be about to do it, but in hellish tortures.
<pjb>
So your choice.
rumbler31 has joined #lisp
khisanth_ has quit [Ping timeout: 264 seconds]
robotoad has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
hydan has quit [Quit: Connection closed for inactivity]
robotoad has quit [Quit: robotoad]
graphene has quit [Remote host closed the connection]
ggole has quit [Quit: ggole]
rumbler31 has quit [Remote host closed the connection]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
pierpal has joined #lisp
igemnace has quit [Quit: WeeChat 2.2]
FreeBirdLjj has joined #lisp
angavrilov has quit [Remote host closed the connection]
FreeBirdLjj has quit [Ping timeout: 245 seconds]
dented42 has joined #lisp
edgar-rft has joined #lisp
orivej has joined #lisp
rnmhdn has joined #lisp
Roy_Fokker has joined #lisp
Achylles has quit [Ping timeout: 252 seconds]
gravicappa has joined #lisp
astalla has quit [Ping timeout: 246 seconds]
warweasle has joined #lisp
kajo has joined #lisp
frodef has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
<aeth>
Lisp doesn't give you the ability to make millions. Programming does.
<aeth>
I think Lisp code looks better than code in most languages, but if you're in it for the money, no one's going to see your code's elegance/inelegance amd you can always pay someone to clean up your technical debt later.
makomo has joined #lisp
<aeth>
*and
rumbler31 has quit [Ping timeout: 272 seconds]
gravicappa has quit [Remote host closed the connection]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lemonpepper24 has joined #lisp
asarch has quit [Quit: Leaving]
rnmhdn has quit [Ping timeout: 252 seconds]
slyrus1 has quit [Quit: slyrus1]
robotoad has quit [Quit: robotoad]
slyrus1 has joined #lisp
SenasOzys has joined #lisp
frgo has quit []
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
kyby64 has quit []
trafaret1 has left #lisp ["ERC (IRC client for Emacs 25.2.2)"]
graphene has joined #lisp
<no-defun-allowed>
With PG's case, he had a better chance working in Lisp since it was better for prototyping and live development. I'd argue that you have a better chance with Lisp but PG is pretty biased since he didn't fail.
<no-defun-allowed>
Also, PG was riding the internet bubble.
robotoad has quit [Max SendQ exceeded]
lemonpepper24 has quit [Ping timeout: 240 seconds]
kajo has quit [Ping timeout: 252 seconds]
<aeth>
he had lucky timing, selling to Yahoo at its peak (and its peak irrationality)
regreg_ has quit [Ping timeout: 245 seconds]
robotoad has joined #lisp
<aeth>
You could argue that he only timed it in time because he wasn't using C++, though
<no-defun-allowed>
Yes, since he was able to develop it faster.
<aeth>
if you're building software to last 20 years, I suspect pg's experience here is irrelevant
<aeth>
You don't want a language where you write things as quickly as possible in that case.
<aeth>
You want a language where you can make sure something is (integer 2 #.(isqrt most-positive-fixnum))
<aeth>
Or any other range where if you go outside it you'll have issues.
robotoad has quit [Quit: robotoad]
Essadon has quit [Quit: Qutting]
Bike has joined #lisp
Pixel_Outlaw has joined #lisp
Guest5800_ has quit [Quit: Connection closed for inactivity]
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
LiamH has quit [Quit: Leaving.]
funnel has joined #lisp
ym has quit [Ping timeout: 260 seconds]
<LdBeth>
GG
<jasom>
aeth: very few customers will pay a premium for software that will last 20 years.
<aeth>
jasom: and yet quite a lot of software lasts a lot longer than 20
robotoad has joined #lisp
<aeth>
I'm using a 16 year old web browser, a 19 year old IRC client, a (probably) 12 year old terminal, a 38 year old compiler (if you count the original branch), a 33 year old editor, etc.
<aeth>
All the software I'm using except maybe the terminal (it's lxterminal and LXDE is moving everything to Qt) has a very good chance to make it past 20 if it's not already past 20
<jasom>
we are using different definitions of "last" then since I suspect most of that software has changes made in the past year or two.
<jasom>
but I really don't want to get into a perseus's ship discussion
<aeth>
jasom: My point is, if something's going to be around for decades anyway, you should optimize for the multi-decade maintenance period, not the first few years of rapid development
<jasom>
s/perseus/theseus
<aeth>
And a lot of website code is probably already at or approaching this 20 year point now in 2018.
<jasom>
aeth: Richard P Gabriel had a lot to say about that
<aeth>
Of course, a language that's mostly compatible with things written 59 years ago is a good choice to write multi-decade software in.
<jasom>
Lisp: Good News Bad News How to Win Big &c.
<jasom>
a core argument was that if you didn't optimize for being successful now, you will be starved of resources by those that do
robotoad has quit [Quit: robotoad]
varjag has quit [Ping timeout: 246 seconds]
<aeth>
jasom: on the other hand, that essay was refuted a few years later in Worse is Better is Worse by Richard P Gabriel
ym has joined #lisp
<jasom>
aeth: which was the rebutted by "Is worse really better"
<aeth>
looks like it's 3-2 in favor of Worse is Better
<aeth>
but we should check back frequently to see if it gets tied again
<jasom>
"And in preparation for this panel, the organizer, Martine Devos, asked me to write a position paper, which I did, called "Back to the Future: Is Worse (Still) Better?" In this short paper, I came out against worse is better. But a month or so later, I wrote a second one, called "Back to the Future: Worse (Still) is Better!" which was in favor of it. I still can’t decide."
rumbler31 has joined #lisp
asarch has joined #lisp
<aeth>
yeah, that's how I got to 3-2
<aeth>
jasom: but I suspect both things are true
<aeth>
jasom: some software has to be successful right away, some software can take its time