<dmiles>
which impl of lisp would be ideal to model its class heirachy?
anyoks has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
<pjb>
dmiles: boolean is not specified as a class, but as a type.
<pjb>
It would be difficult to make it a class (deftype boolean () `(member nil t))
<dmiles>
i guess i was sutrised that NIL was returnin a null
<dmiles>
surprised
<pjb>
Notice that T is also a system class, like null.
<pjb>
The thing here is that you cannot take the union of two classes to make a new class.
<pjb>
NULL is an indirect subclass of T, the union if it was possible as a class, would be T.
fikka has joined #lisp
<dmiles>
oh, so it matters most because it comes down to :include other and your boolean example
<pjb>
Well, I confused T as a class and T as an instance.
<pjb>
T is a direct instance of the system class SYMBOL, like NIL.
<pjb>
Yes, you're right, NULL is surprising :-)
<pjb>
as a subclass of symbol.
<pjb>
there are rules about the additionnal class an implementation may provide.
<dmiles>
type-of tries slightly to be OOish
<dmiles>
but there is not built-in-class called BIT right?
fikka has quit [Ping timeout: 240 seconds]
<dmiles>
i guess what i was thinking is all teh return values of typeof might have a system class
<dmiles>
(that would fit into the same hierachy)
<dmiles>
but perhaps type-of is older and got stuck in its ways?
sjl has quit [Ping timeout: 268 seconds]
<pjb>
type-of returns a type.
<pjb>
class-of returns a class.
<pjb>
more precise, a type specifier.
<pjb>
there's no first class type objects in CL.
<pjb>
cf. 4.2.2
fikka has joined #lisp
<pjb>
so you're asking if an implementation could provide a system class BOOLEAN corresponding to the type BOOLEAN and containing only T And NIL, with as superclass SYMBOL and as subclass NULL.
<dmiles>
maybe i meant the opposite.. NULL as a subclass of Symbol and Boolean a subclass of Symbol
<pjb>
cf. 4.3.1 and 4.3.7
Bike_ has joined #lisp
<pjb>
"Individual implementations may be extended to define other type specifiers to have a corresponding class. Individual implementations may be extended to add other subclass relationships and to add other elements to the class precedence lists as long as they do not violate the type relationships and disjointness requirements specified by this standard."
<pjb>
dmiles: it would seem that an implementation would be allowed to do that.
<pjb>
It would have to be a system class, like the null class.
fikka has quit [Ping timeout: 248 seconds]
Bicyclidine has joined #lisp
<dmiles>
makes sense
Amplituhedron has quit [Ping timeout: 268 seconds]
<pjb>
Since it wouldn't be a standard class, conforming programs would avoid using it. Do you think it would be useful?
<Bike_>
you can use class-of if you want a class back.
<dmiles>
pjh: the only use it give me is save maybe 10 lines of code .. so i think i wont create that exra trouble fo a user by grabing up any nsamespace
Bike has quit [Ping timeout: 248 seconds]
<pjb>
you can use EQL : (defmethod foo ((objc (eql t))) 'true) (defmethod foo ((objc null)) 'false)
<dmiles>
(as in they might want it as a standard class)
<pjb>
well, it's CL:BOOLEAN, so the user cannot use it to define types or classes.
<pjb>
11.1.2.1.2 point 4
Bicyclidine has quit [Ping timeout: 268 seconds]
damke has joined #lisp
<dmiles>
at least nohtng is expecitly disallowed
turkja has joined #lisp
Bike_ is now known as Bike
damke_ has quit [Ping timeout: 240 seconds]
<pjb>
as an implementer you can study 11.1.2.1.1 and 11.1.2.1.2 to see what you can and cannot do with the CL symbols.
<pjb>
You can do a lot!
margeas has quit [Ping timeout: 248 seconds]
damke_ has joined #lisp
jmercouris has quit [Ping timeout: 240 seconds]
nowhere_man has quit [Ping timeout: 255 seconds]
<dmiles>
it woiuld ve a ton of work on the part of an implementor to actually prevent the user for doing most of that
<dmiles>
for/from
damke has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
TCZ has quit [Quit: Leaving]
fikka has joined #lisp
<pjb>
dmiles: this is why it's forbidden! :-)
<dmiles>
haha
damke has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
damke__ has joined #lisp
<dmiles>
pjb: dont remember if i got a chance to show you how it ended up doing tagbodys
<dmiles>
it really does seem tagbody can handle all this
<pjb>
yes.
fikka has quit [Ping timeout: 268 seconds]
<pjb>
does your go handle unwind-protect cleanups?
<dmiles>
yes do to that it is always going deeper .. it backs out up the stack
damke__ has quit [Ping timeout: 240 seconds]
<dmiles>
do/due
<dmiles>
(a faked prolog stack)
vzerda has joined #lisp
earl-ducaine has joined #lisp
<dmiles>
but it is really easy for me (i feel compelled constantly) to write non backtracking code
<dmiles>
just be it allows one to do non standard things that are normally hard in prolog (since its always ready to unwind
damke has quit [Ping timeout: 240 seconds]
fortitude has quit [Quit: Leaving]
Tobbi has quit [Quit: Leaving]
damke has joined #lisp
stnutt has left #lisp [#lisp]
<dmiles>
just because swi-prolog allows me to do non standard things that are normally hard, if not impossible, in other prologs .. i just have to keep reminding myself throw/1 can be called
<dmiles>
oh that where i was going.. i thought that return-froms were just as unpredictable
damke_ has joined #lisp
GrayArea has joined #lisp
GeyArea has joined #lisp
damke__ has joined #lisp
damke has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
cromachina has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
TCZ has joined #lisp
<dmiles>
oh i think i see that even unwind protects might need to live in a tagbody
jstoddard has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
fikka has joined #lisp
fikka has quit [Read error: Connection reset by peer]
<dmiles>
mentally it is hard form to picture that when i call a predicate from another predicate how that constitutes backing out.. it *looks* like its diving in deeper
papachan has quit [Quit: WeeChat 0.4.2]
<dmiles>
yet the grandparent frame is already collected by the time you enter the grandchild frame
vaporatorius__ has quit [Remote host closed the connection]
<dmiles>
the wierdness is that the second example @ http://clhs.lisp.se/Body/s_tagbod.htm works because the "(go out)" is calling a whole separated compiled subroutine that only contains "(prin1 n)"
phoe has joined #lisp
<aeth>
pjb: Thanks for the help, I think I'm going to go with this: (loop for x on '(1 2 3 4 . 5) by (lambda (x) (let ((next (cdr x))) (if (not (listp next)) `(&rest ,next) next))) collect (car x))
<aeth>
This turns a Scheme-style dotted lambda list into the CL equivalent, i.e. (x y z . foo) => (x y z &rest foo) as long as the special case of not a list at all is dealt with first.
fikka has joined #lisp
vancan1ty has joined #lisp
<aeth>
(I use (not (listp next)) instead of (atom next) because nil is an atom and that'll blow up the list into an infinite loop)
pierpa has quit [Quit: Page closed]
<stacksmith>
G'day... Can someone tell me what happened to uiop:launch-program? What is a good way to run another program (asynchronously) and get its stdin and stdout?
JenElizabeth has quit [Remote host closed the connection]
<Xach>
stacksmith: I use sb-ext:run-program a lot.
JenElizabeth has joined #lisp
<stacksmith>
SBCL only...
fikka has quit [Ping timeout: 255 seconds]
<Xach>
I am pretty committed to sbcl.
<stacksmith>
Huh. I always thought you were a CCL man.
<Xach>
Rarely.
<stacksmith>
So there is nothing even 'semi-portable', as launch-program claimed?
<Xach>
I don't know, sorry - I never tried anything portable.
<stacksmith>
Thanks. SBCL still has no multithreading on ARM32, I think...
SaganMan has quit [Quit: WeeChat 1.6]
vancan1ty has quit [Ping timeout: 250 seconds]
phoe has quit [Ping timeout: 255 seconds]
phoe has joined #lisp
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
wigust has quit [Remote host closed the connection]
TCZ has quit [Quit: Leaving]
dmiles has quit [Ping timeout: 268 seconds]
jameser has joined #lisp
dmiles has joined #lisp
yangby has joined #lisp
vancan1ty has joined #lisp
Arcaelyx has joined #lisp
mson has quit [Quit: Connection closed for inactivity]
yangby has quit [Quit: Go out for a walk and buy a drink.]
phoe has quit [Ping timeout: 248 seconds]
Ellenor is now known as Reinhilde
phoe has joined #lisp
fikka has joined #lisp
python476 has quit [Ping timeout: 255 seconds]
d4ryus2 has joined #lisp
d4ryus1 has quit [Ping timeout: 268 seconds]
vancan1ty has quit [Ping timeout: 255 seconds]
quazimodo has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 248 seconds]
safe has joined #lisp
igemnace has quit [Quit: WeeChat 1.9.1]
anunnaki has quit [Ping timeout: 240 seconds]
pjb has quit [Remote host closed the connection]
igemnace has joined #lisp
bigos has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
milanj has quit [Quit: Leaving]
<rumbler31>
stacksmith: hail! Also, uiop launch-program still exists
<rumbler31>
if you're trying to use ccl, I think ccl bundles an old version of asdf, so you might have to load a recent version to get it?
<rumbler31>
alternatively, uiop is available in quicklisp
fikka has quit [Ping timeout: 248 seconds]
cpape has quit [Ping timeout: 240 seconds]
eSVG has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
vzerda has quit [Ping timeout: 250 seconds]
eschatologist has quit [Remote host closed the connection]
eschatologist has joined #lisp
bjorkintosh has left #lisp ["Leaving"]
fikka has joined #lisp
aoeu256 has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 248 seconds]
damke has joined #lisp
resttime has joined #lisp
damke__ has quit [Ping timeout: 240 seconds]
pjb has joined #lisp
<resttime>
Sup, I've been writing small bits of Common Lisp to test a C++ daemon I'm writing that's going to be on a satellite which got me imagining lisp in space so I'm curious if it's possible to protect against random bitflips in space due to radiation with whatever is available.
<resttime>
I dunno too much about how objects in lisp are represented in memory.
<resttime>
Like could a random bitflip screw up a type and cause devastating errors throughout the whole lisp image or make the garbage collector delete the wrong memory?
anunnaki has joined #lisp
epony has quit [Read error: Connection reset by peer]
<resttime>
An example to kind of protect against this in C is to represent a flag for example is reprsentating ON/OFF with a UINT16 instead of a single bit
<Bike>
and then, what, check truth/false by majority?
<resttime>
Yup
<resttime>
Use popcount to count bits
<resttime>
ROund up orr down
<resttime>
But anyways, I don't know anything about this for lisp, like is it enough to use T and Nil?
<resttime>
etc. etc.
Oladon has quit [Quit: Leaving.]
<Bike>
bit flips would probably fuck up a lot of things
<resttime>
Memory redundency in lisp in other words is what I'm wondering
<Bike>
you'd have to specifically think about it. i mean, like you could do the popcnt booleans in lisp as well
<resttime>
Bike: Yeah no kidding
<resttime>
But aren't these typed in a way with bits as well?
fikka has joined #lisp
antonv has joined #lisp
<pjb>
resttime: space hardened hardware protects you from bit flips.
<resttime>
Errr but again this is going into implentation territory I dunno about so I'm here to ask :)
<pjb>
resttime: you can write your own implementation, or patch an existing implementation, to add redundancy in the internal representations.
<resttime>
pjb: Supposedly yeah, but still protection is pretty important that stuff is still implemented like that. Example being multiple copies of data of polling data (there's been discussion about something like partitioning to store multiple copise of samefile on disk etc on satellite)
<resttime>
pjb: Hmmm, interesting
<resttime>
I wonder if there's some source of the lisp that ran on other space hardware and/or technical specifications of them somewhere
<pjb>
For example, there have been lisp implementations where there were no (obvious) type tag. Instead, data of a given type was stored all in the same memory page. So the type depended on the address. Then you would have to protect bits in pointers!
fikka has quit [Ping timeout: 255 seconds]
<pjb>
resttime: AFAIK, the lisp used on DeepSpace 1 was Allegro CL.
marusich has joined #lisp
<pjb>
resttime: but seriously, it shouldn't be too hard to patch an implementation to do that.
<Bike>
deep parts of object representation? i dunno about that
<resttime>
Like the garbage collector as well?
<pjb>
Sure.
<pjb>
Have fun!
<resttime>
Well I suppose it's just a small thought experiment for now, but hmmmmm
epony has joined #lisp
fikka has joined #lisp
<Zhivago>
I like the dylan approach which had the type tags point at the objects, allowing the tags to be elided where static inference was sufficient.
<resttime>
pjb, Turns out it was the Harlequin implementation which ran on Deep Space 1
lisp_guest has joined #lisp
safe has quit [Read error: Connection reset by peer]
resttime has quit [Quit: Leaving]
fikka has joined #lisp
dddddd has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
oleo has quit [Quit: Leaving]
<earl-ducaine>
It'll always be Lucid Commmon Lisp to me.
neoncontrails has quit [Remote host closed the connection]
fikka has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
eSVG has quit [Ping timeout: 240 seconds]
antonv has quit [Ping timeout: 240 seconds]
vlatkoB has joined #lisp
zmt00 has quit [Quit: Leaving]
<turkja>
trying to get linedit installed on a debian box... what heck is going on, any idea? I get errors like this: "Just performed compiling #<MADEIRA-PORT "linedit" "ports" "ccl"> but failed to mark it done"
eSVG has joined #lisp
zaquest has joined #lisp
fikka has joined #lisp
neoncontrails has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
LocaMocha has joined #lisp
alpert has joined #lisp
<turkja>
so strange... can't understand what is this.. some ASDF confusion
<turkja>
ASDF could not load linedit because
<turkja>
Just performed compiling #<MADEIRA-PORT "linedit" "ports" "ccl"> but failed to mark it done.
<beach>
Yes, you said that.
greyavenger has joined #lisp
<Zhivago>
I'd start by searching for "failed to mark it done" in the asdf source.
<turkja>
this is the bleeding edge SBCL-1.4.1 from git... hm that's a good pointer Zhivago
fikka has joined #lisp
* greyavenger
mishoo has quit [Ping timeout: 255 seconds]
emacsoma` has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
<greyavenger>
#lisp
fikka has joined #lisp
<harovali1>
are roswell and quicklisp more or less the same idea ?
fikka has quit [Ping timeout: 255 seconds]
<beach>
greyavenger: Your utterances are a bit cryptic.
<beach>
greyavenger: Are you new here? I don't recognize your nick.
fikka has joined #lisp
Karl_Dscc has joined #lisp
shka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
lisp_guest has quit [Ping timeout: 248 seconds]
flamebeard has joined #lisp
mishoo has joined #lisp
<stacksmith>
me lisp too.
rippa has joined #lisp
panji has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
<greyavenger>
beach: yes just learning
Karl_Dscc has quit [Remote host closed the connection]
<beach>
greyavenger: Great! Welcome to #lisp.
<beach>
greyavenger: It is easy to choose the wrong tools, so if you need help, you should say so.
<shka>
greyavenger: good luck, have fun
dec0n has joined #lisp
<greyavenger>
thanks!
bkst has quit [Read error: Connection reset by peer]
shka has quit [Ping timeout: 248 seconds]
shka has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
fikka has joined #lisp
scymtym has quit [Ping timeout: 255 seconds]
greyavenger has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 260 seconds]
igemnace has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
<Shinmera>
stacksmith: uiop:launch-program works fine enough for async processes. I recently switched simple-inferiors to use it instead of external-program.
fikka has quit [Ping timeout: 255 seconds]
neoncontrails has quit [Remote host closed the connection]
<jackdaniel>
harovali1: they are not
<jackdaniel>
roswell has many goals, while quicklisp is a library manager
fikka has joined #lisp
igemnace has joined #lisp
mingus` has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
mingus has quit [Ping timeout: 258 seconds]
raynold has quit [Quit: Connection closed for inactivity]
mishoo has quit [Read error: Connection reset by peer]
harovali has joined #lisp
harovali1 has quit [Read error: Connection reset by peer]
test1600 has quit [Ping timeout: 268 seconds]
<Ober>
the roswell seems to use a lot of C
phadthai has quit [Ping timeout: 248 seconds]
Posterdati has joined #lisp
angavrilov has joined #lisp
<Shinmera>
Can't use lisp if you want to let people install a lisp without a lisp already on the system.
damke has joined #lisp
hhdave_ has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
phadthai has joined #lisp
<Ober>
ahh like sbcl
Amplituhedron has joined #lisp
caseyowo has quit [Ping timeout: 248 seconds]
Tobbi has joined #lisp
arbv has quit [Ping timeout: 255 seconds]
arbv has joined #lisp
resttime has joined #lisp
wxie has joined #lisp
<resttime>
Is the static-vectors library for sharing lisp simple arrays to C functions without copying it to C memory?
<Shinmera>
Yes.
<Shinmera>
Specifically simple-vectors, though.
<resttime>
Thanks, I'm looking into the source for SBCL and it seemed different from another way which seemed to be done by 'pinning' the object against the garbage collector and then passing a pointer to it or something
bkst has joined #lisp
<resttime>
Errr, the source for the static-vectors implementation for SBCL that is
<Shinmera>
Well, pinning isn't necessarily enough. The memory representation for the elements must match that of C oo
<Shinmera>
*too
damke_ has joined #lisp
<Shinmera>
Pinning just means the memory won't move, which is one of the requirements for C.
lagagain has joined #lisp
damke has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
<resttime>
Hmmm, would you happen to know if SBCL is an implementation which cleans up these static vectors with the GC? (something mentioned in the readme, although it advises to not rely on it)
<Shinmera>
I don't. I don't usually write unportable code.
fikka_ has joined #lisp
murii has joined #lisp
<resttime>
Kk, thanks for for the info on the lib.
fikka has quit [Ping timeout: 248 seconds]
Amplituhedron has quit [Read error: Connection reset by peer]
murii has quit [Quit: ¯\_(ツ)_/¯]
emaczen`` has joined #lisp
murii has joined #lisp
emaczen` has quit [Ping timeout: 240 seconds]
Arcaelyx has quit [Ping timeout: 250 seconds]
EvW has joined #lisp
fikka_ has quit [Quit: leaving]
fikka has joined #lisp
Arcaelyx has joined #lisp
gigetoo has quit [Ping timeout: 260 seconds]
gigetoo has joined #lisp
Cymew has joined #lisp
_cosmonaut_ has joined #lisp
dcluna has quit [Ping timeout: 248 seconds]
dcluna has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
wigust has joined #lisp
damke_ has joined #lisp
marusich has quit [Quit: Leaving]
EvW has quit [Ping timeout: 258 seconds]
damke_ has quit [Ping timeout: 240 seconds]
damke has joined #lisp
aoeu256 has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
xfwduke has quit [Ping timeout: 268 seconds]
angular_mike has quit []
angular_mike has joined #lisp
mingus` has quit [Read error: Connection reset by peer]
mingus` has joined #lisp
Cymew has quit [Remote host closed the connection]
nsrahmad has joined #lisp
igemnace has quit [Quit: WeeChat 1.9.1]
emaczen`` has quit [Ping timeout: 255 seconds]
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nsrahmad has quit [Ping timeout: 240 seconds]
resttime has quit [Quit: Leaving]
lisp_guest has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 240 seconds]
panji has quit [Quit: Leaving.]
pedh has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
pedh has quit [Quit: pedh]
pedh has joined #lisp
wxie has quit [Remote host closed the connection]
edgar-rft has quit [Quit: edgar-rft]
fikka has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
<turkja>
so it looks like ASDF 3.3.1 doesn't like what is in the linedit.asd: (:madeira-port "ccl" :when :ccl)
cpape has joined #lisp
<turkja>
i just removed that and now linedit loads
fikka has joined #lisp
Cymew has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 248 seconds]
lagagain has quit [Quit: Connection closed for inactivity]
Cymew has joined #lisp
saki has joined #lisp
mingus` has quit [Read error: Connection reset by peer]
margeas has joined #lisp
fikka has joined #lisp
m00natic has joined #lisp
jameser has joined #lisp
saki has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 240 seconds]
pedh has quit [Quit: pedh]
pedh has joined #lisp
mishoo__ has joined #lisp
fikka has joined #lisp
mishoo_ has quit [Read error: Connection reset by peer]
sjl has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Cymew has quit [Remote host closed the connection]
saki has joined #lisp
sjl has quit [Ping timeout: 268 seconds]
saki has quit [Client Quit]
fikka has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
johnnymacs has joined #lisp
<johnnymacs>
can lisp be used in purely reversible computing?
<phoe>
johnnymacs: what do you mean by "purely reversible computing"?
Cymew has joined #lisp
pedh has quit [Quit: pedh]
damke_ has joined #lisp
<johnnymacs>
In the sense that one programs on a purely reversible computer so that that processor won't consume any energy
rgrau has joined #lisp
<Shinmera>
... huh?
<phoe>
> so that processor won't consume any energy
<phoe>
do you want to run your computer without a battery and not plugged into a power socket?
<phoe>
every computation uses energy, no matter how efficient the computer is
<Shinmera>
Reversible computing as I understand it means that the state can always be rolled back or "reversed in time" in some fashion. Energy has nothing to do with that.
<johnnymacs>
Modern quantum computers use reversible architectures
<phoe>
Following wikipedia, if reversible computing is an art of bypassing Landauer's principle, then it is not a matter of language but a matter of computer architecture
<phoe>
contemporary computers use irreversible computation and are therefore subject to Landauer's principle
<johnnymacs>
when you destroy information in a computer it gives off heat
<johnnymacs>
and energy
<phoe>
and I bet that whatever language you use to program quantum computers, you can write yourself a Lisp there as well.
<Shinmera>
Anyhoo, turing equivalence says that if quantum computers are turing machines, then you can run lisp on them if you want :shrug:
<johnnymacs>
The video I linked explains what I am talking about
<jdz>
johnnymacs: you don't expect everybody in here to go watch that video now, do you?
<johnnymacs>
Not everybody no
<johnnymacs>
I am willing to wait a long time for the answer
<jdz>
Do you yourself know what your question is?
<johnnymacs>
My question is whether lisp is suitable for purely reversible computing
<phoe>
why wouldn't it be?
fikka has joined #lisp
<phoe>
as long as you have a reversible computer I bet you can implement any language on it
<johnnymacs>
True but those languages won't run as efficiently as a reversible language
<phoe>
and unless you have a reversible computer, all languages are equally unusable for reversible computing
<phoe>
what makes a language better at reversible computing than other languages?
dec0n has quit [Read error: Connection reset by peer]
<johnnymacs>
By being able to do general purpose computing without irriversable operations
<johnnymacs>
*irreversible
dec0n has joined #lisp
mishoo_ has joined #lisp
<johnnymacs>
Landaur's principle is the key to the query
<phoe>
a language isn't the one doing irreversible operations
mishoo__ has quit [Read error: Connection reset by peer]
<phoe>
it's the machine underneath that operates, the language only instructs it how to do it
<johnnymacs>
An example of an irriversable operation is lisp's + function
Ven has joined #lisp
<phoe>
every sane language has an addition function
<johnnymacs>
In reversible computers you have +/- operators
Bicyclidine has joined #lisp
Ven is now known as Guest25798
<Shinmera>
Can we just say Lisp isn't suitable and move on to more fruitful topics
<phoe>
then go ahead and implement a ± operator in Lisp
<johnnymacs>
(defun plus-minus (x y) (list (+ x y) (- x y))))
<phoe>
there you go
<johnnymacs>
This operator is reversible unlike +
<johnnymacs>
With the addition and the subtraction I can find out what the initial two terms were
fikka has quit [Ping timeout: 248 seconds]
<phoe>
good, so for each irreversible operator, go and define its reversible version
<phoe>
and you can do this in Lisp as much as you can do it in all other sane languages
<phoe>
so I still fail to see how this is Lisp-specific
<johnnymacs>
My research involves finding programming languages that can do anything that is possible for a language to do
<johnnymacs>
According to my current research lisp falls into that category
<johnnymacs>
so for lisp to do everything it has to be able to do reversible c omputing
<phoe>
all Turing-complete languages can do everything all other Turing-complete languages can do
<jdz>
You must have heard of Alan Turing and his research, right?
<johnnymacs>
Alan Turing's turing machine is not as complete as you'd hope
<phoe>
so you can implement Lisp in Brainfuck and Brainfuck in C and C in Pascal and Pascal on a hypothetical bounded Turing machine and a hypothetical bounded Turing machine in Lisp
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<phoe>
and right now, we're in the land of Turing machines.
<johnnymacs>
It is true that with a turing machine you'd get a machine that can solve any math problem. However there are guarantees that you will not get. For example being turing complete gives you no guarantees as to how fast the computation will get done. Or as to how easy it will be to express the computation.
Josh_2 has joined #lisp
<phoe>
and this is not a Common Lisp problem because Common Lisp is a Turing-complete language.
<johnnymacs>
Being turing complete also gives no guarantees as to what features the machine will come preinstalled with.
<phoe>
this isn't a Common Lisp problem either.
<johnnymacs>
It most certainy is a query about common lisp.
<jdz>
Somehow this reminds me of Quantum computation.
<johnnymacs>
By definition javascript can not be as more than turing complete as lisp can.
jameser has joined #lisp
<phoe>
no, it is a query about hyper-Turing-completeness, and is about computability more than Lisp itself.
<phoe>
than about Lisp itself.*
<johnnymacs>
My point is the reason I don't go ask this in #javascript is that javascript is already out of the race
<jdz>
Why so?
<phoe>
so, by definition, so is Lisp.
<johnnymacs>
no
<jackdaniel>
I understand nothing from all this - either it is very close to nonsense or I'm too primitive to comprehend
<johnnymacs>
lisp can do things javascript can not do
<jdz>
The Common Lisp that is implemented in a browser in JavaScript is no longer a Common Lisp?
<phoe>
By definition Lisp cannot be as more than turing complete as JavaScript can.
<phoe>
So there is nothing that Lisp can do than Javascript can't.
<Josh_2>
If it meets the standard then it is an ansi common lisp no?
<johnnymacs>
There are features to a computer besides the limit of the computations it can do
<phoe>
Stop jumping around topics so much.
<johnnymacs>
In javascript you can not invent your own syntax
<johnnymacs>
in lisp you can do that
<phoe>
Lisp and JS are both Turing-complete and you can implement one in the other.
<Josh_2>
You can if you implement a lisp in JS
<phoe>
You can implement a JS compiler in Lisp and a Lisp compiler in JS.
<phoe>
What you are talking about is the features of the language.
<johnnymacs>
Yes not all languages can implement all features
<phoe>
Which has little in common with Turing-completeness.
<johnnymacs>
lisp can implement all features which are possible to implement
<johnnymacs>
in theory
<phoe>
But you can implement a Turing-complete language in any other Turing-complete language.
<Josh_2>
The quote goes something like this "every significantly complex programming project will have at some point implemented a lisp"
<jdz>
johnnymacs: so there you have it -- lisp can implement reversible computing, as you just said.
<phoe>
So in theory JS is capable of everything that Lisp is capable of.
<Josh_2>
aye
<Shinmera>
jackdaniel: It's mostly nonsense.
<johnnymacs>
jdz javascript can not implement purely reversible computing
<phoe>
So whatever you say about JS, also concerns Lisp, and vice versa.
<phoe>
So Lisp cannot, either.
<phoe>
EOT
<jdz>
johnnymacs: why not?
<johnnymacs>
That is false
<johnnymacs>
The interpreter to javascript is not reversible
<johnnymacs>
the language javascript by design can not be purely reversible
<jdz>
Interpreter is a machine.
<johnnymacs>
Yes
<phoe>
Just build a better interpreter then.
<jdz>
Common Lisp is also interpreted by a machine.
<johnnymacs>
To be purely reversible all of your hardware and software from the bottom of your stack to the top of the stack has to be reversible
<johnnymacs>
Anyone who watched the video would know this by now
<Shinmera>
13:26:55 Shinmera | Can we just say Lisp isn't suitable and move on to more fruitful topics
<phoe>
The hardware that CL is running on is non-reversible.
<Josh_2>
lies jdz mine CL is interpreted by my cat fluffles
<johnnymacs>
There are machines in existence which are reversible in the hardware. They are called quantum computers
<phoe>
Let's move this to #lispcafe since this does not concern Lisp as a language.
<johnnymacs>
IBM and INTEL are both working on versible architectures
<johnnymacs>
It is very much concerned with lisp
<phoe>
It is not concerned with Common Lisp.
<johnnymacs>
The query is "can *common lisp* do purely reverisble computing"
<Shinmera>
Can we just say Lisp isn't suitable and move on to more fruitful topics
<phoe>
It is concerned about hypertheoretical Lisp dialects tha nobody created yet and almost no one has computers to run it on anyway.
<jackdaniel>
#lispcafe for reversible computing! ;-) but seriously, it fits nowhere near #lisp channel
<phoe>
Kindly move it to #lispcafe.
johnnymacs has left #lisp ["Killed buffer"]
<jackdaniel>
/rewind-time -10m
<Shinmera>
Hah
<Josh_2>
rewinding forward
<Shinmera>
Unfortunately the universe is mostly deterministic, so we'd just relive the last 10 minutes again over and over.
<Josh_2>
Probably because we are all doing something for a reason anyways
<python476>
there's a reversible js debugger IIRC
<jackdaniel>
I don't get the "mostly" part, it either is or isn't (and my belief is that it is not deterministic)
<phoe>
Shinmera: if the universe is reversible, then we can relive the last 10 minutes forever and still be unaware of it repeating
<python476>
also, lets just embed js in prolog heh
<python476>
phoe: unless you store the continuation
<jdz>
phoe: no, we should be able to live with time running backwards.
<Shinmera>
jackdaniel: Quantum mechanics says it isn't, but the fluctuations smoothen out with scale, so it is deterministic if you don't zoom in too much.
AntiSpamMeta has quit [Read error: Connection reset by peer]
<jdz>
The devil is in the details, as *they* say.
AntiSpamMeta has joined #lisp
<Shinmera>
Who said that? The X3J13 team?
<jdz>
*they*
<jackdaniel>
Shinmera: taking into account chaos theory, even small changes may influence a big picture
<jdz>
Shadow people.
<Shinmera>
jackdaniel: Sure, that's why I said mostly.
fikka has joined #lisp
<jdz>
The closest I've seen of "reversible computation" is append implementation in Prolog.
<paule32>
hello
<jdz>
Oh noes.
<paule32>
with list-length, i can get the length of a list
<paule32>
("Menu1" A ("SubMenu1" AB))
<python476>
jdz: you've never seen Friedman talks about kanren ?
<paule32>
how about this peace
<phoe>
paule32: this list has 3 elements
<python476>
Im not sure it's proper reversible but it's inverts the eval relationship
<phoe>
"Menu1", A, and ("SubMenu1" AB)
<python476>
(probably one of the most jawdropping things I will ever see)
<paule32>
phoe: yes, i try to implement a menu pane
<phoe>
then this list is 3 elements long.
<paule32>
so, there can be normal menu items, and sub menu items
fikka has quit [Ping timeout: 258 seconds]
<phoe>
Yes, I understand that.
<paule32>
the problem i see: how to iterate dynamical - e.g. Menu1 has 3 items, Menu2 has 4 ..
mishoo__ has joined #lisp
<phoe>
I still don't understand this. Iterate dynamically? What do you want to achieve?
<paule32>
loop through menu1 with its submenus, and normal items, which are not submenus
mishoo_ has quit [Read error: Connection reset by peer]
<phoe>
you have a tree-like structure there. use recursion for handling this.
<paule32>
yes, a tree
random-nick has joined #lisp
vibs29 has quit [Ping timeout: 240 seconds]
xantoz has quit [Ping timeout: 240 seconds]
Bicyclidine has quit [Ping timeout: 248 seconds]
xantoz has joined #lisp
vibs29 has joined #lisp
EvW1 has joined #lisp
norserob has joined #lisp
jmercouris has joined #lisp
Guest25798 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
damke has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
norserob has quit [Client Quit]
norserob has joined #lisp
fikka has joined #lisp
dddddd has joined #lisp
varjag has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 268 seconds]
engblom has quit [Changing host]
engblom has joined #lisp
fikka has joined #lisp
eSVG has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
eSVG has quit [Ping timeout: 240 seconds]
edgar-rft has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kevslinger has joined #lisp
oleo has joined #lisp
foom2 has joined #lisp
fikka has joined #lisp
brendyn has quit [Quit: WeeChat 1.9.1]
foom has quit [Ping timeout: 252 seconds]
Jesin has quit [Quit: Leaving]
fikka has quit [Ping timeout: 240 seconds]
mishoo__ has quit [Ping timeout: 240 seconds]
LiamH has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
whoman has quit [Ping timeout: 240 seconds]
EvW1 has quit [Ping timeout: 255 seconds]
mson has joined #lisp
fikka has joined #lisp
whoman has joined #lisp
yrk has joined #lisp
Ven has joined #lisp
Ven is now known as Guest40983
FreeBirdLjj has joined #lisp
cromachina has quit [Read error: Connection reset by peer]
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
papachan has joined #lisp
jameser has joined #lisp
bigos has joined #lisp
bigos has quit [Ping timeout: 240 seconds]
eudoxia has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
mishoo__ has joined #lisp
_rumbler31 has joined #lisp
Jesin has joined #lisp
jmercouris has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
mingus has joined #lisp
Oladon has joined #lisp
caseyowo has joined #lisp
murii has quit [Remote host closed the connection]
<jmercouris>
This one includes a lot of updates from feedback that I got from the community here about how to improve my code. There's still a long way to go, don't get me wrong, but it's slowly getting better and more mature
<jmercouris>
I'm looking for anyone who would like to help work on a GTK release with me, or just leave a star on github, thank you for your time
<Josh_2>
How do I make the binary go?
<Josh_2>
Or does this only work on Mac?
<jmercouris>
Josh_2: Only MacOS for now, working on the GTK port
<jmercouris>
It used to be cross-platform via QT, but I've sought better performance, so I've gone native + CCL
<Josh_2>
Have you considered McClim?
<jmercouris>
Josh_2: Yes, and without going to deep into it, it is not suitable for my purposes
<jmercouris>
s/to/too
caseyowo has quit [Ping timeout: 260 seconds]
<jmercouris>
Most of the GUI work I'm doing is just basic rendering of a Web canvas, the majority of the logic is in managing those canvas' and the associated datastructures associated with a web-page
<jmercouris>
There's also some network logic as well, but that's still in progress
brendyn has joined #lisp
Cymew has quit [Remote host closed the connection]
Josh_2 has quit [Remote host closed the connection]
Guest40983 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
TCZ has joined #lisp
warweasle has joined #lisp
muresanvlad_ has joined #lisp
hexfive has joined #lisp
TCZ has quit [Quit: Leaving]
dec0n has quit [Read error: Connection reset by peer]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
pjb has joined #lisp
thinkpad has quit [Ping timeout: 268 seconds]
eli has quit [Ping timeout: 258 seconds]
flamebeard has quit [Quit: Leaving]
caseyowo has quit [Ping timeout: 268 seconds]
caseyowo has joined #lisp
Ven has joined #lisp
Ven is now known as Guest48681
nullman has quit [Ping timeout: 260 seconds]
nullman has joined #lisp
varjag has quit [Ping timeout: 264 seconds]
remi`bd has joined #lisp
jealousmonk has joined #lisp
GrayArea has quit [Ping timeout: 258 seconds]
jealousmonk has quit [Read error: Connection reset by peer]
jealousmonk has joined #lisp
jealousmonk has quit [Read error: Connection reset by peer]
rumbler31 has quit [Remote host closed the connection]
jealousmonk has joined #lisp
Tristam has joined #lisp
zmt00 has joined #lisp
warweasle is now known as warweasle_brb
jealousmonk has quit [Read error: Connection reset by peer]
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
muresanvlad_ has quit [Remote host closed the connection]
jealousmonk has joined #lisp
varjag has joined #lisp
siriusirc has joined #lisp
damke_ has joined #lisp
jealousmonk has quit [Read error: Connection reset by peer]
jealousmonk has joined #lisp
damke has quit [Ping timeout: 240 seconds]
muresanvlad_ has joined #lisp
jmercouris has quit [Remote host closed the connection]
jealousmonk has quit [Read error: Connection reset by peer]
jealousmonk has joined #lisp
jealousmonk has quit [Read error: Connection reset by peer]
GrayArea has joined #lisp
jealousmonk has joined #lisp
jealousmonk has quit [Read error: Connection reset by peer]
warweasle_brb is now known as warweasle
muresanvlad_ has quit [Remote host closed the connection]
<Josh_2>
Am I right in assuming that Quicksort isn't so great when you have lots of repeating values you have to sort?
varjag has quit [Ping timeout: 248 seconds]
<_rumbler31>
try it and see?
<Josh_2>
I don't think my array is big enough for it to matter
<Bike>
then... why are you asking
<pjb>
well, I don't know exactly in that case, but if the vector is almost sorted, quicksort is not necessarily the fastest in practice. Having a lot of repeating values would render the vector almost sorted, so…
<Josh_2>
Because this coursework is all about using the correct algorithms
<Bike>
wikipedia agrees, for what it's worth
<_death>
if the values are bounded you may want to try counting sort
Guest48681 is now known as Ven``
<Josh_2>
In an array of over 1300 there are about 6 different values
<Josh_2>
What do you mean by bounded?
<_death>
meaning you know or can infer the minimum and maximum of possible data
<Josh_2>
Ahh yes I do know. I'm going to try out counting sort
<Shinmera>
For short keys radix sort can also be a very good bet.
<lisp_guest>
introsort is also interesting, it's a hybrid of quicksort and heapsort
Oladon has quit [Quit: Leaving.]
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
python476 has quit [Ping timeout: 255 seconds]
caseyowo has quit [Ping timeout: 248 seconds]
siriusirc has left #lisp [#lisp]
hhdave_ has quit [Ping timeout: 268 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
Ven`` has quit [Ping timeout: 258 seconds]
python47` has joined #lisp
<pjb>
Josh_2: if you have a (small) bounded number of different elements, then you can easily sort the vector in O(n)!
<pjb>
perhaps that's what you mean by counting sort.
rumbler31 has joined #lisp
m00natic has quit [Remote host closed the connection]
varjag has joined #lisp
FreeBirdLjj has joined #lisp
rumbler31 has quit [Ping timeout: 258 seconds]
johnnymaster has joined #lisp
<johnnymaster>
HI can someone help me with a common lisp problem
<pjb>
Sure.
<pjb>
But not if you don't ask!
<johnnymaster>
So basically i am trying to implement a function that takes a function and a nested list and applies the function to the the list (like reduce)
<johnnymaster>
So if i have the list '((1)) 2 3) and the function '+ i should get 6 as my answer
<mfiano>
will it always operate on the flattened list?
<eudoxia>
why not flatten the list first, then use reduce?
<mfiano>
You can use alexandria:flatten and mapcar then
<johnnymaster>
Can you help me shorten the last line (t (......) using reduce and a lambda call
<johnnymaster>
I want to be able to use reduce and a lambda call
<johnnymaster>
I initially did a flatten list method but it was very heavy with cons
<johnnymaster>
pjb: any thoughts?
<pjb>
Let me see.
Josh_2 has quit [Ping timeout: 260 seconds]
<pjb>
Using flatten and thus implementing a modular solution would be good to ensure you get a correct function, but it would use more temporary space (and more O(1) time), so it may be rejected for production. Of course, if you need to avoid the use of space, you need to be working on trees that fill half or more of the memory!
<johnnymaster>
Hmm yeah
<johnnymaster>
So I was thinking to do it as follows:
<johnnymaster>
its more of a nested list than a tree
TCZ has joined #lisp
<pjb>
johnnymaster: what you would put in that lambda, is what you should put for the whole function! ;-) cf: (t (......) using reduce and a lambda call
<pjb>
<johnnymaster> I want to be able to use reduce and a lambda call
<pjb>
<johnnymaster> I initially did a flatten list method but it was very heavy with cons
<pjb>
<johnnymaster> pjb: any thoughts?
<pjb>
<pjb> Let me see.
<pjb>
*** Josh_2 (~user@cpc88041-dund14-2-0-cust452.16-4.cable.virginm.net) has quit: Ping timeout: 260 seconds
<pjb>
<pjb> Using flatten and thus implementing a modular solution would be good to ensure you get a correct function, but it would use more temporary space (and more O(1) time), so it may be rejected for production. Of course, if you need to avoid the use of space, you need to be working on trees that fill half or more of the memory!
<pjb>
<johnnymaster> Hmm yeah
<pjb>
<johnnymaster> So I was thinking to do it as follows:
<Bike>
i'm familiar, but i don't understand the relevance.
<pjb>
johnnymaster: in general, it's better to use &key rather than &optional, because you soon will want to add optional arguments, and then &key is more practical, since you can pass them in any order.
<pjb>
johnnymaster: for example, you could want to add a key argument to extract the value to reduce from each node.
<shka>
as shown by my code, :key argument is for instance quite handy!
neoncontrails has joined #lisp
nullniverse has joined #lisp
<johnnymaster>
Ah, I understand what you mean @shka
nullniverse has quit [Max SendQ exceeded]
nullniverse has joined #lisp
<shka>
johnnymaster: numerous other sequence functions accept similar arguments, it is beneficial to stick to this set
zaquest has joined #lisp
<shka>
it probably took decades to come up to this
<pjb>
What's interesting when you do that, is to compare an school case implementation, to an actual implementation with a lot of special cases and options.
<shka>
riiiight
neoncontrails has quit [Remote host closed the connection]
<shka>
anyway, i don't have anything useful to say
<shka>
have a nice evening!
alpert has quit [Remote host closed the connection]
shenghi has quit [Remote host closed the connection]
shenghi has joined #lisp
alpert has joined #lisp
neoncontrails has joined #lisp
johnnymaster has quit [Ping timeout: 260 seconds]
alpert has quit [Ping timeout: 260 seconds]
pourquoi has joined #lisp
fikka has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
klltkr has joined #lisp
damke_ has joined #lisp
fikka has quit [Ping timeout: 258 seconds]
fraya has joined #lisp
<trn>
beach: You might be interested ...
<trn>
Others too... I finally hacked up from ttyd a proper Web terminal for the Multics emulation. So, you can login with "e Guest", to get a proper terminal, "stty -ttp vt102_132c_50l" and then "wdc invoke" for a proper 132x50 terminal. Enjoy Emacs 12.9 and MacLISP, etc. Now no mosh/ssh/telnet needed :)
<trn>
No permanent storage for guest users, but, you can have temp space in the process dir ( cwd [pd] )
vlatkoB has quit [Remote host closed the connection]
Atomic_NhLwj has joined #lisp
pourquoi_ has joined #lisp
Atomic_NhLwj has quit [Client Quit]
pourquoi has quit [Ping timeout: 240 seconds]
<Xach>
neat
pourquoi_ has quit [Ping timeout: 248 seconds]
attila_lendvai has quit [Quit: Leaving.]
alexmlw has joined #lisp
pourquoi has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
wigust has quit [Remote host closed the connection]
rumbler31 has joined #lisp
Oladon has quit [Quit: Leaving.]
Tex_Nick has joined #lisp
Tex_Nick has left #lisp [#lisp]
<trn>
You can look at https://ban.ai/ - there is mosh/ssh/telnet/web methods, I am not sure the web interface is very stable yet. It already gave me one bus error.
<trn>
Sadly msot people live in a web browser these days, so this lowers the bar for people to play with it.
rumbler31 has quit [Ping timeout: 248 seconds]
random-nick has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
<trn>
Xach: Are you the author of snarf?
<XachX>
trn: if you have a bug report, no way. Otherwise yes.
<trn>
Oh, cool. No bug report, I happen to use it, is all. It's part of the tools I haul along everywhere with me and some script or another I wrote uses it.
attila_lendvai has joined #lisp
<trn>
Thanks, I owe you a beer. I could switch to curl of course, but I don't fix what isn't broken.
<trn>
Ah, it's a gopher thing.
<trn>
Anyway, thanks.
eudoxia has quit [Quit: Leaving]
alexmlw has quit [Quit: alexmlw]
zachk has joined #lisp
angavrilov has quit [Remote host closed the connection]
epony has quit [Quit: QUIT]
random-nickname has joined #lisp
random-nickname is now known as random-nick
alpert has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
Josh_2 has joined #lisp
alpert has quit [Ping timeout: 248 seconds]
neoncontrails has quit [Ping timeout: 258 seconds]
pourquoi has quit [Ping timeout: 240 seconds]
papachan has quit [Quit: Saliendo]
fikka has joined #lisp
attila_lendvai has quit [Quit: Leaving.]
WorldControl has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
python47` has quit [Remote host closed the connection]
WorldControl has quit [Ping timeout: 248 seconds]
python476 has joined #lisp
harovali1 has joined #lisp
harovali has quit [Ping timeout: 248 seconds]
TCZ has quit [Quit: Leaving]
MrBusiness has quit [Ping timeout: 250 seconds]
mson has quit [Quit: Connection closed for inactivity]
scymtym has joined #lisp
neoncontrails has joined #lisp
eSVG has joined #lisp
MrBusiness has joined #lisp
aindilis has quit [Ping timeout: 268 seconds]
epony has joined #lisp
dyelar has quit [Quit: Leaving.]
<Xach>
trn: no problem. i wrote it to fetch Dr. Fun comics in cron. that was before web browsers worked all that well.
<Xach>
and predates curl and wget by a bit
fikka has joined #lisp
<Xach>
i actually don't use it any more because curl is more ubiquitous.
<paule32>
hello Xach
random-nick has quit [Remote host closed the connection]
<paule32>
how are you
<Xach>
hi paule32
<Xach>
paule32: have you considered modernizing to paule64?
<paule32>
haha, no
<Xach>
paule32: it would allow for immediate single-floats
aindilis has joined #lisp
<paule32>
hmm, i actually don't work with floats
<paule32>
i have worked with xmm in assembly, but few month ago
dieggsy has quit [Remote host closed the connection]
Bike has joined #lisp
dieggsy has joined #lisp
_rumbler31 has quit [Ping timeout: 260 seconds]
MrHackit has joined #lisp
resttime has joined #lisp
earl-ducaine has quit [Remote host closed the connection]
earl-ducaine has joined #lisp
emaczen has joined #lisp
damke has joined #lisp
<resttime>
Bike: Ah I've been wondering what you meant about unboxing a simple integer, does it mean just grabbing the pointer to the piece of memory??
<Bike>
i don't remember the context entirely
<resttime>
Theoretical memory redundancy for lisp in space
damke_ has quit [Ping timeout: 240 seconds]
<Shinmera>
resttime: FWIW you can't do fault detection in software if any bit can fail, because the fault detection itself might fail. All you can do is rely on hardware and hope you don't get really unlucky.
<Bike>
oh. i think i meant that small integers would just be fixnums, i.e. no pointer
<Shinmera>
*itself might get hit
<Bike>
well that's why it's "redundancy" and "tolerance", not "no problems ever", right?
<resttime>
Yeah someone I've asked said that there's maybe 20 SEU's (bitflips) per day
<Shinmera>
Bike: Sure, my point is more that such low-level issues are better left to the hardware and OS.
thinkpad has joined #lisp
<Bike>
i think the compiler could be reasonably included
<Shinmera>
Also, given by how meticulous NASA is about everything space, I'd be very surprised if they didn't research this as well.
MrHackit has quit [Ping timeout: 258 seconds]
<Shinmera>
So, maybe look around for papers.
<pjb>
You have to count on the hardware to correct errors in the instructions.
<pjb>
Shinmera: sure, what they do is to put 5 computers, and let them vote.
<pjb>
and use old technology (core memory), instead of high density DRAM.
<pjb>
or the cheat and remains below the radiation belt :-)
<pjb>
s/the/they
<earl-ducaine>
Hi Lispateers! I'm seeing that there's a new version of ASDF out. Yay! I'm also seeing that the standard version bundled with SBCL as rather old.
<earl-ducaine>
What have people found is the best way to install it on SBCL?
<earl-ducaine>
On-the-fly or rebuilding SBCL pointing at the new version.
<Shinmera>
It's not old if your SBCL isn't old
<earl-ducaine>
(in an Ubuntish environment.)
<Shinmera>
And the best way is the same as everywhere else. Load the asdf.lisp before the implementation version is loaded.
<earl-ducaine>
Shinmera: you called me out! I'm using stock SBCL.
<earl-ducaine>
shameful I know.
<Shinmera>
:shrug: I don't care
<Colleen>
‾\(ツ)/‾
<earl-ducaine>
So, if I just pull SBCL master I should have 3.3.1 or something close?
<Shinmera>
SBCL is currently at 3.4.1 and that ships 3.3.0.1, I think? 1.4.2 will have 3.3.1
<Shinmera>
*at 1.4.1
<earl-ducaine>
Shinmera: thanks for the info! I was under the impression that SBCL master lagged more than that. Misinformation on my part.
<Shinmera>
It did until a while ago
<Shinmera>
SBCL is somewhat conservative with ASDF upgrades, because ASDF upgrades also tend to break things.
<resttime>
Bike: Interesting paper, I'll ask about people about it and on the designs some more.