<edgar-rft>
IRC gives us two choices: either 1) display all /join and /quit messages and lose conversation context if posts and answers are half-a-day apart, or b) hide all /join and /quit messages and lose track who's online and who's not - that's what makes IRC so great :-)
Pixel_Outlaw has quit [Client Quit]
CrashTestDummy3 has quit [Remote host closed the connection]
CrashTestDummy has joined #commonlisp
chomwitt has joined #commonlisp
CrashTestDummy has quit [Read error: Connection reset by peer]
Bubblegumdrop has quit [Ping timeout: 268 seconds]
CrashTestDummy has joined #commonlisp
xaos has joined #commonlisp
fitzsim has quit [Read error: Connection reset by peer]
CrashTestDummy2 has joined #commonlisp
CrashTestDummy3 has joined #commonlisp
CrashTestDummy has quit [Ping timeout: 255 seconds]
jweeks has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 255 seconds]
<beach>
The answer to my question is: "It doesn't".
<beach>
But then when I do (clast:free-variables (clast:parse '(macrolet ((m () *x*)) (+ 20 (m))))) I get NIL and "WARNING: CLAST: walking a form for which no structure is yet known: (#<MACRO-DEFINITION-FORM ...>)
Bubblegumdrop has joined #commonlisp
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
<beach>
marcoxa's work reminds me that we (who hang out on IRC) are bad at exposing our work to others (i.e, the ones how don't hang out on IRC).
<beach>
Because he obviously does not know about our work on Trucler to create a better environment interface than that of CLtL2, he doesn't know about the s-expression-syntax library created by scymtym, he doesn't know about Iconoclast which is a library that provides AST classes for all (I think) of Common Lisp, and he doesn't know about Common Boot that uses all those libraries to handle all (I think) of Common Lisp, including MACROLET.
<beach>
So we (who hang out on IRC) need to get better at communicating what we do.
<jackdaniel>
even people who communicate on IRC tend to do the same things over and over again, implementing common lisp anew included; so perhaps it is not a communication problem but rather a NIH syndrome as a common lisper trait
CrashTestDummy2 has joined #commonlisp
<beach>
Touché, I guess!
CrashTestDummy has joined #commonlisp
shka has joined #commonlisp
<contrapunctus>
Obligatory reminder that I run a Lisp community on XMPP 🙂 https://xmpp.link/#lisp@conference.a3.pm?join
<ixelp>
XMPP Invitation
CrashTestDummy3 has quit [Ping timeout: 255 seconds]
<Nilby>
i like things with no dependencies. it makes it easier to rewrite them
<beach>
jackdaniel: I know that you think that what we do is "not very convincing", and I think I understand this opinion of yours.
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 260 seconds]
CrashTestDummy has quit [Ping timeout: 268 seconds]
<beach>
But for the record, we are not just "implementing common lisp anew". We are splitting it up into independent libraries that are (or will be) separately maintained and tested. And those libraries are meant to be useful in other contexts as well.
CrashTestDummy has joined #commonlisp
<jackdaniel>
I think that people hack on what's interesting to them, and hacking a common lisp implementation is definetely interesting; I'm only sceptical about some claims here and there
<jackdaniel>
(please don't ask which, because I'm not keen to dig irc logs to list them!)
<beach>
Yes, I know. You regularly express this skepticism.
CrashTestDummy3 has quit [Ping timeout: 268 seconds]
<jackdaniel>
I don't think I'm talking on this channel very often, but OK
<beach>
I said "regularly", not "often".
CrashTestDummy2 has joined #commonlisp
<jackdaniel>
regularity requires some kind of non-marginal frequence, otherwise it is sporadically
<beach>
Also for the record, we are also not just "implementing common lisp anew" using the same techniques used by existing Common Lisp implementations. We have written a bunch of papers on improved techniques, and we have invented other techniques that are not (yet) published.
pve has joined #commonlisp
CrashTestDummy has quit [Ping timeout: 268 seconds]
<jackdaniel>
it would be disappointing if a new implementation used only techniques expressed in existing implementations, so that's good
CrashTestDummy2 has quit [Ping timeout: 256 seconds]
<beach>
contrapunctus: What is XMPP and what is this community used for?
<pranav>
beach: XMPP is an instant messaging protocol. eXtensible Messaging and Presence Protocol.
<contrapunctus>
beach: XMPP is a federated chat network like IRC, but more featureful and without the shortcomings of other protocols. It's also the IETF standard for chat.
attila_lendvai has joined #commonlisp
skeemer has quit [Ping timeout: 268 seconds]
<beach>
I see. Thanks.
<pranav>
One might recognize it by its original name—Jabber.
wbooze has joined #commonlisp
NotThatRPG has joined #commonlisp
NotThatRPG has quit [Ping timeout: 240 seconds]
<xaos>
in case anyone knows... does the Lem editor have a shell mode, like Emacs' `M-x shell`?
amb007 has quit [Ping timeout: 268 seconds]
amb007 has joined #commonlisp
tfb has joined #commonlisp
dino_tutter has joined #commonlisp
mwnaylor has joined #commonlisp
skeem has joined #commonlisp
tfb has quit [Quit: died]
Cymew has joined #commonlisp
chomwitt has quit [Ping timeout: 256 seconds]
chomwitt has joined #commonlisp
<Shinmera>
beach: As another data point: even though I think my game engine by now has proven itself as actually feasible and is probably the most "known" one, folks still seem to prefer to make their own instead of advancing Trial
<beach>
Shinmera: I haven't followed your development, but do you think that is because of ignorance due to lack of communication (as I hinted for marcoxa), because others think Trial is lacking features (the reason for the SICL project), or just NIH (as jackdaniel suggested)?
<Shinmera>
how about all of the above? :)
<beach>
Fair enough! :)
CrashTestDummy has joined #commonlisp
<Shinmera>
I get the impression that there's two kinds of thinking. Either you try to use an existing tool and bend it to your problem, or you prefer to make a new tool for that problem.
<Shinmera>
For me at least I notice I often get exhausted very quickly with the first line of thinking, and I assume it's the same for a lot of others.
<Shinmera>
I suppose that goes under NIH
<beach>
Interesting observation. It makes sense since I forget who said this, but understanding some existing code can require the same amount of effort as creating new code.
CrashTestDummy2 has joined #commonlisp
<Shinmera>
Right.
<beach>
So if you need to alter some existing code, that could be just as hard as writing your own stuff.
skeem has quit [Ping timeout: 250 seconds]
<Shinmera>
I think what helps with that aspect the most is good and extensive documentation.
<beach>
I mean, if you need to alter some existing code in order for it to do what you want..
<Shinmera>
If it's easy to find how to do what you're looking for, you'll be less incentivised to just do your own thing from scratch
<beach>
Yes, and maintainable code.
<Shinmera>
Trial does have some documentation, but I still think it is far too little for it to truly be approachable
<beach>
I see.
<Shinmera>
Even for something like Unity or Godot, which have gigantic communities with forums and everything, people still frequently complain that they can't easily figure out how to do something.
CrashTestDummy has quit [Ping timeout: 256 seconds]
<Shinmera>
In a way, I feel like the requirement for documentation increases exponentially with the complexity of the problem domain
<Shinmera>
And game engines cover quite a vast domain
<beach>
Another interesting observation.
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 264 seconds]
CrashTestDummy3 has quit [Ping timeout: 256 seconds]
CrashTestDummy has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
CrashTestDummy has quit [Ping timeout: 252 seconds]
xaltsc has quit [Quit: WeeChat 4.3.3]
CrashTestDummy has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
CrashTestDummy has quit [Ping timeout: 240 seconds]
edgar-rft has quit [Quit: don't waste your life by reading this]
CrashTestDummy has joined #commonlisp
kevingal has joined #commonlisp
kevingal_ has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
mgl_ has joined #commonlisp
CrashTestDummy3 has joined #commonlisp
CrashTestDummy has quit [Ping timeout: 240 seconds]
CrashTestDummy2 has quit [Ping timeout: 240 seconds]
CrashTestDummy has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 268 seconds]
cognemo has joined #commonlisp
CrashTestDummy has quit [Ping timeout: 268 seconds]
X-Scale has joined #commonlisp
sailorCat has quit [Ping timeout: 264 seconds]
varjag has joined #commonlisp
X-Scale has quit [Ping timeout: 250 seconds]
wacki has quit [Read error: Connection reset by peer]
sailorCat has joined #commonlisp
wacki has joined #commonlisp
notzmv has quit [Ping timeout: 268 seconds]
edgar-rft has joined #commonlisp
mwnaylor has quit [Ping timeout: 268 seconds]
chomwitt has quit [Ping timeout: 246 seconds]
donleo has joined #commonlisp
chomwitt has joined #commonlisp
tfeb has joined #commonlisp
tfeb has quit [Client Quit]
chomwitt has quit [Ping timeout: 246 seconds]
chomwitt has joined #commonlisp
chomwitt has quit [Ping timeout: 268 seconds]
chomwitt has joined #commonlisp
danse-nr3 has quit [Ping timeout: 264 seconds]
kevingal_ has quit [Ping timeout: 268 seconds]
kevingal has quit [Ping timeout: 268 seconds]
random-nick has joined #commonlisp
yitzi has joined #commonlisp
Gleefre has joined #commonlisp
skeem has joined #commonlisp
notzmv has joined #commonlisp
rtypo has joined #commonlisp
X-Scale has joined #commonlisp
notzmv has quit [Ping timeout: 268 seconds]
decweb has joined #commonlisp
meritamen has joined #commonlisp
agm has joined #commonlisp
lucasta has joined #commonlisp
phantomics has joined #commonlisp
<agm>
hello everyone, what does the standard say about redefinition of non-standard condition classes? I can't find anything
chomwitt has quit [Ping timeout: 255 seconds]
<bike>
agm: i don't know that it says anything. in practice define-condition usually works like defclass.
chomwitt has joined #commonlisp
<jackdaniel>
sbcl if I recall correctly does not implement many standard-class protocols for the condition-class
<agm>
okay!
X-Scale68 has joined #commonlisp
X-Scale has quit [Ping timeout: 250 seconds]
cage has joined #commonlisp
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
wbooze has quit [Remote host closed the connection]
meritamen has quit [Ping timeout: 264 seconds]
X-Scale has joined #commonlisp
X-Scale68 has quit [Ping timeout: 250 seconds]
X-Scale30 has joined #commonlisp
lucasta has quit [Quit: Leaving]
X-Scale has quit [Ping timeout: 250 seconds]
fitzsim has joined #commonlisp
X-Scale30 is now known as X-Scale
<Shinmera>
jackdaniel: is there a way to force ECL to keep the source code of a function so it can disassemble it? declaim inline doesn't seem to do the trick
zxcvz has joined #commonlisp
varjag has quit [Quit: ERC (IRC client for Emacs 27.1)]
<jackdaniel>
Shinmera: no, it stores the definition only for bytecodes compiled functions
<Shinmera>
I see
skeem has quit [Ping timeout: 250 seconds]
wbooze has joined #commonlisp
Cymew has quit [Quit: Konversation terminated!]
skeem has joined #commonlisp
zxcvz has quit [Quit: zxcvz]
X-Scale has quit [Ping timeout: 250 seconds]
X-Scale has joined #commonlisp
yitzi has quit [Remote host closed the connection]
yitzi has joined #commonlisp
<mrcom>
beach: What is Common Boot, and where does one go to look at it?
<beach>
I can explain what it is and where to find it, but I don't recommend you try it quite yet, because I haven't set things up for a more general consumption.
awlygj has joined #commonlisp
<beach>
Essentially, it uses the s-expression-syntax library, and the Iconoclast library to create an AST from source code. Then it turns the AST into host Common Lisp code that works against a first-class global environment provided by Clostrum so that executing that host code is equivalent to executing the original source, except that it doesn't use the host global environment.
<beach>
Oh, and the host code created from the AST is based on CPS, so that the resulting code does not consume host stack. This fact also simplifies debugging and it makes it easier to do non-local control transfers in target code.
<beach>
mrcom: Maybe that's not a good enough description, so feel free to ask questions.
<beach>
Common Boot is currently used for the SICL bootstrapping procedure, but I hope it will also be used to analyze code in the buffer of an editor for Common Lisp.
<mrcom>
Could we (once in proper state) use it for running test cases, with multiple independant environments? I'm trying to fake-it by backing-out definitions at the end of a test case.
<mrcom>
Would prefer more robust solution.
<beach>
Yes, I think so.
<beach>
You basically just translate the original code to an AST and then back to host code that uses a Clostrum environment.
<beach>
All references to the global environment in the original code are replaced by references to the Clostrum environment.
<beach>
One issue with it right now is that the CPS code that is generated is huge, so the SBCL compiler can't handle it. So I use the SBCL interpreter instead, which is slow. I am working on applying closure conversion to the AST so that the generated code can be less deeply nested. That way, the compiler ought to be able to handle it.
<beach>
Closure conversion is necessary anyway for SICL, so it has to be done at some point.
ocra8 has quit [Ping timeout: 260 seconds]
ocra8 has joined #commonlisp
chomwitt has quit [Ping timeout: 256 seconds]
<mrcom>
Closure conversion?
chomwitt has joined #commonlisp
<beach>
It's a standard compiler transformation. It turns a function that might refer to variables in an enclosing environment into a function that also has a static environment that contains this information, so that it no longer refers to enclosing environments.
ocra8 has quit [Excess Flood]
varjag has joined #commonlisp
skeem has quit [Quit: Client closed]
beach has quit [Ping timeout: 268 seconds]
beach has joined #commonlisp
<beach>
Sorry, I had to reboot.
<mrcom>
Didn't miss anything.
<beach>
Good.
<mrcom>
Was looking at internet resources re closure conversion. (Is that the CC in scheme's call/cc?)
<beach>
No, that CC is "current continuation".
xaltsc has joined #commonlisp
xaltsc is now known as Guest1816
Guest1816 has quit [Client Quit]
cage has quit []
X-Scale has quit [Ping timeout: 250 seconds]
<mrcom>
Ran into a paper about "Compositional Compiler Correctness". Interesting abstract--compositiion in this case means between components written in dissimiliar languages.
<mrcom>
Did notice one kind of eyebrow-raising claim: "In particular, they allow compiled components to be linked with code whose functionality cannot even be expressed in the compiler's own source language."
<mrcom>
What, we are speaking of non-turing-complete compilers?
<beach>
mrcom: Imagine you have (let ((x 10)) (lambda (y) (+ x y))). You turn that into (let ((x 10)) (make-function :static-environment (vector x) :code (lambda (y) (+ (aref static-environment 0) y)))).
<beach>
So now the code for the new function can be compiled without references to the surrounding environment.
<mrcom>
Basically turning closure into injection.
<mrcom>
Is refactoring an important part of doing so? e.g., (lambda(y) (+ w x y)) => (static (z (+ w x))) , (lambda (y) (+ y (aref for z rather than w & x)))
<mrcom>
Or is most of the benefit simply from hoisting w & x out of the lambda?
skeemer has joined #commonlisp
NotThatRPG has joined #commonlisp
xaltsc has joined #commonlisp
xaltsc has quit [Changing host]
xaltsc has joined #commonlisp
<beach>
You can only transform the references to closed-over variables.
<beach>
I mean, hoisting code like that is a separate transformation if it is possible.
<beach>
And closure conversion is not just a "benefit". It is a necessity for creating native code. You have to have a representation of the lexical environment for the function to access.
<beach>
There are other ways of representing the lexical environment, but this one is the most appropriate one in a language with automatic memory management.
<NotThatRPG>
Any people who use sly remote connections out there? Having some troubles I don't understand and would like to compare notes.
mgl_ has quit [Ping timeout: 246 seconds]
<younder>
beach: I would like to warp that view a bit to take into account memory alignment. Behind the scenes of course
<younder>
Thing is modern CPU's like arrays and nested is statements and for now that is what a Lisp structure should compile to
<younder>
s/is/if/
<beach>
That's an orthogonal issue though.
<younder>
I can't heal all so I will focus on cons cells
<younder>
orthogonal to what?
<craigbro>
does it work only on top-level exprs? That would be my intuition
<beach>
To closure conversion.
<younder>
So is SSA
<beach>
craigbro: "it"?
<younder>
SSA mostly mandates this change
<craigbro>
clostrum;s env lifting
<beach>
craigbro: Closure conversion is not specific ti Clostrum or SICL. It turns every nested function that closes over some variables into a global function with a static environment.
<beach>
*to
varjag has quit [Remote host closed the connection]
<beach>
younder: I am lost.
<beach>
And I need to go fix dinner for my (admittedly small) family, so perhaps someone else can take over.
varjag has joined #commonlisp
<younder>
I will be happy to discuss some of the design considerations later
<craigbro>
let me rephrase, is clostrum able to transform and expose/manipulate the env of non top-level functions
<craigbro>
similiar tho slightly different question, can I manipulate lexical bindings
<yitzi>
So labels and flet?
<craigbro>
my mental model here are the explicit env objects in some lisp interpretets
<craigbro>
yitzi: yah, lets and flet and such
<craigbro>
that would, I would presume, require a more signifivant transform
<craigbro>
and also, just curious, `go read source` is a fine response
<younder>
will do
<yitzi>
I think beach's response earlier has the answer " It turns every nested function that closes over some variables into a global function"
<craigbro>
nvm, beach already described it as rewriting refs to global env above. I promise, I can read for comprehension, hahaha.
<bike>
craigbro: clostrum does not access anything in any functions. it is an implementation of (global) environment objects, and doesn't in itself provide any way to get at any environments.
<craigbro>
that's what I get for walking into middle of conversation while waiting for lawnmower battery to recharge
varjag has quit [Ping timeout: 246 seconds]
<younder>
Well I just move them as an argument to the function and allocate them in an array. At compile-time I need to ensure the scope of the variable
<younder>
I admit it seems a bit clumsy and might make the compiler slower.
<younder>
This clearly needs a lot of thought. I need to try to get the basic structure right, but I thought I would start with something stupid and refactor that I got a better picture
<younder>
until
<younder>
s/until/when/
ocra8 has joined #commonlisp
<younder>
My goal remains the same though - make memory linearity a priority - then try not to confuse the branch predictor by doing unusual things
<younder>
Today's code is from the 1980's. Ideally you could get a boost in Lisp performance by adhering to these rules. A good profiler is still a must for SICL though.
<younder>
Ideally it would record cache misses and branch mis-predictions. That would help in the design of the compiler as well.
<younder>
I've been digging low into the micro-code of modern processors to get a clue, but work remains