Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
Essadon has quit [Quit: Qutting]
krwq has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
shifty has joined #lisp
<krwq>
hey, i think i've encountered some bug in perhaps sbcl - could anyone take another look to check if I'm perhaps not missing something? I've done something like this (simplified) https://pastebin.com/dKTz7eTR as a top level form in one of my systems. in my .sbclrc I've put ql:quickload on that system and ocassionally I get extra characters ('.' specifically) in the string. I suspect this is a dot coming from quicklis
<krwq>
p when it's loading stuff. when i click recompile or load it from slime everything seem to be working
<minion>
krwq, memo from pjb: In the case of oddp, it's implementation dependent since it returns a generalized boolean. But in the case of digit-char-p, the result is precisely specified. (however, all the main implementations return T from (oddp 3)).
<aeth>
someone should create a troll-CL that returns things technically allowed by the implementation. so e.g. for any unspecified generalized boolean, return 1 for true. Of course, in CL, 0 is also true, so that's why it would be a troll-CL
<aeth>
mess with expectations
<aeth>
Could actually have a use in seeing if certain programs aren't as portable as they could be
<no-defun-allowed>
is there a way that i can make, say handler-case, use a restart every time a certain condition is signalled?
<krwq>
no-defun-allowed: yes, let me find the example
<krwq>
what you do is do handler-bind and in the condition say something like this: (let ((restart (find-restart 'restart)))
<krwq>
(when restart
<krwq>
(invoke-restart restart)))
Mr-Potter has quit [Quit: Leaving]
<no-defun-allowed>
nice! thanks.
<krwq>
so i.e. something like (handler-bind ((error 'my-handler)) (do-something-which-makes-error))
<krwq>
and in the my-handler do the invoke-restart
<krwq>
i can't ever remember the syntax for that lol
<sjl>
It's common to define a function with the same name as the restart that invokes the restart, so you can then just (handler-bind ((foo-error #'some-restart)) ...)
<krwq>
sjl: i personally need it so rarely i can't even remember where to search for it but at least now I'll probably remember it's somewhere in the PCL
<krwq>
sjl: also same issue with conditional expressions in the format - always have to go to PCL
<no-defun-allowed>
got it, thanks
<sjl>
yeah I've googled for "clhs 22.3" probably several hundred times at this point
<no-defun-allowed>
had to reach in for the right restart symbol since it's an sbcl encoding problem
<sjl>
I should probably just print it out
Kundry_Wag has joined #lisp
zmt00 has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
isBEKaml has joined #lisp
makomo has quit [Read error: Connection reset by peer]
emar has joined #lisp
torbo has joined #lisp
isBEKaml has quit [Quit: WeeChat 2.3]
frodef has quit [Ping timeout: 258 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
wusticality has quit [Remote host closed the connection]
wusticality has joined #lisp
wusticality has quit [Ping timeout: 268 seconds]
permagreen has quit [Remote host closed the connection]
permagreen has joined #lisp
wusticality has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
karlosz has joined #lisp
<LdBeth>
Could someone suggests some historical readings about LOOP macro?
<vms14>
LdBeth: what you mean for "historical readings"
<PuercoPop>
LdBeth: historial readings?
<vms14>
you mean a good post or something that explains well what is the loop macro?
<vms14>
but sure will be inside historical lisp posts
<LdBeth>
Thanks
<vms14>
LdBeth: the only thing I see is when they proposed the loop macro, but there is not a "standalone" post
<vms14>
just some comments and mailing lists
gabiruh has joined #lisp
Kundry_Wag has joined #lisp
ebrasca has quit [Remote host closed the connection]
<wusticality>
hey folks - i'm looking for reasons to prefer CL instead of Clojure ..
Kundry_Wag has quit [Ping timeout: 244 seconds]
<wusticality>
I'm having a hard time coming from Clojure - I enjoy the consistency of Clojure's APIs, their use of [] {} #{}, its consistency, etc
<thrig>
I found clojure (java) too slow to get off disk
<no-defun-allowed>
clojure's use of [] {} #{} isn't consistent though
<vms14>
well, clojure has some advantages, like when you need to work with java, and when you need to work with js
<vms14>
and has some cool things, like the memoize some guy wanted to port to cl
<vms14>
weren't you?
<vms14>
xD
<no-defun-allowed>
which is about 10 lines of CL but ok
<vms14>
wusticality: for what you want cl or clojure?
<no-defun-allowed>
in fact, i'd wager most of clojure can be done in components, each 10 ballpark lines of CL
<vms14>
clojure has the advantage that it works on top of java, so it can just call its api
<vms14>
but then also has the disadvantages of java
<wusticality>
I'm finding it hard to come to CL, it being a Lisp 2
<vms14>
like eating ram as if it were a chrome browser
<wusticality>
I'm sure that's heresy, but it drives me crazy
<vms14>
what are you missing in cl?
<wusticality>
Also got used to Clojure's namespaces
<vms14>
just use the language with you feel more comfortable
<vms14>
but remember that clojure will have java's problems
<buffergn0me>
wusticality: Have you tried Racket
<wusticality>
I'm an engine programmer, but just sick of C / C++, so I'm building a real game in Lisp for fun
<wusticality>
Not a fan of Racket
<vms14>
sounds nice
<wusticality>
Clojure's concurrency primitives are pretty awesome
<wusticality>
Not sure about CL
<buffergn0me>
Depends on the implementation
<wusticality>
Clojure is not ideal, ironically, because of it's immutability (which I love)
<buffergn0me>
LispWorks has really nice concurrency support
<wusticality>
never gonna hit 60 fps allocating tons of stuff every frame
<wusticality>
like, even their vector type is actually like a trie I think, memory isn't contiguous
<wusticality>
vms14: what's the story for namespaces in CL?
<wusticality>
is it just a global function namespace?
<buffergn0me>
CL has packages, which is a single level (no nesting) namespace virtualization
<vms14>
you mean something to avoid name conflicts?
<vms14>
there it was something which I don't remember for avoiding name conflicts without using packages
<wusticality>
yeah sure - clojure has namespaces
<vms14>
I'll look about
<wusticality>
was it like classnames or something
<wusticality>
it's all namespace/function
egp__ has joined #lisp
egp_ has quit [Ping timeout: 258 seconds]
iovec has joined #lisp
<vms14>
oh man I cannot find it
<vms14>
but it made a symbol with a weird name like #gsr12
<LdBeth>
I heard these days JVM can be very compact, but I think it’s about mobile phone version
<vms14>
and only the function inside could call this symbol by it's name
rumbler31 has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
Kundry_Wag has joined #lisp
esrse has joined #lisp
robotoad has quit [Quit: robotoad]
<vms14>
wusticality: gensym
Kundry_Wag has quit [Ping timeout: 246 seconds]
<krwq>
wusticality: i don't know much clojure but maybe this: https://borodust.org/projects/cl-flow/ or lparallel would work for you as concurrency routines
<vms14>
also sbcl seems to have some thread support
robotoad has joined #lisp
<vms14>
SBCL provides support for native threads via its sb-thread package. These are very low-level functions
<LdBeth>
I think there’s some packages provided actor model based concurrency
<vms14>
btw LdBeth, I found nothing interesting about the history of lisp
<vms14>
lisp loops*
<LdBeth>
vms14: at least CLtL gives some insight, and I find something from CMU AI Repo
<krwq>
vms14: the most popular low level package for threads is usually bordeaux-threads
<krwq>
iirc lparallel builds on top of that, not sure about cl-flow
<vms14>
I've just tried a bit the C fork, so atm I don't care much about threads and processes XD
<vms14>
but I need to learn about sooner or later
<LdBeth>
vms14: May not very related to the topic, but I think the paper The Connection Machine has some interesting ideas about the importance of parallel computing
<vms14>
I have a book waiting for me
<vms14>
Unix network programming volume 1, which I started and talks only about sockets
<vms14>
it shows how to make concurrent servers in C
<vms14>
and the same name, but volume 2 which teachs about process interaction
<vms14>
fifos, semaphores, shared memory, etc. Whatever is IPC
<vms14>
I just steal books and finish no one
slyrus_ has joined #lisp
orivej has quit [Ping timeout: 244 seconds]
mrcom has quit [Read error: Connection reset by peer]
krwq has quit [Remote host closed the connection]
vms14 has quit [Quit: Going to fap...]
mrcom has joined #lisp
orivej has joined #lisp
Lord_of_Life has quit [Ping timeout: 258 seconds]
Lord_of_Life has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
gravicappa has joined #lisp
dddddd has quit [Remote host closed the connection]
egp__ has quit [Quit: Leaving]
egp_ has joined #lisp
egp_ has quit [Remote host closed the connection]
<beach>
Good morning everyone!
<LdBeth>
Morning
Kundry_Wag has joined #lisp
moei has quit [Ping timeout: 246 seconds]
Kundry_Wag has quit [Ping timeout: 250 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
notzmv has joined #lisp
gxt has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
Kundry_Wag has quit [Ping timeout: 250 seconds]
nowhere_man has joined #lisp
khisanth_ has quit [Ping timeout: 250 seconds]
wusticality has quit [Remote host closed the connection]
Bike has quit [Quit: Lost terminal]
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
khisanth_ has joined #lisp
rumbler31 has quit [Remote host closed the connection]
Guest86938 has quit [Remote host closed the connection]
Guest86938 has joined #lisp
<random-nick>
huh, I thought the hyperspec didn't list any documentation option, but I looked again and it
<random-nick>
does list it
<jackdaniel>
I've put it there to make you confused a few seconds ago ;-)
Essadon has joined #lisp
Essadon has quit [Max SendQ exceeded]
Essadon has joined #lisp
Guest86938 has quit [Read error: Connection reset by peer]
Guest86938 has joined #lisp
sindan has joined #lisp
Mr-Potter has joined #lisp
Selwyn has joined #lisp
Mr-Potter has quit [Remote host closed the connection]
Mr-Potter has joined #lisp
<phoe>
jackdaniel is such a mighty lisper that he retroactively edits the common lisp standard
<phoe>
I want to be like him one day
<jackdaniel>
lol
atgreen has quit [Ping timeout: 244 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Guest86938 has quit [Remote host closed the connection]
Guest86938 has joined #lisp
edgar-rft has joined #lisp
<flip214>
phoe: I guess you might want to have been like him one day, retroactively speaking ;)
<phoe>
(:
plugd has joined #lisp
<flip214>
jdz: looking at your (?) rfc2388 library I notice that it looks for the TNBL package (file uploads); hunchentoot still has that as a nickname, but perhaps it should be changed nowadays?
<flip214>
and another question - how do you feel about supporting file-uploads but not storing the file but just piping buffers into some function (in my usecase to hash it)?
<jdz>
flip214: Maybe. But then again, nobody is removing the TBNL nickname, right?
<jdz>
flip214: I was thinking about improving the library, but have not gotten around to do it...
<flip214>
jdz: btw: hunchentoot has a hook that should get called by rfc2388 after creating a file, but it seems it doesn't get called anywhere
Kundry_Wag has quit [Read error: No route to host]
<Selwyn>
i would like to configure SLIME so that M-. jumps to a source code file on a remote machine using plink/ssh, as opposed to searching for the source code on the local machine
<Selwyn>
does anyone have any pointers on how to do this?
Inline has joined #lisp
<jackdaniel>
Selwyn: in slime manual there is a passage about source pathname traslations
<jackdaniel>
this is not enogh, but that will show you what interfaces are used
<jackdaniel>
when you investigate how it is implemented you will notice, that that are easy to write elisp lambda which do the translation
<jackdaniel>
so you'll have to hack it to use your functions which perform translation with ssh:// path (this is not supported out of the box, but api is ready for that)
<jackdaniel>
so instead of (add-to-list 'slime-filename-translations (slime-create-filename-translator …)) you need to write your own selwym-create-filename-translator which initializes structure with your own translation functions
Lycurgus has joined #lisp
<Selwyn>
thanks very much
<jackdaniel>
you're welcome
shrdlu68 has quit [Quit: WeeChat 2.2]
heisig has quit [Ping timeout: 268 seconds]
robotoad has joined #lisp
sjl_ has joined #lisp
Selwyn has quit [Remote host closed the connection]
Selwyn has joined #lisp
Guest86938 has quit [Ping timeout: 252 seconds]
anamorphic has joined #lisp
ebrasca has joined #lisp
Selwyn has quit [Remote host closed the connection]
gko has quit [Ping timeout: 268 seconds]
gko has joined #lisp
flamebeard has quit []
Lord_of_Life_ has joined #lisp
LiamH has joined #lisp
robotoad has quit [Quit: robotoad]
vms14 has joined #lisp
Lord_of_Life has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
nullheroes has quit [Quit: WeeChat 1.9.1]
FreeBirdLjj has quit [Remote host closed the connection]
<dlowe>
I'd be interested in your experience if you decide to actually use it.
<aeth>
Usually things go the other way around and you embed an s-expression format of the desired language (which trivially maps to generated strings) in your Lisp/Scheme file rather than directly working in the syntax of the language with some embedded Lisp or mini-scripting-language or whatever
slyrus_ has quit [Ping timeout: 258 seconds]
<ober>
interesting
<ober>
thanks
<aeth>
dlowe: do you use reader macros in your system?
rozenglass has quit [Ping timeout: 250 seconds]
<dlowe>
aeth: yeah, it's essentially just a couple of reader macros plus some supporting functions.
Kundry_Wag has joined #lisp
sauvin has quit [Ping timeout: 268 seconds]
<dlowe>
I've thought about making a more complete templating solution, which would track dynamic evaluation contexts that would basically be filters on the output of embedded code.
rk[ghost] has joined #lisp
<dlowe>
So, for instance, it would know if an embedded value needed to be url-encoded
<dlowe>
Simple is good too, though.
X-Scale has quit [Ping timeout: 268 seconds]
<rk[ghost]>
suggest library for communicating to a tty serial device?
Kundry_Wag has quit [Ping timeout: 258 seconds]
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<hjudt>
i guess it already does. that's part of the problem. and it is not my server.
zmt00 has quit [Quit: Leaving]
<hjudt>
hm. but maybe 302 is not a plain redirect?
<hjudt>
no, at the moment it is 301. i will suggest this.
<ober>
I had the same issue.
<hjudt>
i have posted this proposal at #shirakumo. we'll see...
<ober>
search the logs, Xach had explained the problem
<ober>
when I brought this up previously
<d4ryus>
Hi, is this: https://pastebin.com/AxrMF3mV expected behaviour? (sbcl 1.4.13) If so, why? can anyone point me to some documentation explaining what iam missing?
dtornabene has quit [Quit: Leaving]
<Bike>
That's because sbcl's LOOP just alters a single i over the course of the loop, rather than establishing a new binding each time.
<Bike>
It's a confusing point.
<Bike>
If you replace the lambda with (let ((x i)) (lambda () (format t "~a~%" x))) you should see what you presumably expect.
<Bike>
let me see if i can find a clhs reference.
ebrasca has quit [Read error: Connection reset by peer]
<Bike>
i don't remember where it is.
<d4ryus>
Bike: ok, thanks
<dlowe>
the inner lambda saves the box, not just the value
<dlowe>
the box (along with its bound value) persists as long as the lambda does
usr123 has quit [Ping timeout: 256 seconds]
Josh_2 has joined #lisp
anamorphic has joined #lisp
akoana has left #lisp ["Leaving"]
relligions has joined #lisp
<relligions>
hey
<relligions>
if I write bitcoin in lisp vs C
<makomo>
hello qo
<minion>
makomo, memo from jackdaniel: please leave me your email address on query, I want to contact you (and you seem to be disconnected)
<relligions>
will lisp one be faster than C
<makomo>
\o*
<makomo>
ah
<relligions>
provided both are optimized
scymtym has joined #lisp
<dlowe>
no.
<dlowe>
relligions: you should write bitcoin in C.
<d4ryus>
dlowe: yes, makes sense, thank you
<relligions>
why? not lisp?
<Josh_2>
How do you write bitcoin?
<relligions>
by writing the software in C
<Josh_2>
(format t "bitcoin")?
<relligions>
I'd like my own
<relligions>
Josh_2: stop joking.
<dlowe>
relligions: have you ever programmed before?
<relligions>
This is serious . I am tallking of some other coin. yes I do
<relligions>
I know C
<anamorphic>
Am I basically SOL if I'm Windows and want to use a library that does "grovelling"?
zmt00 has joined #lisp
<dlowe>
anamorphic: grovelling just automates a tedious process. You could write your own ffi definitions.
<relligions>
if I were to write my own cryptocurrency will lisp sbcl be faster than optimized C ?
<relligions>
but they told me on #lisp it would be faster than C
<dlowe>
This is #lisp
Bike has quit [Ping timeout: 256 seconds]
<relligions>
ok as fast is enough. dlowe on ##c they told me this is ##c
<relligions>
I just don't want lisp to be slower- that's all
<dlowe>
however, computation speed isn't very relevant for a cryptocurrency implementation
Bike has joined #lisp
<jackdaniel>
usually biggest bottlenecks come from wrong structures / naive algorithms used
<jackdaniel>
of course highly optimized code may get even x1000 faster than the same code which is not optimized by the compiler, but wrong structure/algorithms give you systematic performance drop (i.e polynomial)
<relligions>
so if I use python ... it depends on the algorithm ?
<relligions>
can I use python?
<dlowe>
implementation speed provides a lower bound for performance
<jackdaniel>
if you pick good algorithm / data structure and implement it in python, you are good. also nobody forbids you to use python
<relligions>
ok then
<jackdaniel>
that said python is offtopical on this channel, so you'd need to look for other people to help you (guide, advise etc)
<relligions>
but if I use the best algorithm for both C and lisp how slow is lisp when compared, provided both are optimized.
<relligions>
I already know c and python. but it's time I think for me to try lisp
<aeth>
well you don't use CL to rewrite a major, mature C program for *better* performance
Zaab1t has quit [Quit: bye bye friends]
<aeth>
our visitor seems to have had the impression that Lisp is the thing you switch to for the sake of performance
<aeth>
(of course, rewriting in CL *might* give you better performance, if the architecture of the C program was rubbish)
<jackdaniel>
my (maybe unjustified) impression is that he wanted to troll us but didn't find enough rage so left with disappointment
<aeth>
pjb: you can't do factorial in C without some library like GMP, so your comparison isn't really fair.
isBEKaml has joined #lisp
<aeth>
jackdaniel: on the other hand, everyone who doesn't use Lisp seems to have a strange view about Lisp
<pjb>
You cannot do anything in C without some library and 30x more code than in lisp!
<pjb>
just use libecl.
<jackdaniel>
libecl is a C program, but it is also a Common Lisp
<jackdaniel>
that gives are clear conclusion, that C is exactly as fast as Common Lisp
<pjb>
:-)
<jackdaniel>
because how libecl could be faster (or slower) than libecl?
<aeth>
I think the correct answer to which language is faster is: Common Lisp is as fast of a language as C, we just don't have the massive amount of resources like GCC and LLVM have to actually complete the optimizations.
<aeth>
I doubt the implementations would turn down the patches.
<pjb>
Of course we have them. We have jackdaniel to implement ECL!
<pjb>
jackdaniel is a massive amount of resources like gcc in himself! :-)
<jackdaniel>
even correctER answer is that that languages are notation which doesn't have inner speed
anamorphic has quit [Quit: anamorphic]
<jackdaniel>
nb: gcc is not very good for compiling lisp to for many reasons
<jackdaniel>
compiling to LLVM's IR gives you more latitude
anamorphic has joined #lisp
<jackdaniel>
s/to gcc/to c/
<aeth>
On the one hand, implementations have speed, not languages. On the other, some languages (and language features, like fexprs) are harder to make fast than others.
<pjb>
jackdaniel: well, LLVM is not C. Targetting C has some advantages. I guess LLVM retain them (portability) in a different way.
<aeth>
With CL, you should be able to reach C-level speed (or faster) with a fast subset of CL with the only necessary overhead being the GC. The 1.5x to 3x slower at best in practice comes from the implementations not being as fast as they could be.
<dlowe>
"as fast as they could be" is either empirically determined or an unknown quantity, depending on how you interpret it
dddddd has quit [Ping timeout: 250 seconds]
<aeth>
dlowe: Empirically, write the same thing in C or C++ and optimized CL, time them (make sure C is at max optimizations), do a ratio of CL over C. That shows you roughly how much the CL implementation could be improved in that microbenchmark for that particular thing. You do have to choose something that's semantically identical and could in theory generate the same ASM, though.
orivej has quit [Ping timeout: 258 seconds]
<aeth>
Of course, the C/C++ probably could also be improved a bit, but I'm assuming diminishing returns in optimizations, too, so it probably won't be off by much.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<dlowe>
Assuming I didn't do something dumb like unintentionally prevent the compiler from generating vector operations.
<aeth>
Yes. You would need expert-level optimized C (or C++, if that's what you choose as the "about as fast as current compilers get" representative) and optimized CL, which could mean writing things in non-obvious ways. Not easy.
<aeth>
And I suspect the former is what's usually missing with various published "$foo is faster than C" microbenchmarks.
<pjb>
THe problem is to write the same thing. As this lisp-vs-c example demonstrate, writing the same thing implies greenspunning, or using libecl.
<pjb>
Ie. the only valid comparison leads you to use Common Lisp.
<aeth>
pjb: you picked a bad example.
<pjb>
Nope.
<pjb>
There are tons of examples. C is not a language to write applications in. It's a high level assembler to write unix kernels.
<aeth>
There's lots of e.g. numerical code that could afaik run pretty much identically, especially e.g. single-float/double-float code with float traps disabled, assuming the optimizers don't ruin the semantics of the calculations
<dlowe>
cryptocurrency hashing is certainly not something that needs greenspunning
<aeth>
I mean, you probably won't get much beyond numerical stuff, but, hey, at least you get CL as a better FORTRAN...
<pjb>
aeth: just activate the new -fsanitize options and have fun with your numerical C code (just integer already!)
cage_ has quit [Remote host closed the connection]
<pjb>
There's not only the running speed.
<dlowe>
pjb: what does it matter that I use libgmp or some CL implementor's bignum
<aeth>
pjb: no, crypto probably would do better with manual bignums, stuff like (make-array 4 :element-type '(unsigned-byte 64) :initial-element 0)
<aeth>
bignums are good for the general case, but if the specific case is well specified, you can make a better specific representation
<dlowe>
FSVO "you"
<dlowe>
I think "language implementations provide a lower bound on performance that can only be roughly estimated" as about as specific as one can say
rozenglass has joined #lisp
ebrasca has joined #lisp
akoana has joined #lisp
shifty has joined #lisp
Essadon has quit [Ping timeout: 252 seconds]
<White_Flame>
aeth: or a compiler could be taught that fixed-size integers larger than fixnum could be optimized
<White_Flame>
it doesn't (shouldn't) always fall on the user
<aeth>
White_Flame: Compilers (can) do that for (unsigned-byte 64) and (signed-byte 64)
<aeth>
Of course, there is a line somewhere.
<thrig>
and Johnny Cash walks it
holycow has joined #lisp
jstypo has quit [Read error: Connection reset by peer]
akoana has left #lisp ["Leaving"]
jstypo has joined #lisp
<White_Flame>
aeth: yeah, I obviously mean multiples of the register size
<White_Flame>
(greater than 1 ;) )
<aeth>
well even 1 is something that's not always supported
dddddd has joined #lisp
anamorphic has quit [Quit: anamorphic]
anamorphic has joined #lisp
atgreen has quit [Ping timeout: 245 seconds]
JetJej has quit [Quit: [Quit]]
yvy has quit [Read error: Connection reset by peer]
flazh has joined #lisp
anamorphic has quit [Quit: anamorphic]
angavrilov has quit [Remote host closed the connection]
varjagg has quit [Quit: ERC (IRC client for Emacs 26.1)]
LiamH has quit [Quit: Leaving.]
Mr-Potter has quit [Quit: Leaving]
holycow has quit [Quit: leaving]
atgreen has joined #lisp
Bike has quit [Ping timeout: 256 seconds]
isBEKaml has quit [Quit: WeeChat 2.3]
Kundry_Wag has joined #lisp
random-nick has quit [Ping timeout: 246 seconds]
Kundry_Wag has quit [Ping timeout: 250 seconds]
<hjudt>
Xach: have you considered for quicklisp using ql-http only for initial setup and once setup load some other system like drakma or dexador and use that for doing https?
<jmercouris>
hjudt: having http anywhere is an issue, it has to be https from the very beginning or nothing, ql could come WITH drakma
<jmercouris>
instead of loading drakma, bundle it into the QL codebase, however heavy and clunky that would be
<hjudt>
jmercouris: one could use some stripped down version perhaps, but that's probably still missing the cl-ssl stuff or whatever is needed.
sjl_ has quit [Ping timeout: 258 seconds]
* hjudt
chuckles. this is a bit like rubygems which still can't do ipv6
<hjudt>
anyway, as long as servers can still do http this should not be a big problem.
<zigpaw>
I think lack of embedded https (so using http), at least for bootstrapping is not an issue if ql would come with checksums for those libraries needed for ssl that it would pull in while installing. On the other hand, embedding everything might be just easier.
<thrig>
a checksum written by whom?
<zigpaw>
by ql author presumably?
<zigpaw>
(for bootstrapping ssl libraries only - so hardcoded, if that wasn't clear enough)
<thrig>
so the attacker checksums something, and then...
<Xach>
hjudt: it is possible now to do that
<zigpaw>
I think I don't follow, what checksums the attacker? if he can alter the hardcoded checksum inside ql bootstrapping code he can already change anything.
<Xach>
I have a setup that is nearly ready to be deployed that works like this: download bootstrap via https, bootstrap code verifies fetched client code via openpgp, client code verifies indexes via openpgp, indexes include digests to verify further downloads.
<Xach>
portable ssl/tls is a problem that led to this somewhat convoluted solution
shka_ has quit [Ping timeout: 244 seconds]
<zigpaw>
As long as someone can curl/wget the bootstrap code via https, openpgp is even an overkill in my opinion. So congratulations :-)
Kundry_Wag has joined #lisp
<thrig>
other package systems do not rely on https
Kundry_Wag has quit [Ping timeout: 245 seconds]
robdog has quit [Ping timeout: 268 seconds]
<zigpaw>
they always should relay on pulling bootstrap code via https (or indirectly via https from linux/bsd distro package manager), or users should verify checksums manually - which they never do.
<thrig>
got a lot of trusted certificates in that there bloaty browser