abhixec has quit [Read error: Connection reset by peer]
sloanr` has quit [Ping timeout: 256 seconds]
vaporatorius has joined #lisp
Colleen has joined #lisp
vaporatorius__ has quit [Ping timeout: 264 seconds]
renzhi has joined #lisp
abhixec has joined #lisp
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
Oladon has quit [Quit: Leaving.]
<fiddlerwoaroof>
I tend to think of DI more as "passing arguments to functions" than "dynamic variables"
<fiddlerwoaroof>
Spring's XML stuff or Guice might be more like dynamic variables, but those are both abominations
<fiddlerwoaroof>
One way to do DI in lisp is "defun over lambda" (defun (dep1 dep2) (lambda (&rest other-args) ...))
<fiddlerwoaroof>
... (defun foo ...)
<fiddlerwoaroof>
scymtym: that video is cool; my only objection is there's no code for me to try out...
sloanr``` has joined #lisp
<scymtym>
fiddlerwoaroof: i can try to publish an initial version tomorrow. i just didn't want to put too much effort into a thing that i wouldn't use myself
<fiddlerwoaroof>
scymtym: yeah, makes sense, I have a "lisp-sandbox" repository on github for this sort of demo
<scymtym>
i will probably just push one eclector branch and one linedit branch
igemnace has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
<scymtym>
the highlighter is currently an eclector example that got a bit out of hand
sloanr`` has quit [Ping timeout: 272 seconds]
<fiddlerwoaroof>
One thing that would be useful with eclector is a more intelligent way to diff CL code
dbotton has joined #lisp
<fiddlerwoaroof>
git supports custom diff tools, and a syntax-aware diff for CL would be really helpful
<scymtym>
i believe pfdietz and colleagues have done that
rgherdt has joined #lisp
shwouchk has joined #lisp
<fiddlerwoaroof>
Interesting, I've looked for this every couple months and never run across an implementation that would work.
andreyorst has quit [Quit: WeeChat 3.0]
igemnace has quit [Remote host closed the connection]
Colleen has quit [Remote host closed the connection]
miasuji has joined #lisp
igemnace has joined #lisp
skapata has quit [Ping timeout: 264 seconds]
Jeanne-Kamikaze has joined #lisp
luckless has quit [Quit: luckless]
luckless has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
Colleen has joined #lisp
skapata has joined #lisp
dbotton has joined #lisp
rgherdt has quit [Ping timeout: 260 seconds]
Colleen has quit [Quit: Colleen]
<mfiano>
Xach: did you see my message from yesterday?
wxie has joined #lisp
<Xach>
mfiano: i'm not sure
<mfiano>
Xach: I was asking about your reecent octree usage.
<Xach>
mfiano: i did not see it
<Xach>
What would you like to know?
<mfiano>
I wanted to know if you used an existing library, or wrote an implementation yourself. I've spent the last 3 days writing a high performance octree for gamedev stuff, but there are a lot of corner cases my algorithm books don't cover, and invariants aren't holding :(
<Xach>
mfiano: ah. i wrote an implementation myself. i put the code on github. it is simplistic. i linked to the reference i followed (original was in javascript). i use it only for quantizing so its suitability for other uses might not be great.
<fiddlerwoaroof>
phoe: I like using keywords for package and systemn names, so I get autocomplete for ql:quickload and in-package :)
<fiddlerwoaroof>
I probably should figure out how to make slime-company special-case these forms
<phoe>
fiddlerwoaroof: hmmm, I understand the idea
abhixec has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
kaftejiman has quit [Ping timeout: 246 seconds]
<fiddlerwoaroof>
Are there any libraries for mutation testing?
asarch has quit [Remote host closed the connection]
ralt has quit [Quit: Connection closed for inactivity]
<fiddlerwoaroof>
I have a library I'm working on where there are several "obvious" ways to generate new test cases from a passing test, and I'd like to generate three or four random assertions for each assertion I write
<mfiano>
proptesting?
<fiddlerwoaroof>
Not exactly
renzhi has quit [Ping timeout: 268 seconds]
<fiddlerwoaroof>
Basically, if I have an assertion (is (= a (func b))), automatically rewriting it to an equivalent one like (is (= a (func2 (inv-func2 (func b)))))
<fiddlerwoaroof>
And rerunning the assertion
<fiddlerwoaroof>
(where func2 and inv-func2 are a function and its inverse)
random-nick has quit [Ping timeout: 272 seconds]
Alfr_ has quit [Remote host closed the connection]
Alfr has joined #lisp
hsaziz has joined #lisp
hsaziz has quit [Client Quit]
hsaziz has joined #lisp
charles` has joined #lisp
abhixec has quit [Quit: brb restarting]
shifty has quit [Ping timeout: 264 seconds]
notzmv has quit [Remote host closed the connection]
abhixec has joined #lisp
fixing_auth_hold has quit [Quit: Leaving]
<thmprover>
Uh, nconc is viewed as...bad form, right? In the sense that there's a better, more idiomatic way to do the same thing, correct?
<aeth>
depends
<aeth>
if it's nconc on something you've created locally without any literals (so no quote/quasiquote) then it's fine, but it's a microoptimization that might not make a difference
<thmprover>
Gotchya.
<aeth>
this is fine... (nconc (list 1 2 3) (list 4 5 6))
<aeth>
this needs to be append... (append '(1 2 3) '(4 5 6))
<aeth>
And if your list function could be used as a helper function in a macro, it has to be append, because source s-expressions are like the latter
<aeth>
at least, afaik. Your style guide may differ
akoana has joined #lisp
<aeth>
thmprover: you might also want to consider this variant, because it's more even generic... (concatenate 'list '(1 2 3) '(4 5 6))
<thmprover>
Hmm...that might work better, for what I'm doing.
<aeth>
that last one could take a vector or a string or (afaik) even a user-defined sequence if the implementation has extensible sequences.
semz has quit [Ping timeout: 258 seconds]
<thmprover>
That's a great point, I'm almost certainly going to be working with user-defined sequences. Thanks :)
notzmv has joined #lisp
surabax has quit [Quit: Leaving]
rumbler31_ has quit [Ping timeout: 265 seconds]
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
abhixec has quit [Remote host closed the connection]
<fiddlerwoaroof>
Sometimes you can re-think your algorithms to avoid appending
Stanley00 has joined #lisp
<fiddlerwoaroof>
e.g. passing an adjustable vector around and vector-push-extending the new lists onto the vector
<fiddlerwoaroof>
And then just writing a version of map that takes such a vector and processes each list in the vector successively.
sgibber2018 has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
notzmv has quit [Read error: No route to host]
notzmv has joined #lisp
miasuji has quit [Remote host closed the connection]
miasuji has joined #lisp
Stanley|00 has joined #lisp
Stanley|00 has quit [Read error: Connection reset by peer]
Stanley00 has quit [Ping timeout: 264 seconds]
Stanley|00 has joined #lisp
ebrasca has quit [Remote host closed the connection]
<loke[m]>
Hello
hiroaki has joined #lisp
<no-defun-allowed>
Hello loke.
<loke[m]>
no-defun-allowed I thought you were in the US?
<no-defun-allowed>
Nope.
Stanley|00 has quit [Read error: Connection reset by peer]
Stanley00 has joined #lisp
<loke[m]>
AU?
<no-defun-allowed>
Yes, Australia.
abhixec has joined #lisp
shwouchk has quit [Quit: Connection closed for inactivity]
dbotton has joined #lisp
dbotton has quit [Client Quit]
abhixec has quit [Read error: Connection reset by peer]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
miasuji has quit [Remote host closed the connection]
miasuji has joined #lisp
abhixec has joined #lisp
Alfr_ has joined #lisp
<beach>
Good morning everyone!
Alfr has quit [Ping timeout: 258 seconds]
Stanley|00 has joined #lisp
Stanley00 has quit [Disconnected by services]
Jeanne-Kamikaze has quit [Remote host closed the connection]
<fiddlerwoaroof>
hi beach
mindCrime has quit [Ping timeout: 258 seconds]
Jesin has quit [Read error: Connection reset by peer]
Jesin has joined #lisp
sgibber2018 has quit [Ping timeout: 256 seconds]
Posterdati has quit [Ping timeout: 256 seconds]
thmprover has quit [Quit: ...and miles to go before I sleep.]
Bike has quit [Quit: Lost terminal]
kagevf has quit [Ping timeout: 272 seconds]
mrios22 has quit [Ping timeout: 265 seconds]
aeth has quit [Ping timeout: 246 seconds]
sloanr``` has quit [Read error: Connection reset by peer]
aeth has joined #lisp
kagevf has joined #lisp
Posterdati has joined #lisp
Alfr_ has quit [Ping timeout: 258 seconds]
wxie has quit [Ping timeout: 272 seconds]
wxie has joined #lisp
shka_ has joined #lisp
<charles`>
Why do default arguments for macros get evaluated?
<beach>
Er, what?
karlosz has quit [Quit: karlosz]
<beach>
charles`: No macro arguments are evaluated.
<beach>
charles`: The entire macro form turn into a single argument of the macro function.
<charles`>
(defmacro test (&optional (a (+ 3 4)))
<charles`>
,a)
<charles`>
(macroexpand '(test))
<no-defun-allowed>
If you put the arguments into the form produced, they get evaluated again after macro-expansion _as per usual_. eg with (defmacro foo (&optional (x 'x)) `(1+ x)), (foo) will expand to (1+ x), which will eventually evaluate X.
<no-defun-allowed>
Yes, evaluating the default values in lambda lists is also normal. But you couldn't write ,a as there is no backquote (just a will suffice).
andreyorst has joined #lisp
<charles`>
it is supposed to be `,a
<no-defun-allowed>
If you want to bind A to (+ 3 4) to put (+ 3 4) in the expansion, then quote it.
<no-defun-allowed>
`,a ≡ a
<charles`>
So I can't have unevaluated default arguments?
<no-defun-allowed>
You quote them, eg (defmacro test (&optional (a '(+ 3 4))) a)
<charles`>
I see, that is most unexpected
<no-defun-allowed>
I'm not sure how it's out of the ordinary, admittedly.
<charles`>
It makes sense if you call it a lambda list, but it if you call it the parameter list for a macro it is confusing. Someone would see that the default argument is quoted and might think that their argument should be quoted as well
<no-defun-allowed>
Lambda lists are lambda lists*, regardless of if I have a lambda list in DEFUN, DEFMACRO, DESTRUCTURING-BIND, MULTIPLE-VALUE-BIND, and so on.
<no-defun-allowed>
*Except that macros have extended lambda lists, with &environment and &whole from memory.
shifty has joined #lisp
<charles`>
It certainly makes sense when put that way
xsperry has quit [Remote host closed the connection]
xsperry has joined #lisp
shifty has quit [Ping timeout: 256 seconds]
shifty has joined #lisp
ldbeth has joined #lisp
<ldbeth>
good aftrenoon
<no-defun-allowed>
Hello ldbeth.
a0 has joined #lisp
<ldbeth>
are there any projects implement aggressive optimizer/inliner/partial evaluator for a subset of CL?
<no-defun-allowed>
How aggressive is agressive? Most compilers will do some partial evaluation.
<beach>
Doing that kind of stuff in an implementation-independent way would imply source-to-source transformations, and that then becomes a mess when it comes to debugging, because source information would be in terms of the transformed code.
<ldbeth>
say given a (fib 45) it can unfold it to constant fixnum
<beach>
Stuff like that is undecidable in the general case.
<no-defun-allowed>
How long would you wait for (A 3 4), where A is the Ackermann function?
<beach>
ldbeth: Imagine that, instead of (fib 45) you said (ackermann 5 10)
<beach>
Heh.
<beach>
ldbeth: A large part of the art of partial evaluation has to do with choosing a decidable approximation of an otherwise undecidable domain.
miasuji has quit [Ping timeout: 260 seconds]
<ldbeth>
Is it pratically feasible if unfolding aborts when the result exceeds biggest fixnum?
<beach>
Not good enough.
<mfiano>
How can you say the result scales linearly in a general case?
<beach>
Do the math. How long does it take for a modern processor to execute most-positive-fixnum iterations.
<beach>
Even if it scales linearly, that's not good enough.
vidak` has quit [Read error: Connection reset by peer]
vidak` has joined #lisp
<ldbeth>
It starts get me interested because GCC Emacs does better than CL on some trival benchmarks
andreyorst_ has joined #lisp
<beach>
Trivial benchmarks usually don't provide any useful information.
<ldbeth>
GCC Elisp takes to run 0.00 fibn from elisp-benchmarks, and from the article it implies the fibn function get unfolded to a constant
<mfiano>
The speedups you see here should only be taken as very roughly indicative of the speedup you may see in real code. When in doubt, benchmark your particular domain on the hardware you intend to run it on.
<ldbeth>
I do realize that trivial benchmarks usually does not reflect pratical performance
<beach>
ldbeth: Also, no sane person would write a call to FIB with a constant value in production code. It would be a read-time evaluation.
Aurora_v_kosmose has quit [Quit: Пока, мир.]
<ldbeth>
sure, in CL we can manually #.
<beach>
The only way I can see that result is if FIB is treated specially.
<beach>
If not, you should try it with the Ackermann function.
frost-lab has joined #lisp
<fiddlerwoaroof>
ACL2 proves theorems in a total subset of CL, right?
<ldbeth>
fiddlerwoaroof: yes
<ldbeth>
but it can hardly be used to optimize "real" CL code
<fiddlerwoaroof>
Well, no one has tried yet :)
<fiddlerwoaroof>
There are other total languages that are trying to be useful: the Dhall expression language and Idris, for two
<aeth>
Write an optimizing compiler that detects when benchmark authors are trying to bench a naively-written Fibonacci number calculation and replace it at compile time with the explicit formula to get the Fibonacci number...
<ldbeth>
ACL2 mainly aims to hardware verification people, they have very different need from a "pratical" programming language
<fiddlerwoaroof>
I'm not dying that, I'm just saying it's an existence proof of what you asked for
<fiddlerwoaroof>
s/dying/denying/
a0 has quit [Ping timeout: 240 seconds]
<fiddlerwoaroof>
The subset of CL that ACL2 can prove theorems about can be aggressively partialy evaluated
pfdietz has quit [Ping timeout: 245 seconds]
<ldbeth>
however GCC Emacs optimize the fib function written with setf as well as using tail recursion
<ldbeth>
an applicative subset is not comparable
<fiddlerwoaroof>
Does gccemacs implement a tracing JIT?
<ldbeth>
no, it precompiles ELisp files
akoana has quit [Quit: leaving]
<ldbeth>
"Despite what the name suggest libgccjit is usable not just for making jitters but for any other kind of compiler."
waleee-cl has quit [Quit: Connection closed for inactivity]
Aurora_v_kosmose has joined #lisp
Jesin has quit [Read error: Connection reset by peer]
galex-713 has quit [Ping timeout: 264 seconds]
narimiran has joined #lisp
ldbeth has quit [Ping timeout: 246 seconds]
quazimodo has joined #lisp
[d] has quit [Remote host closed the connection]
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
wxie has quit [Remote host closed the connection]
ldbeth has joined #lisp
wxie has joined #lisp
ralt has joined #lisp
imode has quit [Ping timeout: 240 seconds]
birdwing has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
Colleen has joined #lisp
ldbeth has quit [Read error: Connection reset by peer]
ldbeth has joined #lisp
ldbeth has left #lisp [#lisp]
oni-on-ion has quit [Remote host closed the connection]
skapata has quit [Remote host closed the connection]
Cymew has joined #lisp
orivej has joined #lisp
jprajzne has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
ym has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
rogersm has joined #lisp
rgherdt has joined #lisp
rogersm has quit [Quit: Leaving...]
andreyorst has quit [Quit: WeeChat 3.0]
andreyorst_ is now known as andreyorst
frodef` has joined #lisp
ex_nihilo has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<frodef`>
beach: thanks for the link.
<beach>
Sure. Enjoy! :)
<beach>
We extracted the code to a library: Clostrum.
<frodef`>
beach: btw, is the general approach SICL to conceptually live "inside" or "outside" the parameters of CL?
<beach>
I am not sure I know what that means.
<frodef`>
beach: not sure how to describe it better... :)
<beach>
Example?
<frodef`>
do you thing of the CL environment as a "subsystem", or is the CL environment the "end goal"...
<no-defun-allowed>
To do things outside the scope of of Common Lisp? Well, sure, there's threads, atomics, weak values, networking, so on and so forth, which weren't always de-facto standard. So everyone lives outside Common Lisp.
<no-defun-allowed>
Oh, never mind.
<frodef`>
(sorry again for such a imprecise question, I'v obviously not thought it very well through.)
<beach>
frodef`: The goal is CLOSOS, if that answers the question.
<beach>
So yes, all the goodies that no-defun-allowed mentioned are needed.
<frodef`>
sure, like every CL implementation.
<beach>
I take it that doesn't answer your question, then. :(
<no-defun-allowed>
Having a good CL environment with as much stuff as possible would be the end goal to me.
<beach>
frodef`: I do want a conforming and strict Common Lisp implementation, but there is plenty of other functionality needed. And I also want to explore all the ways the standard allows in order to simplify the code.
<no-defun-allowed>
Or do you mean that the Lisp environment is a subsystem of a larger programming system, with an external editor, a profiler, a version control system, and other tools?
<beach>
Oh, that one! Yes, definitely a CLIM-based IDE is what I am aiming for.
MichaelRaskin has joined #lisp
<frodef`>
how about a system that is "good" (i.e. "great!") and also just reasonably compatible with CL programs?
<frodef`>
no-defun-allowed: something like that I guess.
<no-defun-allowed>
I want to work on putting "modern" stuff like high performance IO and concurrent programming tools in Common Lisp, but in a way that doesn't completely mess up my programming style, and if I have to hack an implementation to get it to work, it will most likely be SICL when it's ready for that.
<no-defun-allowed>
I don't see SICL breaking compatibility in Common Lisp any time soon?
<beach>
frodef`: That is certainly an option, but I don't want that to be the only thing. I do want to create a good Common Lisp system for people who are currently Common Lisp programmers.
<beach>
frodef`: The problem is mainly that I am not smart enough to change the language. I just don't have the experience that the good people who wrote the standard did, even back then.
<beach>
no-defun-allowed: Exactly!
<no-defun-allowed>
The way I see it, making breaking changes not only leaves you with the pieces if something goes wrong, it leaves you with everything else which is now broken if everything goes right.
<beach>
frodef`: The first-class global environments is such a thing that it is transparent to conforming Common Lisp programs, but it gives a whole new tool if the programmer wants to go beyond the standard.
<beach>
no-defun-allowed: Very philosophical. :)
<frodef`>
beach: yup, seems a good idea.
<beach>
I am still not sure whether your question was answered, but I hope you have some more hints. What was the reason for your question?
<no-defun-allowed>
Although hardly related, I have this opinion after a discussion with my favourite co-author about "Why Turtl Switched From CL to JavaScript" <https://lisp-journey.gitlab.io/blog/why-turtl-switched-from-lisp-to-js/>, in which the author was mainly stuffed, because they began writing asynchronous code, and had to either patch in, or completely rewrite, all this synchronous stuff that already existed.
<frodef`>
beach: sure thanks, sorry again for being wishy-washy.
<beach>
No problem. But what was the reason? :)
<frodef`>
I do think CL have some warts and shortcomings. Warts like e.g. the sequence functions that I sometimes see as both awkward to use and incurs extra O(N) performance hits.
<frodef`>
beach: reason being general interest and trying to understand the SICL project, combined with my own related experience I guess.
<beach>
frodef`: Yes, I have seen hints about your opinions lately.
<beach>
frodef`: The reason for the SICL project is that I wanted to improve on implementations, but not the language (for which I am not smart enough), but the improvements I could see would be unacceptable to maintainers of existing implementations.
madage has quit [Ping timeout: 240 seconds]
luckless has quit [Ping timeout: 240 seconds]
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
<beach>
frodef`: In particular, I want to improve on development and debugging tools. I am always amazed when I see how some people here think Emacs+SLIME represent the best development environment around, no matter the language.
<frodef`>
beach: right.
<beach>
I mean, calling the "SLIME debugger" a "debugger" is a joke.
<beach>
... as my paper on debugging explains.
<frodef`>
beach: that brings me to antoher of my pet peevs, the lack of a recursive debugger/repl in SLIME.
<frodef`>
s/peeves
<frodef`>
...isn't it?
<phoe>
recursive? what do you mean?
<phoe>
you can nest debuggers
<phoe>
and you can interact with the REPL while the debugger is open
<frodef`>
phoe: have you used ELI?
luckless has joined #lisp
<phoe>
frodef`: nope. what is it like?
<beach>
frodef`: I don't consider "staring at a backtrace when things go wrong" a "debugger". I want to be able to set breakpoints without recompiling the code, and I want to be able to step from a breakpoint.
<frodef`>
beach: yes, that too.
Aurora_v_kosmose has joined #lisp
<frodef`>
phoe: what I think is essential, is basically to be able to do this: ...
<beach>
And, if I run ASDF from the SLIME REPL, I get no presentations to click on, and I get compiler messages as text that I then have to manually match to the source code.
<mfiano>
Sly stickers, and breaking stickers, are a vast improvement over the SLIME debugging experience, and print traditional "print debugging".
<phoe>
frodef`: oh, a new one, as opposed to reusing the old one?
<phoe>
because in slime, the old REPL then ends up in that new dynamic context
<phoe>
until you leave the debugger, that is
shifty has quit [Ping timeout: 240 seconds]
<beach>
mfiano: If the underlying Common Lisp implementations can't set breakpoints, I think there are limits to the possible improvements.
<beach>
mfiano: But I haven't used Sly, so I don't know how much better it is.
<frodef`>
phoe: well, maybe slime even works the way it should, but the "debugger" buffer gives me a very strong impetus to "get out of here!" immediately.
<mfiano>
Indeed. You don't have to tell me. I have seen your talks. I'm just saying there are better alternatives/companions to the "SLIME Debugger"
shifty has joined #lisp
<beach>
mfiano: I also seem to recall some people here mentioning features that are missing in Sly that I often use.
<beach>
mfiano: Ah, OK.
<frodef`>
phoe: maybe I should investigate slime more carefully.. :)
<phoe>
frodef`: I see and understand; still, the REPL buffer is still working even with the debugger open
<phoe>
you can minimize the buffer or keep it elsewhere while you REPL your way out of the error
<mfiano>
beach: Which features that you often use?
<phoe>
and only then hit some restart in the debugger window, or manually INVOKE-RESTART in the REPL to make it disappear
<fiddlerwoaroof>
frodef`: as far as the O(n) issues with sequence functions, most of those are solvable
<beach>
mfiano: I can't remember what it was. I just saw someone mention it as lacking is Sly, and I recognized that I used it.
<beach>
frodef`: So, I suggest that, instead of trying to improve the language, you use your experience and knowledge to help create a better development environment.
<fiddlerwoaroof>
The SERIES package is one example of a solution
<mfiano>
The only thing I can recall off hand that is lacking in Sly over SLIME, is a contrib for SBCL's statistical profiler.
<beach>
That doesn't ring a bell.
<frodef`>
beach: sure, trying to get up to speed again :)
<beach>
mfiano: Maybe I should just try Sly and let you know when I wanted something that is missing.
<phoe>
frodef`: there's an upcoming video where I show the basics of this thing off
<beach>
frodef`: Great!
<fiddlerwoaroof>
mfiano: is there slime-media in SLY?
<phoe>
it'll be available tomorrow evening and I'll post it on Reddit once it's made available
<mfiano>
Sly is forked off of SLIME with nothing really removed, just features added and bugs fixed that weren't in the interest of SLIME. Of course, there are probably some exceptions to this, which I cannot recall off hand.
<frodef`>
phoe: nice! "upcoming" as in "there's already a series of videos on related stuff"?
<phoe>
presentations
<phoe>
frodef`: yes
galex-713 has joined #lisp
<mfiano>
In Sly, everything is a button and can be clicked on to inspect/further manipulate.
madage has joined #lisp
<mfiano>
So no, no presentations. We have more useful buttons.
<phoe>
someone asked me for an interview about the Common Lisp condition system and it turned out to be an interview about Common Lisp in general
<beach>
Oh, nice! Who is "someone"?
<phoe>
and the video will go public tomorrow, showing off my majestic technical screensharing setup too
<phoe>
beach: you'll see
<phoe>
:D
<beach>
Heh, OK.
<mfiano>
One nice feature of Sly, is a function which can be used to send arbitrary data to the REPL from CL. I use this in a game engine to be able to cast a ray through 3-space where the mouse cursor is, and return a CLOS instance of the first object intersecting that raycast, so "mouse picking" in a projected 3-dimensional space.
liberliver has joined #lisp
<mfiano>
But Stickers, as I've mentioned, is one of it's main selling points for me.
hendursa1 has joined #lisp
<frodef`>
phoe: is there a link to said video series?
<flip214>
mfiano: is that a kind of dev env like Unity?
<mfiano>
I have a game engine I've been working on for years, that takes a lot of inspiration from Unity (and fixes a lot of its mistakes [and admittedly creates more still])
<phoe>
oh bother, the video is already there :O
hendursaga has quit [Ping timeout: 240 seconds]
<phoe>
even though it's unlisted!
<frodef`>
phoe: thanks!
* phoe
just broke the veil of silence
<frodef`>
phoe: why the veil/unlisting?
<flip214>
mfiano: I'd love to have something unity-like (but not too like it ;) in CL... that could enable quite a lot of quick game ideas
<frodef`>
phoe: oh.. the /series/ wasn't unlisted, I guess.
<phoe>
frodef`: it's scheduled for a minor premiere tomorrow.
<phoe>
yes, the playlist is public
<phoe>
and a public playlist can contain links to unlisted videos.
<frodef`>
phoe: right. thanks again.
a0 has joined #lisp
* phoe
notifies the playlist owner and waits for the scolding
<mfiano>
Sadly my game engine is not documented yet, and aimed at professional-quality games, not quick prototypical projects. Its focus is on interactivity, thus removing the need for an "editor". For example, there is a rather complex DEFINE-PREFAB macro that can be used to describe arbitrary sub-trees that can be instantiated or spliced into other sub-trees to be instantiated with them. C-c C-c'ing any of
hsaziz has quit [Ping timeout: 265 seconds]
<mfiano>
these as a game is running is an easy way to redefine large portions of the game. There is a DEFINE-* form for everything actually, including individual GLSL shader functions.
<flip214>
sounds cool!
<frodef`>
phoe video: "... why don't everybody do this if it has been known for a long time?", indeed.
<no-defun-allowed>
They're functional programmers, so they should know the answer.
<no-defun-allowed>
And, of course, they know the answer is because no one wrote a paper detailing the denotational semantics and underpinning by the lambda calculus or something like that.
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
<no-defun-allowed>
(But actually, someone told me that without the presence of state, having the dynamic environment doesn't matter. Also, aren't they supposed to not have bugs or something? I'll stop now.)
<flip214>
mfiano: is it open source, per chance?
<mfiano>
flip214: The problem is it's a lot of work, as evidenced by working at it for about a decade now, and while it can be used to make games currently, it is still far from ready. The sad part is, even with a complete game engine that is general-purpose enough for the kind of game you want to make, game development is an even longer process. Just the playtest-tweak feedback loop could take a year or
<mfiano>
longer, and that's after all the game logic, assets, have allocated a lot of time. I wouldn't advice anyone to make an engine if that are looking to make a game, heh.
<mfiano>
Yes it is, but I wouldn't recommend using it yet, not that it'd make much sense, being such a large codebase and without documentation yet.
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
<frodef`>
no-defun-allowed: the idea that a software system should not be designed on the assumption that there are no bugs, seems to be lost.
Alfr has joined #lisp
Alfr has quit [Client Quit]
<mfiano>
It's quite a large project, and has been refactored several times, and I still wouldn't call it the nicest code I've written. Just the math support library is 15hloc and growing, which is quite a lot for Lisp.
Alfr has joined #lisp
<mfiano>
15kloc*
<flip214>
mfiano: well, make it a well-known project and hope for volunteers to help clean it up?!
shifty has quit [Ping timeout: 272 seconds]
<mfiano>
My goal right now is to add some of the missing features that are absolutely needed, so that I can finalize its API and begin documenting it. Only then can I advertise or recommend its use
shifty has joined #lisp
<mfiano>
I was prepared to give a talk on phoe's stream soon, but I decided against that, as I really want to stabilize it first (sorry phoe).
<phoe>
no problem, quality before quantity
<mfiano>
I might consider giving a theory talk on why I think CL is the best language for gamedev, but as far as demonstrating my project(s), I don't think that is a good idea.
<frodef`>
Is there really no way to add your own slime shortcuts? The comma commands, I mean.
<phoe>
that's the implementation for ,restart-inferior-lisp
<phoe>
see above for more examples
<frodef`>
phoe: right, thanks.
pve has joined #lisp
<beach>
phoe: "VAR-ee-able", not "var-EYE-able"
<phoe>
beach: thanks, I'm trying to fix this :D
<beach>
Your written English is quite good, so I am aiming for perfection. :)
<beach>
"un-w-eye-nding" not "un-wind-ing"
<phoe>
I remember that one too
hsaziz has joined #lisp
<flip214>
beach: +1, though I'm not sure how much improvement you can get (or expect)
<beach>
From what?
Aurora_v_kosmose has quit [Remote host closed the connection]
<flip214>
from people's speeches
Aurora_v_kosmose has joined #lisp
<beach>
Like I said, phoe's written English is quite good, and he has only a few major quirks, so I think there is hope. :)
makomo has quit [Ping timeout: 246 seconds]
<beach>
For speakers of German pronouncing English `v' as an English `w' I have much more work to do. :)
<flip214>
"only a few major quirks" would get me a MAJOR look from my daughter ;)
<beach>
I don't understand.
hiroaki has quit [Remote host closed the connection]
hiroaki has joined #lisp
andreyorst has quit [Ping timeout: 264 seconds]
<flip214>
My daughter opines that I've committed some major faults in her (and her siblings) education, being too sincere or outright and similar stuff
<beach>
Ah, I see.
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
shifty has quit [Ping timeout: 272 seconds]
contrapunctus has joined #lisp
shifty has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
<beach>
flip214: I see huge differences in my students, with respect to the willingness to learn and to be humiliated and embarrassed (which is an essential part of learning). My estimate is that phoe prefers to learn and that he can deal with humiliation and embarrassment, especially since he knows me and my intentions.
<beach>
For your offspring, you need to tread carefully according to the attitude of each one.
<frodef`>
beach: differences in what direction? Or do you mean individual differences?
<beach>
Individual differences in attitude toward learning new stuff.
<frodef`>
right, at first I thought you meant an overall trend over the years.
<beach>
No, not at all.
<frodef`>
good :)
dhil has joined #lisp
<flip214>
beach: most of that is just good-natured leg-pulling... and everything that we've done wrong it's too late to change now anyway ;)
<beach>
Sure.
<beach>
Also parents have a tendency to hugely exaggerate their influence on their children.
v3ga has left #lisp ["WeeChat 2.8"]
v3ga has joined #lisp
aartaka has joined #lisp
<ralt>
I personally think the "praise in public, blame in private" motto is not a too bad one
<ralt>
especially for things like correcting english, doing it in PM isn't too much of a chore, and would potentially avoid the off-topic in #lisp ;-)
<beach>
Point taken.
<flip214>
but then all the other people couldn't learn at the same time, increasing beach's work by a factor > 1!
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
MichaelRaskin has quit [Ping timeout: 256 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 264 seconds]
<beach>
phoe: This interview is an excellent exposure of Common Lisp to (I assume) people who did not yet know much of it.
* phoe
bows
<phoe>
hope that it works well
<beach>
At 52 minutes, that implementation is known as "shallow binding".
<phoe>
beach: thanks
* phoe
adds a note for second edition for TCLCS
<frodef`>
beach: do you have thread-safe shallow binding for sicl?
andreyorst has joined #lisp
<beach>
My plan is to use deep binding.
hsaziz has quit [Ping timeout: 272 seconds]
<frodef`>
ok
<frodef`>
it's an interesting problem I think.
<beach>
I am kind of the co-designer of the technique used by SBCL. :)
<frodef`>
beach: cool, do you have a pointer to info?
<beach>
Not really. It was designed together with dan_b some 20 years ago.
<frodef`>
..an executive summary, then? :)
<beach>
I counted on him to do the real implementation work, which apparently he did.
<beach>
Number the symbols, or at least the ones that are bound. Provide a thread-specific slot in the thread object. Put old values on the stack.
<beach>
The thread object contains an array of slots, indexed by the symbol number.
<beach>
So access to a special variable is: Go to the thread object, and index the vector with the symbol number.
<beach>
Global values have to be handled specially. I forget what we came up with.
<phoe>
if the thread-specific slot is EQ to some unbound value, visit the thread-independent global value stored somewhere?
<phoe>
that's the first thing that comes to my mind
<frodef`>
beach: isn't that O(1)-ish shallow binding?
<beach>
Yes, that was the idea.
<beach>
Not cheap, but O(1).
<beach>
phoe: Not quite. The latest binding can be unbound which is valid.
<beach>
That's what PROGV does as I recall.
<phoe>
huh? can it make a variable unbound?
<beach>
Yes, I think the phrase is "binds it and then makes it unbound" or something like that.
<phoe>
> progv creates new dynamic variable bindings and executes each form using those bindings. Each form is evaluated in order.
<beach>
phoe: I am currently reading it. I was given it for christmas.
<phoe>
beach: I know, you told me
<beach>
Oh. :(
<beach>
Memory!
<phoe>
no problem, I'm here to remind you :D
wxie has quit [Ping timeout: 256 seconds]
<beach>
Good. Can I hire you full time to do that?
<ralt>
phoe: it has my name on it, I have to buy it anyway :P
<beach>
phoe: I don't know the interviewer, but I take it it's about functional programming, usually, yes?
<phoe>
ralt: :D
<beach>
But let me say this again. Excellent plug for Common Lisp. And the ease with which you manipulate the development environment is bound to impress them.
<phoe>
beach: yes, this person comes from the functional programming community and was interested by TCLCS and Lisp in general
<beach>
Great!
<phoe>
I mentioned to him that Lisp isn't really functional, but he wanted to discuss things anyway
<beach>
Yes, I see.
<phoe>
so, well, we discussed em
heisig has joined #lisp
nullheroes has joined #lisp
frodef` has quit [Read error: Connection reset by peer]
makomo has joined #lisp
frodef` has joined #lisp
<ralt>
actually, how is a retry restart not going down the stack if it's just a normal function?
<phoe>
ralt: what do you mean, not going down the stack?
<phoe>
a restart is just a structure, it's a piece of data
<ralt>
restart handler, sorry
<phoe>
it has a restart function that can perform a non-local jump
<phoe>
that's all
varjag has joined #lisp
<ralt>
what I mean is when you execute a function, you add a new entry to the stack
<phoe>
yes
<ralt>
if you execute a restart handler, and you pick "Retry", the naive way would be to call the function again
<phoe>
and then this entry on the stack can perform a GO or a RETURN-FROM or a THROW
<ralt>
which would add to the stack
<phoe>
and therefore unwind the stack
<phoe>
the whole magic of the condition system is because we have UNWIND-PROTECT and TAGBODY/GO/BLOCK/RETURN-FROM
SpaceIgor2075 has quit [Ping timeout: 246 seconds]
random-nick has joined #lisp
vegansbane6 has joined #lisp
<flip214>
phoe: the Hello-world example is on the SBCL20 shirts!
<phoe>
flip214: which example?
<phoe>
the tagbody one?
makomo has quit [Ping timeout: 264 seconds]
galex-713 has quit [Ping timeout: 258 seconds]
<flip214>
yeah
okflo has joined #lisp
<flip214>
the example is not that great, or surprising, anyway...
<phoe>
surprising to whom exactly though
<phoe>
I've showed it to several people and the general reaction was either "wow you can do that in Lisp?" or "wow you can do BASIC in Lisp?"
<phoe>
so I'd count it as an eye-opener; a very trivial one, yes, but still
<flip214>
great, that's what I was aiming at
<phoe>
there are more contrived examples to be shown, including LOOP expansions (which I did in the video), but IMO it's important to start with something as simple as possible
frodef`` has joined #lisp
<phoe>
and the tagbody hello world example is perfect for that
frodef` has quit [Ping timeout: 246 seconds]
<flip214>
right!
<flip214>
and at least the previous generation (now in management) will find that familiar
shifty has quit [Ping timeout: 265 seconds]
<phoe>
the "now in management" comment made me giggle
<flip214>
well, age-wise
frgo has quit [Remote host closed the connection]
<phoe>
yes, I understood that
frgo has joined #lisp
<flip214>
so we need to have some similar-to-python snippets for such videos in 20 years, when The Next Generation has taken over
galex-713 has joined #lisp
<Krystof>
I like the optimism that the world will still exist in 20 years
<Krystof>
Happy New Year!
<no-defun-allowed>
If we don't do the impossible, we will be faced with the unthinkable.
<no-defun-allowed>
Doing the impossible requires some stubbornness though.
<Krystof>
and a good breakfast
<flip214>
Krystof: as I invested in having kids, it better not stop turning until that has paid off!
<beach>
Krystof: You too.
<flip214>
you can surely relate to that...
<flip214>
Krystof: so you're moving to France?
<Krystof>
what? No, not currently planning to
<flip214>
well, you talked about getting a good breakfast ;)
<beach>
French breakfast is horrible compared to English breakfast.
<heisig>
French breakfast is a cup of coffee and a cigarette.
<flip214>
really? I haven't been to the UK for more than switching between planes, but there's this joke about Canada...
<beach>
heisig: A croissant if you have been good.
<ralt>
And a pain au chocolat
<beach>
That would be OR.
<beach>
Besides, they are called "chocolatines" where I live.
<ralt>
No. And. I'm hungry for breakfast.
<ralt>
I live in another part of France, those calling it "chocolatine" are considered heathens around here :p
<heisig>
And thus, the channel derailed...
* beach
will stop now.
<flip214>
heisig: food always makes a good /topic
<beach>
flip214: I see you are set on starting two off-topic discussion with short intervals.
<flip214>
beach: oh, sorry. I'll shut up.
<phoe>
food is on-topic in #lispcafe!
<ralt>
beach is not over here tho
<phoe>
well, he should join, I'm kinda curious about French breakfasts but I don't want to make #lisp participants hungry by discussing foodstuffs here
<phoe>
:D
igemnace has quit [Remote host closed the connection]
SpaceIgor2075 has joined #lisp
<varjag>
anyone knows if there's a way to broadcast udp in lispworks, other than via ffi?
<beach>
*sigh*
Stanley|00 has quit []
SpaceIgor2075 has quit [Remote host closed the connection]
SpaceIgor2075 has joined #lisp
luckless has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
luckless has joined #lisp
SpaceIgor2075 has quit [Remote host closed the connection]
SpaceIgor2075 has joined #lisp
SpaceIgor2075 has quit [Client Quit]
SpaceIgor2075 has joined #lisp
SpaceIgor2075 has quit [Remote host closed the connection]
makomo has quit [Read error: Connection reset by peer]
makomo has joined #lisp
<flip214>
SpaceIgor2075: also, UIOP has a function for that
<ralt>
`sbcl --eval '(asdf:make :foo)'` is what you're supposed to use
cosimone has joined #lisp
makomo has quit [Read error: Connection reset by peer]
_whitelogger has joined #lisp
saganman has joined #lisp
wsinatra has joined #lisp
pfdietz has joined #lisp
<dim>
now I am wondering if this linux-packaging tool could be used with pgloader...
<SpaceIgor2075>
It seems my project name was so complicated i typed it with typos and asdf didn'r work. Tip for the future: don't use project names that are too complex
rumpelszn has quit [Quit: ZNC 1.6.6+deb1ubuntu0.2 - http://znc.in]
<shinohai>
Interesting thread this morning, I've been looking into methods for producing binaries. linux-packaging tool looks neat but I just can't overcome my distaste for Docker to make it useful in my case.
SpaceIgor2075 has quit [Read error: Connection reset by peer]
<dim>
docker is quite nice for dev/test environments really
SpaceIgor2075 has joined #lisp
<dim>
for managing an easy to reproduce env to produce binaries, it looks pretty well suited for the task
<shinohai>
Producing actual *fully static* binary that will run irregardless of system still pipe dream I suppose.
<frodef``>
shinohai: what's the issue with Docker?
<shinohai>
frodef``: nothing I guess if that is one's bag.
notzmv has quit [Remote host closed the connection]
SpaceIgo` has joined #lisp
amb007 has quit [Ping timeout: 260 seconds]
SpaceIgor2075 has quit [Remote host closed the connection]
SpaceIgo` has quit [Remote host closed the connection]
notzmv has joined #lisp
SpaceIgor2075 has joined #lisp
_whitelogger has quit [Ping timeout: 260 seconds]
_whitelogger_ has joined #lisp
gxt has quit [Quit: WeeChat 3.0]
heisig has quit [Quit: Leaving]
<SpaceIgor2075>
Should i use :depends-on (#:CL) in my asdf:defsystem?
dyelar has joined #lisp
<SpaceIgor2075>
SBCL says ; Evaluation aborted on Component #:CL not found, required by #<SYSTEM
cosimone has quit [Quit: cosimone]
<Bike>
What would that indicate?
<Bike>
You're already writing your code in common lisp, right?
<SpaceIgor2075>
yes
nicktick has joined #lisp
rumbler31_ has joined #lisp
<SpaceIgor2075>
Removed it and, finally, after 12 hours of tinkering, asdf:load-system works
gxt has joined #lisp
waleee-cl has joined #lisp
amb007 has joined #lisp
Steeve has joined #lisp
pfdietz has quit [Ping timeout: 245 seconds]
luckless has quit [Ping timeout: 240 seconds]
luckless has joined #lisp
<SpaceIgor2075>
Now I want to build an app
ggoes_ is now known as ggoes
<ralt>
shinohai: as I was saying in #sicl a few hours ago, I think sbcl recently got some fixes to work with musl, so static binaries might be possible now. Haven't played with it yet.
<shinohai>
ralt: oh neat, didn't know sbcl got some musl fixes, ~year ago I managed to get 1.5.7 patched together to work on musl system, still using it.
<phoe>
there is only a CL package
mankaev has quit [Ping timeout: 260 seconds]
gxt has joined #lisp
sjl_ has joined #lisp
<SpaceIgor2075>
phoe: should i mention it anywhere?
<phoe>
yes, in your DEFPACKAGEs
<phoe>
unless you want to explicitly qualify all CL symbols, which would be... weird
mankaev has joined #lisp
<SpaceIgor2075>
Is there a builtin way to make executables in clisp, like sb-ext:save-lisp-and-die in sbcl?
<SpaceIgor2075>
:components ((:file "main"))) inherit components and dependencies of foobar?
<phoe>
please use pastebin for larger code blocks
<phoe>
also, what do you mean, components and depenencies? this will require foobar to be loaded before this is system is loaded
<phoe>
and loading foobar requires its dependencies to be loaded, and then its components to be compiled and loaded, too
<phoe>
so I guess, yes... but I wonder why you need a separate system for building executables
<phoe>
I guess that build-operation, built-pathname, entry-point can all be specified in foobar itself, unless you have other issues
tyson2 has joined #lisp
hnOsmium0001 has joined #lisp
liberliver has quit [Quit: liberliver]
abhixec has quit [Quit: leaving]
shifty has joined #lisp
<SpaceIgor2075>
It works. I'm so happy. Are there newbie guides on doing stuff with a lisp program while it runs in slime?
Cymew has quit [Ping timeout: 256 seconds]
<SpaceIgor2075>
I've heard a lot about this "interactive development" thing
<Xach>
SpaceIgor2075: i find it helps to think of the lisp program as a thing to which you connect, and which you extend incrementally with new functions, types, data, etc.
jonas[m]1 has joined #lisp
<Xach>
it's not something you design, start, it runs and completes, and you think about what you want different for the next time.
<Xach>
start, design, add pieces, run pieces, design, add more pieces, run more pieces, design, etc
<SpaceIgor2075>
i understand, i just want to see some explanations and examples
<Xach>
Hmm, I'm not sure what might be available, sorry. I think the SLIME video might have some examples (it's pretty old but the concepts are not outdated)
<phoe>
Baggers' Little Bits of Lisp
<Xach>
I think Rainer Joswig has some videos using LispWorks
<Xach>
That's a good option too!
<tyson2>
I am using the free book Practical Common Lisp, which uses sbcl and slime by default, seems to work well. Just set up Slime a couple of weeks ago.
<tyson2>
(although I did it a few years ago and gave up).
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
rpg has joined #lisp
cosimone has quit [Quit: cosimone]
scymtym_ has joined #lisp
cosimone has joined #lisp
scymtym has quit [Ping timeout: 264 seconds]
v88m has joined #lisp
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
andreyorst has quit [Ping timeout: 264 seconds]
matryoshka has quit [Client Quit]
v88m has quit [Ping timeout: 256 seconds]
matryoshka has joined #lisp
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
v88m has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
v88m has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
scymtym_ has quit [Remote host closed the connection]
aartaka has joined #lisp
bitmapper has joined #lisp
matryoshka has quit [Client Quit]
scymtym has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
aartaka has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
v88m has joined #lisp
sjl has joined #lisp
zmagii_ has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
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
matryoshka has joined #lisp
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
orivej has joined #lisp
shifty has joined #lisp
rogersm has quit [Quit: Leaving...]
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
zmagii has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
matryoshka` has joined #lisp
matryoshka has quit [Read error: Connection reset by peer]
imode has joined #lisp
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
<aeth>
VincentVega: You can write a macro which replaces each _ with a new gensym, saves those gensyms into a list, and then adds an implicit (declare (ignore ,@gensym-list)) at the start.
<aeth>
I'm not sure if it would be useful enough to be worth the (minimal) effort, though.
heisig has joined #lisp
heisig has quit [Remote host closed the connection]
<aeth>
It might be useful for certain advanced macros that might do actions on otherwise-ignored things, where it could instead do (declare (ignorable ,@gensym-list)) instead.
<aeth>
(i.e. it's not used in the user code, and it may or may not trigger the macro processing that uses it in the macro's code)
birdwing has quit [Ping timeout: 256 seconds]
luckless has quit [Quit: luckless]
cosimone has quit [Remote host closed the connection]
luckless has joined #lisp
cosimone has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
<VincentVega>
aeth: I see what you mean. I don't have macro code needing that yet, but i will keep this possibilityin mind!
cosimone has quit [Quit: cosimone]
cosimone has joined #lisp
SpaceIgor2075 has quit [Read error: Connection reset by peer]
<fe[nl]ix>
ralt: it seems that the feature test tools-for-build/os-provides-dlopen-test.c fails somehow
<fe[nl]ix>
try compiling and running that under musl
<ralt>
fe[nl]ix: exits with code 104
<ralt>
it does compile, though
dhil has quit [Ping timeout: 256 seconds]
<ralt>
dlerror() returns null...
rumbler31_ has joined #lisp
<ralt>
I don't understand how it's supposed to run
<ralt>
it returns exit code 104 if... dlsym() returns a good pointer?
<ralt>
anyway, for another day.
<etimmons>
ralt: I helped get the musl support merged back in 2.0.5. and have been using it successfully since
<ralt>
etimmons: thanks a lot!
<etimmons>
But I haven't run the full test suite on musl in a while (currently doing that). Wouldn't surprise me if it's a bug in the test
<ralt>
I'm playing with it to generate a static binary, a bit unsuccessfully so far, but linkers are finicky beasts :)
<etimmons>
Coincidentally I also have a set of patches to make static executables with musl. I sent some early versions to sbcl-devel a while back, but they didn't get traction
<ralt>
do you need a static sbcl to build a static dumped image?
<ralt>
either way, I'm very interested, could you point me to those?
<etimmons>
I was literally in the middle of doing a little writeup on how to actually make a static executable when I paged over here and saw the discussion
<ralt>
ha
<ralt>
amazing :)
<etimmons>
Will drop a pointer in here when it's up.
<etimmons>
There are really two ways to do it. There's supposedly a way to do it with the static shrinkwrapping recipe in the SBCL repo, but that does some low level assembly stuff and currently only works on amd64.
<etimmons>
I have also yet to get a good explanation from Doug Katzman on how to get rid of the requirement on libdl with that route (but it seems he/Google has a way)
akoana has joined #lisp
<etimmons>
The second route is with my patches. They should work on any arch, but require two compilations of your code: one with a dynamic SBCL to record the needed foreign symbols, and then one with a static SBCL to dump the final executable
abhixec has joined #lisp
matryoshka has joined #lisp
<ralt>
etimmons: can't you use the /usr/lib/sbcl.o file for the foreign symbols?
<ralt>
I meant /usr/lib/sbcl/sbcl.o, sorry
<ralt>
or is that the shrinkwrapping recipe?
<ralt>
are you aware of the --with-linkable-runtime option, and the generated sbcl.mk?
<etimmons>
Yes, I'm aware of that. I had some nasty recipes in the past that used that as a starting point.
<etimmons>
The issue is SBCL's linkage table. It records all the C addresses of the foreign symbols and uses dlopen/dlsym at runtime to populate it.
<etimmons>
I'm sure you could get the symbols needed for SBCL's runtime from sbcl.o, but that won't tell you what user code needs (if it uses CFFI)
<ralt>
Ok, I'll wait for your write-up then
igemnace has joined #lisp
<etimmons>
The shrinkwrapping recipe rewrites a core so that the system's dynamic linker populates the linkage table for SBCL at runtime. My set of patches instead generates a C file that needs to be compiled into the core. That's how I get away with doing this knowing ~zero assembly
<phoe>
likely what no-defun-allowed meant: swank-crew, lfarm?
<ralt>
no-defun-allowed: is there some existing stuff for this besides netfarm?
<no-defun-allowed>
As phoe already said.
<etimmons>
ralt: shameless self plug; if you're into Docker I maintain a set of Docker images for SBCL, including Alpine based ones. They used to be at daewok/sbcl, but I'm working with the CLF to move them to a more community owned space for longevity.
<etimmons>
Beta is up at clfoundation/sbcl
<no-defun-allowed>
Netfarm is for mostly-untrusted replicated object storage, and you do not want to use it for distributed computation. You want something more like lfarm for computing.
<ralt>
etimmons: you're daewok? I've used your images before :)
<etimmons>
indeed!
<no-defun-allowed>
Hey, same, the GitLab CI stuff aeth and I use uses daewok/lisp or something like that.
<ralt>
no-defun-allowed: I want a cloud-hosted mainframe in Lisp
<scymtym>
phoe: thanks
<etimmons>
ralt: Nice, I'll take a look at that after dinner
<no-defun-allowed>
ralt: I seriously don't give a fuck, and I hope you don't act on that desire.
sjl has quit [Ping timeout: 272 seconds]
<no-defun-allowed>
Please ignore the former half of that, I did not mean to say that.
<ralt>
etimmons: anyway, I'm going away now, please look at your PMs, I sent you my email because I'll disconnect from irc, I really want static binaries :P
<no-defun-allowed>
But we don't need more centralisation in this world.
<no-defun-allowed>
I suppose I'll head out, before I say something else that's stupid.
no-defun-allowed has left #lisp ["User left"]
<ralt>
no-defun-allowed: by mainframe, I mean a "lisp process" that never dies, no matter what the underlying hardware does