<joelteon>
that one scared the shit out of me the firs ttime I saw it
<jdhartley>
"The name "Paamayim Nekudotayim" was introduced in the Israeli-developed[1] Zend Engine 0.5 used in PHP 3. Although it has been confusing to many developers who do not speak Hebrew, it is still being used in PHP 5, as in this sample error message:"
<jdhartley>
learn something new every day, don't you
<ec>
so check out Relation->clone() and Object->clone()
<ec>
(you're here, yes? Are we doing this? I've got time now.)
<alexgordon>
ec: you were going to explain staging?
<ec>
not quite yet.
<ec>
getting there. Still covering receivers, last I recall?
<alexgordon>
err
<ec>
(by the way, I think after you left, talking to whitequark, we re-named “juxtaposition” to combination.)
<alexgordon>
what's that
<ec>
lolk
<purr>
lolk
<alexgordon>
NOOOOOO
<alexgordon>
whitequark: I hate you.
<ec>
pfff, you said that *last* time it got renamed.
<ec>
you were all OMG SPACE OPERATOR BUT THAT MAKES ME FEEL LIKE SPACE-JAMES-BOND
<purr>
Let it be known that joelteon hearts big butts and i cannot lie.
<alexgordon>
juxtaposition is my name! you just killed my child
<ec>
… or maybe that was jeannicolas … I don't remember
<ec>
joelteon: --
<purr>
Let it be known that ec hates joelteon:.
<alexgordon>
wait what
<ec>
…
<ec>
joelteon: ++
<purr>
Let it be known that ec is indifferent to joelteon:.
<ec>
lol'd
<ec>
purr <3
<purr>
Let it be known that joelteon is indifferent to big butts and i cannot lie.
* purr
rrr
<purr>
Let it be known that alexgordon loves tits.
<alexgordon>
++ tits
<ec>
purr ++
<purr>
Let it be known that ec loves purr.
<purr>
Let it be known that joelteon hearts tits.
<ec>
anyway.
<ec>
alexgordon: you remember what we covered of Scripts?
<ec>
vil: room is moderated.
<ec>
Nobody but me can see what all of you say.
<ec>
except via purr.
<ec>
-stop
<ec>
and now, not even that. ;)
<ec>
basically, we're now getting into the *semantics* of Scripts, alexgordon
<alexgordon>
yay
<ec>
Scripts are expressions, and an expression is an ordered list of words.
<alexgordon>
right
<alexgordon>
type Script = Expr;
<ec>
(I'm trying to put this into the spec *as* I explain it. hence slow.)
<alexgordon>
type Expr = [Word]
<alexgordon>
furrow description of paws!
<alexgordon>
that would blow ec's mind
<ec>
lol Paws implemented in Furrow-implemented-in-C++
<ec>
jesus H christ
<ec>
(dskuza: why, what?)
<alexgordon>
omg just realized how to do ADTs in furrow
<alexgordon>
ec: and what's a word again?
<ec>
errrrr, wasn't that in the spec
<ec>
oh, sorry
<ec>
Node*
<ec>
ugh fuck that re-naming that word
<alexgordon>
heh
<ec>
oh blah okay
<ec>
it's a Node.
<ec>
but the actual data is named “word.” whatever.
<ec>
"foo" "bar" "baz"
<ec>
each of those is a word.
<alexgordon>
so just an expr?
<alexgordon>
this is getting a bit complicated
<alexgordon>
you have three names for the same thing
<alexgordon>
Script, Expr, Node/Word
<ec>
no.
<ec>
expression ≠ word
<ec>
ugh I don't know the term for this, errr,
<ec>
think Reference in the ES5 spec.
<ec>
Ugh no okay. BLAH.
<ec>
dskuza: why not, what? o_O
<ec>
alexgordon: let me explain, and *then* you can help me fix the verbiage. 'k?
<alexgordon>
wait is dskuza saying things? I can't see any messages
<ec>
yes, only I can see them.
<ec>
-find mod
<purr>
ec: Found: modes, santa is female, and irc modes
<ec>
HOW IS THIS NOT A FACTOID.
<alexgordon>
ec: I feel like this complexity is unnecessary
<alexgordon>
ec: this is where you knowing haskell would be really helpful
<alexgordon>
since it's easy to describe this stuff in haskell
<ec>
-moderated @ vil
<purr>
vil: This channel is currently moderated. Only operators (+o) can hear what you say, unless you've been voiced (+v). This probably means we're [-working]. ;)
<ec>
-working @ vil
<purr>
vil: The channel is currently focused on a task. Please, for once, stay on-topic; at least until the project at hand is complete.
<ec>
there we go. <3
<ec>
anyway
<ec>
alexgordon: okay, let me work through this, then I'm happy to hear suggestions.
<ec>
somebody needs to knee whitequark in the nads, and wake him up.
<alexgordon>
but rewriting the spec in haskell speak
<ec>
(he should be able to see everything.)
<alexgordon>
whitequark: AWAKE, COMARDE
<ec>
So, alexgordon, describing the *semantics* of a Script, or “Paws program-graph.”
<ec>
Ugh, I don't know how to describe that clearly *at all*.
<ec>
“A juxtaposition of two objects (left-associative, and thus working from left-to-right) implies a “combination” of the right-hand object, with the result of the previous combination to the left.”
<alexgordon>
<@ec> is it clear enough, that if you hadn't worked on these same concepts with me on, Orb, would you be able to implement it off of this?
<alexgordon>
don't understand the question
<ec>
well, you said you understand this stuff enough
<ec>
but I thought the point of all of this was to make *something* like a spec
<alexgordon>
oh no I don't understand the paws stuff
<alexgordon>
but the juxtapositions are similar
<ec>
not done yet
<ec>
but the part I have written, is clear, yes?
<ec>
blue parts refer elsewhere in the document. obviously not written yet. getting there, slowly.
<ec>
devyn: made that tire-fire my Twitter profile background
<devyn>
ec: thank god, you've needed to do this for a long time :3
<ec>
devyn: well, it's fucking difficult. But alexgordon is helpful on this particular task.
<alexgordon>
I'm token idiot
<ec>
token idiot <3
<ec>
okay. next.
<devyn>
alexgordon: get micah to take a look at that, I'm kind of busy right now, plus he went a lot further trying to implement Paws in Haskell than I ever did
atln has left #elliottcable [#elliottcable]
<ec>
lol all the SB'ers are leaving
<alexgordon>
devyn: I'm not really trying to implement it, just describe it
<ec>
what pussies, can't handle a little paws in their ass
<ec>
JD's one of my closest friend around here, and he and his interns all flooded the room a couple hours ago
yorick has quit [Remote host closed the connection]
<audy>
I have a ruby question and #ruby made fun of me and told me to grow nards
<ec>
they have some *huge* musical clients
<devyn>
I like the parallax effect on the images+text
<devyn>
it's a little too much though
<devyn>
maybe toning it down would be good
<alexgordon>
man haskell IO monads confuse me so much
<devyn>
anyway, gone to write a shitty essay
<devyn>
alexgordon: haha how so
<alexgordon>
so ghetto
<alexgordon>
it's like they *really* don't want you using those bits
<devyn>
they don't
<devyn>
you're supposed to keep IO out of your application as much as possible
<alexgordon>
right
<alexgordon>
so why write it?
<alexgordon>
not very Apple-like
<alexgordon>
either do it nicely, or don't do it at all
<devyn>
because you need IO at some point, but it's best to abstract your input output until it actually needs to be passed to the operating system somehow
<alexgordon>
don't give me something purposefully shit
<ec>
it's enforcing good form by ghettolysis.
<devyn>
haha
<ec>
It's always safe to assume that the programmer using your tool/language/product is fucking smarter than you.
<alexgordon>
devyn: stinks of nanny-state programming languages
<ec>
If they're not, then somebody *else* who *is*, will fucking teach them to be. You, and your tool/language/project/product, will *not*.
<devyn>
ec: there's a good reason for keeping IO out of reach as much as possible, and that has to do with optimization
<devyn>
it's much easier to optimize pure code
<ec>
Yes, I'm quite aware, honeybuttonsfacepants.
<devyn>
lol
<ec>
I'm not talking about whether it's *better*.
<alexgordon>
devyn: just saying, if they don't want me using it, they shouldn't include it at all
<devyn>
they do want you using it
<devyn>
just appropriately
<ec>
I'm talking about *designing your language to punish*, instead of *documenting that fact*.
<ec>
For once, I'm with alexgordon
<ec>
anyway. moving on.
<devyn>
I'm not against alexgordon
<devyn>
Haskell's IO could be way better
<ec>
-working
<purr>
ec: The channel is currently focused on a task. Please, for once, stay on-topic; at least until the project at hand is complete.
<devyn>
just ask micahjohnston; he had some neat ideas
<devyn>
anyway gone
<ec>
I think “he had some neat ideas” fully describes micahjohnston/incomprehensibly.
<alexgordon>
fuck it, writing this function in furrow
<alexgordon>
TRY AND STOP MY, SPJ!
<alexgordon>
ME
<ec>
SPJ?
aarya123 has quit [Quit: Page closed]
<alexgordon>
ec: simon peyton jones
<ec>
dunno who that is.
<alexgordon>
ec: designer of Haskell, and C-- and other stuff
<alexgordon>
made GHC
<ec>
c--?
<alexgordon>
like llvm but only one quarter as good
<ec>
receiver is an Execution that “receives” combinations.
<ec>
basically, it's any Execution that takes a three-argument Object, and generates a value of some sort for them.
<alexgordon>
I meant in the doc :P
<ec>
two very important receivers are the default Object receiver, which basically preforms “a lookup”
<alexgordon>
I'm writing the stuff as you write it
* ec
nods
<ec>
and the default Execution receiver, which basically preforms staging (“procedure application.”)
joelteon has left #elliottcable ["bye"]
joelteon has joined #elliottcable
<ec>
alexgordon: all clear?
<ec>
basically:
<ec>
woah I fucked that up *royally*
<ec>
ignore all of that. >,<
<ec>
okay.
<ec>
alexgordon: that.
<alexgordon>
lol
<alexgordon>
fixed?
<ec>
yep.
<ec>
forgot that I'd excised naughty-logic from everywhere but find()
<ec>
okay.
<ec>
all clear?
<ec>
moving on.
<ec>
the two default receivers.
<alexgordon>
wait you deleted the stuff about continuations?
<ec>
nope
<ec>
it's execution again
<ec>
talked through this with whitequark.
<alexgordon>
lol
<alexgordon>
k
<ec>
they're different enough to deserve their own name. as I keep telling people, and they keep not believing me, until I explain it thoroughly.
<alexgordon>
probably good
<ec>
Geeze, it's like a guy can't be expected to just up and design his own program-flow primitive or somethin'. ddis
<ec>
If there's one “elliott-word” kept in Paws, it should probably be execution. Or maybe jux.
<ec>
kkkkkkkkkkk
<alexgordon>
I feel like furrow should have unicode set operators
<ec>
probs
<alexgordon>
ec: btw this is awesome
<ec>
wat
<alexgordon>
agree with devyn, you should have done this years ago
<ec>
lol
<alexgordon>
a spec!
<ec>
it's so half-arsed though
<ec>
D:
<ec>
I'm SO FUCKING BAD AT THIS.
<ec>
I can't stress that enough.
<alexgordon>
ec: doesn't matter as long as I understand
<ec>
This is the least formal, least complete, and least robust spec ever created.
<alexgordon>
ec → spec → alexgordon → normal people
<ec>
LOL.
<ec>
the missing evolutionary link, is it?
<alexgordon>
I'm the Prophet of Paws.
<ec>
“The First Follower”
<ec>
actually, pretty sure that's micahjohnston.
<ec>
you're one of the disciples or something.
<alexgordon>
well micahjohnston has several wives, so he fits the profile of muhammad
<ec>
ture
<alexgordon>
ec: question
<alexgordon>
"If the object has a receiver property, and the value of property is stageable (i.e. an Execution), then that callable value is the is the result."
<alexgordon>
do you clone it?
<ec>
LOL
<ec>
all you have to do is select it
<ec>
it's BRIGHT FUCKING PINK in my screen when you do so
<ec>
anyway:
<alexgordon>
LOL
<ec>
alexgordon: you don't clone it when *finding* the receiver.
<ec>
so that's not a part of *that* algorithm.
<alexgordon>
so just return the receiver
<ec>
but, as you'll see soon, the next step of the combinatorial algo (“call it”) *does* involve cloning it.
<alexgordon>
kk
<ec>
Which, by the way, is exactly what the “call” pattern is
<ec>
er, “call” algorithm:
<ec>
it's, given an execution: make a clone() of <it>, <clone> … unstage <it> … stage <clone> with given-value
<ec>
er
<ec>
unstage caller*(
<ec>
fuck
<ec>
whatever
<ec>
HENCE SPEC!
<ec>
CLEAR!
<ec>
getting there.
<alexgordon>
ugh this code sucks. why did I design it like this
<alexgordon>
furrow really doesn't like references :P
<alexgordon>
guess that's a good thing
<alexgordon>
doesn't make implementing paws any easier though
<ec>
I have an enormous (bigger than a handle … maybe 2-litre?) bottle of Grey Goose's Cherry Noir vodka sitting next to my laptop.
<ec>
I can't stop staring at it.
<ec>
It's calling me.
<alexgordon>
oh shit
<alexgordon>
drunk paws
<ec>
How can I be expected to specify Paws *sober*!?
<ec>
I mean, right? That's reasonable, right? I've been drunk every time I've ever explained Paws previously, sooooo …
<alexgordon>
you have? that explains SO much
<ec>
oh, no, it makes it better
<ec>
the maybe one-out-of-four times that I've been sober, it's always been terribly ineffective.
<ec>
;)
<ec>
anyway
<alexgordon>
my mind just went paws → booze → bars → paws chatup lines!
<ec>
… oh gods.
<alexgordon>
[drunkenly] "sweetheart, your eyes are pristine executions and my reactor is ready"
<ec>
ddis
<ec>
oh come on the terminology is getting more boring
<ec>
be nice
<alexgordon>
well we're getting there
<devyn>
ec: the working draft doesn't have to be formal or robust, it just has to be there
<ec>
lolk
<devyn>
just *being there* helps so much
<ec>
kk
<devyn>
:)
<ec>
are you here/watching?
<devyn>
not really
<ec>
any input? now's better than later.
<devyn>
I just happened to switch to irssi tab for a sec
<ec>
instead of drinking girly, cherry-flavoured vodka; I'm eating a decadent chocolate mousse pie from the steakhouse the other night.
<devyn>
mm
<ec>
Elliott writing spec === girl who just got dumped.
<ec>
At least, in terms of emotional state and coping actions.
<ec>
;)
<devyn>
haha
<devyn>
took me a while to figure that out *scratches head*
<ec>
huh?
<devyn>
as in what you meant by that
<devyn>
lol
<ec>
oh k
<alexgordon>
man this is so javascript
<ec>
okay.
<ec>
What now?
<alexgordon>
lol
<ec>
huh?
<alexgordon>
implementing this in furrow is quite hard
<ec>
explain bits that are difficult.
<ec>
*that* kind of thing is *exactly* why I wanted for you to be involved, so badly.
<alexgordon>
mmm
<alexgordon>
just the way it involves heterogeneous data
<ec>
Need *different* implementations. I can handle the procedural JavaScript/C approach, and micah will be able to give me the “implementing this in functional form” viewpoint; I needed the C++/Java *object-oriented* mindset.
<alexgordon>
I'll figure it out
<ec>
how so? example?
<alexgordon>
currently writing the default receiver
<alexgordon>
but the parameters are in an object
<ec>
Ahhhhh yes they have to be
<ec>
but what's wrong with that?
<alexgordon>
so I have to put them in an object (which is messy) and then unpack them out of the object
<alexgordon>
I think I may just not do that
<ec>
er, yes, that's built-in to the design
<ec>
executions only take one “argument” at a time.
<ec>
and, for obvious reasons, *receivers* cannot coconsume.
<alexgordon>
okay :P
<alexgordon>
when I understand the bigger picture I'll be more able to change stuff
<alexgordon>
right now I'm just implementing exactly what you write
<ec>
thus, the “API” for receivers, is that they must be implemented to consume exactly one argument, which gives them everything they need.
* ec
nods
<ec>
COOL MOVING ON :D
<ec>
default-receiver for objects.
<ec>
default-receiver for executions.
* ec
writes
* alexgordon
leaves ec to do his thing
<alexgordon>
but I'll füd
<alexgordon>
some of this is unclear to me
<ec>
huh?
<ec>
no, ask.
<ec>
I need food too, by the way. Let me know if you want to take a mutual break. I'll have to walk somewhere, so I may be a middling-while.
<ec>
alexgordon: still here?
<ec>
ugh
<ec>
lost 'im
<alexgordon>
ec: back
<ec>
hi
<ec>
what was unclear, alexgordon?
<alexgordon>
ec: executions
<ec>
haven't gotten there yet :D
<alexgordon>
oh I see you've written about the look up algorithm
<ec>
I wrote the very little bit that's down there, day before yesterday; but everything else I've done so far is to “skirt around” queueing/executions
<ec>
and formally specifying everything up unto that point
<alexgordon>
ec: this bit is new to me
<alexgordon>
"If the “value” slot of a matching object is empty, then this algorithm still generates a result: that emptiness itself"
<ec>
That doesn't mean anything in terms of implementation to you, *just yet*.
<alexgordon>
empty objects were not described earlier
<ec>
yeah, there is no such thing.
<alexgordon>
is that an object with no members?
<alexgordon>
confused
<ec>
I'm about to update the only place (so far) that *uses* the lookup-algo, to describe how to handle each of those circumstances.
<ec>
basically:
<ec>
there's no “undefined” type in Paws' Nucleus. Similarly, there's no booleans (truthiness, or falsiness.)
<ec>
I'll add a rationale section describing this a bit later.
<alexgordon>
okay but how can an object have an empty value slot
<alexgordon>
if there's no such thing as emptiness
<ec>
oh, *that's* possible.
<ec>
It's just not visible from the user-facing end of things.
<ec>
yes, I definitely need a rationale section on emptiness and “Paws' booleans.”
<alexgordon>
okay so
<alexgordon>
how do I encode that
<ec>
which is something of an inside joke, because Paws doesn't *have* booleans … a Paws boolean is *not returning at all*.
<alexgordon>
an empty value slot
<ec>
undefined, or null, or whatever you like.
<ec>
as long as your implementation can recognize it.
<ec>
it will never be passed along to the user. (er, to libside.)
<alexgordon>
but that's different from a list with no members?
<ec>
yes. a list with no members is still a value, a thing.
<ec>
so, for example:
<ec>
() is different from (, , 'a')
<ec>
the former has no member-slots, the latter has two empty member-slots and a value in the third.
<joelteon>
I thought paws didn't have syntax
<alexgordon>
lol
<ec>
joelteon: it doesn't, and that syntax wasn't Paws. ;)
<joelteon>
oh
<joelteon>
ok
<alexgordon>
ec: okay so member slots can be empty, but objects can't?
<ec>
alexgordon: errrr, how do you mean by that
<alexgordon>
well if you can have
<ec>
an object can be “empty” in that it has zero members …
<alexgordon>
(,foo)
<alexgordon>
the first slot being empty...
* ec
nods slowly, and waits …
<alexgordon>
but you can't have an empty *object*
<alexgordon>
as in
<alexgordon>
null
<ec>
correct.
<alexgordon>
so like it's not (null, foo)
<ec>
there is no empty-object type, or “empty-state” for objects.
<ec>
correct.
<alexgordon>
okay so I could represent that as a map
<ec>
or rather, it *could* be on your end, but the user would never be able to differentiate.
<ec>
If there's no value in a slot, then they simply cannot *get* the value of that slot. Nothing happens.
<alexgordon>
or a list of maybes
<ec>
They don't get some sort of “nothing was there” response, such as a null object.
<ec>
all that matters in a Paws object are the indices that *have* values.
<alexgordon>
right
<ec>
definitely need a rationale section on that.
<ec>
omg too many to-do's floating around in my head.
<ec>
need an incomplete section D:
<prophile>
so you can formalise an operation in paws, disregarding time, as essentially returning a list
<prophile>
which maps onto how many times it returns
<prophile>
and looking up a missing key gives you [] rather than [null]?
<ec>
waitwat
<alexgordon>
jesus fuck this is complex
<ec>
lolwat
<alexgordon>
ec: is there a difference between (foo,) and (foo) ?
<joelteon>
the fuck
<alexgordon>
are they of the same identity?
<ec>
alexgordon: no, there's a difference.
<ec>
oh, sorry
<ec>
mis-read that, multitasking too much
<ec>
That is of no importance, yet, to the language.
<alexgordon>
not what I asked though :P
<joelteon>
so this explanation has taken two days so far, right?
<alexgordon>
say your key is (foo,)
<ec>
The *only place* that will come into play, later, is *when or if* I provide a length() primitive-action,
<alexgordon>
and you're testing it against (foo)
<alexgordon>
is that a match, or not?
<ec>
well, even two (foo) (foo) will not compare-as-equal.
<ec>
Come back and hang out with us for a couple hours later tonight? (=
<prophile>
we'll see :)
<ec>
aww
<ec>
but i miss u
<ec>
bby pls
<ec>
>:
<alexgordon>
"but I need to go and eat some sausage"
<alexgordon>
ec: "This algorithm obeys the zeroth rule, particularly with respect to the pseudo-pairs it "
<alexgordon>
three words:
<alexgordon>
what
<alexgordon>
the
<alexgordon>
fuck?
<ec>
“zeroth rule”
<alexgordon>
it's not even english
<ec>
there's an enumeration thereof in the definitions section
<alexgordon>
oh encourages
<alexgordon>
ok so it IS english
<alexgordon>
but not any english I understand
<alexgordon>
wtf is a pseudo-pair
<ec>
I tried to rename “naughty” something better?”
<ec>
it's nothing.
<ec>
It's in a rationale section brah.
<ec>
it's saying, a thing that is kind of a pair.
<ec>
a pseudo-pair is not an actual thing that exists in Paws, hence why it's “pseudo-”
<ec>
It's a description of *why* that algorithm works the way it does. That is, how it's treating the data.
<ec>
make any sense?
<alexgordon>
none whatsoever
<alexgordon>
so it's meaningless, even to you?
<alexgordon>
"thus being compatible, also, with clearly-superior one-indexed designs"
<alexgordon>
lol gtfo
<alexgordon>
ec: can't wait to implement this in C
<alexgordon>
with GCD
<alexgordon>
will be awesome
* ec
laughs
<ec>
I'm excited, too.
<ec>
I'm so happy you're involved now. (':
<alexgordon>
now that I sort of understand how it works
<alexgordon>
I *might* be able to optimize it
<joelteon>
Is the explanation doen?
<alexgordon>
so that it's not so horrifically slow
<joelteon>
done?
<alexgordon>
joelteon: no, but it's getting there
<joelteon>
ok
<joelteon>
I can't really follow along with explanations when they last more than 12 hours
<alexgordon>
ec: this has come at just the right time, I need a crazy project like this to rekindle my love of programming
<joelteon>
so someone's gonna have to make a condensed version
<ec>
joelteon: It's only this slow because I'm *using* the explanation-to-alexgordon *to help spec it*.
<alexgordon>
joelteon: once i understand it, and I'm closer than ever now :P I'll explain
<ec>
joelteon: I can easily teach you almost all of the Nucleus in five hours flat.
<ec>
Especially with both a spec AND an implementation to point to, now.
<ec>
omg.
<joelteon>
wow, five hours
* ec
O_O
<joelteon>
it takes like what, 30 minutes to explain ruby to someone
<ec>
joelteon: … you seriously believe you can teach somebody to program in Ruby in thirty minutes?
<joelteon>
i could teach them to define a function in less than that
<ec>
joelteon: with *no* experience in any related, procedural programming language, or anything else sharing a similar paradigm?
<joelteon>
that said "hello world"
<joelteon>
oh
<joelteon>
maybe not
<joelteon>
but I have procedural programming language experience
<ec>
You forget, Paws is extremely out-there. This is a lot more like teaching somebody Haskell or Prolog; and if you could make substantial progress in making somebody with no prior knowledge in the field self-sufficient in Haskell or Prolog in thirty minutes … I'd be very impressed.
<ec>
and quoting five hours, is for me to literally teach you *everything* about it. Enough to *implement* it.
<ec>
the Nucleus is intended to be Scheme-like in that aspect: it's supposed to be rather ascetic. Easy to implement a copy. Small specification, under twenty pages.
<joelteon>
ok
<alexgordon>
ec: teach a man to fish, and he'll eat for life. Write a book on it and everybody can eat
<alexgordon>
NO TEACHING WHILE SPEC IS UNFINISHED
<ec>
lolk
* ec
goes back to writing the header-material
<joelteon>
wow, the wikipedia articles on programming language comparisons are absolutely awful
<alexgordon>
haha
<ec>
RIGHT.
<ec>
OH. MAH GOD.
<ec>
I feel like this room needs the equivalent of one of those public-works teams …
<ec>
“Adopt a Highway”-style, we should take one Sunday out of each month, and go do public-works style “clean up programming-language-related Wikipedia.”
<ec>
Turns out Google *really* doesn't like emoji. fail.
<alexgordon>
lol
<ec>
fixed. Monospace ftw.
<rckts>
I'm excited to see what Paws' Fullness ends up looking like
<ec>
rckts: Oh, there's plenty of data out there on that from a few years back, when I was designing full-bore at the Fullness level.
<rckts>
Oh that must've been fun /s
<ec>
Now that i've got a pretty clear idea of what I want at Fullness (at least, at a high-level pass), I've dived into specific work on the Nucleus VM-design.
<ec>
or, uh, VM-spec-design? whatevs.
<ec>
actual VM-design is over my head.
<ec>
rckts: hi!
<ec>
rckts: haven't seen you in here in ages. where'd you come from?
<rckts>
LOL did you just realize it was me
<rckts>
I just reinstalled Textual and remembered the room so I decided to join again
<rckts>
cba to install irssi on my VPS
<rckts>
well, installing is easy, it's more like i cba to configure it
<ec>
no, I know who you are, I'm just distracted and busy
<ec>
alexgordon: what now?
<alexgordon>
ec: staging?
PragCypher has quit [Quit: Leaving]
<ec>
I'm intentionally avoiding that :D
<ec>
is there *anything else*, in everything I've written, that is unclear?
<alexgordon>
ec: not sure, I need to read everything first
<ec>
kk
<ec>
do that now.
<ec>
getting food.
<alexgordon>
k
<ec>
read it in detail, now is a *really* good stopping-point to offer responses.
<ec>
small things (typos, obvious contradictions), ask in here.
<ec>
anything medium or large, open a GitHub issue, though, please.
<ec>
<3 records.
<joelteon>
I love coffee
<ec>
I love joelteon
* ec
enjoys his break, and eats Jimmy John's.
<alexgordon>
hi ec
<ec>
Todo: Object->push/pop/shift/unshift
<alexgordon>
ec: so I understand everything written about
<alexgordon>
everything I don't understand is not written about :P
* ec
nods
<ec>
cool cool
<ec>
alexgordon: hi.
<ec>
Harvest started.
<ec>
eating, and spec'ing. Let's do this.
<alexgordon>
haha
<alexgordon>
gonna start a C implementation then
<ec>
let's do this in here first. Been doing spec-first too much, got kinda ahead of myself. But that was mostly because I was spidering down into sub-topics that I had to explain to even begin to cover the over-topic.
<ec>
fresh start, here.
<ec>
SO.
<ec>
As you've probably surmised by now, “running code” (which until I come up with a better word, I will call the ‘realization’ of code), basically boils down to processing some series of these ‘combinations.’
<alexgordon>
right
<ec>
so mostly, what we have to talk about next, is going to be how we *order* the realization of a queue of combinations.
<ec>
… which I guess, is our first topic: the queue.
<alexgordon>
I hope you're going to spec all of this :P
<alexgordon>
ec: btw, what about changing symbol's "content" to "name"
<alexgordon>
talking about a symbol name makes more sense than symbol content
chris-tina has joined #elliottcable
eligrey has quit [Quit: Leaving]
rckts has quit [Quit: slepu]
<alexgordon>
"Additionally, note that the parameters object has no ‘zeroth’ (or empty slot at index zero.) In the above, the Execution being passed as the first parameter is literally the first element of the parameters-object's members."