elliottcable changed the topic of #Paws.Nucleus to: http://Paws.mu — coming soon™ ... or not.
_whitelogger_ has joined #Paws.Nucleus
ELLIOTTCABLE has quit [Remote host closed the connection]
ELLIOTTCABLE has joined #Paws.Nucleus
whitequark has joined #Paws.Nucleus
<whitequark> did you know
<whitequark> that my logger finally works with dat channel? http://irclog.whitequark.org/Paws.Nucleus/2013-06-14
<ellio> lol
<ellio> so.
<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> right now we're:
<ellio> core boring shit => thorough asynchronicity => magical concurrency => time-travel => distribution => IPP
<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.
<whitequark> I see
alexgordon has joined #Paws.Nucleus