Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
damke has quit [Ping timeout: 264 seconds]
Bike has joined #lisp
loli has joined #lisp
damke has joined #lisp
loli has quit [Client Quit]
LiamH has quit [Quit: Leaving.]
loli has joined #lisp
loli has quit [Client Quit]
pierpa has joined #lisp
Cymew has joined #lisp
figurehe4d has joined #lisp
beach` has joined #lisp
vtomole has joined #lisp
fisxoj has joined #lisp
loli has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
loli has quit [Client Quit]
beach has quit [Ping timeout: 256 seconds]
shifty has joined #lisp
smasta has joined #lisp
newcomerr has joined #lisp
loli has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
EvW has quit [Ping timeout: 265 seconds]
loli has quit [Quit: WeeChat 2.0.1]
dddddd has joined #lisp
newcomerr has quit [Quit: leaving]
sysfault_ has joined #lisp
sysfault_ has quit [Client Quit]
sysfault has quit [Quit: Leaving]
sysfault has joined #lisp
sysfault has quit [Client Quit]
al-damiri has quit [Quit: Connection closed for inactivity]
sysfault has joined #lisp
PinealGlandOptic has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
jstypo has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
sysfault has quit [Quit: leaving]
sysfault has joined #lisp
igemnace has quit [Quit: WeeChat 2.0.1]
edgar-rft has joined #lisp
jtroseme has joined #lisp
loli has joined #lisp
aindilis` has quit [Remote host closed the connection]
lnostdal has joined #lisp
Kundry_Wag has joined #lisp
aindilis` has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
philosau1 has quit [Quit: philosau1]
python476 has quit [Ping timeout: 256 seconds]
philosaur has joined #lisp
sysfault has quit [Quit: leaving]
fikka has joined #lisp
sysfault has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
aindilis` has quit [Remote host closed the connection]
EvW has joined #lisp
aindilis has joined #lisp
python47` has joined #lisp
Amplituhedron has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
ckonstanski has quit [Remote host closed the connection]
sjl has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Ping timeout: 256 seconds]
<emaczen>
what format argument gives me fixed width?
<emaczen>
Oh, just a number before the ~A or whatever type
<edgar-rft>
fixed-width font?
nhandler has quit [Remote host closed the connection]
<pierpa>
the width is the first argument, there can be several other.
nhandler has joined #lisp
damke_ has joined #lisp
willmichael has quit [Ping timeout: 256 seconds]
nhandler has quit [Remote host closed the connection]
damke has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 240 seconds]
nhandler has joined #lisp
nhandler has quit [Remote host closed the connection]
jtroseme has quit [Remote host closed the connection]
nhandler has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
drewc has quit [Read error: Connection reset by peer]
paul0 has joined #lisp
orivej has joined #lisp
d4ryus1 has joined #lisp
d4ryus has quit [Ping timeout: 260 seconds]
warweasle has joined #lisp
Oladon has joined #lisp
Kundry_Wag has joined #lisp
mikecheck has joined #lisp
loli has quit [Quit: WeeChat 2.0.1]
Kundry_Wag has quit [Ping timeout: 260 seconds]
nhandler has quit [Remote host closed the connection]
drewc has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
nhandler has joined #lisp
Kundry_Wag has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 256 seconds]
loli has joined #lisp
saki has quit [Quit: saki]
loli has quit [Quit: WeeChat 2.0.1]
loli has joined #lisp
saki has joined #lisp
tokik has quit [Ping timeout: 265 seconds]
tokik has joined #lisp
ckonstanski has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
emacsomancer has joined #lisp
python47` has quit [Ping timeout: 252 seconds]
<ckonstanski>
Hunchentoot questions OK here?
smurfrobot has joined #lisp
<Bike>
you bet
warweasle has quit [Quit: Leaving]
drewc has quit [Ping timeout: 245 seconds]
<ckonstanski>
I need to implement my own user session persistence because it needs to be stored in the database. This is done; that's not the issue. The issue is integrating it with hunchentoot's session cookie handling. There is this blurb about it in the hunchtntoot docs:
<ckonstanski>
The other way to customize Hunchentoot's sessions is to completely replace them. This is actually pretty easy: Create your own class to store state (which doesn't have to and probably shouldn't inherit from SESSION) and implement methods for SESSION-VERIFY and SESSION-COOKIE-VALUE - that's it.
<ckonstanski>
Question: session-verify and session-cookie-value: I'm not entirely clear on how these are to be implemented. Do I create a file that is in the hunchentoot package? Or does hunchentoot somehow find my functions that are in my app's package?
vtomole has quit [Ping timeout: 260 seconds]
johnnymacs has joined #lisp
<johnnymacs>
Is it possible to write an ansi compliant lisp that uses pushable and popable hash tables instead of lists?
<ckonstanski>
If I'm not supposed to inherit from session then CLOS isn't going to find these methods..
<johnnymacs>
oops nvm support question going on already don't mind me
<Bike>
johnnymacs: as long as it does cons/car/cdr the underlying implementation is irrelevant
smurfrobot has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
<ckonstanski>
My other option is to completely sidestep hunchentoot's session handling and do the cookie mysrlf. I'm so close to just going this route. But I want to take a stab at doing it the Right Way.
beach` is now known as beach
Kundry_Wag has joined #lisp
<nydel>
is there a function already that is like #'/ but evaluates down to a float rather than ratio even if given integers? like (/ x y) would be as if it were (/ (* 1.0 x) y) ?
<nydel>
i.e. is this something i should add to my own set of tools or is it usually part of a lisp by some other function name
<beach>
Good morning everyone!
<beach>
nydel: (float (/ x y))
<nydel>
morning beach! hope you're well
<beach>
Yes, thanks. You too, I hope.
<nydel>
thanks i'm well and thanks, that's a much simpler answer than what i was going to try
<nydel>
it involved coerce so.. yeah. thanks
<beach>
Sure.
Kundry_Wag has quit [Ping timeout: 245 seconds]
<fouric>
Question: why do we use GENSYM in many macros instead of just manually creating an ininterned symbol with '#:foo?
<fouric>
It seems like the latter would be much easier to read while manually macroexpanding for debugging.
<beach>
fouric: Because macro invocations might be nested, and then you would have a symbol clash.
<fouric>
...oh.
<fouric>
Derp.
<fouric>
ty
<beach>
ywlcm
omilu has joined #lisp
nika has joined #lisp
<fouric>
...I actually don't understand this.
<fouric>
Wouldn't the '#:x in each macro be read in as a separate symbol?
<beach>
Yes, but you can have nested invocation of one and the same macro.
<beach>
(with-my-stuff (a) (with-my-stuff (b) (do-stuff (+ a b)) (do-stuff (- a b)))) Suppose WITH-MY-STUFF expands to something containing #:x, then in the DO-STUFF forms, you could get the wrong #:x.
<Bike>
the definition of the macro is only read once
<beach>
If I were more awake, I might come up with an example.
<ckonstanski>
Isn't there also a potential issue with a symbol in your macro colliding with a free variable?
<fouric>
beach: I've been trying to but my LSP stat is too low ):
<beach>
ckonstanski: Only if it comes from a different invocation of the same macro.
<fouric>
Something is wrong with this example but I'm not sure what.
<beach>
I was thinking of nested invocations, not by the macro body itself, but by the user, e.g., as in my example above. Something not predicted by the macro author.
Oladon1 has joined #lisp
<fouric>
(to be clear: I believe you that this is the case, but it's not obvious to me *why*, which is why I'm continuing to ask questions)
<pjb>
fouric: (defmacro m () `'#:foo) (m) -> #:FOO (eq (m) (m)) -> T
<pjb>
this is the reason why we use gensym.
<fouric>
Beautiful. Thanks!
<pjb>
The point is not of having an uninterned symbol for having an uninterned symbol, but of having a UNIQUE symbol.
<pjb>
You could use gentemp instead of gensym.
<pjb>
The only thing with gentemp, is that user provided symbols could be identical to a symbol returned by gentemp, so it wouldn't be unique.
<pjb>
But sometimes, to debug a macro, you could s/gensym/gentemp/ temporarily.
<pjb>
Notice that you can also pass a prefix argument: (gensym "FOO") --> #:FOO49371 to make it more readable.
<pjb>
gentemp takes this prefix too.
<pjb>
(gensym "RESULT-") --> #:RESULT-49372
fikka has quit [Ping timeout: 240 seconds]
<pfdietz>
Uninterned symbols do have the advantage of not sticking around after they've been created, if there are no references. Interned symbols are referenced by the tables for the package and can never be GCed.
<fouric>
ckonstanski: I think I might be able to make a partial stab at an answer for your question
<fouric>
if it wasn't answered already
<fouric>
wait nvm
<fouric>
...hm, actually, if there was a generic method SESSION-VERIFY defined, then if you implemented it for a completely separate class, shouldn't it still be "found" by hunchentoot?
damke has joined #lisp
mikecheck has left #lisp ["part"]
cbs has joined #lisp
<fouric>
there's a defgeneric session-verify (request)
<fouric>
in session.lisp
smokeink has joined #lisp
<fouric>
I'm not good enough with packages to know whether you'd (defmethod session-verify ...) or (defmethod hunchentoot:session-verify ...), but I *think* that that would work.
damke_ has quit [Ping timeout: 264 seconds]
smasta has quit [Ping timeout: 245 seconds]
<smokeink>
if *package* is hunchentoot then you can use the first form
<smokeink>
(of course, the 2nd one also works) if *package* is something different, for example :cl-user and you didn't import the symbol session-verify in it, you can use (defmethod hunchentoot:session-verify ...)
<fouric>
oh, right
smasta has joined #lisp
<fouric>
I was more concerned with Hunchentoot doing things to prevent you from modifying its functions, like the "package lock" placed on cl-user and some SBCL packages - but then i realized that that would be silly in this case.
<fouric>
smokeink: how do you "import" a symbol?
<ckonstanski>
Hunchentoot already has implementations for these two methods. (One specializes on session, the other on request.) The only thing that makes sense to me is: if I reimplement these methods, mine will overwrite the originals because they are compiled later. That seems like it would work, but it's kludgy.
<ckonstanski>
If you just (:use #:hunchentoot) then you import all of its exported symbols.
<smokeink>
:use is to tell it that you want all symbols from those packages
<Bike>
use isn't importing
smasta has quit [Ping timeout: 245 seconds]
<ckonstanski>
Semantics. You don't have to fully-qualify the names.
Duns_Scrotus has quit [Ping timeout: 240 seconds]
<fouric>
ckonstanski: you should be able to just do (defmethod session-verify ((session my-class)) ...)
banjiewen has quit [Ping timeout: 240 seconds]
<mfiano>
ckonstanski: I would strongly recommend developing for clack instead of hunchentoot so that your persistent session code works for any web server instead of being tied to an old web server such as hunchentoot.
<Bike>
they have different semantics
jyc has quit [Ping timeout: 240 seconds]
<fouric>
wait sorry
<fouric>
i didn't see the other thing you wrote
<fouric>
one sec
splittist has quit [Ping timeout: 256 seconds]
billstclair has quit [Ping timeout: 265 seconds]
<ckonstanski>
Never heard of clack. Looking...
dmh has quit [Ping timeout: 240 seconds]
mjl has quit [Ping timeout: 240 seconds]
jeremyheiler has quit [Ping timeout: 240 seconds]
danlentz has quit [Ping timeout: 256 seconds]
<Bike>
also, USE is only exported symbols, and given this symbol is apparently internal...
mbrock has quit [Ping timeout: 256 seconds]
alms_clozure has quit [Ping timeout: 256 seconds]
zkat has quit [Ping timeout: 256 seconds]
<smokeink>
mfiano: does clack have good documentation ?
XachX has quit [Read error: Connection reset by peer]
devlaf has quit [Read error: Connection reset by peer]
CEnnis91 has quit [Read error: Connection reset by peer]
drmeister has quit [Read error: Connection reset by peer]
tfb has quit [Read error: Connection reset by peer]
asedeno has quit [Read error: Connection reset by peer]
ggherdov has quit [Read error: Connection reset by peer]
tazjin has quit [Read error: Connection reset by peer]
trig-ger has quit [Read error: Connection reset by peer]
d4gg4d_ has quit [Read error: Connection reset by peer]
terrorjack has quit [Read error: Connection reset by peer]
gendl has quit [Read error: Connection reset by peer]
stylewarning has quit [Read error: Connection reset by peer]
weltung has quit [Read error: Connection reset by peer]
Meow-J_ has quit [Read error: Connection reset by peer]
kilimanjaro has quit [Read error: Connection reset by peer]
angular_mike_ has quit [Read error: Connection reset by peer]
gbyers has quit [Read error: Connection reset by peer]
rann has quit [Read error: Connection reset by peer]
tobel has quit [Read error: Connection reset by peer]
rvirding has quit [Read error: Connection reset by peer]
l1x has quit [Read error: Connection reset by peer]
<ckonstanski>
I just got off of araneida...
jerme_ has quit [Ping timeout: 255 seconds]
p_l has quit [Ping timeout: 256 seconds]
johs has quit [Ping timeout: 256 seconds]
gz_ has quit [Ping timeout: 256 seconds]
Kevslinger has quit [Ping timeout: 252 seconds]
adulteratedjedi has quit [Ping timeout: 256 seconds]
convexferret has quit [Ping timeout: 256 seconds]
raynold has quit [Ping timeout: 252 seconds]
<smokeink>
I gave clack a try but I couldn't figure out how to tell it where to store the logs
Kevslinger has joined #lisp
l1x has joined #lisp
drmeister has joined #lisp
<fouric>
Wait, you wouldn't be "reimplementing" the methods if you performed defmethod later, unless you had it specialize on exactly the same types
<ckonstanski>
The README.md is tiny. Hunchentoot is still active, albeit it got its atart in the early 2000s.
<ckonstanski>
Araneida dies in 2005.
CEnnis91 has joined #lisp
<fouric>
you'd be declaring a separate generic function, and isn't that dispatch done at run-time *anyway*?
<smokeink>
session-verify is exported by hunchentoot . Bike: so what's the difference between (:use)ing a package and manually importing all its external symbols ?
<Bike>
yeah, i couldn't think of a way to do it without some macrolet
schoppenhauer has quit [Ping timeout: 255 seconds]
gendl has joined #lisp
adulteratedjedi has joined #lisp
jyc has joined #lisp
dmiles has quit [Ping timeout: 245 seconds]
<fouric>
i can knock it off if you like, i just figure that a sane default is to verbally express gratitude
<fouric>
erm
<fouric>
or expand into a full sentence, either way
devlaf has joined #lisp
schoppenhauer has joined #lisp
raynold has joined #lisp
<beach>
Somehow "ty" just rubs me the wrong way. It is an indication that people either use the wrong tools or don't know how to use the right one.
willmichael has joined #lisp
<ckonstanski>
Neat trick. You could have "fu" expand to "Thank you for the constructive advice. I will endeavor to implement it in my daily work." And similar abbrevs for "yourmom" and "eatshit". Simple pleasures. I wonder if slack can do this?
<beach>
ckonstanski: To me, using abbrevs is not a "trick". It is a tool that saves me a lot of typing on a daily basis. One of many tools to improve my productivity.
fikka has joined #lisp
dmiles has joined #lisp
rme has joined #lisp
XachX has joined #lisp
johs has joined #lisp
asedeno has joined #lisp
edgar-rft has quit [Quit: Don't Cry for Me, Argentina...]
krwq has joined #lisp
<smokeink>
beach: if the motivation for that (lb) binary logarithm function wasn't the performance, then what was it? Is it more precise than CL's (log x 2) ?
<fouric>
beach: thank you
<fouric>
noice
<fouric>
script complete
aindilis has quit [Read error: Connection reset by peer]
<smokeink>
cuz I can see that (lb big_x) ==> 792481.2503605781d0 while (log big_x) ==> 792481.25 , but I think the decimals after .25 are not correct or precise
<smokeink>
s/(log big_x)/(log big_x 2)/
gbyers has joined #lisp
gz_ has joined #lisp
d4gg4d_ has joined #lisp
convexferret has joined #lisp
billstclair has joined #lisp
dmh has joined #lisp
rann has joined #lisp
Bike has quit [Quit: Lost terminal]
saki has quit [Remote host closed the connection]
<smokeink>
It can't have better precision than (log) because it uses arithmetic shift for hundreds of digits, and then it still uses (log) under the hood but only for 100 digits
saki has joined #lisp
alms_clozure has joined #lisp
mbrock has joined #lisp
mjl has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
<smokeink>
so it's faster because it has less precision
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 276 seconds]
vtomole has joined #lisp
nika has quit []
sjl has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
terrorjack has joined #lisp
<beach>
smokeink: Oh, I just wanted to see how it could be implemented for large integers without losing precision.
<beach>
smokeink: I am actually surprised that it might be able to compete with the native SBCL implementation.
<smokeink>
well, it uses sbcl's implementation :)
<beach>
Only for floats.
<beach>
smokeink: It preserves 100 digits precision which is more than what is available in DOUBLE-FLOAT on SBCL.
deng_cn has joined #lisp
<beach>
Also, it looks like SBCL returns a SINGLE-FLOAT.
<smokeink>
that's the part which I don't get
<beach>
I shift right with 100 fewer digits than the integer-length of the number.
sjl has quit [Ping timeout: 265 seconds]
<beach>
So, I have 100 digits left.
<smokeink>
yes there are 100 digits left, upon which sbcl's (log) does the calculation
<beach>
I convert those 100 digits to a double float, leaving less than 60 digits mantissa in the double float.
<beach>
I forget the exact number of mantissa bits in double float.
<beach>
Then I take the LOG of that, presumably using a machine instruction.
<beach>
So the precision of the argument to LOG is very high (provided the conversion to DOUBLE-FLOAT is accurate), and therefore also the result of computing the LOG.
<beach>
To that result, I add an exact integer.
igemnace has joined #lisp
<beach>
I don't see how the precision can be higher than that.
<smokeink>
and the hypothesis is that taking (log) of 100 digits of a number, which are converted double float, is more precise than taking (log) of the whole number ? how to prove that?
<beach>
No, but it can't be less precise either.
smasta has joined #lisp
<smokeink>
the precision comes because doing it upon a double float is inherently more precise than doing it on an integer?
<beach>
There is no machine instruction for taking the LOG of a bignum.
<beach>
So that is up to the implementation.
fisxoj has quit [Quit: fisxoj]
<beach>
The implementation might use several possible strategies:
<beach>
1. It could try to compute the LOG itself, not using the machine instruction.
<beach>
2. It could convert the big number to a float, and then use the machine instructio.
<beach>
3. It can do what I did.
<beach>
and possibly more ways that I can't think of right now.
<smokeink>
"So the precision of the argument to LOG is very high" , so the original number can't be converted directly to double float because it's too big, but those 100 digits can ?
<beach>
Well, what is the biggest possible exponent in a double-float?
<beach>
10^1023 it looks like. That would be 2^3000 or so.
<smokeink>
ok. I'll try to find a counter example, a number that gives different results with (lb)
<smokeink>
just to explore and to understand what's really happening there
<beach>
Sure.
<beach>
smokeink: Try calling my function on (expt 10 2000).
<beach>
Then try (float (expt 10 2000) 1d0).
<smokeink>
Too large to be represented as a DOUBLE-FLOAT
fikka has quit [Ping timeout: 240 seconds]
<beach>
By the way, my function is NOT faster than SBCL LOG.
<beach>
smokeink: See?
<beach>
So the implementation must do something else.
<smokeink>
oh
<smokeink>
(lb) is slower than sbcl's (log) only for small numbers , but for big numbers it's faster - at least this is what my tests showed
<beach>
All I did was to make an educated guess about how an implementation could deal with taking the LOG of integers that are bigger than what can be represented in the highest-precision float format that it supports.
<beach>
OK, let me try for some really huge numbers.
<smokeink>
I just tried with (expt (expt (expt 3 5000) 10) 10)
<smokeink>
for small numbers (less than 100 digits) all the arithmetic shifting is just extra work, so we could add an if < (integer-length ...) 100 ) ;then use the sbcl's log directly, else use your method
<beach>
I can't reproduce that result.
<smokeink>
I'll put the code up
sjl has joined #lisp
<smokeink>
maybe I did something or saw it wrongly
<beach>
I do get comparable performance for very large numbers though, but not as spectacular as what you get.
dddddd has quit [Remote host closed the connection]
<smokeink>
do you mean that formula? if not, what factor ?
<beach>
Yes, that one.
<smokeink>
all right
<smokeink>
btw are you using sbcl 1.4.4 ?
<beach>
No, 1.4.0
<smokeink>
1.4.4 is what I'm using
<beach>
So there could be some variation.
<smokeink>
yes
arbv has joined #lisp
smasta has quit [Ping timeout: 256 seconds]
AxelAlex has joined #lisp
paul0 has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
Oladon1 has quit [Ping timeout: 240 seconds]
vtomole has quit [Ping timeout: 260 seconds]
damke_ has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
damke has quit [Ping timeout: 264 seconds]
sjl has joined #lisp
deng_cn has joined #lisp
Oladon has quit [Quit: Leaving.]
paul0 has joined #lisp
<smokeink>
beach: I'm playing with some bigger numbers and the results seem to start diverging: (log x 2) ==> 3962406.3 , (log2 x) ==> 3962406.2518028906d0
<phoe>
smokeink: collect the data and make a graph
<smokeink>
ok
<phoe>
it seems we have seven decimal digits of precision... about the width of a single float.
sjl has quit [Ping timeout: 265 seconds]
<smokeink>
with a much smaller X, the results were very similar: (log x 2) ; ==> 792481.25 , (log2 x) ; ==> 792481.2503605781d0
dtornabene has quit [Quit: Leaving]
<phoe>
smokeink: not really "very similar".
<phoe>
this is still seven digits of precision.
AxelAlex has quit [Quit: AxelAlex]
<phoe>
...or rather, eight here. hmmm.
<phoe>
So we might be losing precision with bigger numbers.
<beach>
smokeink: Sure, SBCL LOG uses single float in this situation apparently.
<smokeink>
both of them are *****.25***** , but for bigger numbers, the precision is lost, sbcl's log gives ***.30 and (log2) gives ****.25*****
<smokeink>
ok
sjl has joined #lisp
<beach>
smokeink: As you add a big integer to a small-ish float, you lose precision.
<smokeink>
my supposition/issue, is this: (log2) is very accurate for those 100 digits, but it also looses much due to that arithmetic shift . If you had a 1 trillion digits number, (log2) does arithmetic shift for most of the digits, and calculates Very precisely only for 100 digits
<beach>
smokeink: *sigh* 100 digits is more than the maximum precision of a double float, so you can't get more accurate than that.
<beach>
We went through this already.
Arcaelyx has joined #lisp
sjl has quit [Ping timeout: 248 seconds]
<beach>
smokeink: Imagine you had a floating-point format with 56 digits mantissa and a trillion digits of exponent. Then you would get the same mantissa for a number with a trillion digits as with that same number shifted a triliion-minus-56 positions to the right.
<beach>
perhaps plus or minus the last digit.
<beach>
I didn't mean "a trillion digits of exponent". I mean "an exponent big enough to represent a number with a trillion digits".
<beach>
So, you can view my technique as simulating a floating-point format with a 56 digit mantissa and an arbitrary large exponent.
<beach>
Like I said, the loss of precision is intrinsic, in that when you add a large integer number to a small-ish floating-point number, no matter the precision of that number, then you lose precision.
<smokeink>
ok I am with you. Cool, it means (log2) is both more precise and faster than (log). Yesterday we discusses about infinite integers, I had thought (log) uses some kind of bigfloats or something, and when I saw the difference in the results I thought (log2) is less precise, but the reverse seems to be the case
<smokeink>
*discussed
<beach>
Yes, log2 is more precise, because it uses double floats.
<smokeink>
very nice
LocaMocha has joined #lisp
<pierpa>
when CL has to build a float from non float arguments, the result is always single-float
<beach>
Oh? I see.
<pierpa>
unless there's a mechanism to specify otherwise, as in FLOAT
<beach>
smokeink: In that case, you can make it even faster by only keeping as many digits as required for SINGLE-FLOAT
<beach>
smokeink: It is now just as precise as LOG, but significantly faster.
<beach>
Oh, and s/56/53/ for IEEE double precision. Sorry about that.
pierpa has quit [Quit: Page closed]
igemnace has joined #lisp
mishoo has joined #lisp
pierpa has joined #lisp
shka_ has quit [Ping timeout: 276 seconds]
d4ryus1 is now known as d4ryus
fikka has quit [Ping timeout: 276 seconds]
saki has quit [Read error: Connection reset by peer]
<emaczen>
When can I expect garbage collection to be run?
<emaczen>
I know different implementations do different garbage collection, but what is reasonable?
<easye>
Nobody expects the reference inquisition!
Kundry_Wag has joined #lisp
Arcaelyx_ has joined #lisp
Arcaelyx has quit [Ping timeout: 248 seconds]
nopf has quit [Ping timeout: 240 seconds]
zooey has quit [Ping timeout: 255 seconds]
Kundry_Wag has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
<pierpa>
It is unreasonable to signal memory exhausted when there's garbage which could be collected. Everything else has been done by some implementation somewhere.
flamebeard has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Karl_Dscc has joined #lisp
fikka has joined #lisp
angavrilov has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
Tobbi has joined #lisp
saki has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
rippa has joined #lisp
<myrkraverk>
Is there a good JS compiler out there? So I can sort of easily have a runnable demonstration of Lisp on my log, without pulling in Hunchentoot and related frameworks?
<flip214>
with current QL and postmodern I get "during macroexpansion of (S-SQL:SQL (:LIMIT 100)): error while parsing arguments to DESTRUCTURING-BIND:
<flip214>
too few elements in (100) to satisfy lambda list (S-SQL::FORM S-SQL::AMOUNT &OPTIONAL S-SQL::OFFSET): between 2 and 3 expected, but got 1
wigust has joined #lisp
fikka has joined #lisp
<krwq>
flip214: that's good, isn't it?
<krwq>
you should pass another query and a number to :limit
<krwq>
this might be pretty close to what you need
Cymew has joined #lisp
<krwq>
go with open demo
<krwq>
you might even point to that directly
<krwq>
I knew I saw it before but couldn't recall :)
<krwq>
interestingly this is by the same author that smokeink pointed to but different repo
<myrkraverk>
I see, I'll take a look.
<myrkraverk>
I'll focus on writing what I want to cover for now; I'll play with demonstration toys later.
<krwq>
myrkraverk: with mal you can build lisp from the ground though - depends what you need
<myrkraverk>
Though there is a good reason I want to have in-browser demonstration tools; but no spoilers.
hiroaki has joined #lisp
<myrkraverk>
Mostly I need common lisp syntax for some (hopefully) simple functions, that a reader can experiment with locally.
<myrkraverk>
But at least one function will likely use SBCL's string-to-octets.
<krwq>
mysterious project
<myrkraverk>
I don't want to spoil it too soon.
<krwq>
if you make clim work on that lisp that would be pretty interesting
<myrkraverk>
And even if people will have to just copy and paste my functions into a REPL, that'll be better than not publishing; imo.
<krwq>
ok, I'll be going, good luck with your project
krwq has quit [Remote host closed the connection]
fikka has joined #lisp
vlatkoB has joined #lisp
<smokeink>
beach: thank you for patiently explaining all those things. Doing a bit of visualisation has helped me to see how obvious all this stuff is. I was thinking that mathematically it might be the case that the errors due to the arithmetic shift are not small ones, but big ones that might influence the result's digits near the decimal point, even the units. This is of course impossible. Anyway, the way I tested (log) and (log2) 's speed is
<smokeink>
wrong: if I reverse their order in that let/progn form , then their speeds interchange too. Running each of them separately in a (dotimes (i 10000)) loop has shown that (log) is significantly faster . This speed the difference could be due to (log2) having an extra function call to (log) , I'm not sure.
fikka has quit [Ping timeout: 240 seconds]
Mutex7 has joined #lisp
chiyosaki has joined #lisp
saki has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
varjag has joined #lisp
sjl has joined #lisp
schweers has joined #lisp
sjl has quit [Ping timeout: 276 seconds]
pierpa has quit [Ping timeout: 260 seconds]
heisig has joined #lisp
Lycurgus has joined #lisp
milanj has joined #lisp
<flip214>
ISTR that there's a function that returns the CONS cell that matches some test function... but FIND returns the CAR and not the cell.
makomo has joined #lisp
<Shinmera>
(loop for cons on list when (test cons) return cons)
<Shinmera>
Or if your test returns the significant value: (loop for cons on list thereis (test cons))
droog has joined #lisp
<jdz>
MEMBER almost matches the description.
<droog>
Does anyone have a good example of a roswell script which simply executes a list of commands?
<droog>
As in, several expressions, one after another.
<droog>
I tried to do something really simple with Roswell and it crashed.
<easye>
Hmm. I see ansible<-->vagrant as not having the same scope. Ansible scripts devops commands on a given machine; vagrant configures a virtualized container.
<myrkraverk>
Is sbcl.org down, or just slow on my end?
<Shinmera>
Sourceforge is still having problems.
<myrkraverk>
Ah.
<myrkraverk>
Now I get to find out if I have a local copy somewhere.
smurfrobot has quit [Remote host closed the connection]
Bike has joined #lisp
milanj has joined #lisp
smurfrobot has joined #lisp
<hjudt>
how can i get dexador to use content-type application/json for posting json content when using post requests? looking at the verbose output, it doesn't seem to set this header (it does set other headers like Accept though).
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<hjudt>
or maybe i am doing it wrong and someone can tell me how to post json content with dexador?
<_death>
looks like it has a special case to _not_ let the user override it.. stupid
smurfrobot has joined #lisp
<hjudt>
in encoding.lisp:detect-charset it seems to do some content-type detection for json
<hjudt>
i wonder how to post json content then. i tried (dex:post uri :headers '(("Content-Type" . "application/json") ("Accept" . "application/json") ("Accept-Encoding" . "gzip")) :content my-json-string).
<_death>
this is for the responses.. the special case is in usocket.lisp:request
<_death>
maybe file an issue
<hjudt>
yes, i see... the part about excluding certain custom headers
<hjudt>
thanks for looking it up
smurfrobot has quit [Remote host closed the connection]
emaczen has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
figurehe4d has quit [Remote host closed the connection]
deng_cn has joined #lisp
figurehe4d has joined #lisp
random-nick has joined #lisp
trittweiler has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
mnoonan has quit [Remote host closed the connection]
jtroseme has quit [Remote host closed the connection]
safe has joined #lisp
Bike is now known as Bicyclidine
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
jtroseme has joined #lisp
python476 has joined #lisp
butterthebuddha has quit [Max SendQ exceeded]
butterthebuddha has joined #lisp
oleo has joined #lisp
smurfrobot has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
Tristam has quit [Ping timeout: 260 seconds]
madmalik has quit [Quit: Connection closed for inactivity]
fdund has quit [Quit: Lost terminal]
oleo has quit [Remote host closed the connection]
oleo has joined #lisp
Kundry_Wag has joined #lisp
elts has quit [Ping timeout: 256 seconds]
elts has joined #lisp
emaczen has joined #lisp
comborico1611 has joined #lisp
makomo_ has joined #lisp
<dim>
seems like I'm making it possible to be at ELS this year, I've cancelled some things ;-)
warweasle has joined #lisp
makomo has quit [Ping timeout: 255 seconds]
<dim>
I don't see a way to register for it yet though?
<jackdaniel>
dim: registeration will be open soon™
<jackdaniel>
we all wait for it
<jackdaniel>
:)
<dim>
hehe ok
<dim>
it's not me then, perfect
<dim>
goodbye NYC, hello Marbella
<oleo>
will you take a dive
Kundry_Wag has quit [Remote host closed the connection]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Remote host closed the connection]
deng_cn has quit [Read error: Connection reset by peer]
hiroaki has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
al-damiri has joined #lisp
deng_cn has joined #lisp
Bike has joined #lisp
sjl has joined #lisp
<beach>
dim: Congratulations! Good choice!
<dim>
beach: hehe thanks ;-)
Ven` has quit [Ping timeout: 240 seconds]
sjl has quit [Ping timeout: 248 seconds]
asarch has joined #lisp
Ven`` has joined #lisp
grublet has joined #lisp
f1gurehead has joined #lisp
azrazalea has quit [Ping timeout: 268 seconds]
figurehe4d has quit [Ping timeout: 276 seconds]
f1gurehead has quit [Ping timeout: 265 seconds]
azrazalea has joined #lisp
serviteur has joined #lisp
dddddd has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
figurehe4d has joined #lisp
Ven`` has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Kundry_Wag has joined #lisp
_paul0 has joined #lisp
Ven`` has joined #lisp
smurfrobot has joined #lisp
paul0 has quit [Ping timeout: 260 seconds]
warweasle has quit [Quit: later]
rumbler31 has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
makomo_ has quit [Ping timeout: 240 seconds]
deng_cn has joined #lisp
pierpa has joined #lisp
serviteur has quit [Remote host closed the connection]
nowhere_man has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
smurfrobot has quit [Remote host closed the connection]
paul0 has joined #lisp
axg has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<beach>
I was inspired by the discussion this morning (UTC+1) about using abbrevs.
Kundry_Wag has joined #lisp
Cymew has quit [Remote host closed the connection]
axg has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Cymew has joined #lisp
damke_ has joined #lisp
axg has joined #lisp
_cosmonaut_ has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Ping timeout: 248 seconds]
damke has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 256 seconds]
Ven`` has quit [Ping timeout: 276 seconds]
smokeink has quit [Ping timeout: 240 seconds]
Ven`` has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
jtroseme has quit [Remote host closed the connection]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
deng_cn has joined #lisp
schweers` has joined #lisp
schweers has quit [Ping timeout: 276 seconds]
pierpa has quit [Ping timeout: 260 seconds]
<jmercouris>
beach: sounds interesting, sounds like something I could even use in Next, maybe I will work on this
<beach>
Great! Yes, definitely something for Next and other similar applications.
chiyosaki has quit [Read error: Connection reset by peer]
aindilis has quit [Ping timeout: 268 seconds]
<beach>
jmercouris: If you decide to work on it, you might want to let me know what you are about to do, so that I can give you feedback on possible choices.
schweers` has quit [Ping timeout: 265 seconds]
pierpa has joined #lisp
trittweiler has joined #lisp
gz_ has quit [Read error: Connection reset by peer]
jeremyheiler has quit [Read error: Connection reset by peer]
fikka has joined #lisp
gz_ has joined #lisp
nowhere_man has quit [Ping timeout: 276 seconds]
shrdlu68 has quit [Ping timeout: 245 seconds]
Duns_Scrotus has quit [Ping timeout: 256 seconds]
<beach>
... or not.
jeremyheiler has joined #lisp
j0ni has joined #lisp
<jackdaniel>
hm?
shka has quit [Quit: Konversation terminated!]
Selwyn has joined #lisp
saki has joined #lisp
warweasle has joined #lisp
<White_Flame>
flip214: I think you meant to ping somebody else...
<jmercouris>
beach: Yes, of course
deng_cn has quit [Read error: Connection reset by peer]
<jmercouris>
beach: I'll probably come up with some proposed design and then run it by you and see what you think
deng_cn has joined #lisp
anunnaki has joined #lisp
Duns_Scrotus has joined #lisp
Kundry_Wag has joined #lisp
anunnaki has quit [Ping timeout: 256 seconds]
_paul0 has joined #lisp
anunnaki has joined #lisp
<beach>
Sounds good. And you can show it here so that more people can give feedback.
comborico1611 has quit [Quit: Konversation terminated!]
paul0 has quit [Ping timeout: 276 seconds]
shrdlu68 has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
gypsydav_ has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
pierpa has quit [Ping timeout: 260 seconds]
pierpa has joined #lisp
Karl_Dscc has joined #lisp
fikka has joined #lisp
figurehe4d has quit [Quit: Leaving]
deng_cn has quit [Read error: Connection reset by peer]
Karl_Dscc has quit [Remote host closed the connection]
<gypsydav_>
Could someone spare five minutes to explain a corner of quoting to me?
sjl has joined #lisp
<dlowe>
Sure.
deng_cn has joined #lisp
<gypsydav_>
So I'm reading Land of Lisp and my brain is chewing itself up over (list 'quote x) where x is a variable
<pjb>
without being wrapped in a quote form, X is evaluated, and its value 42 is returned.
<gypsydav_>
sure - got that bit
<pjb>
when wrapped in a quote form, (quote X) evaluates to X itself, without evaluating X.
<pjb>
So we say that quote prevents the evaluation of its argument.
<gypsydav_>
ahhhhhhhhhhhhhhhhhhhhhhhh
<phoe>
(+ 2 2) evaluates to 4.
sjl has quit [Ping timeout: 248 seconds]
<gypsydav_>
So, while it's a list when you've nested the ''x, that's only because you've prevented the evaluation of 'x
<phoe>
'(+ 2 2) evaluates to a three-element list; its first element is the symbol +, its second element is the number 2, its third element is the number 2.
<phoe>
yep
nika has joined #lisp
<dlowe>
(eval (eval '(+ 2 2))) will be 4, though :)
<phoe>
that is because 4 evaluates to itself.
<gypsydav_>
So when (let ((x 42)) (list 'quote x)) ... ?
<phoe>
in Lisp, cons cells evaluate to function/macro calls, symbols evaluate to their values, and everything else is self-evaluating.
<phoe>
42 evals to 42.
<gypsydav_>
agreed :D
<phoe>
oh wait
<gypsydav_>
(list 'quote 42) then
<phoe>
that's (list 'quote 42)
<phoe>
that will evaluate to (QUOTE 42)
<dlowe>
(eval (eval ''(+ 2 2))) will be 4, too :)
<phoe>
which is also noted as '42
<beach>
The collective pedagogical skills of this channel are mind-blowing.
<dlowe>
beach: very few have had training
<gypsydav_>
But different somehow to (list '+ 1 1) ... or am I still not getting something?
<beach>
dlowe: It makes it worse that so many people with different pedagogical ideas try to help simultaneously. But maybe I am overreacting.
<pjb>
gypsydav_: No, it's not fundamentally different.
<pjb>
gypsydav_: in both cases, it returns a form, ie. a sexp (some data), that could be interpreted by EVAL.
<dlowe>
beach: it's not orderly, that's for sure.
Kundry_Wag has quit [Remote host closed the connection]
<random-nick>
gypsydav_: the most important difference between quote and list is that quote is a special form while list is a function
<pjb>
gypsydav_: remember that we don't write lisp code, we write lisp data. (+ 1 2) is not code, it's data. It's a list of 3 elements, (a symbol, and 2 integers).
<gypsydav_>
totally
<pjb>
gypsydav_: what makes lisp code, is that we take some lisp data, and pass it to EVAL (or to COMPILE or COMPILE-FILE when it's stored in a file).
<pjb>
This is why we need QUOTE: when we need to put some literal data in a program; since the program is itself normal lisp data, we need an operator to prevent evaluating the literal data: we use quote.
<pjb>
(list 5 (quote =) (quote (+ 2 3)) (quote =) (+ 2 3)) is data, a list of 6 elements. When we evaluate it, we get the list of 5 elements: (5 = (+ 2 3) = 5).
<gypsydav_>
Sure, but eval to one side for a second, just as data - (list 'quote 1) vs. (list
<gypsydav_>
Sure, but eval to one side for a second, just as data - (list 'quote 1) vs. (list '1+ 1)
Kundry_Wag has joined #lisp
<pjb>
Notice how the list (list 5 (quote =) (quote (+ 2 3)) (quote =) (+ 2 3)) can be evaluated without signaling an error, while the list (5 = (+ 2 3) = 5) cannot be evaluated without signaling an error.
<pjb>
We call the former a form, and the later a sexp.
<pjb>
(forms are sexps too).
flamebeard has quit [Quit: Leaving]
<gypsydav_>
OK, now we're getting somewhere
jtroseme has joined #lisp
saki has quit [Ping timeout: 276 seconds]
jtroseme has quit [Max SendQ exceeded]
<gypsydav_>
Actually, no we're not... (list 'quote 1) isn't a list, but (list '1+ 1) is a list... eh?
attila_lendvai has quit [Read error: Connection reset by peer]
<pjb>
gypsydav_: but notice also that in lisp, errors are not _exceptions_; they're just _conditions_. There are other conditions that are not errors. And you can handle conditions. So (handler-case (eval '(5 = (+ 2 3))) (t () 42)) #| --> 42 |# doesn't signal an error. EVAL will signal an error when interpreting (5 = (+ 2 3)), but this condition will be handled by the handler-case, and it will return 42.
<pjb>
both (list 'quote 1) and (list '1+ 1) are lists!
jtroseme has joined #lisp
saki has joined #lisp
<gypsydav_>
then what's the car of (list 'quote 1)
<random-nick>
gypsydav_: when quoted or when evaluated
<phoe>
'(quote 1) and (list 'quote 1) both produce a list of length 2 whose CAR is QUOTE and CADR is 1
cbs has joined #lisp
jtroseme has quit [Remote host closed the connection]
<beach>
gypsydav_: You need to be careful with the word "is". "<mumble> is a list" could mean that <mumble> is a list before being evaluated, or it could mean <mumble> evaluates to a list. Those are very different meanings.
<pjb>
gypsydav_: so, since we write data instead of code, when we talk, we must always express whether we consider the plain data, or the result of evaluating the data! This is the important point to understand.
<beach>
phoe: "produce", do you mean "evaluates to"?
<beach>
phoe: or do you mean that the reader returns what you said?
attila_lendvai has joined #lisp
<pjb>
gypsydav_: (list 'quote 1) IS a list of 3 elements. (list 'quote 1) EVALUATES to a list of 2 elements: (quote 1)
<gypsydav_>
sure
<pjb>
gypsydav_: (quote 1) IS a list of 2 elements. (quote 1) EVALUATES to an integer: 1
<beach>
pjb: Excellent!
jtroseme has joined #lisp
<pjb>
gypsydav_: if you make the distinction between what a lisp object IS and what it EVALUATES to, you'll be fine.
smurfrobot has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
<pjb>
gypsydav_: notice also another thing: 'x READS as (CL:QUOTE X)
<beach>
pjb: Your pedagogical skills are improving by the minute. Congratulations.
<pjb>
gypsydav_: and when we say in general (list 'quote 1) IS a list, we mean actually that it READS as a list. This is dependent on the *readtable* context; it could read to something else, if a different reader macro was installed for #\( (the character open parenthesis).
<beach>
... and I mean it.
<pjb>
beach: that's always how I explain those things. I find the scheme way very confusing for students.
<beach>
pjb: Maybe so, but you also have a tendency to confuse the hell out of newbies with too complicated examples. Not this time, which is what I am remarking on.
<dlowe>
all that time in #clnoobs
* beach
does not participate in #clnoobs, but maybe he should.
<gypsydav_>
wait - there's a #clnoobs?
<pjb>
Yes.
<gypsydav_>
Maybe I'll just head over there for a bit ;)
<gypsydav_>
Thanks for your help y'all - doing some mulling now ...
<dlowe>
#lisp is a good spot too, but at #clnoobs, everyone is there for learning and/or teaching
<beach>
gypsydav_: You seem to have the right attitude, so I am sure you'll get it.
_paul0 has quit [Quit: Leaving]
giraffe has quit [Remote host closed the connection]
itruslove has quit [Remote host closed the connection]
cbs has quit [Quit: Leaving]
Kundry_Wag has quit [Remote host closed the connection]
smurfrobot has joined #lisp
quietcharlotte has joined #lisp
nika has quit [Ping timeout: 276 seconds]
parjanya has joined #lisp
trittweiler has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
fikka has joined #lisp
zotan has quit [Ping timeout: 260 seconds]
Karl_Dscc has joined #lisp
gypsydav_ has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 256 seconds]
jtroseme has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 276 seconds]
zotan has joined #lisp
SaganMan has joined #lisp
willmichael has quit [Ping timeout: 240 seconds]
neirac has joined #lisp
varjag has joined #lisp
willmichael has joined #lisp
pierpa has quit [Ping timeout: 260 seconds]
raynold has joined #lisp
kuwze has joined #lisp
smurfrobot has joined #lisp
nowhere_man has joined #lisp
mlf has joined #lisp
sjl has joined #lisp
<phoe>
beach: I meant "evaluate to", yes.
<_death>
(write (read-from-string "'x") :pretty t) ;; try also with :pretty nil
Keliner has quit [Quit: Lost terminal]
lnostdal has quit [Remote host closed the connection]
smurfrobot has quit [Ping timeout: 248 seconds]
lnostdal has joined #lisp
Kundry_Wag has joined #lisp
sjl has quit [Ping timeout: 260 seconds]
SumoSudo has joined #lisp
fikka has joined #lisp
<beach>
phoe: Yes, but that was not obvious. So my message is "be very careful with terminology, especially when giving help to newbies".
<phoe>
beach: yes, thank you. I should sleep more before trying to teach.
<beach>
That's a very good plan actually. It is important to have a clear mind when the pedagogical skills are needed.
fikka has quit [Ping timeout: 256 seconds]
Guest31288 has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
fourier has joined #lisp
fourier has quit [Remote host closed the connection]
fourier has joined #lisp
EvW has quit [Ping timeout: 252 seconds]
fourier has quit [Changing host]
fourier has joined #lisp
sjl has joined #lisp
krasnal_ has quit [Ping timeout: 265 seconds]
aindilis has joined #lisp
quietcharlotte has quit [Ping timeout: 256 seconds]
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
nydel has quit [Read error: Connection reset by peer]
m00natic has quit [Remote host closed the connection]
Patternmaster has quit [Ping timeout: 252 seconds]
shrdlu68 has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
damke has joined #lisp
fourier has quit [Ping timeout: 260 seconds]
trittweiler has joined #lisp
trittweiler has quit [Remote host closed the connection]
smurfrobot has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
jtroseme has joined #lisp
chat_ has quit [Ping timeout: 265 seconds]
jtroseme has quit [Remote host closed the connection]
SaganMan has quit [Quit: WeeChat 1.6]
shrdlu68 has quit [Ping timeout: 252 seconds]
epony has joined #lisp
razzy` has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
shrdlu68 has joined #lisp
razzy` has quit [Remote host closed the connection]
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
chat__ has joined #lisp
fikka has joined #lisp
Amplituhedron has quit [Ping timeout: 276 seconds]
aindilis has quit [Read error: Connection reset by peer]
jtroseme has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
nowhereman_ has joined #lisp
jtroseme has quit [Remote host closed the connection]
willmichael has quit [Ping timeout: 276 seconds]
shrdlu68 has quit [Quit: Lost terminal]
attila_lendvai has quit [Read error: Connection reset by peer]
fikka has joined #lisp
nowhere_man has quit [Ping timeout: 260 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
jmercouris has quit [Remote host closed the connection]
freeman42x]NixOS has joined #lisp
fisxoj has joined #lisp
aindilis has joined #lisp
<neirac>
I was trying to move an application to openshift, is there any caveats at this point with sbcl/quicklisp on that platform ?
willmichael has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
Rawriful has joined #lisp
fisxoj has quit [Quit: fisxoj]
energizer has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
zkat has quit [Ping timeout: 252 seconds]
zkat has joined #lisp
Kundry_Wag has joined #lisp
safe has quit [Read error: Connection reset by peer]
attila_lendvai has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 248 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
wigust has quit [Ping timeout: 255 seconds]
comborico1611 has joined #lisp
smurfrobot has joined #lisp
shka_ has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
sysfault has quit [Ping timeout: 245 seconds]
aeth has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
fikka has joined #lisp
deng_cn has joined #lisp
LocaMocha has quit [Read error: Connection reset by peer]
Selwyn has quit [Remote host closed the connection]
sysfault has joined #lisp
sysfault has quit [Client Quit]
sysfault has joined #lisp
funnel has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Remote host closed the connection]
funnel has joined #lisp
neirac has quit [Remote host closed the connection]
deng_cn has quit [Read error: Connection reset by peer]
quietcharlotte has joined #lisp
deng_cn has joined #lisp
<flip214>
White_Flame: right, sorry.
spm__ has quit [Ping timeout: 240 seconds]
knicklux has joined #lisp
quietcharlotte has quit [Quit: Leaving]
quietcharlotte has joined #lisp
whyNOP has joined #lisp
lnostdal has quit [Ping timeout: 255 seconds]
Cymew has joined #lisp
damke_ has joined #lisp
nydel has joined #lisp
damke has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 260 seconds]
aeth has quit [Read error: Connection reset by peer]
aeth has joined #lisp
k-stz has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
lnostdal has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
deng_cn has quit [Read error: Connection reset by peer]
willmichael has quit [Read error: Connection reset by peer]
willmichael has joined #lisp
saki has quit [Read error: Connection reset by peer]
chat__ has quit [Ping timeout: 240 seconds]
comborico1611 has quit [Quit: Konversation terminated!]
lnostdal has quit [Ping timeout: 255 seconds]
Kundry_Wag has quit [Remote host closed the connection]
saki has joined #lisp
* stacksmith
scratches his head trying to figure out if Thrift is interesting or another pile of complicated shit soon forgotten.
vlatkoB has quit [Remote host closed the connection]
emacsomancer_ has joined #lisp
Kundry_Wag has joined #lisp
emacsomancer_ has quit [Client Quit]
emacsomancer_ has joined #lisp
AxelAlex has joined #lisp
fikka has joined #lisp
chat__ has joined #lisp
kajo has quit [Quit: WeeChat 2.0.1]
emacsomancer_ has quit [Client Quit]
angavrilov has quit [Remote host closed the connection]
kajo has joined #lisp
emacsoma1 has joined #lisp
scymtym has quit [Ping timeout: 276 seconds]
emacsoma1 has quit [Client Quit]
knicklux has quit [Quit: Leaving]
emacsoma1 has joined #lisp
emacsoma1 has quit [Client Quit]
random-nickname has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
warweasle has quit [Quit: away]
random-nickname is now known as random-nick
lnostdal has joined #lisp
python476 has quit [Ping timeout: 268 seconds]
shka_ has quit [Ping timeout: 256 seconds]
milanj has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
grublet has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
lnostdal has quit [Ping timeout: 255 seconds]
kajo has quit [Quit: WeeChat 2.0.1]
kajo has joined #lisp
pierpa has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
comborico1611 has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
scymtym has joined #lisp
butterthebuddha has quit [Max SendQ exceeded]
butterthebuddha has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
lnostdal has joined #lisp
Kundry_Wag has joined #lisp
* jasom
is trying to figure out how it differs from protobufs
saki has quit [Ping timeout: 276 seconds]
<jasom>
ah, Thrift is from facebook protocol buffers is from google. The fact that they each came up with one, and that they are so similar, suggests that it's at least useful when managing a large number of interconnected services
Kundry_Wag has quit [Remote host closed the connection]
* stacksmith
prays to God of Lisp: 'Please do not make me manage a large number of interconnected services... I'll do anything.'
Kundry_Wag has joined #lisp
<dim>
it's a binary RPC data format for exchange, basically
<jasom>
But I do wonder what they do that XML/SOAP/ASN.1 didn't
<rumbler31>
you can get the length of fields without knowing them in advance
<dim>
Thrift goes further than that in also defining the RPC signatures and allowing standard code generation IIRC
<jasom>
Any format with an IDL can perform code generation though, right?
<rumbler31>
the protocol will tell you how many bytes constitute each field, in a manner that keeps the overhead low
emacsoma1 has joined #lisp
emacsomancer has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
<jasom>
rumbler31: ah, so it's a performance/code simplicity advantage vs previous line formats?
emacsoma1 has quit [Client Quit]
saki has joined #lisp
<rumbler31>
so you don't have to know anything about the format of the data as you serialize
bigfondue has quit [Ping timeout: 276 seconds]
<rumbler31>
not vs line formats per se
<dim>
in the area see also http://ubf.github.io/ubf/ ; it goes a step further by taking care of a whole communication contract, not just single rpc calls but the transitions from one to another too
fikka has joined #lisp
<foom2>
XML, SOAP, and ASN.1 are _much_ more complex encodings.
Mutex7 has joined #lisp
<rumbler31>
so if you want to naively serialize 3 32bit ints, you'll always use 98 bits
willmichael has quit [Read error: Connection reset by peer]
<jasom>
rumbler31: is there any robustness against protocol disagreements?
<rumbler31>
with at least protocol buffers, they do an encoding that minimizes the number of bytes necessary to represent the number, while at the same time
<jasom>
rumbler31: if one side things it's serializing 3 32 bit ints, but the other thinks it's receiveing a string?
<rumbler31>
so its built into the protocol
<rumbler31>
it knows that as it reads its reading an int
<jackdaniel>
(atm of course)
mishoo has quit [Quit: (save-lisp-and-die)]
<jasom>
rumbler31: but that relies on both sides having schema agreement, which will happen in properly functioning systems; is there any attempt to detect schema disagreement?
<rumbler31>
so disagreements don't come from the user's data format, you just read, and when you're done, you have all the fields
<rumbler31>
correct, on top of that, no I don't think there is an understanding of schema disagreements
smurfrobot has joined #lisp
<rumbler31>
at least on google protocol buffers but I only topically inspected the implementation once last year
<jasom>
rumbler31: thanks for the info
<rumbler31>
you essentially get a dataset that you have to query
axg has quit [Ping timeout: 240 seconds]
EvW has joined #lisp
marusich has joined #lisp
<rumbler31>
but basically if you add or remove fields, you don't have to change anything in serialization. If you added or lost a value you don't care about then you won't fail to parse the stream
vtomole has joined #lisp
mishoo has joined #lisp
damke has joined #lisp
marusich has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 264 seconds]
marusich has joined #lisp
smasta has joined #lisp
bigfondue has joined #lisp
PinealGlandOptic has quit [Quit: leaving]
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
willmichael has joined #lisp
comborico1611 has quit [Quit: Konversation terminated!]
smasta has quit [Quit: WeeChat 2.0.1]
smurfrobot has quit [Remote host closed the connection]
papachan has quit [Quit: WeeChat 2.0.1]
Kundry_Wag has joined #lisp
<cgay>
Slightly rephrased, protobuf readers know to ignore fields their schema version doesn't have yet. They never care about missing values unless they're marked "required" (a distinction that was removed in version 3 protobufs).
<cgay>
When I looked at Thrift, briefly, a few years ago it seems like protobufs with maps and a slightly nicer source syntax.
Kundry_Wag has quit [Ping timeout: 268 seconds]
vtomole has quit [Ping timeout: 260 seconds]
openthesky has joined #lisp
Amplituhedron has joined #lisp
pagnol has joined #lisp
sjl has quit [Quit: WeeChat 1.9]
Pixel_Outlaw has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
sjl has joined #lisp
lnostdal has quit [Remote host closed the connection]
lnostdal has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
lnostdal has quit [Remote host closed the connection]
lnostdal has joined #lisp
sjl has quit [Quit: WeeChat 1.9]
lnostdal has quit [Ping timeout: 255 seconds]
sjl has joined #lisp
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
Amplituhedron has quit [Read error: Connection reset by peer]
Amplituhedron has joined #lisp
deng_cn has joined #lisp
rumbler3_ has quit [Remote host closed the connection]
lnostdal has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
Tristam has joined #lisp
Karl_Dscc has joined #lisp
sjl__ has joined #lisp
trocado has joined #lisp
sjl has quit [Ping timeout: 260 seconds]
random-nick has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
Bike has joined #lisp
troydm has joined #lisp
parjanya has quit [Ping timeout: 256 seconds]
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
nowhereman_ has quit [Ping timeout: 245 seconds]
hhdave has quit [Quit: hhdave]
cleanslate has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
axg has joined #lisp
EvW has quit [Quit: EvW]
python47` has joined #lisp
saki has quit [Ping timeout: 260 seconds]
saki has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Amplituhedron has quit [Ping timeout: 260 seconds]