<ellio>
my system for dynamic is completely weird.
<ellio>
straight-up.
<ellio>
high-level summary:
<ellio>
there's an additional step between “compile-time” and “run-time”
<ellio>
we'll call it transform-time
<ellio>
At transform-time, APIs are made available to your code that have mutation-access to Scripts
<ellio>
but all *externally-visible* APIs are no-ops.
<ellio>
then, at run-time, the Script-mutation APIs are no-ops, but the rest of the real-world-interaction APIs are available again.
<ellio>
the IPP *runs* your code, in that transform-time mode, completely normally: all functions, all branching, all what-the-fuck-ever you've implemented … as long as it isn't *dependent* on filesystem/network/console/whatever access … operate as per normal,
<whitequark>
I have this in Foundry, heh
<ellio>
except that any time a call into the mutation API is completed, it immediately halts the world, and starts over with the mutated code.
<ellio>
so, syntax-modifying/“magic” code is interspersed *right alongside* all other code: you can define syntax right in the middle of the body of your function, based on the same heuristic the “run-time” branches of your code are using, or what the fuck ever …
<ellio>
… you can ship syntax for your library *inside* the library, so that when the library is required/included/whatever'd, the syntax is available as well …
<ellio>
… and any syntax involved in a higher-level language built on top of Paws (which is the entire point of Paws) can all be introspected through user's code, and modified, from within their own code
<ellio>
so:
<ellio>
by design, if you're running some sort of *source-code* (i.e. cPaws, or another format similar thereunto, say a graphical code-representation in an IDE) for the first time,
<ellio>
it's actually likely to be *partially* run, hundreds of times. Or even thousands.
* whitequark
raises his hand
<ellio>
as each syntax-modifying section is reached in turn, and executed.
<ellio>
obviously, this can be largely optimized. but nonetheless, it's expected to be slow.
<ellio>
mmhmm?
<ellio>
lolitsIRCbrojusttalk
<whitequark>
let's omit this part and implement every part of paws except syntactic shit
<whitequark>
it's kind of cool but let's focus on massively parallel stuff
<whitequark>
not holywar-inducing syntax rage
<ellio>
yep
<ellio>
I'm doing exactly that
<ellio>
that's the entire point of cPaws and the IPP
<ellio>
it gives me two, really really nice cop-outs when discussing Paws:
<ellio>
A) “Don't worry! It'll be beautiful *later*.”
<ellio>
and B) “no, I won't listen to you argue with me about the syntax of cPaws. It's not even *intended* to represent all possible Paws programs, so it doesn't *need* to be robust/perfect/whatever.”
<ellio>
anyway.
<ellio>
IPP's the next step after distribution, design-wise.
<ellio>
we've done everything up to concurrency; right now, the design work is all going into time-travel/bubbles/whatever-you-wanna-call-em
<ellio>
but this is why I want alexgordon's attention: I need his mindset, that is, the mindset of a boring programmer, *not* a batshit-insane-programmer *or* super-intellectual-PLT-nerd, to see how other boring people might design Paws implementations
<ellio>
that's the kind of thing I need to be thinking about for the upcoming work on distribution.
<ellio>
have to make sure the protocol, and any language-design-changes necessary for distribution, is flexible enough to support non-Elliott-insane implementations.