Josh_2 has quit [Remote host closed the connection]
slyrus has quit [Ping timeout: 240 seconds]
BBS has quit []
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
slyrus has joined #lisp
karstensrage has joined #lisp
Kundry_W_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
APic has joined #lisp
APic has quit [Ping timeout: 265 seconds]
Helmholtz has joined #lisp
Nilby has quit [Ping timeout: 276 seconds]
curtosis[away] has joined #lisp
kevingal has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
semz has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 268 seconds]
abhixec has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
Helmholtz has quit [Quit: Helmholtz]
huonib has joined #lisp
<huonib>
can someone help me with this? I am working on a project and I am looking to use a lisp that compiles to a small binary - either ecl, chez, or chicken scheme
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
thinkpad has quit [Ping timeout: 240 seconds]
<huonib>
huh - I didn't have that much faith in ECL, since I heard nobody really uses it, but it generates a binary of 2.1 MB whereas chicken scheme is at 4.6 MB
<huonib>
that's impressive
slyrus has quit [Remote host closed the connection]
<Bike>
ecl is actively developed. i don't use it regularly but it sounds like it works fine
thinkpad has joined #lisp
<huonib>
Bike: that is great to hear
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
slyrus has joined #lisp
<huonib>
Bike: I am a complete idiot, so bear with me, but chicken scheme can compile without the runtime - is that possible with ecl?
<luis>
I've just noticed that SLIME's presentations weakly reference their respective object: they don't prevent the object from being GCed and if the object is GCed, the presentation is disabled (it turns into plain text). I'd never noticed this before. Is this how LispM/CLIM presentations work too?
<loke[m]1>
luis: that's not how they behaved in the past. I'm pretty sure I needed to C-x M-o to lose the references to them.
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
moshes has quit [Ping timeout: 260 seconds]
slyrus has joined #lisp
dilated_dinosaur has joined #lisp
<luis>
loke[m]1: I was under that impression too, but *object-to-presentation-id* and *presentation-id-to-object* have been weak hash-tables for well over a decade and I don't think the REPL has ever stored them anywhere but * ** ** / // //. At some point (2006-ish?) SBCL didn't support weak hash-tables.
rick-monster has joined #lisp
<loke[m]1>
luis: Perhaps the reference is held somewhere else. I just tried creating a large array, leaving it in a presentation and did a (gc :full t)
<loke[m]1>
I did several actually. And the presentation still works.
slyrus_ has joined #lisp
<luis>
loke[m]1: did you evaluate enough subsequent forms to clear it from * ** ***?
Stanley00 has joined #lisp
karlosz has quit [Quit: karlosz]
<loke[m]1>
The 5 evaluations of (gc :full t) should have been enough, but for good measure I did about 10 more evaluations of simple numbers followed by a few more gc's.
slyrus has quit [Ping timeout: 265 seconds]
slyrus has joined #lisp
kevingal has joined #lisp
slyrus_ has quit [Ping timeout: 246 seconds]
<luis>
loke[m]1: how did you determine the presentation still works?
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
<luis>
Try right clicking it.
<loke[m]1>
luis: Well, I went to it and typed C-c C-v TAB. But yes, right-clicking also works.
<luis>
loke[m]1: Well, I'm stumped. That's not the behaviour I'm seeing.
<loke[m]1>
I use the version of SLIME synced from the git repository today.
minion has quit [Read error: Connection reset by peer]
specbot has quit [Read error: Connection reset by peer]
slyrus has quit [Read error: Connection reset by peer]
slyrus_ has joined #lisp
<luis>
We need a third volunteer to try and reproduce this. :-)
* luis
looks around
minion has joined #lisp
specbot has joined #lisp
<luis>
Anyone with SBCL and SLIME on hand?
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<no-defun-allowed>
I remember copying the presentation to another buffer, and then doing some more stuff, including clearing output, then the presentation would stop working.
lotuseater has joined #lisp
varjag has joined #lisp
<luis>
no-defun-allowed: that's expected since clearing output clears presentations (or it tries to, I'm baffled by that particular bit of code too, but that's another story)
slyrus_ has joined #lisp
<no-defun-allowed>
Ah, I am talking about something else. /me rereads
<no-defun-allowed>
CLIM presentations would strongly reference from memory, else they could not be ACCEPTed or used for gesture translation(?) later, and I don't recall reading that the implementation could allow ACCEPT to stop working for whatever reason.
<luis>
So, the test case is: evaluate the following forms in the slime-repl one by one: (make-array 10), 1, 2, 3, (gc :full t) then right click (or C-c C-v TAB) the array presentation. I get "object no longer recorded" but it works for loke[m]1 for some reason.
slyrus has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
But I also agree that I thought *slime-repl* served as "roots" somehow.
<luis>
We're all in agreement about how it /should/ work so far. :-)
<no-defun-allowed>
Huh, it does in fact say "Object no longer recorded" in the right-click menu, and then it ceases to be clickable.
Stanley00 has quit []
<luis>
Ah, a confirmation. That's nice.
slyrus has joined #lisp
slyrus_ has quit [Read error: Connection reset by peer]
<luis>
no-defun-allowed: thanks. loke[m]1: not sure why you're getting different results.
amb007 has joined #lisp
<rick-monster>
luis I couldn't repro (assuming 1,2,3 means wait 3 seconds)
slyrus has quit [Read error: Connection reset by peer]
<no-defun-allowed>
It means to evaluate 1, then evaluate 2, then evaluate 3, in order to clear out the "history" variables.
slyrus has joined #lisp
<rick-monster>
in that case I can repro - C-c C-v TAB results in "Attempt to access unrecorded object (id 94)"
eden has quit [Remote host closed the connection]
slyrus has quit [Read error: Connection reset by peer]
eden has joined #lisp
slyrus has joined #lisp
<rick-monster>
software versions for repro: sbcl 2.0.8, swank/slime 2.26.1, linux.
slyrus has quit [Read error: Connection reset by peer]
h4ck3r9696 has left #lisp [#lisp]
aartaka has joined #lisp
slyrus has joined #lisp
vegansbane6963 has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
slyrus has quit [Read error: Connection reset by peer]
slyrus_ has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<luis>
rick-monster: thanks.
slyrus has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus_ has joined #lisp
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
yitzi has joined #lisp
yitzi has quit [Remote host closed the connection]
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
skapatov has quit [Ping timeout: 260 seconds]
slyrus has joined #lisp
<rick-monster>
I'm dusting off an old music-control framework I wrote for lisp-on-linux and would like to discuss an aspect of the design.
<rick-monster>
the project is called 'serial hub' because it aggregates events from serial devices (eg midi, OSC, other usb music-controller peripherals). Currently each serial device or network socket has dedicated blocking thread to translate incoming serial data from a stream to lisp object. lisp objects from various sources are aggregated by sending them into a threadsafe channel (lisp library calispel). application layer simply re
<rick-monster>
out of channel - easy event loop programming.
Feldman has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
<rick-monster>
thought for a while I should make the framework single-threaded. Rather than threads aggregate threadsafe channel, better to poll a group of file-descriptors in event-loop idle phase. I suspect this makes timing more deterministic when run on single-core linux.
slyrus_ has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
<rick-monster>
now, 2 questions...
<rick-monster>
1. will I run into horrible insurmountable problems with this file-descriptor-polling approach (sbcl/ccl for linux x86/ARM) when USB cable of a serial device is unexpectedly pulled?
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
<no-defun-allowed>
I think polling allows you to detect errors somehow, but I forgot how.
<rick-monster>
2. is there a good existing lisp library which will handle the file-descriptor-polling part?
<luis>
rick-monster: if you're going to serialize event handling anyway polling a group of fds seems better, but nothing beats testing. iolib seems like a good candidate for that.
<no-defun-allowed>
There's an array of file descriptors and flags you pass, and one of those flags is to poll for errors.
skapata has joined #lisp
slyrus_ has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
slyrus has quit [Ping timeout: 260 seconds]
Feldman has joined #lisp
<rick-monster>
no-defun-allowed: think I remember previously hitting a case where reading a now-unplugged USB-device file descriptor raises a signal which got mis-handled by sbcl causing a meltdown. Maybe this poll-for-errors is the trick I was missing
slyrus has joined #lisp
slyrus_ has quit [Read error: Connection reset by peer]
<no-defun-allowed>
You might also want to handle the signal then.
<luis>
rick-monster: that seems like a problem that would happen regardless of polling strategy.
dilated_dinosaur has quit [Ping timeout: 240 seconds]
<rick-monster>
luis, no-defun-allowed thanks for your input. think I need to approach the problem with a new mini-project which simply reads/writes a single serial device via iolib, but correctly detects and handles USB hotplugging
slyrus_ has joined #lisp
slyrus has quit [Ping timeout: 240 seconds]
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
skapata has quit [Remote host closed the connection]
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
dilated_dinosaur has joined #lisp
Helmholtz has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
klltkr has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus_ has joined #lisp
slyrus has joined #lisp
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
frost-lab has joined #lisp
Adamclisi has quit [Quit: Leaving]
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
Adamclisi has joined #lisp
<kevingal>
I'm trying to implement streams using macros. So I can write (scons (/ 1 0) empty-stream) and it'll expand to something like (cons (quote (/ 1 0)) nil).
Helmholtz has quit [Quit: Helmholtz]
<kevingal>
Then the head can be evaluated later.
slyrus has quit [Read error: Connection reset by peer]
<kevingal>
But of course I've found that this doesn't work when I do something like (scons (+ a b) empty-stream) because the "a" and "b" are no longer bound when I try to evaluate the head.
slyrus has joined #lisp
<kevingal>
Is there a way to capture the environment? Or is that a pants-on-head thing to do?
<Xach>
kevingal: you could expand into (lambda () ...) and funcall it to get the value.
Inline has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
<no-defun-allowed>
Yes, usually you implement lazy conses with a macro that expands to something with (lambda () <form>) wrapping the car and cdr.
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
Bike has joined #lisp
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
<kevingal>
Riiiight, that makes sense. Thank you.
cage_ has joined #lisp
slyrus_ has joined #lisp
slyrus has quit [Ping timeout: 260 seconds]
aggin has joined #lisp
<aggin>
anyone here ever tried using lquery with cl-arrows ?
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
aggin has quit [Ping timeout: 240 seconds]
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
Helmholtz has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
Helmholtz has quit [Client Quit]
Feldman has joined #lisp
slyrus_ has joined #lisp
slyrus has quit [Ping timeout: 265 seconds]
cchristiansen has quit [Remote host closed the connection]
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
aggin has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
<aggin>
hmm so I think concatenate is in LQUERY-MACROS
slyrus has joined #lisp
<phoe>
yes, looks like $ does lots of stuff under the hood and it implements its own DSL in place of stndard Lisp
<Shinmera>
Lquery treats function names specially to avoid requiring you to prefix them all with the package name.
<aggin>
guess I should use a let statement for concatenate
slyrus_ has quit [Read error: Connection reset by peer]
motersen has joined #lisp
Kundry_Wag has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
aggin has quit [Quit: WeeChat 3.1]
slyrus_ has joined #lisp
slyrus has quit [Ping timeout: 260 seconds]
ljavorsk has quit [Ping timeout: 260 seconds]
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
slyrus_ has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
frost-lab has quit [Quit: Connection closed]
slyrus_ has joined #lisp
wsinatra has joined #lisp
slyrus has quit [Ping timeout: 265 seconds]
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus_ has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
slyrus has quit [Ping timeout: 260 seconds]
slyrus has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
slyrus_ has joined #lisp
eden has quit [Remote host closed the connection]
slyrus has quit [Ping timeout: 240 seconds]
eden has joined #lisp
slyrus has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
Feldman has joined #lisp
slyrus_ has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
ikrabbe|2 is now known as ikrabbe
slyrus_ has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
VincentVega has joined #lisp
<kslt1>
I'm using emacs/SLIME/SBCL. I wanna use a testing framework for my project from the start. Are there any "survey's" of quicklisp installable testing frameworks I can take a look at?
<Shinmera>
Sabra said he'd make a survey some time, but I don't think he ever found the time to actually do it.
<phoe>
kslt1: how much do you want from your test framework?
slyrus has quit [Read error: Connection reset by peer]
slyrus_ has joined #lisp
<kslt1>
I dunno yet.
<Shinmera>
I wrote Parachute, so I'm biased towards that.
<phoe>
the absolute minimalism is using DEFUN over ASSERT
<phoe>
a step above absolute minimalism is using 1AM
<kslt1>
Was hoping to build on appetite based on the survey.
<phoe>
above that there's, in random order: fiasco, parachute, fiveam, prove, tens of other test frameworks that are more or less popular
slyrus has joined #lisp
<kslt1>
I got interesting looking at the Common Lisp Cookbook example using "prove".
cpape` has quit [Quit: ERC (IRC client for Emacs 26.3)]
slyrus_ has quit [Ping timeout: 240 seconds]
cpape has joined #lisp
<kslt1>
I'll do a little more research using above list as starting point. Thanks!
aindilis has quit [Ping timeout: 240 seconds]
slyrus has quit [Ping timeout: 240 seconds]
sp41 has joined #lisp
cpape has quit [Client Quit]
cpape has joined #lisp
APic has quit [Ping timeout: 240 seconds]
APic has joined #lisp
charles` has quit [Ping timeout: 258 seconds]
shka_ has joined #lisp
slyrus has joined #lisp
noobineer has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
slyrus has quit [Ping timeout: 260 seconds]
<MichaelRaskin>
phoe: I am pretty sure I wrote assert-based example/test sets without defun, so _absolute_ minimalism is just assert
sjl has joined #lisp
Noisytoot has joined #lisp
aindilis has joined #lisp
Feldman has joined #lisp
<kslt1>
prove docs mentioned prove becoming obsolete, which made me wonder about it.
sjl has quit [Quit: WeeChat 2.3-dev]
<phoe>
MichaelRaskin: oh right, sure
<phoe>
if you want compile-time testing then just ASSERT is enough
<phoe>
DEFUN is just to defer testing to execution time
aartaka has quit [Read error: Connection reset by peer]
<shka_>
i kinda like prove
amb007 has quit [Read error: Connection reset by peer]
<shka_>
it remains simple, but it integrates with the asdf
<shka_>
didn't tried rove yet
amb007 has joined #lisp
aartaka has joined #lisp
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<mfiano>
FInd it odd that prove was deprecated in favor of rove, when rove doesn't even have all the testing constructs prove does
<jackdaniel>
who deprecated it?
<phoe>
the author
<jackdaniel>
mhm
<mfiano>
More like obsoleted, but yeah
<jackdaniel>
I like 5am - totally not sexy but quite dependable
<mfiano>
I still use prove. I've tried other frameworks and had some bugs with false positives and never really needed anything more from prove. It does use ASDF in a deprecated way, causing warnings.
<mfiano>
But whatevs
<kevingal>
Is there a way to define self-referential lexical variables? I'm trying to define an infinite stream in terms of itself, which worked with DEFPARAMETER, but when I try to use LET or LET*, I get an unbound variable error.
<kevingal>
E.g. (defparameter ones (stream-cons 1 ones)) is the infinite stream of 1s (example from SICP).
<kevingal>
So do I understand correctly that the variable is only available for capture within the body of the LET?
<kevingal>
Sorry, that should be: (scdr (let ((wuns (scons 1 (symbol-value 'wuns)))) wuns))
<Bike>
yes, variables are only bound by let within the body of the let.
<Bike>
also, symbol-value is about dynamic variables, not lexical variables, so it's probably not relevant to your question.
long4mud has joined #lisp
Feldman has joined #lisp
<Bike>
sicp is using LETREC for this, not LET, right?
<kevingal>
So far it has only used DEFINE.
chipolux has quit [Quit: chipolux]
<Bike>
oh, well, okay.
<Bike>
top level definitions can be recursive, obviously. for recursive local definitions you can't use LET since it doesn't make the bindings available to the value-forms.
<Bike>
LETREC does, but it doesn't exist in the common lisp standard. instead you have to use labels, which is similar, but only allows binding functions.
<kevingal>
Gotcha, that's very helpful, thanks.
<kevingal>
I think for now I'll just steal your version of LETREC, haha.
<Bike>
keep in mind i wrote it in two minutes and didn't test it, so it may bite
<Bike>
also it can be much more simply written with mutation
<Bike>
i didn't write it that way because i forgot
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Nilby>
letrec etc is not needed for this, cons-stream is just a macro. you just have to make delay/force which could most simply be quote/eval or quote/symbol-value.
Inline has quit [Ping timeout: 260 seconds]
<pjb>
kevingal: the problem is that you wrote stream-cons wrong.
Aurora_iz_kosmos has joined #lisp
<Bike>
eval would be even worse than my overcomplicated letrec macro.
Aurora_v_kosmose has quit [Disconnected by services]
Aurora_iz_kosmos is now known as Aurora_v_kosmose
mindCrime_ has joined #lisp
rogersm has joined #lisp
<kevingal>
Howso? My stream-cons / scons macro expands to a cons with both of the elements wrapped in a lambda.
<Bike>
well, the relevant way eval won't help is that it cannot access lexical variables.
<kevingal>
I initially tried using quote, but that didn't capture surrounding variables so this gave an error: (let ((a 1) (b 2)) (scons (/ a b) the-empty-stream).
<Bike>
right.
<kevingal>
(I was pestering people in the channel about this earlier).
zaquest has quit [Read error: Connection reset by peer]
zaquest has joined #lisp
rogersm has quit [Ping timeout: 240 seconds]
<pjb>
kevingal: but yes, there's no let form in CL that evaluate the initialization form in a scope where the variable is defined. We'd have to write a letrec macro…
huonib has joined #lisp
hoz has joined #lisp
<huonib>
does anyone know how to create a static binary with ecl?
<huonib>
I posted on #ecl too
ech has joined #lisp
<shka_>
how can I get the current condition in the restart-case?
<shka_>
uhm, i think that this is wrong question
Feldman has joined #lisp
<Bike>
it would have to be passed to the restart.
<shka_>
kevingal: you can fake it with labels, as already demonstrated
<shka_>
Bike: yeah, i realized that
karlosz has joined #lisp
ljavorsk has quit [Ping timeout: 268 seconds]
luna_is_here has quit [Ping timeout: 246 seconds]
luna_is_here has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<pjb>
shka_: (loop for i below 10 do (with-simple-restart (continue "continue") (if (zerop (random 2)) (invoke-restart 'continue)) (princ i))) #| 25679 --> nil |#
<pjb>
shka_: no condition.
_whitelogger has joined #lisp
thmprover has joined #lisp
emacsomancer has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
emacsomancer has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
cosimone has quit [Remote host closed the connection]
kpoeck has joined #lisp
eden has quit [Quit: Leaving]
rogersm has joined #lisp
emacsomancer has quit [Ping timeout: 240 seconds]
huonib has quit [Read error: Connection reset by peer]
<shka_>
uh, it is solved
rogersm has quit [Ping timeout: 240 seconds]
emacsomancer has joined #lisp
cosimone has joined #lisp
luna_is_here has quit [Ping timeout: 240 seconds]
luna_is_here has joined #lisp
jonatack has quit [Quit: jonatack]
Inline has joined #lisp
curtosis[away] has joined #lisp
wilfredh has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
ikrabbe has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
galex-713 has quit [Ping timeout: 260 seconds]
Lycurgus has joined #lisp
galex-713 has joined #lisp
kpoeck has quit [Ping timeout: 240 seconds]
luna_is_here has quit [Read error: Connection reset by peer]
Feldman has joined #lisp
luna_is_here has joined #lisp
jonatack has joined #lisp
rogersm has joined #lisp
cosimone has quit [Remote host closed the connection]
ljavorsk has joined #lisp
rogersm has quit [Ping timeout: 240 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
skapata has joined #lisp
luna_is_here has quit [Ping timeout: 265 seconds]
aartaka_d has quit [Ping timeout: 240 seconds]
luna_is_here has joined #lisp
ech has quit [Ping timeout: 240 seconds]
aartaka has joined #lisp
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
logand``` has quit [Ping timeout: 268 seconds]
drl has joined #lisp
thinkpad has quit [Ping timeout: 252 seconds]
cage_ has quit [Quit: Leaving]
rogersm has joined #lisp
thinkpad has joined #lisp
luna_is_here has quit [Read error: Connection reset by peer]
logand has joined #lisp
luna_is_here has joined #lisp
anticrisis has joined #lisp
scm_ has joined #lisp
luna_is_here has quit [Read error: Connection reset by peer]
luna_is_here has joined #lisp
cosimone has joined #lisp
villanella has joined #lisp
ech has joined #lisp
luna_is_here has quit [Ping timeout: 260 seconds]
rpg has joined #lisp
curtosis[away] has joined #lisp
luna_is_here has joined #lisp
villanella has quit [Ping timeout: 258 seconds]
villanella has joined #lisp
hoz has quit [Quit: ERC (IRC client for Emacs 26.1)]
ikrabbe has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
albusp has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Lycurgus has quit [Quit: Exeunt]
rogersm has quit []
cosimone has quit [Remote host closed the connection]
mindCrime_ has quit [Ping timeout: 240 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 26.1]
CrazyEddy has joined #lisp
charles` has joined #lisp
luna_is_here has quit [Ping timeout: 246 seconds]
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
luna_is_here has joined #lisp
rogersm has joined #lisp
rogersm has quit [Client Quit]
ech has quit [Quit: leaving]
ech has joined #lisp
luna_is_here has quit [Read error: Connection reset by peer]
luna_is_here has joined #lisp
thecoffemaker has quit [Ping timeout: 240 seconds]
wilfredh has quit [Quit: Connection closed for inactivity]
huonib has joined #lisp
thecoffemaker has joined #lisp
gaqwas has quit [Remote host closed the connection]
gaqwas has joined #lisp
gaqwas has joined #lisp
wsinatra has quit [Ping timeout: 268 seconds]
quazimodo has quit [Ping timeout: 268 seconds]
luna_is_here has quit [Ping timeout: 246 seconds]
luna_is_here has joined #lisp
gaqwas has quit [Ping timeout: 240 seconds]
VincentVega has joined #lisp
karlosz has quit [Quit: karlosz]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
wsinatra has joined #lisp
ech has quit [Ping timeout: 240 seconds]
ech has joined #lisp
shka_ has quit [Ping timeout: 246 seconds]
wsinatra has quit [Ping timeout: 240 seconds]
scm_ has quit [Ping timeout: 240 seconds]
ebrasca has quit [Remote host closed the connection]
mn3m has joined #lisp
<jmercouris>
there is no way to safely call C right? because CFFI relies on the C code returning successfully right?
lawt has joined #lisp
<jmercouris>
and when it doesn't, there is no realistic way to recover state, no?
<White_Flame>
maybe launch a C thread and wait for its return as a side effect somewhere, with a timeout that blows away the thread?
<White_Flame>
but still, can't easily prevent C from trampling things
<jmercouris>
right
<jmercouris>
C can write anything to anywhere and always mess up your program
<moon-child>
iirc that's what go and haskell do
<White_Flame>
would need full long hardware transactional memory
<jmercouris>
unless you use some operating level system protection right?
<jmercouris>
maybe a completely different process or something
<White_Flame>
process would definitely work, but taht also means marshalling everything
<White_Flame>
you could fork to make the call, too
<moon-child>
still have to marshal the result
<White_Flame>
right, elminates half the marshallings
<moon-child>
if the c lib allocates, you need some way to figure out what it allocated and copy it through
luna_is_here has quit [Ping timeout: 246 seconds]
<jmercouris>
right, which involves complex wrapping
aartaka has quit [Ping timeout: 246 seconds]
<moon-child>
or force it to allocate shmem, which comes with its own issues
<White_Flame>
all depends if the C return value is standalone, or if you need C's side effects
<jmercouris>
and I was thinking if the C code could crash the Lisp machine
<White_Flame>
even in a separate process, C could kill the lisp process, unless you make it under another user with low permissions etc
<White_Flame>
how far do you want to go?
<White_Flame>
C could use privilege escalation attacks as well etc
<jmercouris>
fair enough
<jmercouris>
I am just thinking about GTK inadvertent failures
<jmercouris>
something like that
luna_is_here has joined #lisp
<jmercouris>
I must say the Open Genera system looks very impressive
<jmercouris>
I understand I'm preaching to the choir here...
<Nilby>
You can safely call C.
<Nilby>
It's just difficult. You have to setup up memory barriers, page tables, processor rings, interrupt tables, etc.
<Nilby>
e.g. the O/S kernel safely calls C
<jmercouris>
right, but the O/S is designed for that
<jmercouris>
and it takes a lot of work
villanella has quit [Ping timeout: 260 seconds]
<jmercouris>
I'm talking about within the realm of realistically possible for a single programmer to achieve
<Nilby>
But the coolest way it to run C as Lisp like Genera did.
<moon-child>
plenty of people have written their own OSes
<moon-child>
Nilby: that's what mezzano does. (Well, it compiles llvm to cl, i think)
<Nilby>
Right. I think that's the nicest way for Lisp to call C, since then you can use the Lisp debugger and tools.
<Nilby>
I think the free Lisps could do a better job of making calling C safe. The commerical Lisps seem to do better.
Alfr has quit [Quit: Leaving]
<moon-child>
I think there was another c compiler written in lisp. Not sure how much progress it had made. The mezzano thing I know was mature enough to run quake
wooden has quit [Ping timeout: 260 seconds]
luna_is_here has quit [Read error: Connection reset by peer]