<minion>
Younder, memo from flip214: speak slowly and carry a megawatt-laser.
<Younder>
Gotcha, You can add memo's
smurfrobot has quit [Ping timeout: 264 seconds]
<Younder>
I take it from flip214 that I need to speak perfectly conceptually clear. And I rely on the spell checker because a simple comma can label me as an idiot,'
<Younder>
I take it from flip214 that I need to speak perfectly conceptually clear. And if I rely on the spell checker because of a simple comma can label you can still me as an idiot.
<Younder>
Editing is indeed great :)
Intensity has joined #lisp
<Younder>
still label me as an
orivej has joined #lisp
<Younder>
I love editing ;)
Tobbi has joined #lisp
<Younder>
Naw, with geniuses like you who needs a purpose, all you need is an itch.
<Younder>
A X-mas present to Xach, from old bann'able and subsequently unemployable younder.
<Younder>
Good riddance I say.
Sigyn has quit [Quit: People always have such a hard time believing that robots could do bad things.]
Sigyn has joined #lisp
orivej_ has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
anunnaki has joined #lisp
Sigyn has quit [Remote host closed the connection]
Sigyn has joined #lisp
m00natic has joined #lisp
peterhil` has joined #lisp
jfb4 has quit [Ping timeout: 240 seconds]
jfb4 has joined #lisp
peterhil has quit [Ping timeout: 240 seconds]
<myrkraverk>
In SBCL, what does "illegal terminating character after a colon: #\" mean?
<myrkraverk>
The colon in question is inside " "s, so I really don't understand the error message.
<Shinmera>
Are you sure it's actually in string quotes
<myrkraverk>
I can double check, and/or replace the "
<myrkraverk>
But yes.
<Shinmera>
Because the error means the comma is not actually inside a string.
<myrkraverk>
Ok, maybe there's some utf-8 corruption here; and or not ascii "
<Younder>
Multiple "" like you forgot one earlier?
<myrkraverk>
Yeah, just thought of that; checking now.
<Shinmera>
Syntax highlighting should catch these kinds of things
<myrkraverk>
Yup, a lot earlyr.
<myrkraverk>
I'm on remote, for this task; ssh and no syntax highlight.
<Shinmera>
use tramp
<Younder>
myrkraverk, I recommend vim and syntastic.
<myrkraverk>
Call me lazy, but I just use nano.
<Shinmera>
Well you reap what you sow.
<Younder>
Whatever, on a remote terminal, vim with syntasic is just about the best you can get.
<Younder>
But you can use EMACS as well
<Younder>
'emacs -nw' gives you the text interface
<myrkraverk>
*nod*
<Shinmera>
Or, y'know, as I already said, just use tramp in your local emacs.
josemanuel has quit [Quit: leaving]
<Younder>
Yes, but then X over SSH has to be enabled. (which I don't recommend)
<Shinmera>
No?
<pjb>
Not for tramp.
<hajovonta>
tramp doesn't require X
<Shinmera>
Tramp is basically just an mode for emacs that copies the file in the back through SSH when you save/load.
raynold has quit [Quit: Connection closed for inactivity]
<jackdaniel>
make file access great again
<jackdaniel>
or something like that
<myrkraverk>
C:
<myrkraverk>
Can I convert from (vector character <number>) to simple-string ?
solene has joined #lisp
<myrkraverk>
I don't know what the <number> means. And google doesn't seem to be much help.
<solene>
hello, is it possible to "validate" read-char using a #\Space ?
<solene>
I'm displaying text in a terminal and I would like to continue scrolling using #\Space
<jackdaniel>
first you need to turn off line buffering in your terminal
<myrkraverk>
My first attempt with coerce was unsuccessful.
<jackdaniel>
myrkraverk: <number> means how many elements vector has
<solene>
jackdaniel, is it possible from common lisp or does it require some C code ?
<myrkraverk>
Ah.
<Younder>
A 'terminal' is just a DEV VT 200 or so emulator
<jackdaniel>
solene: I bet it is possible - in worst case with cffi
<jackdaniel>
but I don't know how exactly, you have to look around
<myrkraverk>
When I do (coerce 'simple-string foo) ; where foo is (vector character 40) why do I get: SIMPLE-BASE-STRING can't be converted to type (VECTOR CHARACTER 40) ?
<myrkraverk>
Oh, maybe I'm using coerce wrong.
<jackdaniel>
(coerce #(#\a #\b #\c) 'string) ; works for me
<jackdaniel>
but it is simple-vector
<Younder>
A sequence
<jackdaniel>
also, simple-base-string has base-char elements, while there is no guarantee, that character is a base-char
<myrkraverk>
The function I'm trying to feed this accepts simple-string and simple-base-string.
<myrkraverk>
And C strings; but I'd rather avoid that headache.
<myrkraverk>
Now I just get "The value VECTOR is not of type BASE-CHAR"
<myrkraverk>
Some with simple-string
<myrkraverk>
VECTOR is not of type CHARACTER
wxie has joined #lisp
<Younder>
BASE-CHAR is configurable. Are you isning SBCL?
<Younder>
Rember all functions are over loadable in runtime. But be careful.
<myrkraverk>
I hope I can work around this without messing with SBCL's internals.
<myrkraverk>
Such as custom looping through the vector to create a simple-string, or something.
EvW1 has joined #lisp
<Shinmera>
(replace (make-string (length s)) s)
<pjb>
jackdaniel: cffi = requires some C code.
<pjb>
solene: what about using RET instead of SPC? Just use (read-line).
<pjb>
solene: if you insist on SPC, have a look at implementation specific features such as #+clisp ext:with-keyboard, or at cl-charms (ncurses).
<solene>
pjb, I would like to be able to use both, I use get-char now and it works well with RET (it's also possible to type others characters in my software)
smurfrobot has joined #lisp
<solene>
I think I'm going with a little of C code, I already have an external C library so most of the work is already there
<pjb>
(cl-charms uses cffi).
<pjb>
You may also use termios, with cffi, but I'd be weary of changing the characteristics of the file descriptor under CL streams.
SaganMan has joined #lisp
phoe has quit [Ping timeout: 248 seconds]
vhost- has quit [Ping timeout: 256 seconds]
Amplituhedron has quit [Ping timeout: 264 seconds]
m00natic has quit [Remote host closed the connection]
m00natic has joined #lisp
<jackdaniel>
pjb: cffi = calling foreign code, that's all. You don't have to touch C to use functions using this calling convention
<jackdaniel>
vide: osicat
wxie has quit [Quit: Bye.]
PenguinHunterX3X has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
vhost- has joined #lisp
smurfrobot has quit [Remote host closed the connection]
PenguinHunterX3X has quit [Quit: Leaving]
igemnace has quit [Quit: WeeChat 2.0]
nimiux has quit [Ping timeout: 240 seconds]
nimiux has joined #lisp
rumbler31 has joined #lisp
smurfrobot has joined #lisp
<hajovonta>
can I somehow check if a stream is open or is already closed ?
<jdz>
hajovonta: closed on which end?
<hajovonta>
hm, good question
<hajovonta>
on my end
<jdz>
One way is to try to read or write, and handle the errors.
<hajovonta>
yeah, that's what I'm doing now
osune has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
rawste has joined #lisp
<pjb>
jackdaniel: cffi has all the disadvantage of the C code compiled with the C compilers requiring cffi.
<jdz>
Email is a better first thing to try, though.
wheelsucker has quit [Remote host closed the connection]
omilu has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
Bike has joined #lisp
EvW1 has quit [Remote host closed the connection]
EvW has joined #lisp
trittweiler_ has joined #lisp
tcr has quit [Ping timeout: 256 seconds]
igemnace has quit [Quit: WeeChat 2.0]
<myrkraverk>
Shinmera: thank you, that worked.
<logicmoo>
macro-function lambda lists are always (form env) .. but not (&whole form env) .. right?
<pjb>
right.
<pjb>
&whole is for macro lambda lists.
<logicmoo>
some lisp are naming 'form' 'whole' and it confused me :)
<logicmoo>
lisps plural
<pjb>
logicmoo: because the macro function receives the whole form.
<logicmoo>
*nod*
trittweiler__ has joined #lisp
<pjb>
It then uses destructuring-bind to split it into the macro lambda list (minus &env which is processed by defmacro and passed as the env argument).
<logicmoo>
this leads me to another question (barely related) nut since you mentioned the destructing-bind was wondering if documentation strings would be left over inside the stored form
<pjb>
I would expect defmacro to handle it.
trittweiler_ has quit [Ping timeout: 256 seconds]
<pjb>
destructuring-bind doesn't take a docstring, but it take declarations. Since declarations may occur after the docstring, it would break if it was left.
<logicmoo>
good thinking
<pjb>
Notice that it all relies on defmacro, which is what is specified. Your defmacro could very well generate the macro-function differently, not using destructuring-bind.
terpri has quit [Remote host closed the connection]
<pjb>
But if you assume it, then this gives constraints on defmacro, such as the handling of &env, of the docstring, and of any declaration concerning the &env parameter.
<pjb>
Those elements must be removed from the form passed to the macro-function.
<logicmoo>
right now i am just removing the docstring
<logicmoo>
(in the defmacro (code that is)
trittweiler__ has quit [Ping timeout: 272 seconds]
<beach>
logicmoo: What are you working on?
terpri has joined #lisp
<pjb>
logicmoo: you must also remove declarations about the &env parameter.
<logicmoo>
i neglected to also synthsize the macro-function though so making sure its proper as one might expect to (macro-function 'symbol)
<logicmoo>
beach: dmiles here.. i sometimes rejoin irc with an alt-nick
<beach>
Oh, I see.
<logicmoo>
(so i am working on my usual.. wam-cl)
logicmoo is now known as dmiles
test1600 has quit [Quit: Leaving]
Cymew has joined #lisp
orivej has joined #lisp
trittweiler has joined #lisp
LiamH has joined #lisp
smurfrobot has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
trittweiler_ has joined #lisp
gorgor_ has quit [Ping timeout: 268 seconds]
trittweiler has quit [Read error: Connection reset by peer]
trittweiler__ has joined #lisp
trittweiler_ has quit [Ping timeout: 264 seconds]
trittweiler__ has quit [Read error: Connection reset by peer]
trittweiler_ has joined #lisp
dilated_dinosaur has quit [Quit: Leaving]
rawste has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Ping timeout: 272 seconds]
cromachina has quit [Read error: Connection reset by peer]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
sjl has joined #lisp
smurfrobot has joined #lisp
oleo has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
nowhere_man has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Ping timeout: 272 seconds]
red-dot has joined #lisp
smurfrobot has joined #lisp
Murii has joined #lisp
smurfrobot has quit [Ping timeout: 272 seconds]
teddy_error has joined #lisp
lisp_guest has joined #lisp
quazimodo has joined #lisp
anunnaki has quit [Ping timeout: 248 seconds]
nowhere_man has joined #lisp
<drmeister>
Hey lispers - Xach told me a few weeks ago about a mechanism in quicklisp to bundle systems for deployment. I'm trying to jog my memory - does anyone know about a quicklisp facility for bundling systems?
<drmeister>
Xach: Does this use the asdf monolithic compilation facility in any way?
<Xach>
drmeister: no
<drmeister>
Ok - that's ok - my end goal is to construct a monolithic fasl that contains code from several quicklisp systems, several quicklisp systems that are in my local-projects and several asdf systems that are provided by my source code.
<drmeister>
Along the way I need a list of source files that will serve as dependencies for the build system that will build this monolithic fasl.
terpri has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
gorgor has joined #lisp
<drmeister>
Currently I use (ql:quickload "main-system-with-many-dependencies") to find all of the asdf .asd files in quicklisp/local-projects and quicklisp/dists/quicklisp/software so that I can grovel the "main-system-with-many-dependencies" to build this list of common lisp files that will be the dependencies of the monolithic fasl.
<drmeister>
The problem with this is that this compiles everything as well.
<drmeister>
Is there a way to get quicklisp to find and load all of the .asd files but not compile everything?
smurfrobot has quit [Ping timeout: 264 seconds]
dilated_dinosaur has joined #lisp
<drmeister>
Sorry if this sounds a bit confused - I'm a bit off the map here - trying to figure out how to properly merge building a monolithic fasl file with our 'waf' build system (written in Python) and get waf to know the dependencies of the monolithic fasl file.
<dmiles>
is it acceptable practice to store important parts of the implementation things in the symbol-plist or should it be kept clear for users?
FreeBirdLjj has joined #lisp
<dmiles>
for instance documention and things like setf-expanders
tlaxkit has quit [Remote host closed the connection]
tlaxkit has joined #lisp
tlaxkit has quit [Max SendQ exceeded]
tlaxkit has joined #lisp
<_death>
dmiles: acceptable, as long as you use symbols in your implementation package
<Bike>
kind of retro, though.
<beach>
Very much so.
<Xach>
drmeister: maybe (ql:list-local-systems) or (ql:list-local-projects) could help?
tlaxkit has quit [Client Quit]
hajovonta has quit [Quit: hajovonta]
<dmiles>
implementation package makes sense .. i was thinking about though as i am loading a file.. for things like warnings
<dmiles>
(for non-impl based packages)
<dmiles>
oh and ftype info
<dmiles>
oh the plist keys ... yes... ok from my impl pacakge
<beach>
Are you planning to write the compiler in Prolog?
<dmiles>
beach: i already have mostly
fikka has joined #lisp
<dmiles>
it transplies the bodys to prolog.. then uses the internal compiler of prolog to make tramploines
<dmiles>
the setf-expanders though i expand from prolog before i compile
<beach>
And this implementation is supposed to become a conforming one?
<dmiles>
meaning i expand all i can before compiling
markong has joined #lisp
<dmiles>
but i also expect macroredefinations and want ot keep there sources arround so i can recmpile as needed
<dmiles>
hrrm i think i do..
<dmiles>
(want it to conform)
_cosmonaut_ has quit [Ping timeout: 240 seconds]
<beach>
OK.
<dmiles>
though that means it easier because i expect users to not poke the bear>?\
<dmiles>
(i expect *them* to be conforming)
<dmiles>
i dont mind giving them lets of workarround and tricks not in the spec
<dmiles>
for exmaple my symbol-function accessor lets them supply an env so they can peer into the flets
thebigj has joined #lisp
<dmiles>
(just like symbol-macro lets them)
<thebigj>
Friends, I am trying to understand https://dpaste.de/ZRvU/raw this sample common lisp code given as the example in Aspected Oriented Programming ECOOP'97
<thebigj>
I am sorry but I have no experience with lisp based programming languages.
<thebigj>
I need help to understand what to code does.
<Bike>
i don't see anything about "or!", am i missing something?
<beach>
Bike: The name of the function.
<beach>
thebigj: No, there is nothing special about the ! character.
<Bike>
In the wikipedia article?
<beach>
Oh, sorry.
<Bike>
oh, in the paste, okay.
<beach>
Yes.
dyelar has joined #lisp
<beach>
thebigj: I still don't understand why you need to understand Common Lisp code when you have no experience with it. Are you trying to learn Common Lisp? If so, it is probably better to read a book.
<Shinmera>
"Common List"?
<_death>
the loops are also ordered wrong, unless it's a fortran-ish lisp or something
<beach>
Shinmera: Yea, I saw it.
<beach>
_death: Oh, true.
<beach>
Should be BELOW.
<beach>
and from 0
<_death>
the outer loop should be over rows, the inner over columns
<beach>
Wow, 10 or more problems in 8 lines of code. Impressive.
<Bike>
the pixel matrices could be something other than the obvious array representation.
<beach>
It could be, sure.
<beach>
Still a bad choice for the indices.
<Shinmera>
Would also be cleaner with dotimes in my opinion
<Bike>
thebigj: so what's this from? some conference you said?
<Bike>
twenty year old conference, now
detectiveaoi has joined #lisp
<thebigj>
Bike: This paper is referenced at one book I am reading.
<Bike>
ey, they had kiczales
<_death>
OR is a weird operator to use in that context, maybe it should be LOGIOR.. and then, you'd want to generalize it so that it'll be (combine image1 image2 #'logior)
<thebigj>
Bike: And this code is given as the example
<thebigj>
Bike: So trying to understand.
<thebigj>
Bike: Unfortunatiley I am not lisper (a lisp programmer)
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<_death>
and then you'd likely want to be able to pass a result image rather than creating a new one
red-dot has joined #lisp
<Bike>
Right. Well, the code is ORing two images together in an explicit nested loop like beach said. It's not great code as everybody said, but that's the gist
Cymew has quit [Remote host closed the connection]
smurfrobot has joined #lisp
dec0n has quit [Read error: Connection reset by peer]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<dmiles>
builds images of itself, lets one reattach and debug
<beach>
Thanks, but I think I'll wait.
k-stz has joined #lisp
hexfive has joined #lisp
scymtym has quit [Ping timeout: 248 seconds]
<dmiles>
yes, that is what i meant, i doubt i left the repo in a working state
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
rme has joined #lisp
wigust has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
scymtym has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #lisp
Cymew has joined #lisp
papachan has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
raphaelss has quit [Remote host closed the connection]
rippa has joined #lisp
<beach>
dmiles: I do not use Prolog, so I'll be interested in your implementation only if it has some advantages over what I currently use. Sorry about that.
Cymew has joined #lisp
fikka has joined #lisp
Younder has quit [Quit: Leaving]
Cymew has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
<beach>
dmiles: Interested in using it, that is. I might be interested in implementation strategies.
<beach>
dmiles: For example, how do you represent standard instances?
<dmiles>
i used a prolog atom (it is a special interned object that acts like aprimary key in the database) .. i record its superclasses and that is it. i lazily create prolog fields in the 'asserta database' as they are either first read or set
smurfrobot has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
<dmiles>
irregadless of the class it takes up 14 bytes
mepian has joined #lisp
<dmiles>
if someone stores a symbol in one of its fields it uses 6 bytes
<dmiles>
oh i might be inderplaying that .. i am sure its more like 12
Cymew has quit [Ping timeout: 272 seconds]
<dmiles>
if someone adds a cons to a field.. i have to create an area that is tracked and modifiable
<beach>
By "standard instance" I meant an instance of a standard class, and not necessarily a class.
Cymew has joined #lisp
<beach>
Er, what? Why does it matter what is stored in a slot?
<dmiles>
i meant an instnace .. except i should have not siad superclass.. i should have said one of more classes it is an instance of
<beach>
It is an instance of exactly one class.
<dmiles>
sure .. i have no problem if it is only one class
dliot has joined #lisp
<beach>
No, I mean, CLASS-OF is unique on a standard instance.
<dmiles>
yes i only return the first
<beach>
But, again, why does it matter what you store in a slot? Why is storing a CONS different from storing, say, a symbol?
thebigj has left #lisp [#lisp]
<dmiles>
the reason it maters is how constant that boject is
<beach>
I don't understand.
<dmiles>
cons can be modifed.. where symbols will remain
<dmiles>
(symbols properies can change .. but not the refernce)
<beach>
Same with CONS.
<beach>
So, what happens if you do (let ((x (cons 1 2))) (setf (slot-value ....) x))
<dmiles>
conses and things mutable have to be in live memory
<dmiles>
(symbols are not pinned to modifiable memory)
Cymew has quit [Ping timeout: 272 seconds]
<beach>
I am sorry, this is not working. For every question I ask, your answer introduces at least one new term I don't understand.
<dmiles>
(let ((x (cons 1 2))) (setf (slot-value ....) x)) that slot gets created on first use .. in live memory
<beach>
The slot gets created? It should already be in the class metaobject
<dmiles>
it gets created on the instance
<dmiles>
i dont actualyl allocate space
<dmiles>
until a the slot is needed .. at which time i confirm on the class metaobject the slot is even valid
pdv has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
solene has left #lisp ["Leaving"]
<beach>
I still don't understand why there is a difference in what happens in the standard object (call it obj) when you do (let ((x (cons 1 2))) (setf (slot-value obj ...) x)) compared to (let ((x 'a)) (setf (slot-value obj ...) x))
<dmiles>
this though wasnt a premature optimazion (though it would sound like one) it is that it is to allow a non determistic deductive system
trittweiler_ has quit [Ping timeout: 248 seconds]
Mon_Ouie has quit [Ping timeout: 248 seconds]
<dmiles>
whay it maters if it is a cons or array vs a constant because constants are all identically idetified
<dmiles>
so they all can be stored by a single referce to the constant
quazimodo has quit [Ping timeout: 260 seconds]
<beach>
What is meant by "identically identified"?
<beach>
And, how are you using the word "constant" here? Certainly not the way it is used in Common Lisp.
<dmiles>
constants are eq to any place they may exist more than once
<dmiles>
(not (eq '(a b) '(a b))) we want o be able to modify them independantly
<beach>
That's a different issue altogether.
<dmiles>
but that is the issue that required me to make my choices
<beach>
I am asking what happens to the CONS cell x when it is stored in OBJ.
<dmiles>
i plut that const cell in heap and make a heap point
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<dmiles>
i plut that cons cell in heap and make a heap pointer ..
<dmiles>
if i put a symbol there.. i put a picture of the symbol
red-dot has joined #lisp
<dmiles>
(it is the opposite of how its done in other languiages)
<beach>
OK, let's do this instead (defun ff (x) (setf (slot-value obj ...) x)). Does it matter what type X is what happens in the (setf slot-value)?
<dmiles>
Objects are all inert pictures as well.. so to put something modifiable in it.. i have to make sure i can modify it later without modifying the object
wigust has quit [Ping timeout: 272 seconds]
<dmiles>
yes..for me it does.. it maters if it is a constant on non-constant
<dmiles>
i'll use rerminolgy from there.. it maters if the object is immutable
smurfrobot has joined #lisp
<beach>
So, suppose the function above was called like this one time (ff (cons 1 2)) and like this another time (ff '(1 . 2)).
<beach>
How do you distinguish between the two cases when you do (setf (slot-value ...))?
raynold has joined #lisp
<beach>
The result of evaluating (cons 1 2) is mutable, but the result of evaluating '(1 . 2) is not.
<dmiles>
oh my setf to the slot value is neutral what it calls is not neutral
<dmiles>
by the time what setf calls sees the cons.. it has already been created
<beach>
About half an hour I asked whether the (setf slot-value) behaves differently if it is a CONS and if it is a symbol, and you said yes.
<beach>
Now you are saying no.
<dmiles>
yes the code under setf changes drastically
<dmiles>
but not code at the same level of setf
dliot has quit [Quit: dliot]
<beach>
I don't think I'll ever understand what you are saying, so for now, I have to give up. Sorry.
anunnaki has joined #lisp
<dmiles>
that is ok.. thank you for trying
<beach>
You might want to make sure you use standard terminology if you want people to understand what you are doing.
<beach>
There is no concept of code being "under" some other code in Common Lisp.
smurfrobot has quit [Ping timeout: 264 seconds]
<beach>
And the concept of a "level" of code does not exist either.
<dmiles>
i dont think there are terms for much of what C or Prolog would do
<beach>
Right.
<dmiles>
worse yet, i try (though not even doing that good a job of it) trying to use more C terminology than prolgo since people have more experience in talking about Lisp in C languages
<dmiles>
as far as what my implementation does in general is acts very lazy so i pay penalities at JIT compiler time
<dmiles>
(which applies to Prolog and not C)
<dmiles>
so it perposely acoids all the allocation choioces a C program would do
<dmiles>
as if it made the same choices, it would be a very poor clone of existing lisps
flamebeard has quit [Quit: Leaving]
<dmiles>
there are many optizations that work on the warren abstract machine (wam-cl) that dont work so great on conventional machines .. the warren abstract machine was created to do things lisp coders where doing at the time with expert system
<dmiles>
s
JenElizabeth has joined #lisp
chocolait has quit [Ping timeout: 264 seconds]
terpri has joined #lisp
turkja has quit [Ping timeout: 272 seconds]
<Bike>
it seems like you're talking about basic semantics rather than optimizations. and like, "levels", "neutral", none of those are lisp terms or c terms.
SuperJen has quit [Ping timeout: 248 seconds]
chocolait has joined #lisp
turkja has joined #lisp
* beach
hopes that Bike has better luck.
<dmiles>
by level i mean down levels of call stack
<Bike>
Then how does code have a level?
nowhere_man has quit [Remote host closed the connection]
<dmiles>
if c1 calls c2 calls c3.. i can say that c3 is two levels down from c1
nowhere_man has joined #lisp
<Bike>
What if c1 calls c1? What level is c1 at?
<dmiles>
setf after its ben resolved to call something, will call something that will have several levles
<shka>
wait
<dmiles>
c1 calls c1 it is still at the same level
<shka>
dmiles: is there open source WAM implementation for CL?
<Bike>
But now there are multiple stack frames.
<dmiles>
Bike: it depends .. you can call c1 from c1 without create stack
<Bike>
I'm talking about a general call that does create a frame.
<Bike>
A non-tail call.
<Bike>
shka: i think sjl was working on one
<shka>
dman
<shka>
*damn
<shka>
WAM is one of the things i really wish to know better
<Bike>
dmiles is rather talking about targeting WAM, using an existing prolog. i... think.
<dmiles>
Bike: if it creates a frame than sure i suppose it could be a a differnt level especially if we have differnt shadow bindings in each c1 (even if TC)
fourier has joined #lisp
<Bike>
What's a "shadow binding"? And where are these terms coming from.
<dmiles>
a shadow binding is where a dynamic symbol has a value that changes durring child frames
rpg has joined #lisp
<shka>
Bike: AWESOME! thanks
<dmiles>
for examples (let ((*sandard-output* (open ... )) (print 1)))
<Bike>
So it's a lisp thing. Where did you get the term "shadow binding" from?
<dmiles>
*standard-output* has a shadow binding durring the call to print
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
* dmiles
seeing if the hyperspec has something close
<Bike>
There is such a thing as "shadowing", but it's different.
<dmiles>
hrrm looks like the term is mostly from emacs lisp and scheme
<dmiles>
i see.. it is not common lisp
teddy_error has quit [Quit: Peace ☮︎]
kini has quit [Quit: No Ping reply in 180 seconds.]
FreeBirdLjj has quit [Ping timeout: 272 seconds]
smurfrobot has joined #lisp
kini has joined #lisp
<dmiles>
so in emacs lisp shadow binding is lexical binding in common lisp
hhdave has quit [Ping timeout: 248 seconds]
<dmiles>
the problem with the term lexical binding is it is used to not biding both dynamic and non-dynamic variables
<dmiles>
used often (maybe by accident) to refer to any LET vars
Murii is now known as IhateSwing
<dmiles>
but since alpha renaming happens its mute.. they are not lexical
<dmiles>
i suppose we could say dynamic bindings
smurfrobot has quit [Ping timeout: 265 seconds]
EvW has quit [Ping timeout: 255 seconds]
<beach>
drmeister: You REALLY need to make sure you use standard terminology, or else you won't be understood. And people might lose interest, the way I did.
<dmiles>
anyhow it is best if i just stick to questions for a while
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Bike>
harsh to meister, lol
<beach>
Ooops.
<beach>
I meant dmiles.
<dmiles>
i doubt my answering of questions will be helpfull as i may not be able to answer them in the terminaolgy desired
<beach>
dmiles: But, you see, if you don't even know the terminology of Common Lisp semantics, your discourse will make some of us doubt that you are capable of implementing the language at all.
<dmiles>
that would be bad, as sometimes i need advice
<beach>
Now, I am particularly dense, so you may have better luck with others.
<beach>
I think it has to do with my training as an engineer, where every word may have some technical meaning.
mepian has quit [Quit: Leaving]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
<dmiles>
when answering questions about how i instance a standard object, i assumed it is becasue it was hard to think aobut in a language that doesnt have mutability or objects being able to do so, so i was trying to answer why it wasnt impossible to do in prolog.. thus the hacks and inventions
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
<dmiles>
but that was *me* assuming you knew it was impossible
raphaelss has joined #lisp
Karl_Dscc has joined #lisp
<beach>
It is safest to assume that the people you are talking to here have very little knowledge about Prolog, especially modern implementations of it.
zooey_ has quit [Remote host closed the connection]
zooey has joined #lisp
IhateSwing is now known as Murii
m00natic has quit [Remote host closed the connection]
norserob has joined #lisp
turkja has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Remote host closed the connection]
<stylewarning>
Hey all, is there documentation anywhere about statically linked C libraries with SBCL/CFFI?
<Bike>
i don't know that sbcl can do that. you could ask #sbcl though.
anunnaki has quit [Ping timeout: 272 seconds]
Jesin has joined #lisp
anunnaki has joined #lisp
fikka has joined #lisp
rawste has joined #lisp
fourier has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
u0_a166 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<stylewarning>
Maybe it's dynamic library linking with static dumping with ASDF/CFFI?
<dmiles>
I ended up using ECL when i needed to do static linking :P
smurfrobot has quit [Ping timeout: 240 seconds]
<stylewarning>
dmiles: Maybe one day...
rawste has quit [Ping timeout: 248 seconds]
<Shinmera>
Bike: It can
<Bike>
huh. didn't see it in the manual.
<Bike>
the sbcl manual i mean.
<Shinmera>
There was a presentation about it at ELS'16
<stylewarning>
I see slides, I see reference in the CFFI manual. Of course, in usual Lisp tradition, no comprehensive docs, no examples, no warnings, etc.
<Shinmera>
If you people knew just how much undocumented, incomprehensible source was out there in other languages...
rpg has joined #lisp
fikka has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
eudoxia has joined #lisp
varjag has joined #lisp
u0_a166 has quit [Quit: WeeChat 2.0]
<stylewarning>
:)
<stylewarning>
When I use static-program-op, I get some business about "undefined symbol _main"
orivej has quit [Read error: Connection reset by peer]
<stylewarning>
all this ASDF stuff I've never seen before
vaporatorius has quit [Ping timeout: 240 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
jesol has joined #lisp
jesol has quit [Client Quit]
jeosol has joined #lisp
<jeosol>
Hi there
<beach>
Hello jeosol.
<jeosol>
Hi, i was not sure if there is any one here
<jeosol>
how are you doing
<beach>
Plenty of people here. How I am doing is off topic, though. :)
Jesin has joined #lisp
<beach>
jeosol: So I take it you are new here? What brings you to #lisp?
rgrau has joined #lisp
<beach>
jeosol: Maybe you just wanted to know whether there was anyone here?
<jeosol>
CLOS design question here. What is the better way (for maintainability) to combine two methods defined on two classes A and B, with B inheriting from A. I normally add :before qualifiers to the method with A's object and then just call the method on B, which is the primary method. I have cases where the defmethod on A is called in B using (call-next-method) (this does not use :before tag on defmethod on B).
<jeosol>
I hope not too technical, but it's a high level question
<jeosol>
yes, first time using this forum
<jeosol>
typo correction: in the latter, I mean't (this does not use :before qualifier on defmethod on A
<beach>
That will take me a while to decode.
<jeosol>
I am asking to the general forum. It's more of a design consideration. I normally use the option adding :before to the defmethod on the base class, but have seen codes with call-next-method obviously to handle some specially cases down the line
fourier has joined #lisp
<beach>
I don't think there is a general answer to your question. The right answer has to do with the protocol that you are designing. Specifically how you describe the role of the primary method(s).
<beach>
It would be unusual to have a call to CALL-NEXT-METHOD in a primary method.
<beach>
A better way would then to have a different method combination.
<beach>
I see CALL-NEXT-METHOD calls mostly in :AROUND methods.
<jeosol>
That is right
<jeosol>
That is where I have seen it most, to handle some special case.
<rpg>
Also, notice that :BEFORE methods are really only done for side-effects, since they don't change what the primary method computes.
<fourier>
is where a tutorial around on how to check some C define with cffi groveller ?
<rpg>
... and they can't establish a context for computation necessarily because they are not scoped *around* the primary method.
<rpg>
jeosol: Have you looked at Sonia Keene's book?
<jeosol>
In that case, in my case, the method on the base class only sets up things for A, so I think it's better to use :before qualifier and rely on the standard method combination
<jeosol>
Yes, I have read that book. I also recently read Andreas compilation and have seen different paradigms used
<beach>
jeosol: I for one find it hard to find typical use cases from such a general description. But you are probably right.
anunnaki has quit [Ping timeout: 256 seconds]
<jeosol>
I do understand how CLOS works, I am just concerned about what makes for better code down the line if I get another developer. The organization of class hierarchy is in my head and the code base is getting fairly large
<jeosol>
thanks for the comments guys, I think it's better to use the :before qualifier on the base class.
<beach>
I understand, and (again) I think the answer depends on the real meaning of the operations in your protocol, and that no general answer exists for all the cases that fit your description.
<jeosol>
I agree <beach>. The relationship right now, is entire linear but it does vary
<jeosol>
The book I was referring to was Objected Oriented Programming: The Clos Perspective Edited by Andreas Paepcke
<rme>
I had never heard about that book until now.
<fourier>
never heard about it, is it worth reading ?
<jeosol>
That is true, I got it a few weeks ago.
<jeosol>
I was lucky to find a copy,
<jeosol>
Chapters 1, and 2 are very good, respectively Introduction to CLOS and CLOS in Context.
<jeosol>
and it also has some information on CLOS use in some large systems.
<jeosol>
Apologies for not being specific enough. Those are the names of the first two chapters.
fikka has quit [Ping timeout: 272 seconds]
<jeosol>
The title of the second chapter is "CLOS in Context: The Shape of the Design Space"
Murii has quit [Ping timeout: 256 seconds]
<rme>
I always say "Keene", because I can't ever remember if it's "Sonya" (in the text and on the copyright page), "Sonja" (on the cover), or "Sonia" (just another spelling).
<jeosol>
It is essentially a summary of Keene's book in Chapter, condensed
<shka>
Sonja?
<shka>
i guess they confused books ;-)
<jeosol>
Yes, it is Sonja
<jeosol>
Sonja E Keene
<jeosol>
Thanks for the add <stylewarning>
<jeosol>
I think so too, it's a great book. I like it a lot especially the application of CLOS in real applications.
<rpg>
stylewarning: Not as well as I should: I don't really use the bundle operations myself, and they were added to ASDF without much participation on my part. One thing I do know, though, is that moving images for some lisp implementations from one location to another can fail as they encounter local dynamic libraries that differ from what they "expect."
<rpg>
stylewarning: But to be honest, I don't know if this problem can occur even without FFI -- I.e., we can dump an image onto a lisp that is sitting on an operating system that has different libraries, providing different entry points to the lisp implementation itself.
pseudonymous has joined #lisp
malm has quit [Quit: Bye bye]
<rpg>
I have decidedly mixed feeling about ASDF's mission-creep from loading systems to providing delivery solution. I believe ASDF kind of slipped into this as it tried to accommodate "compile-to-C" approaches to CL (notably ECL).
<stylewarning>
That
<stylewarning>
s what it seems. Then again, a robust and flexible solution across all implementations seems nice.
BitPuffin|osx has quit [Ping timeout: 256 seconds]
LocaMocha has quit [Ping timeout: 272 seconds]
<rpg>
stylewarning: Right, but it's a test and maintenance nightmare.
<stylewarning>
I myself am going through a lot of effort right now to make a command-line program faster to start/stop, and it seems like a major bottleneck is the dlopen-ing of 4 libraries.
<stylewarning>
was looking for inspiration in static linking and the like
<rpg>
stylewarning: So this is for working with FFI? Or is it just a slowdown when the lisp implementation itself is starting?
<stylewarning>
The Lisp impl itself seems relatively OK. The FFI clocked at about 0.3-0.5s
<stylewarning>
(By FFI, I mean reloading all of the dynamic libs on startup)
<rpg>
stylewarning: then this operation might work for you. You might well get a more portable application out of it, too.
<stylewarning>
I'm fighting to get it to work. I'm getting some issue where it says it can't find _main when doing some linker operation with "static-runtime_XXXX"
<rpg>
stylewarning: which CL is this?
<stylewarning>
SBCL
orivej_ has quit [Read error: Connection reset by peer]
orivej has joined #lisp
EvW1 has joined #lisp
HDurer has quit [Ping timeout: 255 seconds]
HDurer has joined #lisp
<rpg>
stylewarning: I'm afraid I don't know that much about the internals of SBCL. But this looks like a problem with CFFI, I think. Not sure why it's looking for main, or who's doing it. Do you have some kind of backtrace for this?
<stylewarning>
I'm trying to make a super minimal example now.
fikka has joined #lisp
JenElizabeth has quit [Remote host closed the connection]
<rpg>
are you sure that "make" maps to the operation you expect? Looks like it should. But just in case -- you're also testing with (oos 'static-program-op "static-fire/static")
<stylewarning>
(but it doesn't make a difference)
<rpg>
also, aren't there limitations on static linking on MacOS?
<stylewarning>
rpg: I'm fairly certain make is doing what it should because it's calling the linker. But yes, in that case, using oos results in the same failure.
<stylewarning>
Possibly; I'm not sure.
<stylewarning>
I poked around in the source and it seemed like MacOS was supported (mostly through the #+bsd feature)
Josh_2 has quit [Remote host closed the connection]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<stylewarning>
rpg: Further hint: On Linux, at least `make` returned T; not sure if/where it wrote to.
<rpg>
stylewarning: I just don't know what compilers support compiling to .o instead of .dylib on that platform.
<rpg>
stylewarning: on linux you should go and root around in the .cache to see if you can find the compiled output. There's some way to redirect the output, but it's not very tasty (IMO), again because of the extension from fasl-building to executable-building.
<rpg>
The whole output-translation idea has a different meaning here.
notzmv has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
<stylewarning>
I do seem to get the same error on Linux, actually.
<fourier>
whats the easiest way to compare 2 class instances which has only numeric slots without manually comparing slots ? iterate over slots using MOP and compare them?
<shka>
fourier: but what comparasion you will use?
<shka>
each slot may require it's own function
<stylewarning>
fourier: no, manually compare them
<stylewarning>
there is no need for crazy magic here
<fourier>
its just integers
<fourier>
all fields are integers (class generated from posix c struct)
<shka>
well, i did that
<shka>
using MOP
<shka>
not worth it
smurfrobot has joined #lisp
<fourier>
ok thanks.. will look at it further
atgreen has joined #lisp
lisp_guest has joined #lisp
Murii has joined #lisp
<shka>
fourier: well, i can give you my code
smurfrobot has quit [Ping timeout: 248 seconds]
<shka>
it works, i don't guaranteeing that it is the best way to do it though
<stylewarning>
No, don't use MOP for things that don't need MOP.
<stylewarning>
What ever happened to writing (defun my-class= (a b) ...)?
<stylewarning>
Is it too hard to write (with-slots ... (with slots ... (and (= a-1 b-1) (= a-2 b-2) ...)))?
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<shka>
stylewarning: well, it was kinda entertaining
<shka>
but not very practical indeed
king_idiot has joined #lisp
<stylewarning>
Unfortunately lots of "kind of entertaining" code makes it into libraries
<fourier>
ill try different ways, maybe endup with just comparing manually
<shka>
fourier: if those are just numbers, stick all of those into vector and use vector= from alexandria
<shka>
or at least i think it is from alexandria
<Bike>
It's easy. You have (defclass foo ...). You write (defun foo= (foo1 foo2) (and (= (foo-a foo1) (foo-a foo2)) (= (foo-b foo1) (foo-b foo2)) ...))
<shka>
yes, that works as well
<fourier>
problem is what i dont know accessors/fields. the struct is generated by cffi's define-c-struct-wrapper
<Bike>
You mean defcstruct?
<fourier>
ah nevermind, found the definition. yes it was sort of defcstruct
<Bike>
"sort of"?
<Bike>
I mean, defcstruct doesn't even make a lisp class you instantiate lisp objects of, does it?
<fourier>
its grovel's cstruct, hard to get dig what it is doing
<fourier>
and define-c-struct-wrapper creates a normal lisp class around it
pedh has joined #lisp
<fourier>
instances of which i need to compare :)
<fourier>
cffi:define-c-struct-wrapper
atgreen has quit [Quit: atgreen]
dieggsy has joined #lisp
HDurer has quit [Ping timeout: 240 seconds]
red-dot has joined #lisp
<Bike>
Maybe, but MOP isn't relevant.
pedh has quit [Ping timeout: 256 seconds]
<Bike>
oh, i see, another undocumented interface
<Bike>
This seems to define a CL class that mirrors a C struct and can be initialized with one (but thereafter loses any connection to any C object)
<fourier>
magic! :)
<Bike>
I'm not sure what the point is, oh well
<fourier>
another question though. is elsconf mailing list dead now or I'm not properly subscribed (resubbed with another email) ?
HDurer has joined #lisp
dyelar has quit [Quit: Leaving.]
scymtym has joined #lisp
<rumbler31>
what was that thing about specifying symbols that are not interned? like if you wanted to ql a package and you didn't want the name you provided to be interned as a symbol. I'm not sure what to google for that
<Bike>
though i think for quicklisp they're string designators, so you could just throw it a string.
smurfrobot has joined #lisp
<rumbler31>
so (ql:quickload #:quickproject) fails but "quickproject" succeeds...
<rme>
fourier: I don't think there's been any traffic on the ELS mailing list. According to the list archives, the most recent message was sent on November 29th.
fikka has joined #lisp
<Bike>
rumbler31: i think quickload is a normal function, so it evaluates its argument (and #:quickproject is an unbound symbol)
<rumbler31>
hmm
smurfrobot has quit [Ping timeout: 265 seconds]
<rumbler31>
I could have sworn that this #: was discussed in the context of quickloading before but
<rumbler31>
Bike: your answer explains the error I see though, so thank you
<Bike>
you can do (ql:quickload '#:quickproject)
fikka has quit [Ping timeout: 264 seconds]
<rumbler31>
so the reader reads #:quickproject, doesn't intern it, it gets passed to quickload as (quote quickproject)
orivej has joined #lisp
<rumbler31>
ahh,
PickleLard is now known as cyberlard
smurfrobot has joined #lisp
shka has quit [Ping timeout: 272 seconds]
eudoxia has quit [Quit: Leaving]
Cymew has joined #lisp
<Bike>
it's nothing special. it's like if you wrote (ql:quickload oiwjefoansd). oiwjefoansd is unbound, so no good
raphaelss has quit [Ping timeout: 240 seconds]
nalkri has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 255 seconds]
jeosol has quit [Quit: Page closed]
rawste has quit [Ping timeout: 272 seconds]
smurfrobot has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
EvW1 has quit [Ping timeout: 240 seconds]
rawste has joined #lisp
rgrau has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Ping timeout: 255 seconds]
smurfrobot has joined #lisp
dieggsy has quit [Read error: Connection reset by peer]
detectiveaoi has quit [Quit: Leaving...]
mishoo has quit [Ping timeout: 240 seconds]
pedh has joined #lisp
smurfrobot has quit [Ping timeout: 272 seconds]
pedh has quit [Ping timeout: 264 seconds]
mnoonan_ has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
beaky has quit [Remote host closed the connection]
norserob has quit [Quit: leaving]
mathrick has quit [Read error: Connection reset by peer]
Xal has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Ping timeout: 265 seconds]
jmercouris has joined #lisp
Karl_Dscc has quit [Ping timeout: 240 seconds]
beaky has joined #lisp
Xal has joined #lisp
<jasom>
suggestions for sending structured data over the network?
smurfrobot has joined #lisp
<pjb>
sexo
<pjb>
sexp
fikka has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<aeth>
If you don't need performance, use s-expressions. If you need performance, nothing beats a custom binary format.
<jmercouris>
jasom: it's almost in your name, json
<pjb>
and (with-standard-io-syntax (read socket))
<jasom>
pjb: probably want *print-readably* as well, right?
<pjb>
it's in with-standard-io-syntax.
pedh has joined #lisp
HDurer has quit [Ping timeout: 264 seconds]
<pjb>
You may want: (with-standard-io-syntax (let ((*read-eval* nil)) (read socket))) for more security, but it would be better to authenticate and validate the data otherwise.
<aeth>
json is problematic because the popular libraries are not two-way, i.e. CL -> JSON -> CL could produce different CL than you started with
<jasom>
oh, I didn't realize that one was set there; I knew it did *print-escape*
<pjb>
and because there are limitations that depends on the programming languages on the other side.
<jasom>
aeth: I have a solution for two-way json at least for the subtypes in json
<aeth>
I would generally treat JSON or XML as an external-to-CL interface and use either s-exp or binary serialization for CL-to-CL
<aeth>
The only problem is people want to use lists and that opens up the '() vs false issue.
<aeth>
Use vectors and hash tables and no issue exists at all
<jasom>
aeth: and then they want to use keywords for object keys as well
<pjb>
Otherwise, I may advise ASN.1 (cl-asinine) for example.
<aeth>
jasom: That's not as big of an issue because you can have a prefix for plists where the car is a 'tag' and the cdr is a well-formed plist
pedh has quit [Ping timeout: 240 seconds]
<aeth>
The big issue is disambiguating an empty regular list and false
shenghi has quit [Remote host closed the connection]
<jasom>
aeth: and few libraries actually do this; they rather have () be null false empty-array and empty-object
shenghi has joined #lisp
<aeth>
Which is stupid
<aeth>
Your mapping makes perfect sense
<jasom>
aeth: to be fair, I would *not* have come up with that mapping before having used a bunch of other mappings for a while first
dliot has joined #lisp
<aeth>
That's why you should write real code and not libraries!
<aeth>
Your mapping makes sense with experience.
<jasom>
anyways I was hoping for something *slightly* higher level; like "Send this message and signal some condition if it doesn't get through" which is ... harder than it should be using just sockets.
<aeth>
You can do that with s-expressions as data
<jasom>
right
<jasom>
or json as data, or conspack or whatever
HDurer has joined #lisp
<aeth>
Never use conspack for this. It's like the Python serialization format. Too powerful so you have to trust it to load it.
<Fare>
pjb: there's uiop:call-with-safe-io-syntax for that
<aeth>
But you shouldn't trust it over the network, even if it's encrypted
<jasom>
aeth: cl-store?
<aeth>
Similarly, don't just eval s-expressions as data, write a mini-eval that only evals what you expect to run
<aeth>
jasom: I'm not sure if cl-store is safe or if it also suffers from serializing too much of the language
<Fare>
stylewarning, hi -- what do you want to know about static linking?
<jasom>
aeth: this is interesting; conspack specifically lists dealing with untrusted peers as a goal, right?
<aeth>
I'm not sure. Perhaps I confused it with another library.
<aeth>
I thought conspack's goal was to serialize just about anything, including objects
<Fare>
it works for things that are declared with e.g. cffi-wrappers; but so far no one has added support for declaring and linking arbitrary C libraries (either statically or dynamically).
<jasom>
aeth: I thought it only deserialized objects that had a method defined
<rpg>
jasom: there are at least a couple of pretty competent JSON libraries for CL.
<Fare>
The heavy lifting was done, but the definition of social standards was too much for me -- I have 0 energy left to fight the CL community.
<rpg>
jasom: They do require you to know a little bit about what you are sending/receiving because of the aforementioned issue of the differences between JSON and CL about what's "truthy"\
anunnaki has quit [Ping timeout: 248 seconds]
<aeth>
jasom: What you want is a very limited serialization imo. Numerical types, very basic data structures, etc. I personally think attempting objects is too much. Just write a way to handle that manually, on both ends.
<rpg>
I think CL-JSON lets you specify whether you want values to be lists or booleans. That must be done in the library, since it's not a JSON thing.
<aeth>
rpg: Defaults matter. cl-json makes the wrong decision for defaults.
<aeth>
Very wrong decisions.
<rpg>
We have also used Google protocol buffers successfully.
<jasom>
rpg: I see 3 ways of dealing with json that make sense 1) using non-native data types (I think jonathan does this) 2) Using a reasonable bijective mapping like I proposed 3) Requiring a schema of some sort so that ambiguities can be resolved
Karl_Dscc has joined #lisp
<rpg>
jasom: CL-JSON, IIRC, uses CLOS to specialize the translations for specific situations. But I haven't used it in years, so I may be misremembering.
<jasom>
rpg: I have gotten cl-json to use the mapping I propose. I also got yason to do it. However, they both have poor defaults.
<rpg>
JSON is a weird standard, because JavaScript's notions of truth, falsehood, and equality are insane.
<jasom>
sabra's review has a good table.
<aeth>
jasom: Writing a library with your mappings would be helpful for the CL community imo.
<rpg>
But XML is a PiTA because it doesn't have a general notion of list or vector.
Murii has quit [Quit: WeeChat 1.4]
<jasom>
JSON is not that weird; many languages distinguish between an empty array, a literal false, 0, and null.
<rpg>
JSON is less weird than JS.
<jmercouris>
The one thing that grinds my gears about JSON is that it comes from javascript
<jmercouris>
otherwise, I would be much happier to use it more often
<jasom>
JSON is far less weird than JS
<rpg>
aeth: I think it might be better to simply write a wrapper around the existing libraries that applies a different set of defaults. On the general rule that we are proliferating more libraries than we (as a community) can maintain
<aeth>
JSON is nice for languages close to JS: Lua, Python, Ruby, Perl, etc. It's tougher when you're in a language that's farther away from the 'scripting languages' family.
<jmercouris>
I would saying that python or ruby are anywhere near js
<Fare>
rpg: and yes, the bundle support was born out of the old asdf-ecl + desire to match xcvb in terms of dumping executables.
smurfrobot has joined #lisp
<jmercouris>
if anything python is closer to something like lisp
<jasom>
back to the subject; I may use something like zeromq or nanomsg for messaging. Thoughts?
<Fare>
also merging into what became uiop in the low-level parts of cl-launch
earl-ducaine has quit [Remote host closed the connection]
<aeth>
The languages I listed (mostly) have similar concepts to the subset of JS that's in JSON, e.g. Python "lists" and dictionaries.
earl-ducaine has joined #lisp
<aeth>
Compare this with CL or C# where which data structures to use are not obvious
<jmercouris>
aeth: "JSON is for languages that have JSON like data structures" :P
<aeth>
Or Java or C++ or Haskell
<aeth>
These have issues
<jmercouris>
ah yes, Java is the master of shitty data structures
<aeth>
CL has added issues with nil being false and '()
<jmercouris>
What's wrong with those truthy values?
<jmercouris>
It makes sense to me that empty list, nil, and false are the same
<aeth>
Java<->JSON is less problematic than CL<->JSON imo
<jmercouris>
Yeah, I don't know about that
<jmercouris>
Java just has a ton of developer time working on some json libs
<jasom>
jmercouris: most languages have more than one false value, rather than having a single value for all falsey things
<rpg>
For CL, you just need to have a sense of when the JSON field is of type boolean and when it's of type list. You kind of need that for, say C, as well, so I don't think it's a problem.
<jmercouris>
it's not that the language is inherently more suited to handling json
<jmercouris>
jasom: More than one false value? why is that an advantage?
<jasom>
jmercouris: whether it's good or bad is up for debate, but JSON makes the assumption that "No Object" "False" and "Empty" are distinguishable
smurfrobot has quit [Ping timeout: 265 seconds]
anunnaki has joined #lisp
<jasom>
jmercouris: there are ergonomic values to having all of them being treated similarly, but you have less information when you cant distinguish them
<jmercouris>
var array = [], indeed it is empty, vs just == false
mikecheck has joined #lisp
<jmercouris>
I can't think of a scenario in which I've needed this distinction, but I'm sure there is one, something to think about I guess
<jasom>
x = []; y = false; x.push(1); y.push(1);
<jmercouris>
I still don't see why I would need to know the type of Y
<jmercouris>
if I want to push something to it, I don't care that it is just false in CL
<jmercouris>
the push will just work
<Shinmera>
Well the point is that it shouldn't
<jmercouris>
But why not?
<Shinmera>
Maybe you want to have it strictly be one of true or false.
<jmercouris>
what is the advantage in this knowledge?
<Shinmera>
Type safety is nice
<Shinmera>
Lets you catch more errors during compilation
<jmercouris>
I think you've been doing a little much java lately Shinmera
<Shinmera>
I don't see how that has anything to do with anything
anunnaki has quit [Ping timeout: 272 seconds]
<jmercouris>
Shinmera: One of the biggest java proponent arguments for all of this type safety bs, generics etc "Catch the problems during compilation time, save development time"
<aeth>
CL but statically typed would be the ideal programming language imo. Might need to separate '() and #f like Scheme, though
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Shinmera>
jmercouris: They're not wrong.
<aeth>
jmercouris: Shinmera iirc is working on a game engine. Game engines mostly deal with very well-defined types. Static typing is a huge win here.
<jmercouris>
Shinmera: Yes they are :P
<Shinmera>
The fact that Java sucks balls has very little to do with people finding advantages in strong typing.
<jmercouris>
Otherwise java programs should have considerably less development time over weakly typed languages, but they dont
red-dot has joined #lisp
<jmercouris>
Especially because of all of this compiler support and IDE support you get in java
<jmercouris>
theoretically it should be so much faster, but I do not see the gains at all
<Shinmera>
A language is more than its type system
<Shinmera>
But whatever, believe what you want, I'm out.
<aeth>
Java sucks because it sets-in-stone 1990s C++ OOP fads while the world has moved on, even the C++ world.
pedh has joined #lisp
<jmercouris>
Java has only been stuck due to the death of Sun
<jmercouris>
there had been huge developments in JIT work at Sun, as well as Dtrace, and all sorts of facility integration that would have made java phenomenalj
<mikecheck>
Java will die when the Sun dies
<jmercouris>
I believe that Java could be so much more today if shit didn't hit the fan at sun
<jmercouris>
I mean, the JVM is an absolutely brilliant idea
quazimodo has joined #lisp
<aeth>
Idea? Yes. In practice? The JVM is designed for Java-like languages and the CLR is designed for C#-like languages, and actually-interesting languages can't run on either unless they were designed to make the compromises necessary to run on one or both.
<aeth>
So it's not that much better than what a transpiler would offer.
smurfrobot has joined #lisp
<jmercouris>
aeth: Are we getting into this transpiler debate again? Last time I was disparaged as some insane heretic for suggesting the word transpiler exists :D
phoe has joined #lisp
<aeth>
I think compiling to CL could support more interesting languages than compiling to the JVM.
<phoe>
In LOOP, can I somehow skip back to the beginning under some condition? Kind of like "continue" in C.
mathrick has joined #lisp
pedh has quit [Ping timeout: 248 seconds]
<aeth>
CL can recompile at runtime. Could you use this to make a JIT language that runs in a CL environment that's not JIT?
<Bike>
phoe: not really. you can use conditionals though.
<jmercouris>
aeth: That's not really the idea behind JIT
Rawriful has joined #lisp
<jasom>
phoe: not really; you just need to have the rest of the loop under a continue, or put the body of the loop in a tagbody and GO to the end
<jasom>
*rest of the loop under a conditinal
<aeth>
jmercouris: I thought you needed two parts: (1) analyze the code and (2) recompile the code at run time. If #1 is sufficient, you could do #2 on a language that runs in CL
<jmercouris>
aeth: You're spot on with your definition, I'm just saying the purpose isn't to have a dynamic system, it's to make compilation quicker
<jmercouris>
that's like literally the only purpose, that and reducing memory footprint
<Bike>
plenty of jit systems take advantage to speed up generated code in ways that would be difficult ahead of time.
smurfrobot has quit [Ping timeout: 264 seconds]
<jmercouris>
that too
<jmercouris>
they can use knowledge of the system state
<Bike>
so not literally the only purpose.
<jmercouris>
Okay, yes, I should avoid speaking in absolutes
rm8 has joined #lisp
<stylewarning>
Fare: I have a little minimal example that I cannot get to work or that I do not understand.
<Bike>
you could do something dumb like (defmacro defunj (name lambda-list &body body) `(let ((counter 0)) (defun ,name ,lambda-list (when (> (incf counter) 10) (compile ',name)) ,@body))) and then you can define a function that's just interpreted at first and then compiled once it's run a lot.
<jmercouris>
Bike: That's actually a really good idea
<jmercouris>
Could make it even more sophisticated as well
<jmercouris>
have some sort of "probability" that some branch will be executed and compile or not compile different paths
<stylewarning>
why not compile everything
<jasom>
I thought the main reason for JITs is to allow efficient compilation of languages where the types are mostly fixed at runtime, but mostly unknown at compile time
<jmercouris>
jasom: No, the types in java are always known at compile time, so there is your first counter example
<Bike>
doesn't it have polymorphism?
<jasom>
jmercouris: java is polymorphic
<jmercouris>
Bike: True true, this is problematic
HDurer has quit [Ping timeout: 265 seconds]
hexfive has quit [Quit: WeeChat 1.9.1]
Kaisyu has quit [Quit: Connection closed for inactivity]
<jmercouris>
Perhaps this is how they support polymorphism, they need JIT
<jasom>
similarly JIT techniques would be one way to make method displatch faster in lisp
<dmiles>
the reason for JVMs JIT i thought was because of limited memory, that it would be too much to compile the entire 9 million classes
<Bike>
you can do polymorphism without jit. it just makes it faster, hopefully. which is what jasom said.
<aeth>
jmercouris: I was more thinking about something like a modern JS-in-CL, which probably requires a fake JIT to support all the magic necessary to have somewhat competitive performance.
<jmercouris>
dmiles: Yes, true
<Bike>
i suppose this means beach's gf dispatch business is jit compilation. that's kind of neat.
<aeth>
JS is a language that simply does not give enough information to produce fast code without a JIT afaik
<Bike>
after a fashion.
<jmercouris>
aeth: Do you mean JS or Java?
<aeth>
JS
HDurer has joined #lisp
HDurer has quit [Changing host]
HDurer has joined #lisp
stara has joined #lisp
<dmiles>
(the entire JDK and all the classes are "interpreted bytecode" ... some a few other langauges can be that way as well .. even lisp)
<Bike>
doing it for methods themselves would be a little trickier, you'd need to save method body sources, or at least enough of a source.
<aeth>
JS JITs are what you get when you take very bright minds and put them to work polishing a turd instead of creating the next generation of very high level declarative languages.
<jasom>
Bike: it's not JIT compilation, it's just iterated AOT compilation
<Fare>
stylewarning, what are you trying to do?
<Bike>
jasom: what is?
<jasom>
Bike: beach's GF dispatch
<jmercouris>
aeth: That's a little bit harsh
<jasom>
what SBCL currently does is closer to JIT; it caches calls to e.g. make-instance
<Bike>
the line seems kind of blurry to me.
<aeth>
jmercouris: JavaScript is one of the worst programming languages out there.
<jmercouris>
I have a lot of complaints about java, but it isn't the worst language in the world, it is very consistent for one, very structured
<aeth>
jmercouris: That people have made JavaScript passable is a miracle.
<Bike>
with beach's dispatch, if you call a gf with a combination of classes it's never been called with before, it compiles a new discriminating function.
<jmercouris>
aeth: I would agree with that statement
<jasom>
this is why ltk is way faster to startup if you create and teardown your GUI before saving your image btw
<aeth>
jmercouris: oh, again I was talking about JS's JIT, not Java's
<jmercouris>
Many JS apologists say "have you tried ES6", and the answer is no, nor do I care to
<Bike>
which is something that could definitely happen at runtime.
<jmercouris>
aeth: Ah okay, sorry for the confusion!
rm8 has quit [Quit: i quit]
<stylewarning>
Fare: I was trying to compile an application, and I thought static-program-op might do magic to make dynamically loaded libraries load faster. I suspect this isn't true (that would be too magical).
dyelar has joined #lisp
<Fare>
stylewarning, can you successfully run the make-static.lisp script in workout-timer?
<jasom>
Bike: oh, I missed that part; I was just aware of the part where it used first-class global environments to inline the GF dispatch function and recompile the usage points at redefinition time.
<stylewarning>
Fare: No.
schoppenhauer has quit [Ping timeout: 248 seconds]
<jmercouris>
THey should have kept the name as livescript
<jmercouris>
I don't understand how javascript isn't somehow a very blatant copyright infringement
<Fare>
stylewarning, wait --- by default static-program-op will still load your dynamic libraries dynamically
<jasom>
jmercouris: I think you mean trademark
<Bike>
jasom: um, i haven't heard of any such part, actually. that sounds more like sbcl make-instance, actually
<Fare>
you need to create a new kind of system that represents your C libraries
<jmercouris>
Bike: Did you type it out five times, or coyp and paste it?
<Bike>
i typed it out five times, as penance.
<stylewarning>
Fare: Yeah, I figured as much. In any case, I couldn't get this example to work. is it a non-sense example? I forgot the IN-PACKAGE form. http://codepad.org/dlY8nyFR
<jasom>
Bike: the general idea was just that you could inline functions without regard to whether or not they might be redefined; GF dispatch is just a special case of this.
<Fare>
such that one of the output-files of compile-bundle-op for them is the .a file
<aeth>
jmercouris: In case I'm unclear, any use of a fake JIT (or would it count as a real JIT?) within CL would be for embedding JavaScript or perhaps Lua or maybe even Python in CL, ideally with competitive performance (probably somewhat slower, but hopefully acceptably slower) to modern JS engines, LuaJIT, or Pypy.
<aeth>
I'm not sure that there would be any use in doing the whole JVM in CL
<aeth>
Or if that would even be possible
<Fare>
was your sbcl compiled with the proper support?
<Fare>
I only just got a PR in CFFI to throw a sensible error message if you didn't
<jmercouris>
aeth: I was about to say "what would the advantage of that be?" then you qualified it at the end :D
<Bike>
jasom: which seems completely different from whatever you're talking about. i'm curious about it; i get the principle of course
<Fare>
if you got your CFFI from QL it quite probably doesn't have that patch yet
<aeth>
jmercouris: Running any one of those three, or all three with a sufficiently clever engine, would be incredibly useful because of how much code is in any of those. (Lua's probably the most obscure but it does have its niches where it is the dominant scripting language, especially games)
<dmiles>
see CLOAK (its a JVM in all Lisp)
<Fare>
I was bitten by that myself :-(
<jmercouris>
aeth: You could just run them in a subprocess and communicate over some IO channel, it'd be much easier than maintaining the spec /runtime for all these languages
smurfrobot has joined #lisp
<Fare>
(uiop:featurep :SB-LINKABLE-RUNTIME) ?
<aeth>
jmercouris: A JavaScript JIT in CL with good interoperability with the host CL would be a huge win for any web browsers written in CL. So JS would be the most useful.
<Fare>
if not T, you need to recompile your SBCL.
<jmercouris>
aeth: For any web-browsers written in CL you say :D? You've piqued my interest :D
<jmercouris>
aeth: I mostly communicate with JSON right now, and the only way that I can get a value back from the browser is as a return from a javascript function, JS itself cannot directly invoke CL
<jasom>
There's already a JS 1.4 implementation in lisp
<stylewarning>
Fare, that was NIL. Thanks. I'll give it a try!
<aeth>
The trick would be having a JS engine that can both interoperate with CL and an existing rendering engine (the rendering engine would probably be *far* too complicated to write in CL unless you have VC funding to hire a team)
schoppenhauer has joined #lisp
<aeth>
jasom: The issue isn't JS, it's JITed JS (or Lua or Python). I know JS and Python both exist in CL, but not fast enough for all uses.
<jmercouris>
aeth: You would neeed A LOT of VC funding
<jmercouris>
aeth: Look at how much servo cost mozilla, and they aren't even close to done
raphaelss has joined #lisp
<aeth>
A fake JITed foo in the CL ecosystem should be somewhere between the actual real JIT and the non-JIT version(s) in performance. e.g. Pypy < some-cl-jit-pthon < Python, or LuaJIT < some-cl-jit-lua < Lua, or modern JS engines < some-cl-jit-js < traditional JS
<jasom>
aeth: yeah, cl-javascript is roughly spidermonkey levels of performance
<aeth>
Although I'm not sure if it is "fake JIT" or actually JIT.
smurfrobot has quit [Ping timeout: 272 seconds]
<jasom>
er TraceMonkey; I guess spidermonkey is the term for all versions
<aeth>
The *extra* problem (past the performance issue) that just applies to the embedded JS is if you can also make it useful for interfacing with non-CL code, i.e. the rendering engine. However that works. I don't really have a deep understanding of browser architecture.
<aeth>
i.e. An acceptable performing JS with JIT-style enhancements through introspection + runtime recompilation could probably work in a JS-to-CL compiler. But can it be used by jmercouris?
<aeth>
The existence of cl-javascript is a great thing, btw, because now that becomes one of the benchmarks to beat.
<aeth>
You probably could actually get comparable performance to a real JS JIT engine in JS-to-CL in SBCL if you write a bunch of SBCL-specific code, potentially including assembly using SBCL's inline assembly (is "inline assembly" the right term in a sexpy language?) extension to CL.
nowhere_man has quit [Ping timeout: 240 seconds]
<jmercouris>
aeth: JS -> CL Compiler, could provide some mild benefit
<aeth>
One of my extremely on-the-side side projects that I come back to every few months is writing a Scheme that compiles to CL. But it would actually be very interesting to instead do something Racket-style and try to embed many languages within a CL environment, rather than just one or a few.
<jmercouris>
I can think of a couple scenarios I have wanted such a behavior, it would allow better interop with existing JS scripts on the web
<aeth>
i.e. I'd like to one day abstract out the common code.
nowhere_man has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
<aeth>
One of my long term plans, especially for when my game engine doesn't consume almost all of my CL programming time, is to try to build up an interoperable language environment on top of CL. This exists to some limited extent to some limited other languages in implementation-specific ways... frequently just Prolog.
<jmercouris>
Have you made any progress on this?
<aeth>
s/to some limited extent to some limited other languages/to some limited extent, restricted to a few languages,/
<aeth>
jmercouris: I have written about 2/3 of a Scheme and about 90% of a Brainfuck, which has given me ideas. JS, Lua, and Python would be nice, but they're trickier because they'd almost certainly require using advanced CL features to do JIT-like things in order to be fast enough to be interesting implementations of those languages.
<aeth>
Prolog would be nice, too. dmiles (iirc) can tell me why that won't work in existing CL implementations.
<aeth>
A lot of this might just be fast only on SBCL, ideally with a slow path for other implementations (some libraries work like this already). Popularity of even just one of those embedded languages would pressure implementations to catch up with SBCL there.
<jmercouris>
Why do so many people prefer SBCL?
<Xach>
jmercouris: it is fast and actively maintained. it is free.
<aeth>
It would be hilariously meta if some of these languages had acceptable performance in ECL... because then you're embedding languages... in an embedded language. But that's actually what Guile was supposed to do when GNU initially pitched it as the standard GNU scripting language in the 1990s (still waiting on that)
<dmiles>
oh well think the best analogy is i cam up with is "imagine taking an assembly language program that twiddles bitmasks and using bignum math to emulate the registers of the Intel-4930k CPU. You might just see some performance differences? "
<dmiles>
there has been a long thread on comp.lang.lisp about wanting to store bitmasks
<dmiles>
do this can be an example of where one outsmarted theemselves.. they might be better of just using a bitarray
k-stz has quit [Remote host closed the connection]
<dmiles>
use this as an analogy to trying to emulate the Prolog machine
<dmiles>
(i use)
<aeth>
jmercouris: Ideally, the embedded languages system will run on SBCL, CCL, and ECL acceptably, and in that order of performance (but ECL surprises me all the time when compared to CCL, so there might be a contest for 2nd place in performance). CLISP will probably never run them performantly and ABCL wouldn't be a priority because it can interface with JVM languages.
<aeth>
But I'm going to just start with a Scheme because it doesn't need a JIT, unlike most of the other interesting scripting languages.
sjl has quit [Ping timeout: 240 seconds]
<jmercouris>
What is your end goal in doing this? Do you enjoy the project or do you have some product in mind?
malm has joined #lisp
phoe has quit [Quit: Page closed]
<aeth>
My primary focus right now is making a game engine that can run in Common Lisp. A long term goal of making implementations of other, potentially more popular, languages that very easily interface with Common Lisp helps that primary objective.
<aeth>
e.g. if you want to mod Minecraft and you hate Java, you have other options.
<jmercouris>
aeth: Are you and shinmera working together?
<aeth>
No, there are about 5 or 6 independent CL engine projects.
<akkad>
like Islisp?
<jmercouris>
Is there a reason you are not working together?
<antoszka>
Are you guys all hanging around #lispgames, though?
<aeth>
Most of us
<antoszka>
cool
<jmercouris>
I'm just saying, instead of 5 or 6 engines, if you all focused your efforts, you might have a very powerful engine
<jmercouris>
of course the different engines will have different strengths, paradigms, philosophies, etc
<aeth>
jmercouris: I started before any other game engines existed except for dto's 2D engines. Also, my approach is very different. e.g. My goal is to have a no-consing game loop so a user of the library could do a call to the GC, disable the GC, and run it between levels on loading screens or whatever, if they choose to (or they can cons in their own code if they choose to, giving them more space on the heap before problems pop up)
<aeth>
My goal for no-consing has required me to reinvent the wheel quite a bit... and I am going to have to eventually replace cl-sdl2 if I am going to reach 0 consing in my game loop. (All of my own code doesn't cons in the game loop)
<jmercouris>
So, all of this to improve performance?
<aeth>
(Note that any implementations of scripting languages will probably cons by their semantics, so the no-consing won't apply to any design of those. And the GC would probably have to be run if you use those.)
LiamH has quit [Quit: Leaving.]
<aeth>
jmercouris: I'm not sure if I have the highest performing code, but it performs pretty fast and makes some unusual decisions in the name of no consing, e.g. I use multiple return values for vectors of size 3 and quaternions. (It'd be a bit too much to use those for 4x4 matrices, so I just declare those dynamic extent and hope for a stack allocation.)
yeticry has quit [Read error: Connection reset by peer]
<aeth>
i.e. during my game loop, I do almost no allocations, except the few cases where I need to do stack allocations (and when I use cl-sdl2 to handle input, which conses, unfortunately)
<jmercouris>
that's pretty impressive
<aeth>
Well, that means I preallocate a lot.
<jmercouris>
This is best
<jmercouris>
I've made a few game engines myself (none in lisp)
<jmercouris>
and I've never had a game loop without allocation
<jmercouris>
of course all assets beforehand, and as much pooling as possible, but nonetheless always some allocation somewhere
<aeth>
The event system is going to be tricky. I'm thinking of using a custom stream that uses a fixed-size byte buffer. So that means I'm *not* going to have the fastest engine if I do that, since there'll be a serialization/deserialization cost. But, on the plus side, that make eventually breaking the code up over the network trivial.
<aeth>
Also, I'm not sure if I cons in CCL and ECL. I don't think they provide enough profiling information as SBCL.
<aeth>
With SBCL, I can be pretty sure that if I didn't accidentally introduce new consing, all of my game loop consing right now is in the cl-sdl2 library, which I will probably have to replace eventually.
<aeth>
That's why SBCL is so powerful. That's some pretty good profiling.
<aeth>
(And disassembly, too, just to be safe.)
<aeth>
I'm not sure if my double-float hack will work on all implementations. In SBCL, I can just work with arrays of double float and as long as I only have constant double floats, double float values stored in an array, or coerce the double floats to something else, then those double floats don't cons! It's surprising to me, actually.
<Xach>
aeth: using preallocated arrays like that is, i believe, an old-ish hack.
<aeth>
I don't use double floats in many places, and I can't generalize my vector math to doubles because I use multiple return values to avoid consing with single-floats, and that won't work with double floats.
<aeth>
Unless I extend my multiple return value system to have stack-allocated "registers" of double-floats
<aeth>
or soething
<aeth>
s/soething/something/
<Xach>
the bit-* functions do something a little along those lines
<aeth>
ah
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<aeth>
One other place that will be tricky, probably is text for the UI. I can't preallocate everything there. Maybe I'll have to use some buffer system.
damke_ has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
damke has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
fourier has quit [Ping timeout: 256 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
smurfrobot has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
jmercouris has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 248 seconds]
pierpa has joined #lisp
Bike has joined #lisp
Amplituhedron has joined #lisp
osune has quit [Remote host closed the connection]
red-dot has joined #lisp
Bike has quit [Read error: Connection timed out]
smurfrobot has joined #lisp
Bike has joined #lisp
pseudonymous has quit [Ping timeout: 272 seconds]
wxie has joined #lisp
smurfrobot has quit [Ping timeout: 264 seconds]
Amplituhedron has quit [Remote host closed the connection]
neoncontrails has joined #lisp
dliot has quit [Quit: dliot]
wxie has quit [Remote host closed the connection]
<Fare>
stylewarning, all good now?
neoncontrails has quit [Remote host closed the connection]