ec changed the topic of #elliottcable to: #
<devyn> alexgordon: not even mormon women know. it's all a mystery
<devyn> alexgordon: whoops, did I say mystery? I meant goddidit
jdhartley has joined #elliottcable
devyn has quit [Read error: Connection reset by peer]
sanitypassing has quit [Read error: Connection reset by peer]
devyn has joined #elliottcable
<joelteon> ok
<joelteon> i set prefix_same_nick to be the empty string
<joelteon> now weechat looks awesome
<purr> <darkf> im not math you should know that
<joelteon> any suggestions?
jdhartley has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
devyn has quit [Read error: Connection reset by peer]
<purr\Paws> [Issues] ELLIOTTCABLE opened issue #8: Single reads can bypass bubbles https://github.com/Paws/Issues/issues/8
devyn has joined #elliottcable
<purr\GH> [purr] ELLIOTTCABLE opened issue #11: Twitter gateway https://github.com/ELLIOTTCABLE/purr/issues/11
eligrey has quit [Quit: Leaving]
alexgordon has quit [Quit: Computer has gone to sleep.]
jdhartley has joined #elliottcable
devyn has quit [Ping timeout: 260 seconds]
eligrey has joined #elliottcable
eligrey has quit [Quit: Leaving]
<purr> <alexgordon> only elliottcable could unwittingly name something after bloody anuses
<joelteon> unwittingly?
<joelteon> not likely
<joelteon> what is it with people who use synthol
<Nuck> What *was* it that he named anyways?
<joelteon> I've been trying to catch rayquaza with a pokeball for a month
<Nuck> Hahaha
<joelteon> i'll hire someone to do this for me
<Nuck> Just go to Home Depot and hire a spare Mexican
<Nuck> Benefits of living in California
<Nuck> -r34 octocat
<Nuck> -34 octocat
<purr> Nuck: ... if you had any sense, you wouldn't have asked.
<purr> Nuck: Here. <http://bit.ly/181YW4w> [NSFW]
<Nuck> .......
<joelteon> tosin abasi is so fucking good
<joelteon> holy butts
jdhartley has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
devyn has joined #elliottcable
devyn has quit [Ping timeout: 255 seconds]
devyn has joined #elliottcable
<purr> <alexgordon> FUCK cups
<racaille> >:(
<prophile> cups of fuck
<whitequark> mmmmmmm
<whitequark> EC: PING
<ec> who the hell is racaille
<ec> whitequark: WHAT
<ec> whitequark: shoulda tweeted at me brah
<ec> whitequark: hi brah
<whitequark> hi
<purr> whitequark: hi!
<ec> whitequark: hi
<ec> whitequark: whazzup
<whitequark> -draft
<whitequark> or how was it called
<whitequark> -paws
<purr> whitequark: “the scientology of programming langiages” <http://ell.io/iksN9>
<whitequark> ugh
<whitequark> EC: WHAT HAVE YOU DONE ON PAWS YET
<ec> how do yew mean
<ec> been driving, brah
<ec> and it's -spec
<whitequark> -spec
<purr> whitequark: Paws' half-arsed Version 10 specification <http://ell.io/ihQzs>
<ec> whitequark: gmail address, so I can add you?
<whitequark> ec: I'm already there
<whitequark> for years!
<ec> what
<ec> no, I mean, to give you access
<ec> right now you're anonymous! D:
<whitequark> mhm? I can read
<whitequark> whitequark@gmail.com by the way, in case IT WASN'T OBVIOUS :p
<ec> ISN'T OBVIOUS
<devyn> GUYS
<ec> omg devyn
<ec> devyn: you too, gmail addy
<devyn> my server won't crash every 5 minutes any more!
<devyn> wow holy shit
<ec> devyn: what?
<devyn> spec
<devyn> kind of impressive now
<ec> what about it?
<ec> is it?
<ec> it's not even half done, for the stuff we have *now* |=
<devyn> it's still looking good
* devyn pats ec on the back
<ec> awwww
<ec> well CONTRIBUTE BITCH
<ec> :D
<ec> (also you're a bat)
<ec> (gmail so you can be a devyn)
<devyn> devyn.cairns@gmail.com
<devyn> you already have had it
<devyn> I also have me@devyn.me when I feel like being an egomaniac
<ec> sent
<devyn> cool I have no idea what to do
<ec> what we're doing, is talking through all of the design that exists right now
<ec> looking for inconsistencies, holes, and unspecified bits
<ec> and as we work through it, I'm doing my best to write a normative spec
<ec> or, at least, a first stab at one
<ec> since I'm crashing soon: best you can do for me, is read through everything that's there, and try to find errors, try to break it, try to find contradictions, etc
<ec> post them here:
<ec> -issues @ devyn
<devyn> holy shit ram is expensive guise
<devyn> :'(
<devyn> okay
<devyn> I'll do that
<devyn> at some point
<devyn> soon
<ec> <3 devyn
<purr> Let it be known that ec hearts devyn.
<devyn> <3 ec
<purr> Let it be known that devyn hearts ec.
<ec> hi whitequark
<whitequark> hi
<purr> whitequark: hi!
<whitequark> new foundry syntax <3
<ec> HASTEBIN. THAT'S WHAT I WAS LOOKING FOR.
<ec> -paste
<ec> -find paste
<purr> ec: Found: elliott's drugs, an oases of what?, and never forget
<ec> -learn paste = <http://hastebin.com/>
<purr> ec: Learned `paste`.
<whitequark> -ovoids
<purr> whitequark: http://pastebin.com/RP1hWBHP
<ec> whitequark: god, it's been so long since I've written ruby. Jesus.
<whitequark> fuck ruby, i'm writing it in ocaml
<whitequark> since doing it from scratch anyway
<ec> wait. foundry is ocaml now?
<whitequark> foundry's compiler is in ocaml now
<whitequark> the language was always a weird mix of ML and Ruby
<ec> ohhhhh.
<whitequark> ec: surprises you?
<ec> I know nearly nothing about ocaml
<whitequark> mmm
<whitequark> it's an ML variant, thus, functional
<whitequark> it is also "practical"
<whitequark> aka you can write shit in it and shit is fast and compact
<whitequark> and it has libraries and all
<whitequark> also, windows
* ec eyebrow
<ec> cool!
<ec> I know nothing about MLs
<whitequark> it also has really really neat OO capabilities
<whitequark> structural typing for OO
<whitequark> and type inference
<whitequark> also, first class modules.
<whitequark> no idea what it is, but it looks like smth which will solve my problems in foundry
<whitequark> hence, writing it in ocaml AND stealing features from ocaml.
<ec> no idea what *what* is?
<whitequark> fuck, 80% of ocaml looks like I would have designed it
<whitequark> <3 ocaml
<purr> Let it be known that whitequark hearts ocaml.
<whitequark> ec: first-class modules.
<ec> ah
<whitequark> it seems like a cleaner solution to modules with type parameters than what they have now, ie functors
<whitequark> "module constructors" analogue to type constructors
<ec> all over my head.
<ec> micah tried to explain what a functor was to me once.
<ec> I think he failed
<whitequark> ec: oh, he was talking about C++
<whitequark> fuck C++, they are abusing the ter
<whitequark> *term
<whitequark> in ocaml, a functor is just a function which executes as compile time and constructs modules
<whitequark> with passed parameters
<whitequark> as I understand it.
<devyn> hey. hey, you. yeah that's right, you. I'm gonna be off IRC for a bit while I re-OS my server
<devyn> I'M STILL WATCHING
<devyn> don't be doin' anythin' STUPID
<devyn> okaaaay?
* devyn gone
devyn has quit [Ping timeout: 240 seconds]
s1n4 has joined #elliottcable
s1n4 has quit [Quit: leaving]
<prophile> a functor is a mapping of morphisms from one category to another iirc
<whitequark> prophile: not in ocaml lingo :)
<prophile> it's the mathematical definition
<prophile> and I suspect it's where ocaml's version comes from
devyn has joined #elliottcable
devyn has quit [Client Quit]
devyn has joined #elliottcable
devyn has quit [Client Quit]
devyn has joined #elliottcable
alexgordon has joined #elliottcable
<purr> <purr> whitequark loves git, console, purr, foo, and Adrian Thurston.
<purr> <Nuck> alexzordon: The GNU userspace tools are infinitely better than the BSD ones
jdhartley has joined #elliottcable
PragCypher has joined #elliottcable
<joelteon> a functor is a thing with a type variable in it
<purr> <Nuck> I guess, but I don't care about build quality or looks, I just want a good cup
<joelteon> heh
<vil> hallo
niggler has joined #elliottcable
<joelteon> hi
<purr> joelteon: hi!
<niggler> any C experts here?
<vil> I know just enough C to be dangerous, basically
<joelteon> I know just enough C to be sneered at by ##c
<joelteon> what's up?
<niggler> i should have said C preprocessor
<joelteon> oh yeah I'm good at that
<vil> joelteon: hah
<niggler> I'm trying to use it for some JS source
<niggler> standard #include etc etc
<niggler> and i find that i always end up with two newlines at the top
<niggler> that is to say, an empty file ends up having two newlines
<niggler> and a file that just #include's another has two lines at top
<niggler> i used the standard -P -C options
<joelteon> God DAMN it
<joelteon> I hate when I underestimate how much coffee is in my cup
<niggler> err
<joelteon> I have no idea why thaht's happening
<niggler> its really strange
<whitequark> niggler: cpp -nostdinc
<whitequark> don't ask
<niggler> still does it
<whitequark> WORKSFORME?
<niggler> lol are you on osx?
<purr> lol
<niggler> maybe its a mac thing
<whitequark> niggler: nope
<niggler> are you on osx?
<whitequark> nope
<whitequark> debian
<niggler> oh
<joelteon> apple developer support is cool
<joelteon> oooooh
<joelteon> mavericks is coming
<niggler> ok whitequark i conceded defeat
<niggler> -nostdinc didn't do anything
<niggler> but it turns out that -C doesn't mandate anything about whitepace
PragCypher is now known as phoon
<ec> hiiii
phoon is now known as PragCypher
<joelteon> hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
<PragCypher> high
<joelteon> it takes 40+ minutes to download GHC if you're also downloading OSX mavericks and xcode 5
<joelteon> today i learned
eligrey has joined #elliottcable
<ec> hi
<purr> ec: hi!
<jdhartley> ec hi
<niggler> joelteon can you check if cpp prepends newlines?
<joelteon> -best t mux
<purr> TMUX IS BESTMUX
<joelteon> -best best iality
<purr> BESTIALITY IS BESTIALITY
<joelteon> you're right purr
<joelteon> -best best iarianism
<purr> BESTIARIANISM IS BESTIARIANISM
s1n4 has joined #elliottcable
<alexgordon> hi ec
<joelteon> pretty good video
s1n4 has quit [Quit: leaving]
<whitequark> -ovoids
<purr> whitequark: http://pastebin.com/RP1hWBHP
<whitequark> ec: I think I finally get them.
<ec> whitequark: hm?
<whitequark> ec: ovoids.
<whitequark> earlier, I just read that log and meh
<whitequark> what the fuck
<whitequark> but now, I read it and duh! ovoids! that's really fucking funny
* whitequark giggles
<purr> <elliottcable> white goo dreeping down my strema
<ec> hi all
<ec> whitequark: lol. you're just grasping that log *now*?
<purr> lol
<joelteon> damn, xcode5 ain't half bad
<ec> really?
<joelteon> yeah
<joelteon> more UI space
<ec> ah
<joelteon> doesn't support xvim yet
<ec> waaaat is xvim
<joelteon> vim mode for xcode
<ec> that sounds epic.
<ec> what about just MacVim and xcodebuild and such?
<ec> Ingredients, git
<ec> working entirely outside the IDE?
<joelteon> yeah but then the debugger is shit
<joelteon> and all the build steps and linking and stuff
<joelteon> that's a pain
eligrey_ has joined #elliottcable
<whitequark> ec: purr is surprisingly relevant
<whitequark> and yeah
* whitequark is playing Gunpoint
<whitequark> it's cool.
eligrey has quit [Read error: Operation timed out]
jdhartley has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<ec> wassat
eligrey_ has quit [Read error: Operation timed out]
<whitequark> ec: game
<ec> never heard of it
<whitequark> the subtitle basically explains it.
<whitequark> I like it a lot.
<whitequark> go play it.
eligrey has joined #elliottcable
PragCypher has quit [Quit: Leaving]
yrashk has quit [Ping timeout: 268 seconds]
sanitypassing has joined #elliottcable
<purr> <brr> elliotcable is *really intelligent*
<whitequark> ocaml is really nice. it's like C++, but sane, and with rubygems.
<whitequark> batteries included: parsers/emitters for audio/video/text (html/css/json/markdown/xml/whatever), *one* set of stdlib extensions
<whitequark> and it's fast as hell
<joelteon> it has parsers for everything?
<whitequark> joelteon: kinda
<whitequark> also has a LR(1) (not LALR(1)) parser generator available
<whitequark> I don't think there is one for ruby, at all.
<whitequark> because all hipsters fucking love PEG
<joelteon> nice
<alexgordon> ocaml is nice
<alexgordon> but it's just not very well designed
<alexgordon> as a language
<whitequark> wat?
<whitequark> elaborate.
<alexgordon> e.g. it has operator overloading, but it's really poorly done
<alexgordon> compared to haskell
* whitequark shrugs
<purr> ¯\(º_o)/¯
<whitequark> it's designed a hell of a lot better than C++ ;)
<alexgordon> I dunno
<joelteon> heh
<joelteon> here are the features of my language!!!
<alexgordon> C++ is great if you use the new stuff
<whitequark> and, incidentally, ruby
<joelteon> 1. better designed than C++
<joelteon> 2. faster than ruby
<alexgordon> joelteon: yeah meet furrow :P
<joelteon> 3. better community than node.js
<joelteon> it was a sarcasm
<alexgordon> no community, but it has like… me!
<alexgordon> I'm nice. sometimes.
<alexgordon> hey I do a good impression of isaacs
<alexgordon> joelteon: you're a fucking idiot
<joelteon> nice one
<joelteon> alexgordon: do you have brain damage?
<joelteon> try listening to the retarded things coming out of your mouth
<whitequark> node.js is close to metal
<joelteon> and/or learn to read
<joelteon> guess who I am
<alexgordon> linus?
<joelteon> zhivago
<joelteon> but they might be the same
<alexgordon> joelteon: either that or ulrich drepper
<joelteon> oh
<joelteon> dunno who that is
<alexgordon> glibc
<alexgordon> like stallman, but more ideological and harder to get along with
<purr> hah
<alexgordon> does purr understand jokes now?
<alexgordon> like cheese but stinkier and with more holes
<alexgordon> ….
<joelteon> what, really
<whitequark> like stallman, but more ideological and harder to get along with
<purr> hah
<joelteon> how can someone be more ideological than stallman
<whitequark> like stallman, but more ideological and harder to get along
<purr> hah
<whitequark> like stallman, but more ideological and harder to get
<joelteon> he's like linux al-qaeda
<whitequark> like stallman, but more ideological and harder to
<whitequark> like stallman, but more ideological and harder
<whitequark> like stallman, but more ideological and
<alexgordon> joelteon: hah on the first page: http://sourceware.org/bugzilla/show_bug.cgi?id=10134
<whitequark> like stallman, but more ideological
<alexgordon> of google
<whitequark> like fuckers, but more ideological and harder to get along
<purr> hah
<whitequark> like fuckers, but more ideological and harder to put along
<whitequark> like fuckers, but more ideological and harder to wat along
<joelteon> uh
<ec> hi
<purr> ec: hi!
<joelteon> heh
<joelteon> so this kid told me that he hates ruby because it's "useless for professional applications" because "it doesn't have eval"
<ec> lolwat where
<purr> lolwat
<joelteon> different network
<ec> lolwat
<joelteon> i'm gonna tear him a new butthole
<ec> lol good luck with that
<purr> lol
<ec> also, instance_eval o_O
<ec> the shit I've done with instance_eval and class_eval are dirty.
<ec> diiiiiirty.
<joelteon> haha
<joelteon> I love instance_eval
<ec> whitequark: so, you're here?
<ec> alexgordon: you, by any chance?
<alexgordon> here
<alexgordon> joelteon: lolwat
<purr> lolwat
<alexgordon> joelteon: is this kid… sephr?
<ec> alexgordon: hi!
<joelteon> alexgordon: nah
<ec> Paws? :)
<alexgordon> ec: where are you?
<alexgordon> driving? :P
<ec> nope, Minneapolis
<alexgordon> of course
<ec> Soooo, Paws? :)
<alexgordon> why Minneapolis
<alexgordon> it's the middle of nowhere
<ec> what?
<alexgordon> Minneapolis
<ec> family.
<alexgordon> o_O not alaska?
<ec> CONUS family
<alexgordon> lol
<purr> lol
<alexgordon> ok paws me
<ec> I endeavoured to not add anything new to the spec since we last talked
<ec> but a lot got updated a tad
<alexgordon> -spec
<purr> alexgordon: Paws' half-arsed Version 10 specification <http://ell.io/ihQzs>
<alexgordon> what's new?
<ec> I don't remember.
<ec> anyway
<ec> fuck, where were we
<ec> alexgordon: I DON'T KNOW WHAT WE WERE DOING
<alexgordon> ec: REACTORS
<alexgordon> ec: STAGING
<alexgordon> STUFF
inimino has quit [Read error: Operation timed out]
<ec> hmmmmmmm
<ec> advancement! that's what.
<alexgordon> right
inimino has joined #elliottcable
<ec> fuck, sorry, multitasking
<ec> okay.
<ec> You've got me until the power/internet goes out, whenever that is;
<ec> minus one hour, because the eldest and father need my help setting up the generator.
<ec> at some point.
<alexgordon> lol
<purr> lol
<alexgordon> ec: so, advancing
<ec> well, the design sucks right now, here.
<ec> need to iterate it towards simplification.
<ec> anyway, what we've been working with thus far:
<alexgordon> jesus fuck
<joelteon> ouch my forearms
<ec> don't bother reading it
<ec> trying to write it out now
<ec> you have the spec open?
<ec> Execution->advance()
<ec> Ugh I'll need to re-design this later.
<ec> terribs.
<ec> alexgordon: I'll just explain it with words, for now.
<alexgordon> lol
<purr> lol
<ec> Basically, advance() takes the execution, and “dives into” the next node.
<ec> i.e., notating by surrounding the “current” node with square-brackets,
<ec> `foo (bar baz) widget`
<ec> let's say it's pointing here:
<ec> [foo] (bar baz) widget
<ec> if we advance() that execution, then two things happen:
<ec> the result of foo gets placed on the stack (to be combined against *later*, when we've got a result for the subexpression),
<ec> and the program-counter pointer is moved forward to point at the expression itself
<ec> foo [(bar baz)]
<ec> (at this point, the stack would look like {O<foo>})
<alexgordon> O?
<ec> object.
<alexgordon> I see
<ec> notation I've been using without any explanation since we started here. my bad, assumed you understood it implicitly.
<alexgordon> lol
<purr> lol
<alexgordon> assume nothing
<ec> S'foo' being the symbol “foo”
<ec> O<foo> being an arbitrary object, that we're calling foo, for now
<ec> called such since it was the result of
<ec> COMBINE(O<locals>, S'foo') => O<foo>
<ec> with me?
<alexgordon> hold on
<ec> anyway
<ec> yes?
<alexgordon> right
<ec> kk
<ec> so.
<ec> execution starts out, looking like this:
<ec> `foo (bar baz) widget`, {}
<ec> (no program-counter, hence no squarebrackets in that notation … and an empty stack.)
<ec> first combination of a pristine execution, juxtaposes S'foo' against O<locals>
<ec> COMBINE(O<locals>, S'foo') => O<foo> happens. somehow. you already understand how that works.
<alexgordon> yah
<ec> so, now the execution, after that combination is complete, looks like this:
<ec> `[foo] (bar baz) widget`, {O<foo>}
<ec> errrrr, gonna change the execution retroactively, to make this easier to explain
<alexgordon> lol
<purr> lol
<ec> `[foo] bar (baz widget) fucktard`, {O<foo>}
<ec> there we go.
<alexgordon> so my plan here is to implement it from the spec, then modify the hell out of it
<ec> lolk
<alexgordon> so it's the same, but different
<ec> sounds like a good plan
<ec> meaning same operational semantics, but differing from all the implementation-specifics in the spec right now?
<alexgordon> yeah
<ec> that's exactly what I need/want you to do. The more “different” your system is from mine, the better.
<ec> helps me:
<alexgordon> hahaha
<ec> A) “triangulate” a unviersal op-sem with as little implementation-defined shit as possible
<alexgordon> I'm going to bleed it dry until there's no elliott left
<ec> B) helps excise design elements which are *dependent* upon implementation being as I imagine it
<alexgordon> anyway, so what's a "pristine" execution
<ec> C) helps us design the bits that need to work across multiple, possibly-wildly-differing implementations
<ec> pristine means it's *never* been advanced
<ec> i.e., in this explanation, pc == NULL
<ec> or sommat like that
<alexgordon> okay so executions start out as pristine
<ec> yep
<alexgordon> then advance turns that bit off
<ec> and the first combination to result from them, makes them no longer pristine
<ec> yep
<ec> this has important repurcussions later. we'll get into that when we talk about queueing.
<ec> or rather, the queueing *operations.*
<ec> anyway.
<ec> so.
<ec> we've advanced this guy once, he looks like:
<ec> `[foo] bar (baz widget) fucktard`, {O<foo>}
<ec> now, same process, a second time:
<ec> COMBINE(O<foo>, S'bar') => O<foo's.bar>
<ec> aka O<fb>
<ec> `foo [bar] (baz widget) fucktard`, {O<fb>}
<ec> notice: the PC tends to point at the last thing we processed, when that thing was an object.
<alexgordon> yeah
<ec> also notice: the “top element” of the stack, is always the result of the very most recent combination.
<joelteon> these chips are really good but the inside of the bag smells like a penis
<ec> joelteon: wat.
<purr> beep.
<ec> next!
<joelteon> you know the distinct musk of dick that hasn't been washed in a day or so
<joelteon> that's what it smells like
<joelteon> and I don't know why
<ec> COMBINE(O<locals>, S'baz') => O<baz>
<ec> now our execution looks like:
<ec> `foo bar ([baz] widget) fucktard`, {O<fb>, O<baz>}
<ec> I'll just skim through the next:
<ec> `foo bar (baz [widget]) fucktard`, {O<fb>, O<bw>}
<ec> now, we're done with the sub-expression, and the next combination is of the result of that, against one higher element in the stack.
<ec> COMBINE(O<fb>, O<bw>)
<ec> and finally, the end-state of our execution after these, being,
<ec> `foo bar [(baz widget)] fucktard`, {O<fb-bw>}
<ec> notice: the PC currently points at *an expression*-node, not an object-node.
<ec> also note; it's still the case that the *top element* of the stack points at the result of the most recent combination.
<ec> easy? with me?
<alexgordon> yeah
<ec> so, result of the last combination would be …?
<alexgordon> god this is like school
<ec> >,<
<ec> just trying to make sure you understand it, because I don't have a nice clean spec-algorithm to show you yet
<ec> since I described it in words, I have to double-check that there's no misunderstanding.
<alexgordon> er `foo bar (baz widget) [fucktard]`, {O<fb-bw-fucktard>}
<ec> yerpyerp
<ec> two more edge-cases you need to know about:
<ec> `foo ((bar)) baz`
<ec> `[foo] ((bar)) baz`, {O<foo>}
<ec> COMBINE(O<locals>, S'bar')
<ec> => O<bar>
<ec> `foo (( [bar] )) baz`, {O<foo>, NULL, O<bar>}
<ec> COMBINE(O<locals>, O<bar>) => O<bar>
<ec> er
<ec> O<bar-meta>
<ec> `foo ( [(bar)] ) baz`, {O<foo>, O<meta-bar>}
<ec> COMBINE(O<foo>, O<meta-bar>) => O<foo-mbar>
<ec> finishes up as,
<ec> `foo [((bar))] baz`, {O<foo-mbar>}
<ec> does that make sense?
<ec> there's always as many elements in the stack, as you are deep into sub-expressions. If there's no previous combination-result to *put* in the stack, there's an empty index there instead.
<ec> and when you're combining against an empty index, it's an *implicit* combination. obviously.
<ec> i.e. against locals, as described in the spec.
<ec> with me?
<alexgordon> right
<alexgordon> the null stuff is weird
<alexgordon> I think it's just your notation though
<ec> yeah
<ec> it definitely is
<ec> this is a tightly-coupled mess.
<ec> For Design-11, I'm going to rip *all* of this out. FYI.
<alexgordon> lol
<purr> lol
<ec> replace it with practically identical semantics,
<ec> but defined in terms of *reductive* coroutines
<ec> that is, replacing elements in the Script *with the results*
<ec> So,,,,,,
<ec> no. not going to muddle your view of things with future-changes yet.
<alexgordon> elol
<alexgordon> eh
<ec> so, that was the first thing you needed to know: how ((foo)) works
<ec> but here's a puzzler for you:
<alexgordon> why not leave implementation details to me
<ec> `foo () bar`
<alexgordon> just say how it should wok
<alexgordon> work
<ec> only because *at the moment*, I can only *explain* it in terms of impl-details
<ec> which is my own fault, and I'm sorry for it. It'll be improving with the next version of the design.
<ec> I think I'm going to split the next version of the spec into three completely separate sections:
<alexgordon> ec: I just worry
<alexgordon> that if you keep changing how things are explained
<alexgordon> it makes it difficult to keep up
<alexgordon> stick to one model, however shoddy
<ec> Grammar, Paws' Object-Model (defined native interfaces for object types, and defined algorithms for methods of those types), and then an Operational Semantics (rules from *within* the language)
<alexgordon> make the changes you need
* ec nods
<ec> but now, we're *spec'ing* it. Which means all the changes are written down. Which improves that massively.
<alexgordon> ec: also if you define in coroutines, how is anybody going to implement it in languages without coroutines?
<ec> wat?
<ec> okay. queue that.
<alexgordon> you said you were going to replace it with a definition in coroutines
<alexgordon> I prefer the current definition
<ec> -queue "ec: also if you define in coroutines, how is anybody going to implement it in languages without coroutines?" @ alexgordon
<alexgordon> lol
<purr> lol
<ec> 'k.
<ec> very important thing:
<ec> since the `foo () bar` is *completely* senseless in the framework I've just outlined, we intentionally override it with special meaning, outside of that framework.
<ec> An empty expression in a Script results in the currently-executing execution.
<ec> we generally write it as <me>, or since I've been tagging types here, E<me>
<ec> so:
<ec> `[foo] () bar`, {O<foo>}
<ec> COMBINE(O<foo>, E<me>)
<ec> => O<return-value>
<ec> `foo [()] bar`, {O<return-value>}
<ec> COMBINE(O<rv>, S'bar')
<ec> presumably, (although not necessarily), O<foo> is an execution; and thus, we're calling it.
<ec> then we're looking up S'bar' on whatever it re-calls us with, or, “returns” to us.
<ec> make sense?
<alexgordon> wtf is O<return-vaule>
<ec> just the result of COMBINE(O<foo>, E<me>)
<ec> the assumption was that O<foo> is actually an E<foo>
<alexgordon> k
<ec> so, we're resuming some execution, that we're calling <foo>, with *ourselves*
<ec> some time later, they call that *ourself*-execution, so we resume, with a resumption value from them.
<ec> a “return” value.
<alexgordon> so is that it for advancing executions?
<ec> for advancement, yes
<ec> javascript impl of exactly that algorithm
<ec> written by micah, not me
<ec> shouldn't be difficult to read therefore, I hope
<ec> in that implementation, advance() *takes* an Object
<ec> that Object being the result-of-the-previous-combination
<ec> because it's a tightly-coupled mess that *also* handles the ->stack as described above
<ec> I *want* to spec advance() (PC-management) and push()/pop() (stack-management) seperately.
<ec> which is what I'm trying to do right now: un-spaghettify that design enough to specify it.
<alexgordon> I see
<alexgordon> ish
<alexgordon> ec: promise you won't rewrite the whole thing after making this spec LOL
<purr> LOL
<ec> I fully intend to.
<alexgordon> gaah
<alexgordon> then why make the spec!
<ec> I'm very open-minded about changing *any* of this, if it becomes necessary for bubbling or distribution.
<ec> for you?
<ec> I *told* you it's likely to change a lot.
<ec> But you guys were entirely right: this is very good for me. For the project.
<alexgordon> yeah but if you're going to change it, then it'll be out of date in a week or so
<ec> oh, no, not within a week
<alexgordon> month
<ec> I intend to change it only in large increments. The next big change is going to be a few months from now, and I hope for us all to update our respective implementations in tandem.
<ec> i.e. Design-10 implementations should always run the same code, as they should all be operating off of this spec.
<ec> but Design-11 will be fixing semantics that I consider broken (the entire point of this iteration *being* to find the broken bits, so we can iterate, and “fix” them), and thus probably be backwards-incompatible with this.
<ec> and so on, through at least three more iterations.
<ec> I won't necessary write a whole new spec for each iteration, nor will we necessarily have to throw out much code. Depends on what all we find that is broken.
<alexgordon> fixing stuff is alright
<alexgordon> but redesigning the whole thing is dizzying
<ec> But, seriously, if we find out that an object system where every object is a function, is more in-line with my goals for distribution, and I think it fits into the parts of the design I care about well … then I'll damn-well throw away three quarters of this spec and re-write it in terms of objects-as-functions.
<ec> lol, I've already re-designed the entire thing a solid five times.
<purr> lol
<alexgordon> exactly
<alexgordon> you need to settle down
<ec> Stratums 2, 3, 5, and 7 each changed a solid 80% of the specifics of the language.
<ec> Strata*
* ec shrugs
<purr> ¯\(º_o)/¯
<alexgordon> thing is
<ec> I know what I'm doing. Okay? Trust me on this?
<ec> I'm not going to change everything endlessly and iterate forever: I have very specific goals.
<alexgordon> if nobody else understands it, because you're the only one who can keep pace...
<ec> Listen: I can tell you with genuine confidence that we're near the end of the changes related to the stuff you're learning.
<alexgordon> then it limits the *other* problems that people can find
<alexgordon> you need other people to look at the design
<ec> The only way this changes much, is if we find *problems* with it, and how it interacts with my goals related to transactions and distribution.
<ec> (for instance, if we find out that this object-model is extremely unfriendly to distribution … or that moving-forward executions are completely incompatible with the transactional error system I want.)
<ec> make sense?
<ec> so it's much less likely to change now than it was in the past; and if it does so, it will be because it *has* to.
<alexgordon> I get the idea that you live in a different planet to me
<ec> in other words: the likelihood of change is trending *downwards* with time, as everything begins to fit together elegantly.
<alexgordon> yeah but we've been doing this for years...
<ec> change is still possible, even likely, but less and less drastic change, as most of the big incompatibilities are ironed out.
<alexgordon> gotta stop some time
<ec> not really.
<alexgordon> say "enough is enough"
<ec> there's been maybe a solid year-and-a-half of real, forward-moving effort, by *one person* for the most part, on Paws' design. and even then, as a free-time project; far from full-time.
<ec> there's more people truly involved now; and we're solidly 3/4rs through the mutable design stage.
<alexgordon> point is, if you started a project (when was it? 2009?) and then 4 years later you're still redesigning the whole damn thing… what's the probability that it will ever be stable
* ec shrugs
<purr> ¯\(º_o)/¯
<ec> minus approximately a year lost, collectively, towards World of Warcraft obsession and a big location-move/relationship on my part that's turned out to be a mess,
<ec> we're right on schedule.
<alexgordon> stratum 10!
<alexgordon> that's a big numbe
<alexgordon> r
<ec> Paws is always going to have big version numbers.
<ec> I fucking hate semver; I'll be incrementing the number every time I damn feel like it.
<alexgordon> it just seems silly to go to all this work to make a spec, then in a month it'll all be out of date
<ec> Paws.js version 50 is a solid possibility within the year.
<alexgordon> and paws will once again only exist in your noggin
<ec> not at all
<ec> I intend to keep a version of the spec solidly in-line with any changes we make; and to boot, all changes from here on out will be discussed on GitHub Issues.
<alexgordon> right but you need me to do that
<ec> Timeline: I wanted a solid, design-stable (for the most part) Paws Nucleus, and a partially-designed and partially-implemented Paws Core, by 2014.
<ec> At least three widely differing, mutually federating, implementations of that stable Nucleus spec, themselves at least alpha-quality and relatively stable, all properly executing the in-progress Core implementation, before 2015.
<ec> I'd say I'm a solid year behind on that schedule; *but* I also now have more people involved than I previously thought I would. I always assumed I'd be doing this entirely alone; but micah's solidly involved, and now I've managed to re-rope you, prophile, and whitequark into the spec-work at the very *least*, if not talking about a compiler.
* ec shrugs
<purr> ¯\(º_o)/¯
<ec> I'm optimistic.
<ec> all make some kind of sensE?
<alexgordon> yes but I can only contribute so long as we have these kinds of spec-building sessions *on irc*
<ec> Don't get me wrong. I *believe* I understand your objections. I'm trying to demonstrate why there's nothing to worry about, *without* having to say “NO WE'RE NOT CHANGING THE DESIGN ANYMORE.”
<alexgordon> github issues doesn't cut it: it's too slow
<ec> I'm more interested in a more *coherent* product, a year later down the road, than a half-arsed *mostly* coherent product with tacked-on distribution that doesn't really work well, a year earlier.
<alexgordon> if you rewrite half of it, and suddenly I don't understand it anymore, then there's nothing I can do
<ec> That said, I have zero desire to drag this out *indefinitely*.
<ec> There's a big difference to me between “a year later” and “three years later.”
<ec> alexgordon: You're building one of less-than-five extant implementations.
<alexgordon> at the moment, while it's current
<ec> alexgordon: believe me, I'll keep you *thoroughly* appraised of any changes I'm considering. ;)
<alexgordon> yeah but your idea of full appraisal generally involves a metric shitton of technobabble
* ec laughs
<ec> and that's what we're working on right now.
<ec> a spec, without Elliottbabble.
<ec> that's, y'know, *why you're here*.
<alexgordon> right
<ec> Don't worry so much. It'll all be okay.
<alexgordon> but I have to be here, every step of the way, apparently
<ec> well, for now.
<ec> I think I'm getting the hand of being a little more alexgordon-compatible with the terminology, no?
<ec> so. advancement, although it's a spaghetti clusterfuck, you understand, yes?
<alexgordon> I don't see the spaghetti clusterfuck
<alexgordon> unless you mean that js code
<ec> well, basically, the stack-handling and PC-handling have to be handled *together*.
<ec> which means that advancement needs to be *aware* of the result of the last combination.
* alexgordon makes a prediction that 6 months from now, the spec will either be: A) an indecipherable heap of elliottbabble, B) completely out of date
<ec> I'm trying to remove that coupling: the advancement algorithm should be spec'd independently of any context with regards to the actual stack, and vice versa
<ec> Well, if you stick around and help me prevent that, it'd be pretty great.
<ec> (Not that I think it's particularly a foregone conclusion *without* your assistance, but …)
<alexgordon> I don't know if I have the patience to stick around through another 10 strata
<alexgordon> it gets difficult, keeping track of both what's new, and what's obsolete
<ec> three*
<ec> basically, here's what you should expect. tell me if you think this is unreasoanble.
<ec> First off, now that we're spec'ing it, we're finding some new inconsistencies in the design. Also, there's some open questions left over from the whirlwind changes of about a year ago. I want to clear those up; and altogether, I expect they *might* make reasonably major changes to the semantics (let's say, ≥ 20%). We'll call that D11.
<ec> Then, we need error-handling. obviously, there's some interesting stuff with transactions in the pipes. We need to smooth that partially-specified plans into real spec, and find the problems and inconsistencies with what has been discussed. That'll be D12.
<alexgordon> ec: there is a big difference between *tweaking inconsistencies* and *redesigning half of everything*
<alexgordon> small changes are good
<ec> Finally, distribution, the last big huzzah. Everything *else* should be stable by then, so we just need to figure out how the design handles being spread out like that. D13.
<alexgordon> I feel like if you o
<alexgordon> oops
<alexgordon> well whatever
<alexgordon> I've said it already
<ec> Then, *if*, and only if, I feel it's a spaghetti mess, maybe I'll allow for another maintenance iteration wherein we re-work things that don't fit together well after all the new stuff with transactional-error-handling and distribution. So, a possible D14.
<ec> Three, *maybe* four more iterations, none of which should *change* more than 30% of what exists, isn't bad.
<ec> And each should change less than the previous one, because the design is already *largely* coherent in my head; we only have to solve problems where what's in my head is naturally inconsistent as it's put to paper, put to code.
* ec nods
<ec> talked it to death. I'm curious what incomprehensibly and devyn have to say on the matter. Let's pick it back up later.
<ec> Up for more spec-work now?
<alexgordon> -spec
<purr> alexgordon: Paws' half-arsed Version 10 specification <http://ell.io/ihQzs>
<ec> brb
<ec> fuckl
<ec> errands, storm preperation.
<ec> will be back later, *hopefully*. unless the cell towers go out.
<alexgordon> lol
<purr> lol