<jasom>
blargh. Suggestions for debugging compiler macros? Specifically cffi:foreign-alloc appears to be not expanding to a fast path
<pjb>
add print expressions.
<Bike>
you want to determine whether or not it's expanding?
<pjb>
compiler macros are not necessarily used by an implementation.
<Bike>
jmercouris: (describe (find-class 'cl-string-match:re-match)) might also be informative.
<pjb>
Otherwise, to debug it, you can just call it directly (extrating the body in a normal function).
<pjb>
or (documentation 'cl-string-match:re-match 'function)
<jasom>
Bike: yes
<Bike>
probably i'd just add prints, yeah
<jasom>
Bike: well I know it's not expandingas expected because I end up with foreign-alloc on the stac rather than %foreign-alloc
<Bike>
so you want to know why?
<Bike>
i'd macroexpand things and see if there's a notinline
cromachina has joined #lisp
<jasom>
I found it eventually; the compiler macro was slightly more stupid than I thought
<jasom>
specifically if you specify initial contents, then it completely loses all optimizations for the type being constant
rumbler31 has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
quazimodo has joined #lisp
<jasom>
I changed my with-foreign-alloc macro to perform the initialization of the memory manually and got a ~1000X speedup
happy_gnu[m] has joined #lisp
akr has joined #lisp
kammd[m] has joined #lisp
thorondor[m] has joined #lisp
dirb has joined #lisp
Sovereign_Bleak has joined #lisp
l04m33[m] has joined #lisp
astronavt[m] has joined #lisp
Jach[m] has joined #lisp
dahs81[m] has joined #lisp
cryptomarauder[m has joined #lisp
RichardPaulBck[m has joined #lisp
Guest15545 has joined #lisp
plll[m] has joined #lisp
CharlieBrown has joined #lisp
hiq[m] has joined #lisp
hdurer[m] has joined #lisp
equalunique[m] has joined #lisp
ArthurAGleckler[ has joined #lisp
trigt[m] has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
emaczen has quit [Read error: Connection reset by peer]
dieggsy has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
emaczen has joined #lisp
Cymew has joined #lisp
<Bike>
so with constant type and unconstant but specified count you'd want it to expand to `(%foreign-alloc (* ,count ,(foreign-type-size (eval type))))?
dieggsy has joined #lisp
<Bike>
for initial contents you'd have to once-only the contents and take the length, i guess.
<Bike>
...and then initialize it.
<jmercouris>
Why does find-symbol ALWAYS return nil on a known symbol found in do-symbols?
<jmercouris>
Damn, it is case sensitive
<jmercouris>
I would have never guessed
Cymew has quit [Ping timeout: 255 seconds]
devon has joined #lisp
jmercouris has quit [Ping timeout: 255 seconds]
TehCraw has left #lisp ["Leaving"]
<Xach>
case-sensitive, case-folding
Amplituhedron has quit [Ping timeout: 264 seconds]
hydan has quit [Quit: Connection closed for inactivity]
vtomole has joined #lisp
kmb has quit [Quit: kmb]
kmb has joined #lisp
kmb has quit [Client Quit]
nirved has quit [Quit: Leaving]
yangby has joined #lisp
hexfour has joined #lisp
<Ober>
huh. 'At the request of John McCarthy, Lisp’s creator, no single language that is a member of the Lisp family is to be intended to be the definitive dialect; that is, none is to be called just “LISP.” '
<k-stz>
we do speak of lisp dialects and of languages being part of the lisp family
NaNDude has quit [Read error: Connection reset by peer]
raphaelss has joined #lisp
dieggsy has quit [Ping timeout: 255 seconds]
NaNDude has joined #lisp
<kini>
and yet here we are in a channel called #lisp where the topic says "Common Lisp" :)
rumbler31 has joined #lisp
<Bike>
luckily, we call it "lisp" instead of "LISP"
<devon>
One Lisp to rule them all
rumbler31 has quit [Ping timeout: 260 seconds]
Zhivago has quit [Remote host closed the connection]
<k-stz>
another tagged pointer example: (setf *a* (1+ most-positive-fixnum) *b* (1+ most-positive-fixnum)) (eq *a* *b*) => nil, but set *a* and *b* to the same fixnum number then (eq *a* *b*) ==> T ! For sbcl at least, because EQ does pointer comparison. I guess, then, with EQ one can test if a value is represented by an immediate tag pointer
mejja has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 250 seconds]
SuperJen has quit [Remote host closed the connection]
<aeth>
There's nothing restricting with-accessors to only be for accessors to CLOS objects, is there? It says undefined, but it should in most if not all implementations just be a trivial symbol-macrolet. http://www.lispworks.com/documentation/HyperSpec/Body/m_w_acce.htm
<Bike>
it says "accessor", which is broader than CLOS. i guess.
<Bike>
oh, but "slots" also.
<aeth>
I'm just wondering if it's also usable for structs
<aeth>
Which also have accessors
Kundry_W` has quit [Ping timeout: 255 seconds]
<Bike>
well, they have slots, so sure
<aeth>
yeah, I was wondering that
smurfrobot has joined #lisp
<aeth>
I'll probably copy the basic symbol-macrolet pattern (and change it slightly) for things that don't necessarily have that slot concept
dieggsy has joined #lisp
EvW has quit [Ping timeout: 246 seconds]
<Bike>
if an implementation did actually restrict it to standard objects, you could probably decently make a case against that to them
red-dot has joined #lisp
<aeth>
Do generics apply to both standard CLOS objects and struct objects?
<aeth>
If they do, that would be a good case against special casing CLOS objects.
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Bike>
er, what?
<Bike>
"apply to"?
<aeth>
Sorry, I mean, you can do (defmethod meh ((foo foo) x) (values foo x)) and that's separate from (defmethod meh (y x) y) with the former being (FOO T) and the latter being (T T). Also, you can do (class-of (make-foo)) and get a structure-class just like you can do (class-of (make-instance 'bar)) and get a standard-class.
<aeth>
So they're definitely instances of a class with slots and accessors.
<Bike>
structure objects are certainly instances of a structure class, and structures are described as having slots and accessors. the question is whether with-accessors means the general senses of those terms or the CLOS-specific senses.
quazimodo has quit [Ping timeout: 264 seconds]
<aeth>
I guess my (failed) argument is that defmethod uses the broader sense.
<aeth>
Although I don't think that would apply to my particular case, where I want to use it on a vector struct. I could definitely see this potentially failing.
smurfrobot has quit [Ping timeout: 268 seconds]
<Bike>
what does defmethod have to do with anything?
<aeth>
It's a bad argument because CL is already inconsistent, so arguing that something would keep things simple and consistent wouldn't really be relevant in an interpretation of the specification.
Zhivago has joined #lisp
d4ryus1 has joined #lisp
Kevslinger has joined #lisp
d4ryus has quit [Ping timeout: 240 seconds]
dieggsy has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
dieggsy has joined #lisp
yangby has quit [Quit: Go out for a walk and buy a drink.]
fikka has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
igemnace has joined #lisp
pfdietz has joined #lisp
karswell has quit [Read error: No route to host]
karswell_ has joined #lisp
<pfdietz>
The random tester appears to have exhausted itself on sbcl. Ah well, the latest campaign was fun while it lasted. Interesting how bugs can breed over time.
<pfdietz>
BTW, I would argue that
<pfdietz>
slot is very broadly defined in the CL spec
<pfdietz>
"slot n. a component of an object that can store a value."
<pfdietz>
"object n. 1. any Lisp datum. ``The function cons creates an object which refers to two other objects.''"
<pfdietz>
"accessor n. an operator that performs an access. See reader and writer."
<Zhivago>
What is the argument about?
<pfdietz>
"access n., [...] 2. n. (of a place) an attempt to access[1] the value of the place."
<pfdietz>
Whether WITH-ACCESSORS applies just to standard objects.
<pfdietz>
I think (with-accessors ((x car) (y cdr)) (cons 1 2) (values x y)) ==> 1, 2 would be valid.
pierpa has quit [Quit: Page closed]
<Zhivago>
Sounds reasonable to me -- it looks like a convenience for establishing a symbol-macrolet.
<Zhivago>
Is there an interesting counter-argument?
<Bike>
I thought maybe it could do CLOS-specific optimizations like using more direct slot access when possible, but it seems to pretty specifically invoke the given accessors.
<whoman>
hmm what is this error from MOP - forward referenced class? not sure how that is going on
<whoman>
nevermind, intuited
<Bike>
(defclass foo (bar) ()): if bar is undefined when this is evaluated, it's forward-referenced.
mson has quit [Quit: Connection closed for inactivity]
drcode has joined #lisp
lanu has joined #lisp
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
<loke>
pfdietz: When you are making guesses it's always good to check the spec first.
<loke>
pfdietz: CLHS has the following to say about WITH-ACCESSORS: “The consequences are undefined if any accessor-name is not the name of an accessor for the instance.”
safe has quit [Quit: Leaving]
mson has joined #lisp
EvW1 has joined #lisp
<aeth>
That adds "instance", which does complicate things a bit.
<loke>
aeth: “instance” is defined as: “instance n. 1. a direct instance. 2. a generalized instance. 3. an indirect instance.]
<loke>
“direct instance n. (of a class C) an object whose class is C itself, rather than some subclass of C. ``The function make-instance always returns a direct instance of the class which is (or is named by) its first argument.''”
<loke>
“generalized instance n. (of a class) an object the class of which is either that class itself, or some subclass of that class. (Because of the correspondence between types and classes, the term ``generalized instance of X'' implies ``object of type X'' and in cases where X is a class (or class name) the reverse is also true. The former terminology emphasizes the view of X as a class while the latter emphasizes the view of X as a type
<loke>
specifier.)”
<loke>
“indirect instance n. (of a class C1) an object of class C2, where C2 is a subclass of C1. ``An integer is an indirect instance of the class number.''”
<loke>
Now here's the fun part...
sjl has joined #lisp
<loke>
Let's look at the definition of “accessor:
<aeth>
It definitely looks like with-accessors should work on any accessor with a reader (foo x) and (setf (foo x) new-object) writer, e.g. cxr
<loke>
“accessor n. an operator that performs an access. See reader and writer.”
<aeth>
with-accessors won't work when the writer isn't a setf writer, will it?
<aeth>
there wouldn't be any way to feed in a new-value
EvW1 has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
<loke>
aeth: Yes. There is a non-normative note in the documenation for WITH-ACCESSORS suggesting the typical implementation is simply a MACROLET
<loke>
I mean SYMBOL-MACROLET
<aeth>
accessors are definitely something that the spec gets right imo. reader (foo ...) and writer (setf (foo ...) new-object) symmetry, that can apply to just about anything.
jameser has joined #lisp
<aeth>
Isn't everything an instance since everything has a class, and so with-accessors should really just work on everything with a conventional accessor pair?
jameser has quit [Client Quit]
<loke>
aeth: That's the thing. That reading is certainly a valid one... Here's the documentation for "accessor":
<loke>
“accessor n. an operator that performs an access. See reader and writer.”
<loke>
“access n., v.t. 1. v.t. (a place, or array) to read[1] or write[1] the value of the place or an element of the array. 2. n. (of a place) an attempt to access[1] the value of the place.”
sjl has quit [Ping timeout: 248 seconds]
shka has joined #lisp
neoncontrails has quit [Remote host closed the connection]
<Bike>
just do it for structs and see if any implementation breaks it.
<aeth>
It seems natural that with-accessors is an abstraction over conventional/idiomatic CL accessors. (And that's probably one reason why it's better than with-slots, it's abstract.)
<aeth>
Bike: After this conversation, I'm tempted to do it over anything that has accessors, not just structs.
<loke>
Bike: Sounds unlikely. Why would any implementation deviate from the standard SYMBOL-MACROLET implementation?
neoncontrails has joined #lisp
<Bike>
of course it's unlikely, that's why i'm saying to do it
<Bike>
throw caution to the fucking wind and do a programming thing
<Bike>
live on the edge
<aeth>
with-accessors on anything with well-defined accessors (i.e. a matching setf foo for any given foo) seems reasonable
* loke
can pretty much guarantee that it'll work on all implementations, regardless of whether it's allowed by the spec or not.
fikka has quit [Ping timeout: 255 seconds]
<aeth>
The implementation is trivial (although SBCL, CCL, and ECL all have slight differences in the macroexpand-1, try it!), so there probably could be an implementation-specific workaround on implementations that don't use this interpretation.
dieggsy has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
<loke>
But, if the original intent of WITH-ACCESSORS was to be allowed for anything, what is the meaning of this statement: “The consequences are undefined if any accessor-name is not the name of an accessor for the instance.”
<aeth>
yes
<loke>
I guess they are referring to something with (WITH-ACCESSORS ((foo print)) x (foo))
<loke>
That would kinda work, I guess.
<loke>
(minus the extra parens around foo
neoncontrails has quit [Ping timeout: 255 seconds]
<aeth>
Two possibilities. (1) they were opening the door for optimizations or (2) they were opening the door for the trivial implementation, which technically makes things work for non-accessors like print.
<aeth>
Technically, #2 is a bit of #1, too, since checking would be slower
_paul0 is now known as paul0
dddddd has quit [Remote host closed the connection]
dilated_dinosaur has quit [Ping timeout: 260 seconds]
dilated_dinosaur has joined #lisp
jameser has joined #lisp
schoppenhauer has quit [Ping timeout: 268 seconds]
<aeth>
it doesn't look like anything really comes close
<aeth>
It seems like almost every language prefers boilerplate
<Zhivago>
Alternately you can see it as other languages preferring not to pollute their function namespace.
<Zhivago>
Since given a.b or whatever you can always produce foo_b(a).
<whoman>
accessors to what? lisp is just lists ..
<Zhivago>
Of course, then you need some boiler plate to make something like foo_b(a) = c work, or you need another explicit function. like foo_b_set(a, b).
<Zhivago>
whoman: Are you delusional or just stupid?
<Zhivago>
whoman: What does make-hash-table produce?
<Zhivago>
It would be nice if CL had first class places, though.
<Bike>
meaning manipulable objects instead of just macrology?
<Zhivago>
Yeah, something you could pass around. You can always wrap a use of a place in a lambda, but then you need one for each kind of use.
<devon>
Some lists have first-class locatives.
<devon>
lists/lisps
<Zhivago>
Although I guess you could do that and then use that object as a place which forwarded.
<aeth>
whoman: (defun lists-have-accessors-too (list) (flet ((caddddr (x) (cadddr (cdr x)))) (with-accessors ((first car) (second cadr) (third caddr) (fourth cadddr) (fifth caddddr)) list (values first second third fourth fifth))))
<Zhivago>
Devon: Yeah, I'm not sure why they went out of fashion -- but I suspect it's because they didn't support place semantics.
<aeth>
Zhivago: You indirectly raise a good question. Does the spec allow implementing everything (including hash tables) as lists? (Not like anyone should try to do this, though!)
<aeth>
Zhivago: Can you provide a code example of what you'd want?
<Zhivago>
No, since then class-of or type-of would not produce the expected results.
<Zhivago>
You would need at least a class carrying header to wrap the list.
<aeth>
Zhivago: or just make the car a symbol that means that it's a hash-table. Any list without a type symbol in the car is a regular list
<Zhivago>
That would be one way to implement a class carrying header.
<Zhivago>
But that cons wouldn't be a cons anymore.
<aeth>
true
<Zhivago>
Sometimes I wonder if starting with dictionaries and then adding schema to them would have produced a better outcome.
k-stz has quit [Remote host closed the connection]
neoncontrails has joined #lisp
<Zhivago>
To be honest, I'm not sure that first class places matter, really.
smurfrobot has joined #lisp
<Zhivago>
They're probably just one of those things that sounds like a good idea until you really think about it.
devon has quit [Ping timeout: 240 seconds]
<Zhivago>
A bit like transparent persistence and not having processes.
hexfour has quit [Ping timeout: 260 seconds]
hexfour has joined #lisp
smurfrobot has quit [Ping timeout: 255 seconds]
SaganMan has joined #lisp
<beach>
Good morning everyone!
shenghi has quit [Remote host closed the connection]
shenghi has joined #lisp
devon has joined #lisp
quazimodo has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
neoncontrails has quit [Remote host closed the connection]
neoncontrails has joined #lisp
devon has quit [Ping timeout: 248 seconds]
neoncontrails has quit [Ping timeout: 255 seconds]
damke_ has joined #lisp
Bike has quit [Quit: Lost terminal]
damke has quit [Ping timeout: 240 seconds]
mishoo has joined #lisp
<emaczen>
morning beach
quazimodo has quit [Ping timeout: 260 seconds]
* beach
is watching the video of McCLIM made by jackdaniel.
<pfdietz>
One can defined a pseudo-pointer class in CL. It would hold reader and writer functions for some actual place. Define DEREF and (SETF DEREF) methods for it.
vlatkoB has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
lanu has quit [Quit: leaving]
<dmiles>
"class-of or type-of would not produce the expected results." I am litterally stuffing classof and typeof ijn the objects properties
<dmiles>
so i can use structs/lists/pldicts/hastables as the objects
vtomole has quit [Ping timeout: 260 seconds]
Kevslinger has quit [Quit: Connection closed for inactivity]
<Zhivago>
The point being that if you re-use something but have class-of report something else, then it no-longer has the semantics of what you were re-using.
lanu has joined #lisp
<dmiles>
well i wanted to proably switch out the underlying structure as i get more experience
<Zhivago>
A fine goal.
<lanu>
join #debian
<lanu>
part
lanu has left #lisp [#lisp]
<dmiles>
i started out using asserted relations (typically that is the fastest) ... but it was messing with my setcdrs
<dmiles>
has anyone done a setf expander that is based solely on gettign first class locatives?
<dmiles>
i am temped to continue doing it traditionally first with (get-setf-expander ..) returning a function call.. but would be nice so see something else
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
mishoo has joined #lisp
<dmiles>
in prolog a variable, is insufficent was a locative i have to use '$LOC'(TermPtr,Offset) % a bit like C.. but at leas the GC moves my pointers
marusich has quit [Ping timeout: 255 seconds]
marusich has joined #lisp
xor-xor has joined #lisp
renard_ has joined #lisp
<dmiles>
so it looks like: TermPtr = cons(a,b), L = $LOC'(TermPtr,2), set_locative(L,b2), to 'replcd
<jackdaniel>
beach: thanks, my first video tutorial
<beach>
Congratulations!
d4ryus1 is now known as d4ryus
scymtym has quit [Ping timeout: 255 seconds]
Karl_Dscc has quit [Remote host closed the connection]
<dmiles>
oh cool! .. Daniel :)
<dmiles>
we like like twins.. left handed ahskenazi russian jews in family tree i can see
mson has quit [Quit: Connection closed for inactivity]
<jackdaniel>
I'm sorry, I don't understand the last sentence
<jackdaniel>
could you elaborate?
<beach>
jackdaniel: He is making statements about your ancestors and your dexterity, as compared to his own.
<jackdaniel>
ah, you mean we look similar? heh
<jackdaniel>
in fact, I'm both handed, but I was left handed when I was a little
* dmiles
was watching video.. looked back at IRC just now
Jen has joined #lisp
Guest24518 has quit [Ping timeout: 255 seconds]
<dmiles>
There is a very strong genetic line that has moved in and accrossed europe over the centuries.. many of the people ended up in russia (my fammily did)
Jen is now known as Guest78438
zmt00 has quit [Quit: Leaving]
<dmiles>
The head of Cycorp and many many programmers that have been hired at cycorp have ended up comming from this genetic line
<Zhivago>
And you ask why people talk about Jewish conspiracies.
<dmiles>
most of us are either left handed or close to it.. actually a few yearts ago at a dinner 25 out of 28 of us relize we are all left handed
<jackdaniel>
heh, ftr I'm not Jewish, but I can join the conspiracy ;)
SuperJen has quit [Ping timeout: 268 seconds]
<Zhivago>
Of course, there is the high comorbidity rate with that group, so ymmv.
* jackdaniel
checks comorbidity word in his dictionary
<dmiles>
yeah.. i was trying to confirm it was "a thing" i could point jackdaniel's to and ran acrossed the high mobidity rate :(
<jackdaniel>
so many hard words
<jackdaniel>
mobidity is not found in my dictionary
<Zhivago>
comorbidity and morbidity are different.
<dmiles>
ah
<jackdaniel>
but I think we are getting offtopic
sjl has joined #lisp
fikka has joined #lisp
sjl has quit [Ping timeout: 240 seconds]
raphaelss has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
<jackdaniel>
Xach: regarding top 100 downloaded projects in Quicklisp: you count raw downloads, or things which are quickloaded? For instance if I type (ql:quickload 'foo) and foo depends on alexandria (so both are downloaded) – is the counter increased for both foo and alexandria?
<jackdaniel>
I would find very useful count for top-level system downloads too
smurfrobot has joined #lisp
hajovonta has joined #lisp
devon has joined #lisp
<aeth>
This... is incredible really. I can copy the basic concept of with-accessors (let above a symbol-macrolet above the body) and abstract everything, with the only issue being that M-. doesn't like it, i.e. M-. looks for the definition of the symbol and fails to find it because the symbol is just a shorthand for some accessor-like form.
<aeth>
(M-. also fails in with-accessors if you use a name other than the accessor name)
vtomole has quit [Ping timeout: 260 seconds]
safe has quit [Read error: Connection reset by peer]
devon has quit [Ping timeout: 240 seconds]
<borodust>
Xach: also, please, check if this example blob works for you https://goo.gl/wH6Fok
smurfrobot has quit [Remote host closed the connection]
shka has quit [Ping timeout: 248 seconds]
varjag has joined #lisp
lrvy has joined #lisp
<jdz>
jackdaniel: pretty sure the stats count raw downloads.
<jdz>
(Pretty sure nobody quickloads rfc2388 without hunchentoot.)
<jdz>
Pretty sure I use pretty sure too much.
momofarm has joined #lisp
smurfrobot has joined #lisp
<loke>
jdz: I'm pretty sure that is not the case.
fikka has joined #lisp
<jackdaniel>
sure, pretty thanks!
<jdz>
Then we'll have to wait for what Xach has to say.
<jackdaniel>
it is said in the post on planet lisp "raw downloads"
<XachX>
Raw downloads not quick loads
<jackdaniel>
I'm more curious if he is interested in adding another stat
<jackdaniel>
oh, you're here
<XachX>
It is 3am. Shhhh.
<jackdaniel>
heheh
<XachX>
Zzz
<jackdaniel>
sleep well
<hajovonta>
hi all
<beach>
Hello hajovonta.
<jdz>
Now I'm pretty sure loke was not talking about quicklisp.
smurfrobot has quit [Ping timeout: 276 seconds]
<loke>
jdz: I'm pretty sure I was referring to your use of pretty sure.
* jdz
is now 99.8% sure all outstanding issues on #lisp are settled.
EvW has joined #lisp
<whoman>
99.8% is pretty sure ?
<aeth>
All that's left to settle is how many ;s to put at a comment that serves as a section title within a long file.
<loke>
aeth: three
<aeth>
so four ;s only go at the top of a file?
<hajovonta>
please help: I have an error starting slime:
<jdz>
whoman: nah, pretty sure is like 92.3%.
<hajovonta>
fatal error encountered in SBCL pid 11749(tid 140737353733888):
<hajovonta>
can't find core file at ~/sbcl/lib/sbcl/sbcl.core
<hajovonta>
but the core file is there.
<whoman>
=P
EvW has quit [Ping timeout: 240 seconds]
<whoman>
i have a feeling that some people have gone crazy or are going crazy with lisp. shoehorning it into how they are thinking, rather than kind of meeting half way. there is a secret whispering in the clay to be sculpted into this or that shape ... just got to listen... and get a decent keyboard.. =)
<jdz>
99.8% is more like "almost certain".
<whoman>
hmm i feel that almost is nearer 90%
<whoman>
quite sure feels around 95%, fairly is lower than 90% say 80-85%
<jdz>
But that's "almost sure", not "almost certain", right?
scymtym has joined #lisp
<whoman>
i wonder how the Matrix would benefit from our human intervention of giving values to numbers. especially them pretty pesky pickly adjectivies
<whoman>
ahh yes. adjusting
<whoman>
literally pushes past 100% these days
<jdz>
More so if "like, whoa!" is added.
<whoman>
if we cannot work out our problems linguistically aka symbolically, i strongly feel certainly confident that surely we are getting too deep into the self-projected communal holograms
<whoman>
but like its like she said and im like whoa
<whoman>
haha oh !
<whoman>
'wow, are you serious'
orivej_ is now known as orivej
knobo3 has joined #lisp
nirved has joined #lisp
<whoman>
lists/trees of words/symbols, which mean different at different times and contexts; eval, compile, read, write, etc... this lisp thing should be rationed to the common folk. digital acid over here
Cymew has joined #lisp
White_Flame has quit [Ping timeout: 248 seconds]
<whoman>
people be getting all stuck up in that there them ideas and ideals of real words meaning real things. its good to experiment. programmers are magicians =) the current alchemy is to.. something human something computer something earth something science... well breaking habits. we should give ourselves more credit - look at all of this stuff we made !! holy hell what potential is life! ahem i hope everyone is inspired to their magnum opus
SaganMan has quit [Quit: WeeChat 1.6]
shrdlu68 has joined #lisp
<shrdlu68>
Hello, is anyone aware of a library that has functionality for generating combinations with repitions?
<shrdlu68>
That is, generating combinations from '(a b c) of length 2 should generate '(c c)
<shrdlu68>
And either '(a b) or '(b a), but not both.
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
devon has joined #lisp
QualityAddict has joined #lisp
<mrSpec>
shrdlu68: I don't. But you know that you can use remove-duplicates with :test #'set-equal? ;)
<alandipert>
i tried inlining it in the run function, but that didn't seem to make any difference, so stuck with funcall
devon has quit [Ping timeout: 255 seconds]
<hajovonta>
mrSpec: that would not remove one of '(a b) and '(b a) because these are not identical.
<hajovonta>
or ... ?
<XachX>
hajovonta: try without ~?
orivej has quit [Ping timeout: 240 seconds]
<aeth>
alandipert: That's because input is a global variable, and those are going to be slow because they're not lexical (or at least, the portable ones aren't)
murii has joined #lisp
<aeth>
They should always be surrounded by *s so you know they're special, i.e. *input*
<alandipert>
aeth hm, but on line 33 i copy-seq it to a local
<hajovonta>
XachX: even with custom test function, it's probably better to come up with a smart generation algorithm from a performance viewpoint
<mrSpec>
hajovonta: (set-equal '(a b) '(b a)) → t
<mrSpec>
,clhs set-equal
<hajovonta>
mrSpec: didn't know that, thanks
<aeth>
alandipert: why so many copies? You copy it twice, once when you convert it into a vector and then again with copy-seq
<alandipert>
aeth because ev2! mutates it.. i'm not sure the copies dominate since they're not in the hot loop (lines 36-37)
* alandipert
just tested not copying at all, runtime is same
<aeth>
and you tried inlining the functions already? hmm...
lrvy has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<aeth>
alandipert: what's the input? is part of the page not visible without logging in?
hhdave has joined #lisp
<aeth>
also, if you're sure they're always fixnum, try benchmarking with '(simple-array fixnum (*)) instead of 'simple-vector
<alandipert>
aeth i think that might have shaved off 10-20 ms, hard to say tho
<alandipert>
the time to beat is 130 ms.. that's how fast a similar and type-hinted clojure algorithm does it on my machine. currently my lisp goes to ~230ms
hhdave has quit [Ping timeout: 240 seconds]
pjb has quit [Remote host closed the connection]
<beach>
alandipert: Do you have to use simple vectors? It might be more efficient to use specialized vectors.
lrvy has joined #lisp
<aeth>
If you want to make a higher-order-function faster, you can usually do that by converting it into a macro, afaik.
<aeth>
I just more than halved it by turning it into a macro, on my machine
<alandipert>
beach i don't think they have to be simple, i'm ignorant of this swath of CL :-) i went with simple because it seemed like.. the simplest
<beach>
alandipert: Well, in Common Lisp a simple vector has element type T. It might be better to use a vector type that stores numbers.
<aeth>
All I did was replaced the funcall with (progn ,@body) and now I define a function instead of passing in a higher order function. Real code should also use gensyms in macros.
Cymew has quit [Remote host closed the connection]
<aeth>
Giving it a fixnum type doesn't make a big performance difference because fixnums are already unboxed (unlike e.g. double-float), fixnums will fit in a vector already, and it's being told they're fixnums with (the fixnum ...)
<aeth>
Even if it made no difference, though, '(simple-array fixnum (*)) in your coerce and removing the (the fixnum ...) feels more idiomatic
<jdz>
alandipert: What's the expected result?
damke_ has joined #lisp
<alandipert>
jdz 23948711
mhitchman[m] has joined #lisp
Cymew has joined #lisp
<jdz>
I get 318883 :?
<aeth>
that's the first one
<aeth>
alandipert: Make sure that the length is known. That's the big thing for vectors. e.g. (declare (optimize (speed 3)) ((simple-array fixnum (1000)) code)) And use a macro instead of a higher order function, i.e. put the loop in a macro, and make the part that differs the body.
dddddd has joined #lisp
<jdz>
aeth: Is there another input file?
<aeth>
I'm just using the same input file for both
<jdz>
For both what?
<jdz>
OK, what's part 2?
<jdz>
I'm reading the original task and there's only part 1?
<alandipert>
jdz you have to log in and solve part 1 in order to see part 2
<alandipert>
aeth i can see how inlining via macro is faster, i was kind of hoping there would be a way to parameterize via defun name at least. and use (declare (inline ...))
<aeth>
SBCL doesn't trust you, btw. It doesn't believe that it's not a fixnum because you're doing addition, afaik. When I disassemble, I see three object-not-fixnum-errors. If the numbers have a tighter bound than fixnum, you can save some checks each iteration of the loop (or at least, some of them might be in the loop)
<aeth>
Not sure which CL you're using. Maybe you use one that trusts the.
<aeth>
Or declare.
<alandipert>
i'm on sbcl
<aeth>
no, don't make the macro like that.
<aeth>
I mean, replace (evnfun code ptr) with (progn ,@body)
_cosmonaut_ has joined #lisp
smurfrobot has joined #lisp
specbot has quit [Remote host closed the connection]
specbot has joined #lisp
<aeth>
i.e. instead of calling a function, you're inlining the whole thing into the loop iteration manually, with the macro.
<alandipert>
im familiar with the technique, but was hoping to avoid its downsides
drcode has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Remote host closed the connection]
<aeth>
SBCL cheats with its built-in higher order functions, and even then the cheating is a leaky abstraction and you can easily ruin performance.
<aeth>
Very high performance CL does not use higher order functions.
Cymew has joined #lisp
kushal has quit [Ping timeout: 248 seconds]
<alandipert>
sure... or we just write C
<aeth>
If prefer using C's macro systme
<aeth>
s/If prefer/If you/
eli has quit [Ping timeout: 248 seconds]
<aeth>
bah
<jdz>
alandipert: what CPU does the 130ms requirement for?
lrvy has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
murii has quit [Ping timeout: 264 seconds]
BitPuffin|osx has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
<aeth>
And afaik you can meet the desired performance if you replace (evfun code ptr) with (progn ,@body) and redefine the functions to use this macro instead of to be passed in. Additionally, declaring it as a (simple-array fixnum (1000)) instead of * (unless it's going to be of a variable size)
<aeth>
In fact, just the length declaration might do it
<aeth>
Unknown length on a vector is expensive
devon has joined #lisp
<aeth>
You get a big, scary "SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS" in the disassembly without a known length, and it's every iteration of the loop because it's in ev2!
<aeth>
I think that contains everything that's relevant
knobo3 has quit [Ping timeout: 240 seconds]
damke_ has quit [Ping timeout: 240 seconds]
knobo3 has joined #lisp
turkja has joined #lisp
<aeth>
jdz's version gives me a consistent 0.69, which is twice as fast as the macro-ified version of ev2+run. Giving it a known length of 1000 speeds it up to about 0.64. More than I thought, but fairly insignificant. It gets rid of several bounds checks, but the bounds checks probably aren't being called every iteration anymore.
<jdz>
Compiling with (safety 0) almost halves the time, but nobody should ever do that.
<aeth>
The macro version probably gave such a dramatic improvement because the compiler didn't have to bounds check as often.
hhdave has joined #lisp
sebboh has quit [Ping timeout: 240 seconds]
<aeth>
jdz: That's the path to the Dark Side
jibanes has quit [Ping timeout: 268 seconds]
* jdz
could not agree more!
Amplituhedron has joined #lisp
momofarm has quit [Ping timeout: 240 seconds]
<jdz>
I wish one of the exercises will use 65-bit (or bigger) integers!
jibanes has joined #lisp
<aeth>
known size is 2 bounds checks and 3 fixnum checks; unknown size adds 2 bounds checks; safety probably removes all the checks because the algorithm is flawless
<aeth>
s/safety/safety 0/
<aeth>
jdz: Project Euler does, sometimes.
rgrau has joined #lisp
Cymew_ has joined #lisp
<alandipert>
jdz your code is awesome, thanks for sharing. i like not using fancy loop stuff. ok now to bed for real :-)
<aeth>
You might be able to remove some more checks if you're clever, without resorting to safety 0. That can get you some of the way there.
Cymew has quit [Read error: Connection reset by peer]
<aeth>
e.g. maybe they're 32 bit signed integers? Then maybe the compiler can assume fixnum longer.
<aeth>
you'd slowly lose clarity, though
Amplituhedron has quit [Read error: Connection reset by peer]
flamebeard has joined #lisp
<schweers>
aeth: your measurements pretty much confirm what I suspected: bounds checks are not that expensive, since running times of programs on modern hardware are pretty much limited by the speed of memory operations.
<aeth>
Individually, the checks are pretty cheap. Collectively, they apparently add up. I don't get half the time, though. I get 0.04 seconds in the safety 0 version. And half the checks that are being removed are checks for fixnum.
<jdz>
Yes, "almost halves".
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<schweers>
you can go from 0.69s to 0.04s? not bad, that on the other hand is not what I expected
<jdz>
Oh, I misread the number.
<aeth>
no
<aeth>
I mistyped a number
<aeth>
.064
<aeth>
Not 0.64
<aeth>
I think I need to sleep.
<schweers>
oh, ok
<schweers>
thanks for clarifying
<aeth>
Also, that's why you should always get in the habit of putting the leading zero! 00.64 would have been obvious
<aeth>
although I think I just was misreading it or something
<aeth>
Or if that's not good enough: (let ((foo (coerce (loop for i from 0 to 10000 collect i) 'simple-vector))) (time (dotimes (i 10000000000) (sb-kernel:hairy-data-vector-set/check-bounds foo 400 42))))
<aeth>
In order for it to matter, your data has to be huge or you have to have a very strict time constraint (maybe 200 frames per second?)
red-dot has joined #lisp
fikka has joined #lisp
wigust has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
shrdlu68 has quit [Ping timeout: 248 seconds]
shrdlu68 has joined #lisp
BitPuffin|osx has quit [Remote host closed the connection]
<aeth>
nevermind, that doesn't do what I think it does.
Cymew_ has quit [Remote host closed the connection]
devon has joined #lisp
devon has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
damke_ has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
igemnace has quit [Quit: WeeChat 2.0]
damke has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
eSVG has quit [Ping timeout: 258 seconds]
sjl has joined #lisp
Cymew has quit [Ping timeout: 250 seconds]
hvxgr has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
sjl has quit [Ping timeout: 240 seconds]
hvxgr has joined #lisp
wxie has joined #lisp
m00natic has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
<shrdlu68>
When working with arrays of integers less than 128, is there a performance benefit in using :element-type '(unsigned-byte 7) rather than '(unsigned-byte 8) ?
<schweers>
shrdlu68: No, as the underlying hardware is probably byte-aligned
<schweers>
i.e. there is no machine instruction to fetch or address a 7-bit region of memory
Tobbi has joined #lisp
<shrdlu68>
schweers: So implementations probably use octets in any case?
<schweers>
I guess
<schweers>
according to the CMUCL manual there are (or were?) even implementations which used even worse representations in such cases
<schweers>
but CMUCL and SBCL should just use octets
<shrdlu68>
I see, thanks!
jmercouris has joined #lisp
jmercouris has quit [Remote host closed the connection]
<schweers>
the same should be true of '(unsigned-byte 15) etc
<schweers>
if it’s a macro, and doesn’t use its argument ... on the other hand the SETF expression does use it anyway. I’m also confused
<Zhivago>
Perhaps it is just a symbol?
fikka has joined #lisp
drcode has joined #lisp
mercourisj has joined #lisp
<mercourisj>
sorry, my internet keeps cutting out, I am checking the logs though, so don't worry
jmercouris has quit [Ping timeout: 240 seconds]
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<mercourisj>
from the project description: "The ps macro takes Parenscript code in the form of lists (Parenscript code and Common Lisp code share the same representation), translates as much as it can into constant JavaScript strings at macro-expansion time, and expands into a form that will evaluate to a string containing JavaScript code."
fikka has quit [Ping timeout: 240 seconds]
jmercouris has joined #lisp
<jmercouris>
Zhivago: What do you mean by "perhaps it is just a symbol"?
<schweers>
does insert-help contain what you expect?
fikka has joined #lisp
<Zhivago>
ps:ps looks like a symbol. Perhaps that's how it is being used.
<jmercouris>
schweers: No
<jmercouris>
It looks like this: "document.body.innerHTML = helpContents;"
mercourisj has quit [Ping timeout: 240 seconds]
<jmercouris>
Whereas it should look like "document.body.innerHTML = "contents of help-contents variable";"
mercourisj has joined #lisp
<shrdlu68>
Is there a way to increase dynamic heap size in sbcl once it's running?
jmercouris has quit [Ping timeout: 248 seconds]
<schweers>
shrdlu68: As far as I know this cannot be done. I wish there was a way though. Or rather I wish this could happen automatically.
mercourisj has quit [Ping timeout: 258 seconds]
<schweers>
jmercouris: can you verify that SETF has any effect? Also, have you tried factoring the (PS:PS ...) expression into a function and calling that with HELP-CONTENTS as an argument?
thinkpad has quit [Read error: Connection reset by peer]
yeticry has joined #lisp
jmercouris has joined #lisp
<jmercouris>
schweers: I haven't tried that, but I don't see how that would help, I didn't write ps:ps it is part of parenscript
mercourisj has joined #lisp
<schweers>
I know, but I don’t know anything about parenscript, so I have no idea what the macro actually does.
<mercourisj>
schweers: setf most definitely has an effect, if you look at the outputted html it has an assignment on the innerhtml of the body
wigust has quit [Ping timeout: 240 seconds]
<mercourisj>
what I need to figure it is how to inline to ps somehow :\
<schweers>
Is it imporant to have the SETF inside the macro?
thinkpad has joined #lisp
yeticry_ has quit [Ping timeout: 255 seconds]
<schweers>
i.e. is setf meant to be carried through to js?
wigust has joined #lisp
jmercouris has quit [Ping timeout: 255 seconds]
jmercouris has joined #lisp
<jmercouris>
schweers: Correct, it must be in JS the point is to set the text of the web page
<jmercouris>
schweers: Correct, it must be in JS the point is to set the text of the web page
devon has joined #lisp
mercourisj has quit [Ping timeout: 255 seconds]
<schweers>
have you macroexpanded it?
mercourisj has joined #lisp
<mercourisj>
yes, the macro expansion is the same as ps:ps
<schweers>
have you macroexpanded the PS invocation?
<schweers>
to see what it does with its arguments
<mercourisj>
Yes the issue is the symbol conversaion rather than evaluation
<mercourisj>
If you look in the reference here:https://common-lisp.net/project/parenscript/reference.html
<mercourisj>
You'll see the section "Symbol Conversion" which is what is happening with the value of help-contents, rather than an eval to its value
jmercouris has quit [Ping timeout: 268 seconds]
jmercouris has joined #lisp
<jmercouris>
alright, so reading the manual again, I retried ps:lisp, apparently ONLY at runtime does the lisp form get evaluated, so I was doing the macro expansion and it looked wrong to me, but did actually work
<jmercouris>
so to anyone reading the log in the future, the following is how I solved my problem (ps:lisp help-contents) instead of just using help-contents which was being translated to a js symbol helpContents
<jmercouris>
within (ps:lisp) any lisp can be eval'd at runtime
<hajovonta>
is that null lexical environment?
<jmercouris>
hajovonta: sorry, what is the question?
mercourisj has quit [Ping timeout: 252 seconds]
jmercouris has quit [Remote host closed the connection]
jmercouris has joined #lisp
Bike has joined #lisp
<jdz>
On SBCL: (upgraded-array-element-type '(unsigned-byte 7)) => (UNSIGNED-BYTE 7)
<schweers>
jdz: but does it have any benefit declaring the element type as (unsigned-byte 7)?
orivej has joined #lisp
<schweers>
now that I think of it: there may be cases in which the compiler can prove that an operation on an element will not be larger than (unsigned-byte 8)
<jdz>
If that's what you will be storing there, then yes.
<devon>
PDP-10 SIXBIT for filenames, SQUOZE for symbol tables, 7-bit ASCII for text, 8-bit SAIL for terminal output, 9-bit... not sure but I'm sure it got some use.
<pjb>
Funny: there's ±
<pjb>
ASCII was invented way later than LISP 1.5…
TCZ has joined #lisp
EvW1 has quit [Ping timeout: 240 seconds]
<devon>
I suspect that " is a mistake and ' is more likely.
<jdz>
Why?
<jdz>
There is Ø and ±, and many unallocated codepoints.
yeticry has quit [Remote host closed the connection]
yeticry has joined #lisp
vap1 has quit [Ping timeout: 250 seconds]
hhdave has quit [Ping timeout: 252 seconds]
test1600 has quit [Quit: Leaving]
orivej has joined #lisp
vap1 has joined #lisp
dieggsy has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
circ-user-81lkm has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
EvW has quit [Ping timeout: 276 seconds]
jmercouris has joined #lisp
<circ-user-81lkm>
Is it possible to query a "system class" like character for its subclasses? e.g. http://www.lispworks.com/documentation/HyperSpec/Body/t_ch.htm#character has base-char and extended-char extending character. Something like (subclasses 'character) => '(base-char extended-char)?
<Shinmera>
You can't query class relationship information in CL at all, you need the MOP for that.
<Shinmera>
Well, aside from probing with subtypep
sellout has joined #lisp
<emaczen>
Almost every implementation provides the MOP though
<emaczen>
There is even a library called closer-mop which will work on most implementations too
<_death>
types aren't necessarily classes, in particular base-char and extended-char are not classes
fikka has joined #lisp
<Bike>
For that particular question you can use subtypep, i.e. (subtypep 'extended-char nil)
<Bike>
which i think is required to give you an actual result.
<Shinmera>
Afaiu he wants to get a list of subtypes, though.
<Shinmera>
If you know the set of concrete types you can probe with subtypep, I guess, but not in general.
<Bike>
the list of subtypes of almost any type is infinite
<Shinmera>
Yeah.
<Bike>
circ-user-81lkm: more information on what you're doing?
<jmercouris>
What's a good way to show the source for any given function?
_cosmonaut_ has quit [Ping timeout: 240 seconds]
<_death>
jmercouris: M-.
<jmercouris>
_death: Outside of emacs, purely in Lisp
<Bike>
if you need to do it programmatically (and as i recall, you're making some kind of editor) it's implementation specific. Look through swank
<Bike>
and what you'll get is a source location, not the actual source form, which has probably been discarded
<_death>
jmercouris: there is no way in plain common lisp.. pjb has a package called ibcl which may be appropriate
<jmercouris>
Bike: You mean like a position + a file?
<circ-user-81lkm>
Well I saw a demo somewhere of a UI that produced a class hierarchy diagram and it included character and it's subtypes but I'm not sure how it produced that
<Bike>
i.e. what M-. uses
<jmercouris>
Maybe I'm just re-inventing emacs at this point, perhaps I shouldn't implement that
<Bike>
pragmatic, shinmera
pjb` has joined #lisp
<Shinmera>
Bike: 's what I do
<jmercouris>
Ah, that is very good indeed, very simple
<Bike>
It's true, though, if you want to do editor things you could do worse than just bringing in swank rather than reimplementing it
akr has joined #lisp
<Bike>
It also has completions and other stuff you were doing
<jmercouris>
Yeah, maybe it is pointless though, because someone can just use slime to connect to my program
pjb has quit [Ping timeout: 255 seconds]
dddddd has quit [Ping timeout: 248 seconds]
<jmercouris>
I should just get slime working with my standalone executable, and avoid too many things like "jump to source" and stuff like that, I'll leave it at showing docstrings for built in help
<Bike>
Is your program not an editor?
<Shinmera>
It's a web browser, if I remember correctly
<Bike>
lisp editing sounds like scope creep, then.
<jmercouris>
sjl: Yeah, I have a branch for that, I was so close to releasing it, but none of the GUI updates were making it on screen
Baggers has joined #lisp
rgrau has quit [Ping timeout: 252 seconds]
<jmercouris>
It doesn't make sense to me how that is even possible that the updates were not happening on screen, because all of the functions that update the gui have a (on-main-thread) macro which calls them in the ccl event process
<circ-user-81lkm>
Thanks for the MOP tip - I think this is what I'm after, e.g. (closer-mop:class-direct-subclasses (find-class 'character)) => (#<BUILT-IN-CLASS STANDARD-CHAR>)
<emaczen>
What does no more immobile pages left mean? It is an error I get from SBCL and then I get sent to LDB?
<emaczen>
Can I just start SBCL with "more immobile pages" like sb-ext:dynamic-space-size?
raphaelss has joined #lisp
<emaczen>
"No more immobile pages available" -- is the exact error message
<circ-user-81lkm>
Although... I get different results in CCL vs. SBCL (where it gives nil)
<Bike>
circ-user-81lkm: extended-char and standard-char are not required to be classes
<Bike>
Whether they are types with elements in them is orthogonal to whether they are classes
varjag has joined #lisp
hexfour has quit [Read error: Connection reset by peer]
brendyn has quit [Ping timeout: 255 seconds]
hexfour has joined #lisp
dcluna has quit [Ping timeout: 268 seconds]
dcluna has joined #lisp
Cymew has joined #lisp
sebboh has joined #lisp
turkja has quit [Ping timeout: 248 seconds]
Cymew has quit [Ping timeout: 250 seconds]
<pjb>
jmercouris: it depends on how on-main-thread is implemented.
<pjb>
I've noticed that with the latest versions of macOS, if you try to draw in a timer, it doesn't work reliably, even though you configure the time to execute on the main thread.
Cymew has joined #lisp
turkja has joined #lisp
varjag has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 255 seconds]
xrash has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
turkja has quit [Ping timeout: 255 seconds]
akr has joined #lisp
<jmercouris>
pjb: Interesting, I'll try some more tests, I just switchted to that branch
<jmercouris>
Gotta go for now, but I'll report later if I come up with something
osune has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
BitPuffin|osx has quit [Ping timeout: 240 seconds]
jmercouris has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 276 seconds]
knobo has quit [Ping timeout: 255 seconds]
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
happy_gnu[m] has joined #lisp
kammd[m] has joined #lisp
Guest87345 has joined #lisp
Sovereign_Bleak has joined #lisp
astronavt[m] has joined #lisp
Jach[m] has joined #lisp
l04m33[m] has joined #lisp
thorondor[m] has joined #lisp
RichardPaulBck[m has joined #lisp
Guest2633 has joined #lisp
dahs81[m] has joined #lisp
equalunique[m] has joined #lisp
CharlieBrown has joined #lisp
cryptomarauder[m has joined #lisp
plll[m] has joined #lisp
hiq[m] has joined #lisp
hdurer[m] has joined #lisp
trigt[m] has joined #lisp
dirb has joined #lisp
ArthurAGleckler[ has joined #lisp
mhitchman[m] has joined #lisp
Tobbi has joined #lisp
nika has quit [Quit: Leaving...]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
Devon has quit [Ping timeout: 264 seconds]
hexfour has quit [Ping timeout: 246 seconds]
circ-user-81lkm has quit [Remote host closed the connection]
shenghi has quit [Remote host closed the connection]
shenghi has joined #lisp
sebboh has quit [Changing host]
sebboh has joined #lisp
varjag has joined #lisp
<earl-ducaine>
<possibly spam> Lispinators! I'd like to do a series of blog posts on MOP that provides enough practicle information and examples to alow someone get get started using it on real world problems (something that I found to be lacking either on the Internet or in the published literature.)
<earl-ducaine>
I'm collecting feedback to guage interest and collect ideas. Feel free to reply here on IRC or post a comment to my blog post requesting the same: https://wordpress.com/view/earlducaine.wordpress.com
<whoman>
earl-ducaine: interesting, thank you ! will check it out.
neoncontrails has quit [Remote host closed the connection]
<earl-ducaine>
Damn. That's what you get for composing a Wordpress first in Emacs. Looked great on my screen with, probably because of exactly alined linebreaks.
Cymew has joined #lisp
neoncontrails has joined #lisp
DGASAU has quit [Ping timeout: 240 seconds]
<Bike>
earl-ducaine: i think the discussion of slots is a bit confusing. objects still 'own' slots in clos
<Bike>
it might be worthwhile to be kind of anal about the distinction between slots (parts of an object, probably anonymous in a vector) and slot definitions
DGASAU has joined #lisp
nonlinear has quit [Ping timeout: 255 seconds]
ryanbw has quit [Ping timeout: 260 seconds]
<Bike>
oh, you gave up on this post, i see...
<Bike>
my mistake
<Bike>
as structuring goes i'd use examples. like some basic features someone want: persistence, observers. stuff you can implement in a simple way in a page or so while introducing mop concepts
<whoman>
interesting how (error ..) is used in :initform s
<earl-ducaine>
Bike: that's exactly the kind of feedback I'm looking for!
Cymew has quit [Ping timeout: 260 seconds]
neoncontrails has quit [Ping timeout: 255 seconds]
<whoman>
singleton ~_~
Cymew has joined #lisp
<whoman>
anyone having success using nEXT browser ? why not just use Ceramic. =)
fikka has joined #lisp
<whoman>
earl-ducaine: your mention of the AMOP book, is it a prerequisite ?
hexfour has joined #lisp
<Bike>
AMOP isn't good as a textbook of how to use MOP because it's definitely intended as a book on developing MOP instead
Kaisyu has quit [Quit: Connection closed for inactivity]
<Bike>
but that just means there aren't any books on using MOP :D
<whoman>
that makes sense.. i read it the other day; was not sure if it was a preview, or a booklet/pamphlette, ..
<whoman>
but MOP is awesome! isn't it? we can defclass with not-yet-defined subclasses (forward) and...
LocaMocha has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 240 seconds]
RichardPaulBck[m has quit [Ping timeout: 240 seconds]
ArthurAGleckler[ has quit [Ping timeout: 246 seconds]
thorondor[m] has quit [Ping timeout: 246 seconds]
akr has quit [Ping timeout: 246 seconds]
cryptomarauder[m has quit [Ping timeout: 246 seconds]
<whoman>
...my sense of OOP is directly tied to syntax, of which CLOS looks like everything else, so i am reserving its application currently. its all just lists anyhow.
plll[m] has quit [Ping timeout: 248 seconds]
l04m33[m] has quit [Ping timeout: 248 seconds]
Jach[m] has quit [Ping timeout: 255 seconds]
dirb has quit [Ping timeout: 250 seconds]
dahs81[m] has quit [Ping timeout: 250 seconds]
Sovereign_Bleak has quit [Ping timeout: 250 seconds]
happy_gnu[m] has quit [Ping timeout: 250 seconds]
CharlieBrown has quit [Ping timeout: 255 seconds]
trigt[m] has quit [Ping timeout: 255 seconds]
hiq[m] has quit [Ping timeout: 255 seconds]
Guest87345 has quit [Ping timeout: 264 seconds]
equalunique[m] has quit [Ping timeout: 264 seconds]
mhitchman[m] has quit [Ping timeout: 276 seconds]
kammd[m] has quit [Ping timeout: 276 seconds]
Guest2633 has quit [Ping timeout: 276 seconds]
hdurer[m] has quit [Ping timeout: 276 seconds]
astronavt[m] has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 248 seconds]
Devon has joined #lisp
josemanuel has joined #lisp
Cymew has joined #lisp
<whoman>
ok earl-ducaine i read it all. my summary: its an introduction to the MOP book, as it talks mostly about it, so i was thinking about that book, and now at the end, after reading it, i feel like i am hungrier than when i came to dinner. i would have the impression that MOP is mysterious undocumented internal assembly unsafe scariness
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
<earl-ducaine>
whoman: Yes, that's exactly what hope to dispell in the revised series!
<borodust>
Xach: that's basically an example code from Getting Started guide
marars91027 has quit [Client Quit]
jack_rabbit has quit [Ping timeout: 248 seconds]
dieggsy has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
Cymew has joined #lisp
<Xach>
borodust: should i expect to see a difference in the scaling issue today with the latest dist update?
<borodust>
Xach: yes, but you need to update the dist first
<borodust>
and remove trivial-gamekit if it is still in local-projects
<Xach>
hmm, right!
<Xach>
no luck, and hello-gamekit is also scaled oddly :~(
<borodust>
ouch
brendyn has joined #lisp
<borodust>
i'll take a look
<Xach>
would a video help again?
Cymew has quit [Ping timeout: 240 seconds]
Guest24518 has joined #lisp
<Xach>
It would basically show what you've seen before - 1/4 scaling in the lower left of the window
EvW has joined #lisp
Cymew has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
<borodust>
Xach: hmm
<borodust>
can you nuke ~/.cache/common-lisp/* and check again?
<Ober>
Shinmera: do you profile your elisp methods for call counts?
<borodust>
i was pretty sure i fixed the issue D:
<Ober>
what is the right way to bundle your .cache/common-lisp fasls/sos
Cymew has quit [Ping timeout: 252 seconds]
jack_rabbit has joined #lisp
<borodust>
Xach: okay, got a second report issue stil persists
<Ober>
allegro puts it all in the same directory as the binary
<Ober>
well shared objects anyways
<borodust>
Xach: going in :)
soma_ has joined #lisp
Cymew has joined #lisp
<Shinmera>
Ober: I don't use elisp
<Ober>
Shinmera: emacs right? was looking to see if you could enable command-frequency, as very curious which slime functions I'm not making use of. you do a lot of stuff where it's not obvious to me which method you invoked
<Shinmera>
Uh, I don't use a lot of stuff
Cymew has quit [Ping timeout: 264 seconds]
<Ober>
might be a simple as me not using the right `select last sexp and eval`
Cymew has joined #lisp
<Shinmera>
I just C-c C-c for that.
<Shinmera>
Other than that the standard paredit things, plus multiple-cursors and expand-region are commands I frequently use.
<Shinmera>
I'm no emacs expert by any means
pjb has quit [Ping timeout: 264 seconds]
<borodust>
Xach: holy moly, i'm dumb, found the source D:
soma_ has quit [Ping timeout: 260 seconds]
neoncontrails has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
<borodust>
Xach: fixed it only for like 99% lol, and forgot one important thing
AntiSpamMeta has quit [Quit: Restart requested by SantaC: brb]
AntiSpamMeta has joined #lisp
Cymew has joined #lisp
damke has joined #lisp
remi`bd has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
raphaelss has quit [Ping timeout: 252 seconds]
<Ober>
Shinmera: thanks
warweasle has joined #lisp
Baggers has quit [Remote host closed the connection]
Baggers has joined #lisp
<borodust>
Xach: i updated the dist, please, check if this version works for you
Karl_Dscc has joined #lisp
shka has quit [Ping timeout: 252 seconds]
<emaczen>
What are the recommended speed and space settings for development?
<emaczen>
1 or 0?
milanj has joined #lisp
<oleo>
speed 1 space 1 ?
<oleo>
or space 0 ?
<emaczen>
yeah with declaim optimize
dirb has joined #lisp
pjb has joined #lisp
<oleo>
debug 2
<oleo>
won't that already make other stuff like speed and space have some default setting ?
<Bike>
they don't affect each other.
jmercouris has joined #lisp
knobo has joined #lisp
dieggsy has joined #lisp
vlatkoB has quit [Remote host closed the connection]
<oleo>
then why not keep it all at level 2 ?
Guest62015 is now known as kushal
kushal has quit [Changing host]
kushal has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
smurfrobot has quit [Remote host closed the connection]
dieggsy has quit [Remote host closed the connection]
fikka has joined #lisp
<fourier>
anyone have had any troubles with alignment/order of the fields in structs returned from C functions by cffi?
<cgay>
asarch: A lisp tutorial seems like a fine idea, even though I'm sure it's not the first. At first glance I can see some problems with the content. Are you asking because you wrote it and you want feedback or because you want to use it to learn Lisp?
<Bike>
tutorialspoint has been kind of bad when i've used it for C
fikka has quit [Ping timeout: 255 seconds]
<jmercouris>
tutorialspoint is good for python, for lisp though, it was terrible, practical common lisp is a really good, though ironically somewhat impractical way of learning lisp
<jmercouris>
I felt like practical common lisp neglected many practical topics, the author addresses that in one of the chapters, but I guess when you get to there, you can start learning on your own
EvW has joined #lisp
<borodust>
jmercouris: oh, wh.. ah, i see
<fourier>
there is common lisp recipes for practical topics as well as "cl cookbook" it is based on
<jmercouris>
the new CL cookbook on github is very good!
<cgay>
I learned with Touretsky's Gentle Intro to Symbolic Computation, which I thought was excellent. It's very basic, but at the time I had no CS background so it worked for me.
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<borodust>
jmercouris: to be fair, that was my experience too
<borodust>
when i learned basics, i just went for making my own stuff
a0503d44f has quit [Remote host closed the connection]
<_rumbler31_>
jmercouris: what practial topics do you feel PCL neglected
<borodust>
but practical there stands for more like "practical" part of CL
<fourier>
dont forget pcl was from 2005 iirc, so how much practical aspects do you want from 12-years old book
<Shinmera>
Well, I mean, when it comes to "practical" things the areas one might want to have covered is almost infinite.
<jmercouris>
Yeah, practical is a very large set, I would have just liked something more cookbooky
<Shinmera>
Have a look at Common Lisp Recipes then.
orivej has joined #lisp
<cgay>
I guess you can't get much more cookbooky than that.
<_rumbler31_>
I was impressed with the mutlithreaeded section
mishoo has quit [Ping timeout: 255 seconds]
<jmercouris>
I've seen them already, but point taken
<_rumbler31_>
I got the gist of the description of how to parallelize a process that can be described as a graph of operations, where peers can be processed simultaneously
<jmercouris>
_rumbler31_: You should take a distributed systems course, you'll learn all about different theories for proving correctness, order, etc
<jmercouris>
Also different scheduling, communication and signaling strategies to ensure correctness, even with failure etc
fikka has joined #lisp
<fourier>
cl recipes is so awesome
<_rumbler31_>
sounds good!
raphaelss has quit [Ping timeout: 240 seconds]
<fourier>
my favorite book, always revert to it
<asarch>
I want to use it as reference cgay
<asarch>
Does it worth?
<asarch>
I mean, is it a good tutorial?
omilu has quit [Read error: Connection reset by peer]
flamebeard has quit [Quit: Leaving]
<fourier>
just buy it
nirved has quit [*.net *.split]
NaNDude has quit [*.net *.split]
Firedancer has quit [*.net *.split]
jdz has quit [*.net *.split]
amer has quit [*.net *.split]
cpt_nemo has quit [*.net *.split]
theBlackDragon has quit [*.net *.split]
Blkt has quit [*.net *.split]
fe[nl]ix has quit [*.net *.split]
sebastien_ has quit [*.net *.split]
akash47 has quit [*.net *.split]
minion has quit [*.net *.split]
pmden has quit [*.net *.split]
chocolait has quit [*.net *.split]
nopf has quit [*.net *.split]
misv has quit [*.net *.split]
sword has quit [*.net *.split]
nikivi has quit [*.net *.split]
sigjuice has quit [*.net *.split]
Rovanion has quit [*.net *.split]
joeygibson has quit [*.net *.split]
danlentz has quit [*.net *.split]
d4gg4d_ has quit [*.net *.split]
tmc has quit [*.net *.split]
Poetichristmas has quit [*.net *.split]
benny has quit [*.net *.split]
askatasuna has quit [*.net *.split]
XachX has quit [*.net *.split]
stylewarning has quit [*.net *.split]
alandipert has quit [*.net *.split]
shaftoe has quit [*.net *.split]
odin has quit [*.net *.split]
exit70 has quit [*.net *.split]
<fourier>
its not a tutotiral but accompanying book
sigjuice has joined #lisp
amerlyq has joined #lisp
exit70 has joined #lisp
<asarch>
Thank you guys
<asarch>
Thank you very much :-)
<asarch>
See you later! Viel Spaẞ!
asarch has quit [Quit: Leaving]
scottj has left #lisp [#lisp]
knobo has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
theBlackDragon has joined #lisp
jdz has joined #lisp
Firedancer has joined #lisp
nirved has joined #lisp
cpt_nemo has joined #lisp
Blkt has joined #lisp
NaNDude has joined #lisp
Rovanion has joined #lisp
danlentz has joined #lisp
fe[nl]ix has joined #lisp
pmden has joined #lisp
Poetichristmas has joined #lisp
akash47 has joined #lisp
d4gg4d_ has joined #lisp
tmc has joined #lisp
nikivi has joined #lisp
sebastien_ has joined #lisp
nopf has joined #lisp
chocolait has joined #lisp
misv has joined #lisp
joeygibson has joined #lisp
sword has joined #lisp
minion has joined #lisp
benny has joined #lisp
askatasuna has joined #lisp
XachX has joined #lisp
shaftoe has joined #lisp
odin has joined #lisp
stylewarning has joined #lisp
alandipert has joined #lisp
damke has quit [Ping timeout: 240 seconds]
nopf has quit [Max SendQ exceeded]
nopf has joined #lisp
damke has joined #lisp
zachk has joined #lisp
<Ober>
nice, modern book
<Ober>
also a great source of what to use, and what not to use
<cgay>
I think there were several overloaded bindings for "it" there, but oh well.
<cgay>
Yup. I think asarch was still referring to TutorialsPoint.
sz0 has quit [Quit: Connection closed for inactivity]
rm8 has quit [Quit: i quit]
fourier has quit [Ping timeout: 240 seconds]
<aeth>
I personally find the best way to write fast CL is to use a mostly-functional style: i.e. pure functions that feed into mutable data structures. One way of getting non-consing pure functions without a lot of macro hacks is to use multiple return values, which will work for non-boxed values (obviously, within reason... 16 return values for a 4x4 matrix probably won't work well with this style).
sjl has quit [Ping timeout: 260 seconds]
<aeth>
I also treat a zero-body do as pure, even though technically it's just a bunch of mutating gotos. This is because do is pure in Scheme (a macro makes it tail recursion instead of mutating values and having gotos) and that do is basically identical to CL's do minus the ability to do gotos in the do body, afaik.
damke_ has joined #lisp
<Devon>
What is this zero-body, is it documented?
damke has quit [Ping timeout: 240 seconds]
<aeth>
Devon: A zero-body do is a do that doesn't have a body... If you're using do in a purely functional way, you usually don't need a body (except perhaps for type declarations) because the body is for side effects.
<aeth>
I suppose nil body or something would be more accurate.
<aeth>
It probably got morphed in a game of telephone
Baggers has quit [Remote host closed the connection]
<aeth>
Note that do uses 1+ instead of incf, so even though it's technically setting if you macroexpand it, you can pretend it's functional.
<aeth>
I think CL is more of a language for making functional languages than an actual functional language itself. You're ultimately going to be mutating, but you can hide it well and pretend you're pure.
<aeth>
It's not surprising at all to see that article have the phrase "These types of languages were also built upon Lisp, many originating on the Lisp machine"
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Devon>
aeth: a disembodied do, like a loop macro with no do clause.
pfdietz has joined #lisp
<aeth>
Yes, I suppose someone once used 'nil body' as an alternative to 'disembodied' and then someone with a dialect where 'nil' means 'zero' said 'zero' instead, and that's how I picked up the confusing term. 'nil body' at least still makes sense.
<pfdietz>
ML was originally implemented in lisp (as part of LCF.)
pfdietz has quit [Ping timeout: 240 seconds]
<aeth>
Anyway, I see Lisp as a langauge for writing declarative (including purely functional) languages, rather than a declarative language, except where the work has already been done by some included macro (usually the macros are left to libraries).
<aeth>
Imo, there's not enough magic going on in the compiler for efficient pure functional programming out of the box... unless you abuse the language, but such abuses should probably be macroified, anyway.
pfdietz has joined #lisp
<jasom>
okay I remember slime being able to eval an expression and add the result as a comment like ;; => FOO
<jasom>
do I need an extension or something for it because I can't find that; just the C-u C-x C-e which prints it with no comment
Bike has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
nirved has quit [*.net *.split]
NaNDude has quit [*.net *.split]
Firedancer has quit [*.net *.split]
jdz has quit [*.net *.split]
cpt_nemo has quit [*.net *.split]
theBlackDragon has quit [*.net *.split]
fe[nl]ix has quit [*.net *.split]
Blkt has quit [*.net *.split]
sebastien_ has quit [*.net *.split]
akash47 has quit [*.net *.split]
minion has quit [*.net *.split]
pmden has quit [*.net *.split]
misv has quit [*.net *.split]
chocolait has quit [*.net *.split]
nikivi has quit [*.net *.split]
Rovanion has quit [*.net *.split]
sword has quit [*.net *.split]
joeygibson has quit [*.net *.split]
danlentz has quit [*.net *.split]
d4gg4d_ has quit [*.net *.split]
tmc has quit [*.net *.split]
Poetichristmas has quit [*.net *.split]
benny has quit [*.net *.split]
askatasuna has quit [*.net *.split]
XachX has quit [*.net *.split]
stylewarning has quit [*.net *.split]
odin has quit [*.net *.split]
alandipert has quit [*.net *.split]
shaftoe has quit [*.net *.split]
damke has joined #lisp
Cymew has quit [Ping timeout: 246 seconds]
damke_ has quit [Ping timeout: 240 seconds]
Firedancer has joined #lisp
akash47 has joined #lisp
sebastien_ has joined #lisp
alandipert has joined #lisp
chocolait has joined #lisp
danlentz has joined #lisp
tmc has joined #lisp
theBlackDragon has joined #lisp
cpt_nemo has joined #lisp
fe[nl]ix has joined #lisp
askatasuna has joined #lisp
odin has joined #lisp
nirved has joined #lisp
sword has joined #lisp
benny has joined #lisp
jdz has joined #lisp
minion has joined #lisp
nikivi has joined #lisp
NaNDude has joined #lisp
Blkt has joined #lisp
joeygibson has joined #lisp
Rovanion has joined #lisp
Poetichristmas has joined #lisp
XachX has joined #lisp
pmden has joined #lisp
d4gg4d_ has joined #lisp
misv has joined #lisp
stylewarning has joined #lisp
shaftoe has joined #lisp
wxie has joined #lisp
pfdietz has quit [Ping timeout: 240 seconds]
aindilis has quit [Remote host closed the connection]
<aeth>
If I'm heavily abusing symbol macros, do you think it's clear enough if I use names like 'location.x instead of 'x-location or 'location-x to abstract over where I store the x location? Definitely probably violates every style guide in existence, but 'location.x seems like the most obvious name for this syntactic shortcut to me.
_rumbler31_ has quit [Ping timeout: 246 seconds]
<aeth>
I have to heavily abuse symbol macros because otherwise my implementation leaks because I use 2D arrays, meaning arefs everywhere. Fortunately, arefs are very similar to accessors (they are accessors?), so I can basically copy the basic layout of with-accessors
<aeth>
e.g. (setf location.x 4f0) becomes (setf (aref location entity-id +x+) 4f0) where +x+ is 0
<aeth>
I could also use the name location-x or something else, but... I don't think I can use the idiomatic (x location) because then I need to add a lot more complexity than just a symbol-macrolet
<aeth>
I also absolutely hate macros that have fake macros/functions in the body that don't even exist because you can't really do things with them that you expect, and you basically can only figure out what's going on when a syntax error pops up by doing something wrong.
<aeth>
At least with location.x or location-x it's clear that it's a symbol, and fairly obvious that something like with-accessors is going on
<aeth>
I'm trying to get this API right because I have to rework half of my code every time I change it because it's very core to my game engine.
pjb has quit [Ping timeout: 252 seconds]
nhandler has quit [Remote host closed the connection]
pfdietz has joined #lisp
vertigo has quit [Remote host closed the connection]
nhandler has joined #lisp
pfdietz has quit [Ping timeout: 240 seconds]
damke has quit [Ping timeout: 240 seconds]
remi`bd has quit [Read error: No route to host]
republican_devil has joined #lisp
<republican_devil>
how do lispers handle big data?
<republican_devil>
or e commerce?
<republican_devil>
without resporting to postgresql?
<republican_devil>
can files and lisp do it?
LiamH has quit [Quit: Leaving.]
pierpa has joined #lisp
Bicyclidine has quit [Remote host closed the connection]
osune has quit [Remote host closed the connection]
<republican_devil>
no no
<republican_devil>
want to avoid sql and postgresql
<republican_devil>
aavoid nosql
<aeth>
Ah, interesting... with-accessors only works without problems because CL is a Lisp-2. This would have to be used with care because this would blow the stack as it infinitely expands the foo: (with-entity-accessors ((foo foo)) 42 foo)
smurfrobot has quit [Ping timeout: 276 seconds]
<aeth>
republican_devil: Just about everyone uses postgresql through postmodern, afaik. And most of the rest will probably use some other SQL system with a different SQL database.
<aeth>
NoSQL would be tricky because quite a lot of them use JSON and CL's JSON support is fairly weak.
<Shinmera>
What are you talking about
<Shinmera>
There's like six or what JSON libraries to do the parsing and serialising in literally every way imaginable.
<aeth>
JSON doesn't map well to CL, and the popular libraries' arbitrary decisions are bad, especially the most popular's, cl-json
<whoman>
aeth: check out the variable capture of anaphoric macro, may help u out now that i think of it =)
<aeth>
thinking "nil" is more "null" than "false" is quite possibly the worst way to approach it, yet cl-json does it that way.
<Shinmera>
So
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
Kaisyu has joined #lisp
<aeth>
Shinmera: so the most popular (by far) JSON implementation is fundamentally flawed in the way it tries to connect JSON's data types to CL's data types
<Shinmera>
Also, there already are libraries to interface with mongo and couchdb, etc.
<aeth>
And being the most popular, that's probably the one most libraries use
<Shinmera>
aeth: So what? That doesn't make JSON support "weak". There's still all the other libraries that offer all the other options.
<aeth>
I'd call CL's regexp support weak if a fatally flawed regexp library was as popular as cl-ppcre and cl-ppcre was obscure
<republican_devil>
why use json?
<Shinmera>
And I'd call that stupid
<republican_devil>
why use a sql database?
<aeth>
republican_devil: People follow the trends, which in 2000 would have been XML and in 2017 is now JSON... In fact, in 2017 it's remaking everything that has been done with XML, but for JSON
<republican_devil>
oracle is cancer in my opinion
<republican_devil>
no no Im talking about using lisp not following trends
wxie has joined #lisp
<republican_devil>
Im on frebsd with icewm and chrome
<aeth>
Shinmera: The problem is that you'll basically be forced to use multiple libraries that do essentially the same thing when it comes to something like JSON, since odds are one of your dependencies is using cl-json and another realized cl-json is stupid and is using one of the other 5
nirved has quit [Quit: Leaving]
<aeth>
Compare this to something where there's one library (e.g. closer-mop, cl-ppcre, babel, trivial-features, trivial-gray-streams, bordeaux-threads, cffi, etc.) that dominates. Less likely to have a dependency explosion
safe has joined #lisp
<Shinmera>
Then that's an issue with the libraries at hand. It doesn't say anything at all about the support for JSON in and of itself.
<Shinmera>
And again, because there are different ways to do it, there's different libraries to do it. This is not the case with the other examples you mentioned (mostly) because there's very little to do differnetly.
jmercouris has quit [Remote host closed the connection]
<Shinmera>
mop, ppcre, encodings, ffi, features, threading, are all sets that are pretty well defined, and the way to implement a library for it is thus clear. The JSON mapping is not.
<aeth>
There's a different way to do babel... treat it like a portability library and e.g. use SBCL's much faster octets-to-string when on SBCL. There's many ways to do regular expressions. There's also probably many ways to do something like bt or cffi. There are different ways to handle what trivial-features does, one library I used to use used that alternative.
<whoman>
sb-alien
<aeth>
trivial-gray-streams is the only unambiguous basically-one-way-to-do-it library there that I know of. I don't know enough about closer-mop, but it might be the same way.
<Shinmera>
bt, ffi, etc. expose a min-max API and are thus also pretty clearly defined and couldn't well be done otherwise.
<whoman>
lisp libraries hmm could be treated a bit less as having an API and more of being a bunch of parts
<aeth>
I'll grant your point on bt. I'm not sure about cffi
<aeth>
Anyway, I do see it as a flaw in the CL ecosystem that there isn't a clearly correct (for most use cases) and popular JSON library... although, that might just be because a lot of people (like me) use s-expressions for data where other languages would use JSON, YAML, or XML. Still hurts interfacing with things written in other languages, though.
<Shinmera>
trivial-backtrace for instance is no longer the best option though :^)
aindilis has joined #lisp
jack_rabbit has quit [Ping timeout: 248 seconds]
* Shinmera
heads off to bed
aindilis has quit [Read error: Connection reset by peer]
rawste has quit [Quit: ZZZzzz…]
python476 has quit [Ping timeout: 258 seconds]
aindilis has joined #lisp
pjb has joined #lisp
<aeth>
republican_devil: If you're talking about using Lisp instead of SQL where SQL would normally be used, then I think it's still technically NoSQL
<Devon>
republican_devil: I scoped out various CL JSON libs for a product I was developing, found one which was round-trip correct, IIRC I still had to hack it a bit to get it right.
wxie has quit [Quit: Bye.]
<aeth>
Devon: Yes, round-trip correctness, that's the issue. It's related to also having reasonable encodings. Not having a separate '() and #f here hurts CL in a naive encoding if one wants to use lists instead of arrays.
<Devon>
Anyone here ever use a "Semantic" database?
<aeth>
jcowan_ pointed out some workarounds to JSON encoding issues in #scheme a few weeks ago, iirc
<aeth>
I'm not sure if any CL library uses them
<aeth>
Devon: can you clarify? "semantic" sounds like it might be too much of a buzzword to search
<Devon>
I have this vague nightmarish recollection of ugly compromises.
<Devon>
Franz, Inc.'s hoopla, has anyone used it?
<aeth>
republican_devil: I'm not aware of a portable CL-native database that has any real popularity. I wouldn't be surprised if LispWorks and/or Allegro have their own proprietary ones.
<aeth>
Some of the entity systems used by #lispgames might be seen as CL-native in-memory databases, but they would be built around being real-time, not around big data.
jack_rabbit has joined #lisp
<aeth>
A portable database that's not in-memory would probably need some portability around mmap. Does this exist? It looks like the only name match in Quicklisp is trivial-mmap.