<zigpaw>
a separate problem of sorts, esp. with the history of computer vendors adding their own to the chain, etc. (not applicable to linux/bsd but still)
pierpal has joined #lisp
robotoad has quit [Quit: robotoad]
pierpal has quit [Ping timeout: 240 seconds]
akoana has joined #lisp
<Xach>
zigpaw: the bootstrap can only fetch the rest via plain http, unfortunately.
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
akoana has left #lisp [#lisp]
pierpal has joined #lisp
<Xach>
plus https is not easily available on all platforms, so
Kundry_Wag has joined #lisp
mn3m has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Ping timeout: 272 seconds]
torbo has joined #lisp
torbo has quit [Remote host closed the connection]
torbo has joined #lisp
robotoad has joined #lisp
jmercouris has quit [Remote host closed the connection]
metallicus has quit [Remote host closed the connection]
jack_rabbit has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
notzmv is now known as zmv
zmv is now known as notzmv
robdog has joined #lisp
wusticality has joined #lisp
Bike has joined #lisp
Kundry_Wag has joined #lisp
orivej has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
Necktwi has joined #lisp
hectorhonn has joined #lisp
<hectorhonn>
morning everyone
iovec has quit [Quit: Connection closed for inactivity]
wusticality has quit [Ping timeout: 272 seconds]
nihilarchy has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
zmt00 has quit [Read error: Connection reset by peer]
zmt00 has joined #lisp
dddddd has quit [Remote host closed the connection]
anewuser has quit [Ping timeout: 268 seconds]
wusticality has joined #lisp
wusticality has quit [Ping timeout: 258 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
orivej has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
ahungry has joined #lisp
robotoad has quit [Quit: robotoad]
parjanya has joined #lisp
wusticality has joined #lisp
robotoad has joined #lisp
meepdeew has joined #lisp
undiscovered has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
wusticality has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 245 seconds]
wusticality has joined #lisp
<beach>
Good morning everyone!
Lord_of_Life has quit [Ping timeout: 258 seconds]
wusticality has quit [Remote host closed the connection]
Lord_of_Life has joined #lisp
wusticality has joined #lisp
torbo has left #lisp ["ERC (IRC client for Emacs 26.1)"]
nihilarchy has quit [Remote host closed the connection]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
wusticality has quit [Remote host closed the connection]
emaczen has joined #lisp
gravicappa has joined #lisp
metallicus has joined #lisp
metallicus has quit [Quit: WeeChat 2.3]
sauvin has joined #lisp
meepdeew has quit [Remote host closed the connection]
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
amerlyq has joined #lisp
Kundry_Wag has joined #lisp
evert1 has joined #lisp
makomo has quit [Ping timeout: 244 seconds]
evert1 is now known as metallicus
Kundry_Wag has quit [Ping timeout: 258 seconds]
metallicus has quit [Quit: WeeChat 2.3]
metallicus has joined #lisp
metallicus has quit [Client Quit]
wusticality has joined #lisp
metallicus has joined #lisp
gko has quit [Ping timeout: 264 seconds]
metallicus has quit [Quit: WeeChat 2.3]
metallicus has joined #lisp
mrcom has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 258 seconds]
gko has joined #lisp
Bike has quit [Quit: Lost terminal]
Kundry_Wag has joined #lisp
Guest86938 has joined #lisp
mrcom has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
metallicus has quit [Quit: WeeChat 2.3]
xrash has quit [Ping timeout: 245 seconds]
amerlyq has quit [Quit: amerlyq]
metallicus has joined #lisp
metallicus has quit [Quit: WeeChat 2.3]
orivej has joined #lisp
<LdBeth>
good morning
metallicus has joined #lisp
<zigpaw>
morning :)
karlosz has quit [Quit: karlosz]
Kundry_Wag has joined #lisp
pjb has quit [Ping timeout: 252 seconds]
Kundry_Wag has quit [Ping timeout: 245 seconds]
mrcom has quit [Read error: Connection reset by peer]
wusticality has quit [Remote host closed the connection]
mrcom has joined #lisp
ahungry has quit [Remote host closed the connection]
Guest86938 has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
jprajzne has joined #lisp
pjb has joined #lisp
Guest86938 has joined #lisp
Kundry_Wag has quit [Ping timeout: 258 seconds]
krwq has joined #lisp
mn3m has joined #lisp
Guest86938 has quit [Ping timeout: 252 seconds]
JetJej has joined #lisp
metallicus has quit [Quit: WeeChat 2.3]
pierpal has quit [Read error: Connection reset by peer]
datajerk has quit [Ping timeout: 246 seconds]
datajerk has joined #lisp
iovec has joined #lisp
themsay has joined #lisp
emaczen has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
JohnMS_WORK has joined #lisp
makomo has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
dale has quit [Quit: dale]
<makomo>
morning
mrcom has quit [Read error: Connection reset by peer]
rippa has joined #lisp
mrcom has joined #lisp
hectorhonn has quit [Quit: Page closed]
themsay has quit [Ping timeout: 240 seconds]
Inline has quit [Quit: Leaving]
<splittist>
morning
<beach>
Hello splittist.
moei has joined #lisp
nowolfer has joined #lisp
mn3m has quit [Quit: mn3m]
rumbler31 has quit [Ping timeout: 272 seconds]
rumbler31 has joined #lisp
beaky has quit [Read error: Connection reset by peer]
drmeister has quit [Read error: Connection reset by peer]
jerme_ has quit [Ping timeout: 264 seconds]
drmeister has joined #lisp
beaky has joined #lisp
Kundry_Wag has joined #lisp
rozenglass has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 250 seconds]
krwq has quit [Remote host closed the connection]
themsay has joined #lisp
angavrilov has joined #lisp
kajo has quit [Ping timeout: 268 seconds]
orivej has quit [Ping timeout: 245 seconds]
xkapastel has joined #lisp
JetJej has quit [Quit: [Quit]]
<phoe>
morniiiiiiiiiiing
findiggle has quit [Remote host closed the connection]
findiggle has joined #lisp
orivej has joined #lisp
Kundry_Wag has joined #lisp
<no-defun-allowed>
hi phoe and splittist
pierpal has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
dlowe has quit [Ping timeout: 252 seconds]
Zaab1t has joined #lisp
themsay has quit [Ping timeout: 244 seconds]
<jackdaniel>
is it me or clhs is down?
<no-defun-allowed>
where are you getting it from?
<no-defun-allowed>
lispworks and lisp.se seem ok
<jackdaniel>
lispworks.com hosts clhs
<jackdaniel>
thank you
<jackdaniel>
then it must be something on my side
<jackdaniel>
(lispworks.com being not responsive)
<no-defun-allowed>
best of luck working that out
dlowe has joined #lisp
<jackdaniel>
will, I'll simply ignore it for now :)
<jackdaniel>
well*
yvy has joined #lisp
w37 has joined #lisp
krrrcks has joined #lisp
<no-defun-allowed>
might be a good time to remind people that despite the clhs being quite restrictively copyrighted you can download the CLHS for personal use, and it's only about 15MB including crappy GIF images and all 2300 HTML files
<no-defun-allowed>
it's 2mb in the targz you get from lispworks so you can do it any time you're bored or have a minute where you're thinking "what language documentation should i download today?"
<jackdaniel>
you may build your own standard draft, change it, annotated it and put it on the website (also use as a pdf with bookmarks - much better to navigate than clhs directly if you ask me, I'm still sold to l1sp.org though)
<ogamita>
More worrying is that lisp logs at ccl have been down since login is required on freenode…
random-nick has joined #lisp
rozenglass has joined #lisp
<no-defun-allowed>
flip214: lol, i tried when i was learning lisp like almost a year ago
Kundry_Wag has joined #lisp
shka_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
<flip214>
yeah, it's still Work In Progress...
<d4ryus>
is there a format directive to print n characters of a string?
<no-defun-allowed>
Would you be okay not using format?
<no-defun-allowed>
If so, subseq works fine, as long as you check the string isn't shorter than your desired length.
Kundry_Wag has joined #lisp
<d4ryus>
no-defun-allowed: thats what i use atm :)
Guest86938 has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
robdog_ has joined #lisp
vms14 has joined #lisp
amerlyq has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
Zaab1t has quit [Ping timeout: 245 seconds]
scymtym has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
atgreen_ is now known as atgreen
wilfredh has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 258 seconds]
Guest86938 has quit [Ping timeout: 252 seconds]
undiscovered has joined #lisp
Kundry_Wag has joined #lisp
plugd has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 258 seconds]
kajo has joined #lisp
yvy has quit [Read error: Connection reset by peer]
yvy has joined #lisp
rozenglass has quit [Quit: ERC (IRC client for Emacs 26.1)]
rozenglass has joined #lisp
_whitelogger has joined #lisp
heisig has joined #lisp
Kundry_Wag has joined #lisp
robdog_ has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 252 seconds]
undiscovered has quit [Quit: WeeChat 2.3]
amerlyq has joined #lisp
undiscovered has joined #lisp
Zaab1t has joined #lisp
Guest86938 has joined #lisp
dddddd has joined #lisp
metallicus has joined #lisp
atgreen has quit [Remote host closed the connection]
kajo has quit [Ping timeout: 252 seconds]
amerlyq has quit [Quit: amerlyq]
amerlyq has joined #lisp
vms14 has quit [Quit: meh...]
kajo has joined #lisp
Guest86938 has quit [Remote host closed the connection]
Guest86938 has joined #lisp
whartung_ has joined #lisp
whartung has quit [Ping timeout: 240 seconds]
whartung_ is now known as whartung
salva has joined #lisp
creat has quit [Ping timeout: 250 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
creat has joined #lisp
Denommus has joined #lisp
whartung has quit [Ping timeout: 272 seconds]
trittweiler has joined #lisp
Zaab1t has quit [Ping timeout: 250 seconds]
<heisig>
What is the best way to obtain the value of a form that is CONSTANTP, e.g., within a compiler-macro? EVAL?
yvy has quit [Read error: Connection reset by peer]
<jackdaniel>
maybe symbol-value?
trittweiler has quit [Ping timeout: 240 seconds]
Essadon has joined #lisp
Essadon has quit [Max SendQ exceeded]
<lieven>
I'd go for load-time-value
<_death>
EVAL should do
<heisig>
jackdaniel: The problem is, '(+ 2 3) is also CONSTANTP. So no symbol-value.
<heisig>
If _death approves, it's probably fine to use EVAL :)
<_death>
but there is an issue.. I believe a form may be a constant form but still its value may not be available at that time
<_death>
for example (defconstant foo 'bar) means FOO is a constant form but at compile-time its value may not be available (for that you'd need eval-when)
<flip214>
heisig: EVAL won't do - the value might use the wrong binding (global vs. thread-local, etc.)
<flip214>
it depends on what you're doing with it; perhaps NUMBERP and/or STRINGP is good enough?!
<heisig>
Hmm, the glossary states a constant form is "any form for which evaluation always yields the same value, ...". Not sure how to interpret that.
<flip214>
if it's a constant, the compiler will fold it anyway - even without a compiler-macro.
<_death>
heisig: it means (eq (eval form) (eval form)) => t, given that its value is available
<flip214>
but I understand the wish to optimize for such cases -- perhaps inlining the "outer" part of a function helps, and that calls some non-inlined inner part?
<_death>
heisig: eql
<heisig>
flip214: In practice, NUMBERP is probably fine for my case. I just thought there might be an 'official' way to address this problem.
<flip214>
heisig: that is not sufficient. (IDENTITY *X*) with (DEFVAR *X* 1) will always return 1 (EQL to 1), but any thread that used (IDENTITY *X*) in an argument list might have *X* bound to a different value!
<flip214>
heisig: CONSTANTP
jstypo has quit [Read error: No route to host]
<flip214>
and a quoted expression is always constantp, right
<flip214>
my CLHS has a few examples; see eg. (constantp '(sin pi)) => implementation-dependent
<flip214>
or (constantp '(let ((a '(a b c))) (+ (length a) 6))) => implementation-dependent
<lieven>
yeah there's an issue associated with it about that
jstypo has joined #lisp
<lieven>
the two authors both think the wording is unambiguous, they just disagree about what they meant
robdog_ has joined #lisp
<_death>
flip214: (identity *x*) with *x* naming a special variable won't be a constant form...
dyelar has quit [Quit: Leaving.]
<scymtym>
*X* won't be either if undefined or declared special
<heisig>
I think I will use (defun conservative-constantp (form) (or (quoted-form-p form) (and (not (listp form)) (not (symbolp form))))) to be on the safe side.
<flip214>
heisig: " If object is a cons, listp does not check whether object is a proper list; it returns true for any kind of list. "
<_death>
heisig: may want to use (atom form) instead of not listp.. NIL considered harmless
<flip214>
so even a circular list will be LISTP
<flip214>
just as an aside ;)
<_death>
heisig: still won't pass the symbolp check though.. maybe (and (symbolp x) (constantp x) (boundp x))
<flip214>
heisig: what about numbers, strings, and keywords? these are all CONSTANTP ..
phoe has quit [Ping timeout: 264 seconds]
zigpaw has quit [Remote host closed the connection]
<scymtym>
heisig: what is the purpose of your predicate? is it suitable for your use-case to, for example, consider (+ 1 2) not constant, but #<CLASS …> constant?
<heisig>
scymtym: The purpose of that predicate was to determine whether a form is so constant that I can EVAL it at any time.
<heisig>
In fact, all I want is a portable sb-int:constant-form-value.
<scymtym>
heisig: what is the resulting information used for, is what i'm asking
Bike has joined #lisp
<heisig>
scymtym: I want to use the result within a compiler macro.
<heisig>
So it is fine if I am conservative, but being smart would be nice, too.
FreeBirdLjj has joined #lisp
<heisig>
It's not terribly important for my program. I just thought that maybe there is already an agreed upon way to deal with this situation.
<scymtym>
moving the evaluation to load time instead of all the way to compile time sometimes works
<scymtym>
cl-ppcre has an example of this approach and illustrates a caveat: for a long time it did "if (constantp regex env) then (load-time-value (compile-regex regex))". this is wrong if REGEX is constant in ENV but not in the null lexical environment
phoe has joined #lisp
ebrasca has quit [Remote host closed the connection]
mathrick has quit [Ping timeout: 260 seconds]
jochens has joined #lisp
Guest86938 has quit [Quit: Konversation terminated!]
<heisig>
I conclude - the right way is to use constantp without an environment and then load-time-value. Thanks everyone!
robdog_ has quit [Remote host closed the connection]
dyelar has joined #lisp
atgreen has joined #lisp
dyelar has quit [Remote host closed the connection]
dyelar has joined #lisp
robdog_ has joined #lisp
Essadon has joined #lisp
sjl_ has joined #lisp
robdog_ has quit [Remote host closed the connection]
robdog_ has joined #lisp
xrash has joined #lisp
<dim>
is there a good documentation somewhere on CL environments and how to use them as a CL user? I'm lacking the practical implications of the idea, and I have no idea how to use &environment in the operators where it exists...
amerlyq has quit [Ping timeout: 252 seconds]
<beach>
I have not seen any such documentation.
dale_ has joined #lisp
<jackdaniel>
dim: as it is specified in CL &environment is mostly good for only passing it to other macros
<jackdaniel>
(as an opaque object)
dale_ is now known as dale
<jackdaniel>
some important primitives did not get through to ANSI CL, but they were specified in CLtL2
<jackdaniel>
and many implementations provide interfaces documented there
<jackdaniel>
so I'd look there
<pfdietz>
The only thing I have consistently used environments for is as an argument when manually expanding macros.
<jackdaniel>
↑
<beach>
Also to get-setf-expansion.
dyelar has quit [Remote host closed the connection]
dyelar has quit [Remote host closed the connection]
aindilis has quit [Ping timeout: 268 seconds]
<sjl_>
Also to constantp in compiler macros
whartung has joined #lisp
aindilis has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<pfdietz>
The thing I've used it for is to exploit the environment as a kind of poor man's symbol table. If I have a macro that wants to make declaration-like things visible to lexically enclosed forms, I encode that with macrolets whose only purpose is to be deliberate expanded by other macros to get the information back out again.
pierpal has quit [Read error: Connection reset by peer]
dyelar has joined #lisp
pierpal has joined #lisp
dyelar has quit [Remote host closed the connection]
dyelar has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
schweers has quit [Ping timeout: 264 seconds]
m00natic has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
FreeBirdLjj has quit [Ping timeout: 245 seconds]
metallicus has quit [Quit: WeeChat 2.3]
metallicus has joined #lisp
ebrasca has joined #lisp
warweasle has joined #lisp
asarch has joined #lisp
metallicus has quit [Client Quit]
Zaab1t has joined #lisp
<dim>
jackdaniel: thx!
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
heisig has quit [Quit: Leaving]
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
Inline has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
Inline has joined #lisp
trittweiler has joined #lisp
edgar-rft has quit [Quit: Leaving]
amerlyq has joined #lisp
maarhart has joined #lisp
maarhart has quit [Excess Flood]
maarhart has joined #lisp
anewuser has joined #lisp
Selwyn has joined #lisp
robdog_ has quit [Remote host closed the connection]
robotoad has quit [Ping timeout: 258 seconds]
orivej has quit [Read error: Connection reset by peer]
trittweiler has quit [Ping timeout: 250 seconds]
orivej has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
amerlyq has quit [Quit: amerlyq]
jack_rabbit has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
hiroaki has joined #lisp
maarhart has quit [Remote host closed the connection]
robotoad has joined #lisp
atgreen has quit [Ping timeout: 258 seconds]
<sjl_>
Is there a guide on how to use a proxy to make quicklisp download over HTTPS so it's not horrifyingly insecure?
<sjl_>
but when I tell quicklisp to use that proxy with (ql-config:config-value "proxy-url") it's still making the requests to http://beta.quicklisp
<sjl_>
so the proxy just passes them through
<Xach>
sjl_: I don't know of a guide, sorry. you can modify ql-http:*fetch-scheme-functions* to use e.g. drakma or something with ssl support.
Josh_2 has quit [Read error: Connection reset by peer]
<sjl_>
I tried setting (setf ql::*client-base-url* "https://beta.quicklisp.org") but that doesn't affect the archive urls that it fetches, because I think it reads those straight from releases.txt which has the bare http:// in there
Josh_2 has joined #lisp
<sjl_>
Xach: running tinyproxy should handle the SSL stuff, I just need a way to tell quicklisp to request https:// instead of http://
<sjl_>
(through the proxy, which is still http://)
<Xach>
I don't know how you might easily do that, sorry.
<Xach>
maybe you could also use *fetch-scheme-functions* for that.
<sjl_>
maybe and :around on archive-url?
<sjl_>
*an
<Xach>
I don't think that would cover enough things.
<sjl_>
Is a config option for "Please use HTTPS urls everywhere, I'll provide a proxy for you" something that could be added to quicklisp?
<sjl_>
I'm not even sure having QL use Drakma would work, because wouldn't it still be requesting http://?
<Xach>
sjl_: It would involve rewriting the url before passing to drakma/curl/whatever.
robdog_ has joined #lisp
<sjl_>
Ahh
<sjl_>
Wait, that's what I need to do.
<Xach>
I think *fetch-scheme-functions* is attractive because everything that fetches flows through it.
<sjl_>
Oh, so you're saying I can wrap the existing "http" fetch-scheme-function to rewrite the URL and then delegate to the old one
<sjl_>
not add a new function to that list
<Xach>
sjl_: I don't know if that will work - I don't know what the existing one will do with a https URL.
<Xach>
I mentioned this yesterday, but I have a system that is almost ready to deploy that involves fetching signed things and checking checksums and adding more confidence aside from https.
atgreen has quit [Remote host closed the connection]
<sjl_>
Ah, so the user would download your public key over https (bundled in the initial setup file or whatever) and then this pure-CL implementation of PGP checks that whatever it downloads is correctly signed?
robdog_ has quit [Ping timeout: 264 seconds]
<Xach>
sjl_: yes. the bootstrap file embeds a pgp signature checker and the initial dist key.
<Xach>
the metadata are signed and include sha256 digests of downloads
<Xach>
and the bootstrap file is on https
<sjl_>
That would work, I think. Doesn't really matter if I get MITM'ed if it can be detected before executing the code.
<sjl_>
Right
<sjl_>
And if someone wants to use a dist other than yours, they'd get the author's pubkey securely somehow and add it into the list of keys that QL trusts
<Xach>
sjl_: yes.
atgreen has quit [Ping timeout: 268 seconds]
<Xach>
there isn't the web-of-trust component that i know is an important part of a real system. this is my attempt at the best "simple" thing when https isn't easily available everywhere.
<aeth>
d4ryus: The way I know about to print part of a string is this way: (write-sequence "Hello, world!" *standard-output* :start 7 :end 12)
<aeth>
d4ryus: In general if you think in sequences, they almost have start/end (or start1/end1 and start2/end2)
<aeth>
If you only want to print the first n characters than you can just say ":end n" and have no :start
<aeth>
s/they almost have/they almost always have/
atgreen has joined #lisp
<aeth>
(So you'd get "Hello" with just ":end 5")
<sjl_>
Xach: Hmm, well wrapping the fetch-scheme-function didn't seem to work, so I guess I'll just wait for that patch to land.
<Xach>
sjl_: i'll try to come up with an example i think should work
rozenglass has quit [Remote host closed the connection]
<sjl_>
Xach: which seems like it should be okay, but tinyproxy says https://plaster.tymoon.eu/view/1078#1078 and I don't have time to dig into how the request is actually happening
<Selwyn>
Hello all
<Selwyn>
which library is best for graph visualisation?
<jackdaniel>
graphviz
<sjl_>
depending on what kind of graph you're talking about, I shell out to either graphviz or gnuplot
<jackdaniel>
if you look for native common lisp solutions, you may try mcclim
<aeth>
Or, yes, I was going to mention gnuplot/graphviz but I was beaten to it
<scymtym>
for graphviz, cl-dot is pretty good
<sjl_>
Yeah, I like cl-dot
<aeth>
I've personally had decent success with graphviz, you just need to generate a .dot ("dot dot"?) file. The format is not quite as high level as I would have liked if you want it to render nicely (even though it *will* render with spaghetti connections if written the naive way)
<Selwyn>
i notice there are quite a few Lispy interfaces to graphviz - cl-dot, s-dot, cl-graph etc
<sjl_>
cl-dot is a good one
<Selwyn>
hm thanks
jochens has quit [Ping timeout: 258 seconds]
<aeth>
Not sure if cl-dot supports it but for complicated graphs you probably want to create intermediate blank nodes so you can control the chaos of the long, overlapping arrows a bit.
<aeth>
So instead of A->B you have A-*->B where * is a tiny diamond or something
<aeth>
in dot syntax: [shape=diamond,style=filled,label="",height=.1,width=.1]
<Xach>
sjl_: this isn't quite what you had in mind, but https://plaster.tymoon.eu/view/1079#1079 was my first try. it doesn't actually work and i'm not fully sure why -- (ql:update-dist "quicklisp") fails for me.
<Xach>
i can't poke further at the moment
hhdave has quit [Ping timeout: 258 seconds]
metallicus has joined #lisp
<sjl_>
Xach: Ah, that rewrites *and* uses drakma. I see.
<Xach>
yes
<sjl_>
Still have the initial bootstrapping of getting Drakma to contend with though
<Xach>
yes
<sjl_>
I think waiting for the PGP stuff to land is fine
<Xach>
ok
<sjl_>
thanks
<aeth>
(Coincidentally, A->B is valid dot, that's not what I meant, of course. I meant instead of "A"->"B" you have "A"->"intermediate" [dir=none] and then "intermediate"->"B" where you'd have a separate entry for "intermediate" that makes it a tiny shape. I can't give the CL syntax because libraries could differ)
<Xach>
no problem, sorry it's not better already - i spent my extra time before work chainsawing a hole through a frozen instead of polishing pgp
<Xach>
"a frozen pond"
<Selwyn>
aeth: it's a shame that it can't figure out how to render complicated graphs in a nice way. i wonder if it is a particularly hard problem to solve?
* Xach
will narrow focus sometime
<sjl_>
Not sure which of those two tasks sounds more unpleasant
<Xach>
both lead to more fun in the future
<aeth>
Selwyn: With dot files, you can break things up into a subgraph, and put the tiny intermediate shapes I was talking about as "inputs" to the subgraph area, which can group things a bit. But if something's complicated it's complicated.
warweasle has quit [Quit: exit]
<Xach>
sjl_: ahh, i got the signature of ql-http:fetch wrong. the file fetched is the second value. adjusting ssl-fetch to return (values nil (drakma-fetch-to-file ...)) fixes things.
<Xach>
i should write this up
parjanya has quit [Remote host closed the connection]
<aeth>
Selwyn: If you're okay with your lines looking roughly like -------*------*-----*----> where * is a tiny shape, except in 2D going in various directions (and iirc the polyline instead of smooth style so it stands out less), then you can micromanage the lines when the program would make it do something really bad.
<aeth>
Of course, this won't work if the graph itself is arbitrary, but it could work for a Lispy preprocessor for fixed data.
<aeth>
There might be a better, more approved way, but that's what I hacked together last time I had something really complicated
<thrig>
or with spendy software you can import dot into omnigraffle or maybe visio and then clicky drag stuff around
<aeth>
thrig: until the data changes
terpri has quit [Read error: Connection reset by peer]
<Selwyn>
aeth: thanks for the tips. for now, i am dealing with simple graphs and don't need the output to be too polished
<aeth>
Imo a hacky .dot (or anything else visual) is at least in theory easier to update by updating generating .lisp file than hand cleaning it
<Selwyn>
that's certainly my experience with gnuplot
<aeth>
s/.lisp file/.lisp files/
<aeth>
I am making so many typos today.
ravndal has quit [Quit: WeeChat 2.3]
<aeth>
Selwyn: You should check to make sure the library you settle on using can handle generating "subgraph cluster_foo { ... }" then because that's probably the most complexity you'll need (e.g. something that's very clearly in two or three semi-independent parts).
<aeth>
Without that, graphviz will basically group the nodes in the way that makes the most sense for it, not necessarily the way that makes the most sense for humans
<aeth>
(You can also say that "foo" and "bar" should have the same rank, i.e. same row)
<aeth>
Those two things are probably the only things a simple graph needs to control layout.
<Selwyn>
i see
makomo has quit [Quit: WeeChat 2.2]
makomo has joined #lisp
terpri has joined #lisp
varjag has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
bendersteed has joined #lisp
robotoad has quit [Quit: robotoad]
edgar-rft has joined #lisp
m00natic has quit [Remote host closed the connection]
robotoad has joined #lisp
robdog_ has joined #lisp
robdog_ has quit [Read error: Connection reset by peer]
robdog_ has joined #lisp
emaczen has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
zigpaw has joined #lisp
pierpal has joined #lisp
X-Scale has quit [Ping timeout: 244 seconds]
robdog_ has quit [Ping timeout: 250 seconds]
gravicappa has quit [Ping timeout: 246 seconds]
bhyde has joined #lisp
random-nick has joined #lisp
kolontaev has joined #lisp
makomo has quit [Quit: WeeChat 2.2]
Selwyn has quit [Remote host closed the connection]
<asarch>
One stupid question: generic dispatch is the same as polymorphism (both happen at run-time)?
<Bike>
"polymorphism" means several things. generic dispatch does happen at runtime, though.
<aeth>
But without fancy libraries like those, the only polymorphism you will see that are not at runtime (afaik) are number and sequence and array (and possibly stream?) operations that you cannot (portably) define yourself.
<aeth>
And all of these (afaik) will default to a slower runtime generic if there is not enough information at compile time.
JetJej has joined #lisp
* asarch
takes new notes...
rjid has joined #lisp
<jasom>
you can also use things like typecase to create your own polymorphic functions.
<aeth>
Typecase is great when there's one, or maybe two, arguments that you want to use the typecase on. Beyond that you would essentially have to build a truth table (except with potentially more than two values) out of nested typecases.
<aeth>
Just assume your dispatch is using a typecase for list or sequence (with sequence coming second so it's really sequence-and-not-list), which seems fairly common. If you want to be able to mix the two types then one argument is just 2, two arguments is 4, three arguments is 8, etc. Very similar to writing out the left hand side of a truth table.
rjid has left #lisp [#lisp]
emaczen has quit [Ping timeout: 250 seconds]
<aeth>
What's nice about typecases, though, is that you could have the sequence-generic version in an inline function and have it consist only of an etypecase/ctypecase that calls either the list version optimized for conses or the other-sequence version assuming O(1) elt access (really, it's written with vectors in mind, but it's also a fallback for implementations with extensible sequences).
<asarch>
Thank you
<asarch>
Thank you very much guys :-)
<aeth>
With the sequence inline typecase design, if the type is known to the compiler and the function is actually inlined by the compiler then the inline etypecase/ctypecase dispatch is removed and it directly calls the non-generic version. Otherwise, it has a very cheap dispatch left in there without inlining a potentially huge function.
<aeth>
It's a neat trick that can be an alternative to generics, especially if you only have one sequence argument.
<aeth>
With more than one sequence you'd probably want to use specialization-store, though.
<asarch>
Ok
<jasom>
I usually just start with generic functions and then if profiling tells me it's a problem I rewrite the parts that need it.
<aeth>
jasom: Yes, this is just a very special case where the performance gains and how to get them are a fairly simple pattern.
<aeth>
In general, I wouldn't start with an approach like this.
krwq has joined #lisp
robdog_ has joined #lisp
rozenglass has joined #lisp
robdog_ has quit [Ping timeout: 268 seconds]
themsay has joined #lisp
JetJej has quit [Quit: [Quit]]
eubarbosa has joined #lisp
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
bexx has joined #lisp
holycow has joined #lisp
janders223 has joined #lisp
atgreen has quit [Ping timeout: 244 seconds]
atgreen has joined #lisp
zmv has joined #lisp
notzmv has quit [Ping timeout: 246 seconds]
anamorphic has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
X-Scale has joined #lisp
pierpal has joined #lisp
emaczen has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<jackdaniel>
since nothing is going on I'll share a screenshot with clim streams maintaining a baseline and word wrapping (new feature): http://i.imgur.com/FjuYQ04.png
<holycow>
jackdaniel: that looks sweet :)
<holycow>
font rendering looks good too, but i don't remember if that was always the way
pierpal has joined #lisp
<jackdaniel>
no, during last few months font rendering had a lot of changes
<jackdaniel>
i.e arbitrary transformations and kerning were implemented
<jackdaniel>
thanks
vms14 has joined #lisp
<jackdaniel>
(of course transformations are not visible on this screencap)
fouric has joined #lisp
<holycow>
interesting to see the autowrap feature autowrap on full word and partial. i don't know if that is a standard to toolkits, but neat.
<jackdaniel>
per-character wrap is part of clim specification, on full word is an addition which was not pushed yet
<jackdaniel>
all depends on stream configuration (end-of-line-action slot namely)
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
<holycow>
that was fun! always love seeing mcclim screenshots
<jackdaniel>
this word wrap is a greedy approach, but I'm tempted to implement minimum raggedness
ft has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
Denommus has quit [Ping timeout: 250 seconds]
holycow has quit [Quit: Lost terminal]
eubarbosa has quit [Remote host closed the connection]
atgreen has quit [Ping timeout: 258 seconds]
orivej_ has joined #lisp
orivej has quit [Read error: Connection reset by peer]
janders223 has quit [Remote host closed the connection]
sonologico has joined #lisp
kajo has joined #lisp
<anamorphic>
When building a CFFI wrapper for something, what are the pros and cons of wrapping pointers in a defclass like, (defclass wrapper () (ptr :initform (cffi:null-pointer))? I see charms (the cl-ncurses fork does that for curses window-types.
<d4ryus>
aeth: ah, write-sequence, thank you :)
bendersteed has quit [Read error: Connection reset by peer]
serichsen has joined #lisp
<serichsen>
good evening
rtypo has joined #lisp
<Inline>
evening
LiamH has quit [Quit: Leaving.]
eubarbosa has joined #lisp
<Bike>
anamorphic: i would think the main thing is you can distinguish different kinds of pointers
<jackdaniel>
(hence, specialize on them)
<Bike>
yeah
<Bike>
and avoid confusing them with some other asshole's pointers and such
borodust has quit [Quit: Leavin']
<aeth>
The main con is pretty obvious: performance. You might be able to get some of that back in SBCL (not sure if other implementations have that optimization) by using defstruct instead of a defclass and typing the pointer's slot with the :type cffi:foreign-pointer
<aeth>
So that's sort of a middle ground in performance vs. convenience
<thrig>
safety, so you can free junk
<aeth>
(I think I have seen this struct-wrapped pointer thing before, so some people seem to think it's worth it)
<anamorphic>
There's a struct version of it in cl-autowrap which is exported
<aeth>
The implementation-specific read-eval optimization is probably unnecessary, though. Especially since you'd almost always initialize it *with* a pointer provided.
Zaab1t has quit [Quit: bye bye friends]
<anamorphic>
I guess my subclass would be via (defstruct (foo-wrapper (:include wrapper))) and in CFFI, i'd be doing something like (cffi:defctype foo (:wrapper :to-lisp #'make-wrapper :from-lisp #'wrapper-ptr))
<anamorphic>
and for the high level cffi wrapping function, something like this: (defun my-func (foo bar) (check-type foo 'foo-wrapper) (check-type 'bar-wrapper) (low-level-cffi-my-func foo bar ...
<aeth>
Are you using autowrap? I wouldn't pull in that very large library for what's essentially a two-liner
atgreen has joined #lisp
hiroaki has joined #lisp
sonologico has quit [Remote host closed the connection]
anamorphic has quit [Quit: anamorphic]
scymtym has quit [Ping timeout: 268 seconds]
kolontaev has quit [Quit: leaving]
borodust has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
angavrilov has quit [Remote host closed the connection]
<hjudt>
Xach: ql pgp and https improvements sound great!
<atgreen>
I just built a containerized mirror of the full quicklisp archive, and hacked the quicklisp client to use it in my environment (OpenShift). Xach - if you can suggest a better way to access it, I'd love to hear...
<Xach>
atgreen: hmm, I don't know - do you need access to everything just in case? or are there subsets you need for a particular task?
<asarch>
Just for fun. With CL REPL I can easily: | CL REPL [Server] |--->| Swank |--->| 1.0.0.1:4005 [Listening] |<---| Slime [Client] |
<asarch>
However, this time I am trying to use the SBCL of another PC: | SBCL |<---| Slime |--->| Swank |--->| 1.0.0.1.4005 [Listening] |<---| Slime [Client] |
<atgreen>
Xach - the mirror is no problem. I build the whole thing. The question is really about the best way to access it. I hack the quicklisp client for now
<Xach>
atgreen: hmm, maybe it could be done with the ql-http:*fetch-scheme-functions* instead.
<Xach>
pillton: my pleasure
robdog_ has quit [Remote host closed the connection]
<Xach>
atgreen: i think a mirror is a fine thing to do but I am not currently sure of the best way to use it with quicklisp. i'll have to think about it.
<atgreen>
ok, thanks. The mirror is useful as a container because it's easy to deploy, and helpful in my case where I am doing regular CI builds
<atgreen>
patching the client works fine for now. I had a quick look at *fetch-scheme-functions*, and I suppose you could map "http" to a new mirrored-http-fetch function that swaps the hostname before calling http-fetch.
<hjudt>
Xach: another question about quicklisp. when you build a system, you also test it by calling the -tests package or similar. i suppose this is done automatically and there is some scheme to follow to implement this correctly?
<Xach>
hjudt: incorrect premise
<Xach>
hjudt: i do not test it with a tests package.
<Xach>
atgreen: right
<hjudt>
Xach: ok. so you simply check for build failures?
<Xach>
hjudt: correct
<hjudt>
using an automated process?
shifty has joined #lisp
<asarch>
From SBCL itself, how do you know its version?
<Xach>
asarch: (lisp-implementation-version) is a portable way
<Xach>
hjudt: yes
<asarch>
"1.4.5.debian"
<asarch>
YEAH!!! \o/
<asarch>
Thank you guys!!!
<asarch>
Thank you very much!!! :-)
drl has quit [Quit: Ex-Chat]
<asarch>
It is good to hack with you!™
<asarch>
;-P
<hjudt>
Xach: in case of packages using foreign libs, do your tests also check which foreign libraries those need and whether they are present?
<phoe>
hjudt: the basic test done by Xach means that a library is loaded into the Lisp image; if a Lisp system depends on a foreign library, that means the foreign library is loaded as well. And, for that, it needs to be present on the system.
<phoe>
...on the operating system, I mean.
robdog_ has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
vms14 has quit [Remote host closed the connection]