devyn changed the topic of #elliottcable to: length matching is better than intuitiveness
eligrey_ has joined #elliottcable
eligrey has quit [Ping timeout: 240 seconds]
yorick has quit [Remote host closed the connection]
alexgordon has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
<abad1dea> fucking FCK
abad1dea is now known as ELLIOTTCABLE
<ELLIOTTCABLE> glowcoil: wake up, please please please
<ELLIOTTCABLE> devyn: and you, perhaps, depending on your sleep schedule
<devyn> hi
<purr> devyn: hi!
<ELLIOTTCABLE> Been brainsing "holes."
<ELLIOTTCABLE> Or the unnamed problem that they nominall solved, more accurately.
<ELLIOTTCABLE> -brainsing
<purr> ELLIOTTCABLE: switch to Spotify. put on Rachmaninov. lean back in couch. fold hands behind head. stare at ceiling.
<ELLIOTTCABLE> so,
<ELLIOTTCABLE> basically,
<ELLIOTTCABLE> nope. /=
<ELLIOTTCABLE> which is disturbing, because i'd been dismissing the-problem-that-holes-nominally-solve, in my head, 'cuz I assumed we were most of the way to a solution on that one.
<ELLIOTTCABLE> not. at. alllllll.
prophile has joined #elliottcable
eligrey_ has quit [Quit: Leaving]
<devyn> I think Tires is the best alternative to the holes thing, but that's a totally different idea :p
<ELLIOTTCABLE> welllllll, they're not super-super related
<ELLIOTTCABLE> well kinda.
<ELLIOTTCABLE> okay am home
<ELLIOTTCABLE> can type now
<ELLIOTTCABLE> so, so exhausted
<ELLIOTTCABLE> have slept N hours, where N is very small
<ELLIOTTCABLE> The Problem:
<ELLIOTTCABLE> arbitrary interlopers can schedule a staging that steals an argument from a strictly-patterned coconsumption exchange
<glowcoil> hi
<purr> glowcoil: hi!
<ELLIOTTCABLE> (or, more generally, some staging-patterns are "structured", and can negatively interact with one-another)
<ELLIOTTCABLE> The Shape of the Solution:
<ELLIOTTCABLE> "during" a "staging-pattern" of some arbitrary form, "lock" out participants from interlopers' other patterns (or individual stagings)
<ELLIOTTCABLE> define:
<ELLIOTTCABLE> during.
<ELLIOTTCABLE> staging-pattern.
<ELLIOTTCABLE> lock out.
<ELLIOTTCABLE> so, originally, thought-process was: "Let's make ‘calls’ exclusive: when you *call* somebody, as opposed to doing explicit Paws-y staging backflips for some arbitrary purpose, give them a ‘shaped hole’ instead of the traditional promiscuous reference-to-current-execution.”
<ELLIOTTCABLE> idea having been, reactor can then register that a hole exists, and then somehow prevent standard stagings from processing until that call is 'complete.'
<ELLIOTTCABLE> I always assumed that would work, in some form. huge mistake.
<ELLIOTTCABLE> issues with that:
<ELLIOTTCABLE> first off, and possibly most importantly, although a bit nebulous … it only proposes to solve the Problem for *a single pattern* (ish.) Basically, whatever "call" pattern we bless with holesing.
<ELLIOTTCABLE> second, and more concrete:
<ELLIOTTCABLE> quick, somebody, try to show me how a coconsumptive parameterization pattern would play out, with holes?
<ELLIOTTCABLE> (it doesn't. I spent half an hour today on that alone. /= )
<ELLIOTTCABLE> holes, first, require knowledge of the 'caller' *and* 'callee' on the part of the hole itself, which breaks the desirable Paws behaviour of discarding the concept of a "caller" at all, and only caring about the return-point we're handed.
<ELLIOTTCABLE> and second, holes work for **a single resumption-slot**. basically, they're continuations. How, exactly, does that work for *any* staging pattern (including simple coproductive parameterization) more complex than 'stage this foreign procedure with a single argument.'
<ELLIOTTCABLE> third, and I didn't get to nail this one down before we arrived here at home where I can type; but I'm *pretty sure* holes require a new syntax; either that, or they're going to *hugely* bloat the code-overhead for a simple fucking procedure-call. Perhaps even to the point of making bootstrapping that with abstractions, impossible.
<devyn> explain holes again?
<vigs> A young Shia LeBouf (sp?) gets in trouble and is sent to a camp where everyone's forced to dig holes as punishment.
<ELLIOTTCABLE> that was actually a good book
<ELLIOTTCABLE> idk the movie
<devyn> oh yeah shia the beef
<vigs> yeah the book's better
<vigs> so I think modifying Array's prototype is adding extra elements to these arrays? wtf https://dl.dropboxusercontent.com/u/13506662/Screen%20Shot%202014-07-13%20at%206.58.01%20PM.png
<vigs> I just printed the contents of this array that I'm iterating through into the console and it prints three resources it gets from the API, then the three functions I added to Array ಠ_ಠ
<vigs> (╯°□°)╯︵ ʇdᴉɹɔsɐʌɐɾ
devyn has quit [Ping timeout: 272 seconds]
eligrey has joined #elliottcable
devyn has joined #elliottcable
<ELLIOTTCABLE> ugh
<ELLIOTTCABLE> vigs: not enumerable.
<ELLIOTTCABLE> vigs: http://mdn.io/defineproperty
<ELLIOTTCABLE> vigs: have fun.
alexgordon has joined #elliottcable
<vigs> ELLIOTTCABLE: hm?
<ELLIOTTCABLE> your javascript problem.
<vigs> oh
<vigs> not enumerable as in it's the for/in syntax? welp
<ELLIOTTCABLE> wat
<ELLIOTTCABLE> vigs: no, as in,
<ELLIOTTCABLE> vigs: If you're modifying prototypes, you need to make the members non-enumerable.
<vigs> right, I got that
<alexgordon> so I just had the CRAZIEST idea
<alexgordon> what if string formats were valid patterns
<alexgordon> e.g.
<alexgordon> "#{a} #{b} MD." = "Elliott Cable MD."
<ELLIOTTCABLE> huh?
<alexgordon> "#{a}, #{b}, #{c}" = "comma, separated, values"
<prophile> how do you resolve ambiguity?
<alexgordon> prophile: same way regexes do I guess
<prophile> in that case, for your first example
<prophile> oh, no, that does work
<prophile> disregard
<prophile> interesting idea
<alexgordon> prophile: http://rubular.com/r/gBPVR5AFQh
<prophile> it'd be .* if it works like string formats, no?
<alexgordon> yeah I guess
<alexgordon> or [\s\S]* to be really pedantic
<joelteon> we got that O(n^2) behavior
<prophile> alexgordon: \s\S?
<prophile> what characters does that exclude?
<joelteon> schroedinger's space
<alexgordon> prophile: it always excludes nothing :P. it's like . but always matches newlines
<prophile> oh, I see
<alexgordon> [\d\D] does the same
<prophile> okay, so it's (.*) in a non-broken regex engine :)
<joelteon> wow, TIL perl is broken
<joelteon> i thought it was the de facto language for using regex
<alexgordon> I actually never use ., I use [^\n] or [\s\S] (and fuck \r :P)
<prophile> perl is broken in so very many ways
<prophile> compared to ending modules with 1; the regex system is relatively sensible
<alexgordon> regex syntax is broken :|
<alexgordon> I wish I could use ragel syntax everywhere
<joelteon> i'm gonna buy a new keyboard soon
<alexgordon> anyway that was just me trying to figure out how to codegen assignment statements
<alexgordon> starts with A, so that's the first one :P
<joelteon> i bought a switch tester today
<joelteon> sounds like blues are gonna be my switch of choice
<joelteon> but i'm going to have the dude put reds in the arrow key positions
<ELLIOTTCABLE> wat
<ELLIOTTCABLE> so confused
<ELLIOTTCABLE> what's new about string interps?
<alexgordon> ELLIOTTCABLE: using them on the left side of an assignment
<ELLIOTTCABLE> oh, that
<ELLIOTTCABLE> nothing new
<alexgordon> it isn't?
<ELLIOTTCABLE> in fact,
<alexgordon> show me a language that does that
<ELLIOTTCABLE> that's … 4, years ago? ;)
<alexgordon> ELLIOTTCABLE: a real language! :P
<joelteon> and a real hero
<joelteon> a real human bean
<ELLIOTTCABLE> show me a working Furrow interpreter, and tell me the syntax to type in to see that working :P
<ELLIOTTCABLE> I didn't say I'd *seen it implemented*. Just that it wasn't a new idea.
<alexgordon> ELLIOTTCABLE: :P
<ELLIOTTCABLE> I've known I'm going to have it in Fullness for ages; and I'm fairly damn sure I'd heard of it somewhere else, first, too.
<alexgordon> so
<alexgordon> I built furrow today
<alexgordon> (built as in compiled)
<alexgordon> and... it compiles
<alexgordon> how cool is that
<alexgordon> was expecting a gazillion errors
<ELLIOTTCABLE> what, have you never compiled it before? o_O
<alexgordon> ELLIOTTCABLE: not for months
<alexgordon> I'd been under the impression that it was totally broken
<alexgordon> which is why I hadn't touched it
<alexgordon> but apparently it was fine
<alexgordon> spent some time today working on an AST program representation
<alexgordon> and now I'm working on a DSL for the codegen stage
<alexgordon> lots of the codegen code is quite mechanical. some bits will have to be special cased but hopefully the majority of it can be auto-generated
<alexgordon> that's right, I'm code generating my codegen code
<ELLIOTTCABLE> lololol
<purr> lololol
<ELLIOTTCABLE> I have no idea what most of this means.
<ELLIOTTCABLE> i am bad progamer
<alexgordon> ELLIOTTCABLE: you know a compiler right?
<ELLIOTTCABLE> yep
<alexgordon> ELLIOTTCABLE: the classical stages of a compiler are lexical analysis (regexes), syntax analysis (parsers), semantic analysis (errors/warnings/static types), code generation (generating asm/c/llvm ir)
<alexgordon> *of a compiler frontend
<ELLIOTTCABLE> k
<ELLIOTTCABLE> my hand hurts from the wheeler
<alexgordon> you and your hand elliott
<ELLIOTTCABLE> lololol
<purr> lololol
<ELLIOTTCABLE> inimino: miss you.
<ELLIOTTCABLE> inimino: forgot how great you were when you actually socially interacted in ##Paws.
<ELLIOTTCABLE> inimino: (not meant as judgement for not doing so now! Just nostalgia.)
<ELLIOTTCABLE> I forget that inimino was ever anything than a “hm”bot.
<alexgordon> I should go to bed
<alexgordon> prophile: go to bed
<ELLIOTTCABLE> no
<ELLIOTTCABLE> write a paws
<ELLIOTTCABLE> hi, prophile
<alexgordon> in furrow?
<alexgordon> :P
<prophile> alexgordon: believe it or not this is actually morning for me
<prophile> hey elliott
<alexgordon> it's so late my f.lux has turned to daylight
<alexgordon> o7 all
alexgordon has quit [Quit: Textual IRC Client: www.textualapp.com]
Rusky1 has joined #elliottcable
Rusky has quit [Read error: Connection reset by peer]
Rusky1 is now known as Rusky
Rusky has quit [Read error: Connection reset by peer]
Rusky has joined #elliottcable
Rusky has quit [Ping timeout: 240 seconds]
prophile has quit [Quit: The Game]
prophile has joined #elliottcable
eligrey has quit [Quit: Leaving]
prophile has quit [Ping timeout: 240 seconds]
amatecha has quit [Ping timeout: 252 seconds]
amatecha has joined #elliottcable
prophile has joined #elliottcable
prophile has quit [Quit: The Game]
yorick has joined #elliottcable
<ELLIOTTCABLE> hi all.
<Cheery> hi
<purr> Cheery: hi!
<ELLIOTTCABLE> Cheery: you should let me teach you Paws. (=
<Cheery> has there been hint that I wouldn't let you?
<ELLIOTTCABLE> hm
<ELLIOTTCABLE> I don't know.
<yorick> devyn: recommend me a haskell web framework?
<ELLIOTTCABLE> there always seems to be a bit of a barrier to infect someone with your enthusiasm with your own pet project. ;)
<Cheery> can you point out some of the simplest examples first? And maybe instruct how to install on linux so I'll see them run?
<Cheery> use links as much as you can.
* ELLIOTTCABLE laughs
<ELLIOTTCABLE> it's too young, probably.
<ELLIOTTCABLE> it's a VM, too, with out anything targetting it yet; so any “code examples” are obtuse as fuck, and teach you really nothing.
<ELLIOTTCABLE> oh devyn, speaking of: I dreamt (literally.) up a solution I'm not sure I hate.
<ELLIOTTCABLE> devyn: wake up and give me feedback. You're not allowed to sleep, you're too useful to me. ;)
<yorick> devyn let us eat your mind we need you
<ELLIOTTCABLE> Cheery: er, Paws, not you, too young. idk how old you are.
<Cheery> 27
<ELLIOTTCABLE> here's some arbitrary simple-ish ‘cPaws’ source
<ELLIOTTCABLE> (which is kind of our intermediate-form)
<ELLIOTTCABLE> vil: morning
<vil> hi ELLIOTTCABLE
<ELLIOTTCABLE> Cheery: the core premise behind Paws is that we wanted a truly asynchronous language.
<ELLIOTTCABLE> (since you're new here: I come from a rather staid / hipster history; lots of Ruby, JavaScript, a lot less Haskell, Lisp, or even-more-obscure shit like stack or logical languages)
<ELLIOTTCABLE> (hence, Paws is very much a language with a slow, but very dynamic and expressive feel; and gives the user a lot more room to shoot themselves in the foot, without things like static typing, purity, or easy static analysis.)
<ELLIOTTCABLE> (I hope that's not up your alley of language tastes.)
<ELLIOTTCABLE> almost every language I've ever run across is inherently *synch*:
<ELLIOTTCABLE> at worst, they're stack-based, and you *can't* ever do anything in 'procedure-call' (whatever form that may take) except preform some calculations, push other procedures (themselves necessarily synchronous) onto the stack, and then give up your control and “return” to some privileged caller up the stack.
<ELLIOTTCABLE> sometimes, if you're lucky, that environment exists on top of some lower-level, opaque "event loop" that your synchronous operations can manipulate and leverage. that's really no solution, most of the time, though, introducing all sorts of conceptual overhead, and relegating you to some linguistic equivalent of callbacks.
<ELLIOTTCABLE> a bit higher up the asynchronicity ladder, you've got truly stackless languages, in which things like coroutines (or at least pervasively available continuations) *let* a user, occasionally, do actually-asynchronous operations amongst their synch code.
<ELLIOTTCABLE> the only places I've seen *real* pervasive asynchronicity are truly weird, obscure shit; things inaccessible to the “average programmer.”
<ELLIOTTCABLE> (I've had this argument before, and don't want to again, so I'll just summarize my definition there, and leave it alone: “average programmers” write Java, C++, Obj-C, JavaScript, Ruby, Python, or another language like that. If you grok Haskell, a LISP, or even know what a declarative logic language *is*, you're no longer an ‘average programmer’ in my
<ELLIOTTCABLE> book, and no longer of interest to me as a target-market.)
<ELLIOTTCABLE> so.
<ELLIOTTCABLE> I came out of that environment wanting the following:
<ELLIOTTCABLE> a language that is asynchronous *always, everywhere* (i.e. any invocation of somebody else's code, inherently assumes that that somebody-else will be able to take *as long* doing *as many things* as they want, with no assumption of ‘returning’ immediately, or even ever.),
<ELLIOTTCABLE> that is accessible to people coming from the completely procedural, ‘object-oriented,’ dynamic languages that are popular nowadays: JavaScript. Ruby.
<Cheery> async dynamic language?
<ELLIOTTCABLE> yep
<yorick> y u no callcc
<ELLIOTTCABLE> yorick: explicit.
<ELLIOTTCABLE> this has to be *explicit*.
<Cheery> doesn't sound much different to what I'm actually attempting to do myself.
<ELLIOTTCABLE> If I write an abstraction that requires asynchronicity,
<ELLIOTTCABLE> I don't want to restrict my abstraction to users who understand a little-used language feature.
<Cheery> I realised yesterday I have to study julia language papers.
<ELLIOTTCABLE> if *every single 'call'*, anywhere, of any sort, is asynchronous, then *asynchronous* abstractions won't be second-class to synchronous ones,
<ELLIOTTCABLE> as they are,
<ELLIOTTCABLE> absolutely,
<ELLIOTTCABLE> fucking,
<ELLIOTTCABLE> everywhere.
<ELLIOTTCABLE> yorick: just sayin'.
<ELLIOTTCABLE> okay. So, that's the “why” rationale.
<ELLIOTTCABLE> lemme know if I'm getting too high-minded and you just want me to tell you bits of the code. :P
<ELLIOTTCABLE> “what” rationale:
<ELLIOTTCABLE> since i'm targetting people coming from very dynamic languages, friendliness to *abstraction* is a very core goal. I want something between Ruby and LISP, something enabling users, with ideas I didn't think of, to write unreasonably powerful abstractions that change the entire feel of the language for other users.
<ELLIOTTCABLE> I discovered that that rabbit-hole goes *very* far down, very fast.
<ELLIOTTCABLE> Paws kinda takes that as far as it can possibly go.
<ELLIOTTCABLE> after much iteration, removing things from the language that we realized could be implemented in terms of *other* things, as abstractions, later on,
<Cheery> I'm bit occupied at the moment :) it's like all the fucking stuff worth reading came out today, not yesterday when it'd have been useful.
<ELLIOTTCABLE> (links!)
<ELLIOTTCABLE> we've long since been at the point where Paws is basically an unusable-by-humans (hah.) virtual-machine for *other* languages in this family to target.
* yorick is waiting for http://tel.github.io/ part 3 of this
<ELLIOTTCABLE> instead of targeting it by compiling to an intermediate-form,
<ELLIOTTCABLE> you target it by writing abstractions on top of an intermediate-form, that modify the semantics (and eventually syntax) of that form.
<ELLIOTTCABLE> very LISPy.
<ELLIOTTCABLE> yorick: “Ah, monads, I can smell the purity already. It’s invigorating.”
<ELLIOTTCABLE> lol'd
<purr> lol
<Cheery> not sure what's worth before read through.. but reading through stuff in cat-v and this one is in line: http://www.cs.virginia.edu/~cs415/reading/bacon-garbage.pdf
<Cheery> hmm..
<ELLIOTTCABLE> "bacon-garbage.pdf"
<vil> I tried to learn it once and can attest to the "unusable-by-humans" part
<ELLIOTTCABLE> vil: heh, it's better, nowadays.
<ELLIOTTCABLE> vil: lol.
<vil> I bet so
<vil> that was quite some time ago
<ELLIOTTCABLE> it's not unusuable in terms of concepts; it's just unusuable without first writing yourself (or using somebody else's) abstractions.
<Cheery> yesterday were reading about algorithm (were trying to figure out a name for an algorithm)
<Cheery> found garbage in garbage out, and first out never out.
<ELLIOTTCABLE> Cheery: m'kay. I'm gonna work on specification-stuff over here, but let me know when you have some time, and I'll work you through the meat of it.
<Cheery> were derailed a bit there.
<ELLIOTTCABLE> vil: wish you knew it better, I need to talk through some though-work here.
<ELLIOTTCABLE> hm, who's kaplan?
<vil> ELLIOTTCABLE: someday I will finally have time to sit down and have you teach it all to me properly
<vil> probably right about when you finish :D
<ELLIOTTCABLE> won't take much time. :P
<ELLIOTTCABLE> make an impl!
<ELLIOTTCABLE> that'll explain it all.
<ELLIOTTCABLE> it's truly trivial to create a non-parallel implementation.
<ELLIOTTCABLE> I keep telling people that.
<vil> which one is currently the best? I should go read it
<ELLIOTTCABLE> the only non-trivial part is working around the terrible specification. >:
<ELLIOTTCABLE> Paws.js is very, very simple code through-and-through.
<vil> hehe
<vil> k
<ELLIOTTCABLE> Hell, I'm subjecting myself to fucking *CoffeeScript*, specifically in hopes that somebody like you will come along and read the source to understand it.
<vil> D:
<ELLIOTTCABLE> the meta-code documentation (i.e. comments and shit) are lacking,
<vil> I am so sorry
<ELLIOTTCABLE> but it's very self-documenting code. Or it should be.
<vil> alright, I will attempt to do that soon
<ELLIOTTCABLE> If any of it's *not* (except perhaps advance(), which is a straight-up clusterfuck and getting thrown away some day), well, tell me, so I can refactor.
<vil> but for now I have to get ready for work
<vil> will do
<ELLIOTTCABLE> o7
<vil> o7
<Cheery> have you seen anything like this before?
<Cheery> I thought it would be shortest path algorithm at first. but it turned out to not be.
<Cheery> can't apply dijikstra to it.
<ELLIOTTCABLE> “apply dijikstra to it.” 'splain, I'm dumb.
<Cheery> well say I have grammar like this:
<Cheery> grammar.terminal('sym')
<Cheery> grammar.rule("term", "sym")
<Cheery> grammar.rule("expr", "term")
<Cheery> grammar.rule("expr", "expr", keyword("plus"), "term")
<Cheery> grammar.rule("stmt", keyword("return"), "expr")
<Cheery> this algorithm tries to find the lowest cost for every rule here.
<Cheery> 'cost' as in how long the shortest correct application of the rule is.
<yorick> is this a smallest grammar problem?
<yorick> well, it's the reverse
<Cheery> on the stmt = "return" expr
<Cheery> since the expr -> term -> sym
<Cheery> it would be 2
<Cheery> because you can create an expr with 1 token.
<Cheery> the information can be used to actually calculate the sequences in grammar, that I can then diff to what my parser has 'seen' :)
<Cheery> lets seee
<Cheery> I'm not sure
<Cheery> I would think it's simple
<yorick> it's like shortest path but it picks the shortest node on every location I guess?
<Cheery> right now solving it with relaxation. going through the grammar summing the rules up, until no rule decreases value of a symbol.
<Cheery> anyway, there it is.
<Cheery> I would guess somebody else has ended up doing it before.
Sgeo has quit [Read error: Connection reset by peer]
<purr\Paws> [Paws.js] ELLIOTTCABLE pushed 9 new commits to support-rulebook+: https://github.com/ELLIOTTCABLE/Paws.js/compare/0e76050bd92a...cb1820cec6e2
<purr\Paws> Paws.js/support-rulebook+ 2f8e362 elliottcable: (- new API) Make all Things into EventEmitters
<purr\Paws> Paws.js/support-rulebook+ f60e5c6 elliottcable: + adding a check operation to the executable
<purr\Paws> Paws.js/support-rulebook+ 249ec46 elliottcable: + fixing flush-debugging
<purr\Paws> [Paws.js] ELLIOTTCABLE pushed 2 new commits to Master: https://github.com/ELLIOTTCABLE/Paws.js/compare/c88580e0be30...5e2d089006eb
<purr\Paws> Paws.js/Master 5e2d089 elliottcable: (- new debug) Clean TRACE_REACTOR output up...
<purr\Paws> Paws.js/Master b2471ae elliottcable: (- new API) Make all Things into EventEmitters
<ELLIOTTCABLE> this is sexy.
<ELLIOTTCABLE> I don't know why I think so. It just feels like it is.
<ELLIOTTCABLE> *really* need to get semicolons working.
<ELLIOTTCABLE> I think it's the only way my 'reference' impl is behind devyn's.
<ELLIOTTCABLE> glowcoil: you, come take a coding-break from life and implement semicolon support in your parser :P
<ELLIOTTCABLE> my git histories are weird and inside-out.
<ELLIOTTCABLE> like, from the perspective of git.
<ELLIOTTCABLE> merr.
<ELLIOTTCABLE> as well as I understand it, and as much as i love using it, git's usage-philosophy and mine differ *massively*. /=
<purr\Paws> [Paws.js] ELLIOTTCABLE pushed 4 new commits to support-rulebook+: https://github.com/ELLIOTTCABLE/Paws.js/compare/cb1820cec6e2...533188461773
<purr\Paws> Paws.js/support-rulebook+ afced54 elliottcable: + fixing eventually on already-dispatched tests
<purr\Paws> Paws.js/support-rulebook+ d200a2d elliottcable: + dispatchable collections
<purr\Paws> Paws.js/support-rulebook+ 621e3ed elliottcable: + adding queue-length to flushing-debugging-output
yrashk has joined #elliottcable
<ELLIOTTCABLE> omg been too long
<yrashk> sup!
<yrashk> greetings from Tokyo
<Cheery> yrashk: echo from kangasala
Rusky has joined #elliottcable
alexgordon has joined #elliottcable
<ELLIOTTCABLE> alexgordon!
<alexgordon> ELLIOTTCABLE!
<ELLIOTTCABLE> boom.
<purr\Paws> [Paws.js] ELLIOTTCABLE pushed 8 new commits to support-rulebook+: https://github.com/ELLIOTTCABLE/Paws.js/compare/533188461773...cb350a7c5fb3
<purr\Paws> Paws.js/support-rulebook+ 56a3ca9 elliottcable: + manage collection in `check`
<purr\Paws> Paws.js/support-rulebook+ 9099d40 elliottcable: (- meta doc) Add some TODOs for the executable
<purr\Paws> Paws.js/support-rulebook+ 9e60dea elliottcable: (new API) Emit 'flush' event on empty-queue
<purr\Paws> [Paws.js] ELLIOTTCABLE force-pushed support-rulebook from bc87c3a to b60cc02: https://github.com/ELLIOTTCABLE/Paws.js/commits/support-rulebook
<ELLIOTTCABLE> ugh irc reporting is DUMHB
* ELLIOTTCABLE pokes github
<ELLIOTTCABLE> UNDERSTAND GRANULAR BRANCHES YOU CRAP
<alexgordon> ELLIOTTCABLE: !
<alexgordon> you're working on paws, I'm working on furrow, what kind of crazy day is it today
Rusky has quit [Ping timeout: 264 seconds]
<yrashk> I am working on all sorts of crazy shit
<ELLIOTTCABLE> fucking fuck,
<ELLIOTTCABLE> semicolons.
<ELLIOTTCABLE> SOMEBODY DO THIS FOR ME
<ELLIOTTCABLE> well, the support-rulebook branch doesn't support the single file in the Rulebook yet. lol.
<purr> lol
<alexgordon> dude you need to embrace the Gordon Approach to compiler writing
<ELLIOTTCABLE> but it'll run this:
<Cheery> alexgordon: what is gordon approach to compiler writing?
<alexgordon> Cheery: GLAD YOU ASKED
<Cheery> alexgordon: smashing it by crowbar?
<alexgordon> step 1: write a plain text, free form description of all elements of the language
<alexgordon> step 2: write scripts to generate a compile from that: https://github.com/fileability/furrow/blob/cleanup/generation/grammar_gen.py
<alexgordon> *compiler
<ELLIOTTCABLE> LOL
<ELLIOTTCABLE> that's not compiler writing, just parser writing
<ELLIOTTCABLE> alexgordon: lookie lookie rulebook lookie
<ELLIOTTCABLE> I'm excited!
<ELLIOTTCABLE> specification: apparently beyond me, although I'm still dead-set on trying
<alexgordon> ELLIOTTCABLE: nope, it works for all stages of the compiler
<ELLIOTTCABLE> (oh btw)
<ELLIOTTCABLE> -spec @ Cheery
<purr> Cheery: Paws' Version 10 specification <http://ell.io/spec>
<ELLIOTTCABLE> (that exists, not that it's helpful)
<ELLIOTTCABLE> but langauge specs?
<ELLIOTTCABLE> I can do that.
<ELLIOTTCABLE> not a substitute,
<ELLIOTTCABLE> but still satisfying.
<alexgordon> ELLIOTTCABLE: I have a blueprint for semantic analysis somewhere
<ELLIOTTCABLE> and feels like big progress.
<Cheery> alexgordon: something like this? http://pastebin.com/16E1MLf7
<alexgordon> Cheery: not reaaaaly
<alexgordon> Cheery: because you still had to write out plus() and minus()
<alexgordon> the point is to generate _everything_ from the grammar
<alexgordon> and the other blueprints
<alexgordon> generate the lexer, the parser, the semantic analysis, the code generation
<alexgordon> that way, if you change something in the grammar it's insanely easy to change all the stages that depend on it
<Cheery> but in that setting you can equally easily change the stuff that depends on each other.. it's sort of the idea why I designed this.
<Cheery> I'll try to emphasize it later.
<alexgordon> Cheery: you can but it doesn't scale
<Cheery> where should it scale to?
<alexgordon> a compiler where you can't fit the whole thing in your head
<Cheery> well.. if you can't, then in my system it takes lot of time to parse.
<Cheery> unfortunately
<alexgordon> Cheery: haha fair enoug
<alexgordon> *enough
<alexgordon> Cheery: C++ is really a great language for writing compilers
<alexgordon> this code is so clean
<Cheery> I keep wondering what would be great way to write a parser.
<Cheery> the CYK was nice, it allows any form, as long as things are per-line
<Cheery> the handwritten parser with 1 lookahead was nice, simple, as long as syntax fits the implementation
<alexgordon> when I've finished cleaning up this it'll be awesome
<ELLIOTTCABLE> mmmm
<yrashk> if anyone is bored, feel free to criticize my paper on decentralized name registration http://bitnom.org/spec/bitnom.pdf
<ELLIOTTCABLE> eli5, yrashk
<purr\Paws> [primitives.js] ELLIOTTCABLE pushed 1 new commit to Master: https://github.com/Paws/primitives.js/commit/9ad2070838af07dc384f4aab370cdf6e3a5a03e3
<purr\Paws> primitives.js/Master 9ad2070 elliottcable: (!! new spec) Implement the 'specification' bag
<purr\Paws> [Paws.js] ELLIOTTCABLE pushed 1 new commit to support-rulebook: https://github.com/ELLIOTTCABLE/Paws.js/commit/f8182061208983c0cbb7912cd5194336e013a86e
<purr\Paws> Paws.js/support-rulebook f818206 elliottcable: (- sub) Sync primitives
<Cheery> hmmhmmmhmm
<Cheery> I feel I'm on the right track
<Cheery> but it won't come out with diffing this
<Cheery> I rather use something I call completion distance.
<ELLIOTTCABLE> hi …
<ELLIOTTCABLE> feeling weirdly droopy
<Cheery> hmm.
<Cheery> now I have completion distances.
<Cheery> so from whatever single match, I can traverse upwards to full completion.
<Cheery> but given that I have several matches in sequence
<Cheery> I'd need to create sort of system which somehow converges them into a single match.
<Cheery> hmm
<Cheery> at this point of matching, the system knows that it did not arrive to a solution.
<Cheery> it also knows every variation of the parse.. as in what can be seen in the input
<Cheery> the completion distance is an useful metric.
<Cheery> but..
<Cheery> I need a mechanism to piece the thing up.
<Cheery> aand.. I suspect it's not the diff -thing.
<Cheery> I need to make a kind of inversion engine, which tries to bunch the pieces together. in order or out of order.
<Cheery> hmhm..
<Cheery> trying a different approach
eligrey has joined #elliottcable
<Cheery> hopeless
<Cheery> the output of this parser gives me permutations, sort of interpretations of the input.
<Cheery> it's useful for the sort of people who understand the grammar. helps to see what kind of parse there is.
<Cheery> that kind of person sees where he can add a symbol, and what the result is
<Cheery> could also, of course, just show in which kind of slots each parse would fit to.
<Cheery> well i'll do that
<Cheery> because it will always propose something at least
eligrey has quit [Read error: Connection reset by peer]
eligrey has joined #elliottcable
eligrey has quit [Ping timeout: 264 seconds]
gozala has joined #elliottcable
prophile has joined #elliottcable
alexgordon has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
eligrey has joined #elliottcable
prophile has quit [Quit: The Game]
<devyn> ELLIOTTCABLE: yo, solution me
alexgordon has joined #elliottcable
alexgordon is now known as motherbitches
motherbitches has quit [Disconnected by services]
alexgordon has joined #elliottcable
<alexgordon> mmmm
<alexgordon> this sucks :|
<alexgordon> type systems!
<joelteon> like a keyboard?
<joelteon> hey guys, what's your favorite cherry mx switch?
<gkatsev> a coworker just got a keyboard made with entirely cherry mx clear
<joelteon> how is it?
<joelteon> those are the stiff tactile, right?
<gkatsev> yeah, they're stiffer than the browns
<gkatsev> he has a brown right next to it
<gkatsev> it's interesting.
<gkatsev> it feels like you can type better with less mistakes because it requires more energy to depress but also you can more readily stop yourself from typing a key
<gkatsev> also, it feels like you can move onto writing the next char earlier
<gkatsev> but I haven't used it extensively
<joelteon> have you used blues?
<gkatsev> I don't think so
<joelteon> ok
<joelteon> I love blues but my coworkers don't
<gkatsev> the clears also end up being quieter than the browns
<gkatsev> this coworker has around $900 worth of keyboards around his desk right now
<joelteon> think I might go with clears then
<vil> joelteon: I've repeatedly heard that clears are the best
<joelteon> :U
<joelteon> maybe i'll go with those then
<vil> they're also typically more difficult to get ahold of
<joelteon> yeah, that won't be a problem
<joelteon> my plan is planned
<alexgordon> joelteon: lol no not like a keyboard
<purr> lol
<joelteon> i know
<joelteon> i was making a joke because i was thinking about my keyboard
<alexgordon> joelteon: I know
Sgeo has joined #elliottcable
oldskirt has quit [Quit: gone]
<joelteon> i gotta try clears out before i buy
<joelteon> i don't know whether they'll take too much force to use
<gkatsev> clears are supposed to be better?
<gkatsev> my coworker is thinking of returning that keyboard, actually
<joelteon> that's what vil just said
<joelteon> that's my source
<gkatsev> I didn't know whether they were supposed to be better or not and that my coworker is thinking of returning the keyboard with the clear keys
<gkatsev> this is the keyboard: http://codekeyboards.com/
<joelteon> yeah i've heard of that keyboard
<joelteon> does your coworker want to return them cause s/he doesn't like the switches
<gkatsev> he has two keyboards on his desk right now. A brown and a clear. He's liking the browns more.
<gkatsev> also, the keyboard with the browns does feel like it's slightly better put together.
<joelteon> is the browns a code keyboard too
<gkatsev> no
<joelteon> das keyboard?
<gkatsev> cmstorm
<joelteon> oh
<gkatsev> that one has the option of all except clear
<joelteon> nice
<joelteon> i ordered a das keyboard 4 but the shipping is delayed a month
<joelteon> so i'm going to cancel that and look at a gon instead
<gkatsev> oh, interesting. didn't hear about the 4.
<joelteon> it looks cool but gon has a lot more customization options
<gkatsev> the problem with the das is that it has the keypad
<joelteon> i like the keypad
<joelteon> so not an issue here
<gkatsev> the keypad should be on the left side or removable
<joelteon> yeah, that's what gon does
<joelteon> the keypad is separate and connects to the main kb via USB
<gkatsev> expensive
<joelteon> super nice though
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
<devyn> joelteon: I have the das keyboard professional model s with browns and I love it
<joelteon> i have the one with blank keycaps
<joelteon> i like the browns but i'm not devoted to them
<devyn> the ultimate
<joelteon> i prefer both blues and reds
<devyn> I wanted to get an ultimate but I didn't want to have to ship it
<devyn> the local store that sells them didn't have ultimates
<joelteon> where do you get a das keyboard in real life
<devyn> just like, a regular electronics store lol
<purr> lol
<joelteon> oh cool
<joelteon> in the USA, you can buy them in NYC
<joelteon> that's the only place
<devyn> you sure?
<joelteon> yeah
<joelteon> it's either adorama, which is in NYC, or j&r electronics, which went out of business
<devyn> huh, well, NCIX is all over the place here
<joelteon> nice
<devyn> they have lots of shops
<joelteon> lucky canadians
<joelteon> you get an eh plus
<devyn> I actually prefer Memory Express though… they have less variety but much larger stores
<devyn> problem with NCIX is that yes, they have huge variety, but their stores are like tiny little kiosks so they don't have much stock
<joelteon> i wish i could find niche electronic stores here
<joelteon> there's a lot of niche stuff in the south bay but i haven't found a decent keyboard store
<devyn> well there's only one Memory Express in my province, heh, but it happens to be somewhat close to where I live
<joelteon> oh, wasd is in milpitas
<joelteon> I think that counts
<devyn> isn't wasd a brand?
<devyn> of keyboard
<joelteon> yes
<joelteon> their store is in milpitas
<devyn> cool
<joelteon> they sell the code keyboard, so that's a good place to try clears
<devyn> looks like you can get WASD's custom keyboard with clears too
<joelteon> yeah, i don't want a wasd
devyn changed the topic of #elliottcable to: a super duper cult :)
<joelteon> i'm either gonna buy a das because this one's been so faithful to me
<joelteon> OR a gon because the build quality is supposed to be so fantastic
<devyn> I really do love my das
<devyn> can't see myself ever replacing it
<joelteon> the thing i really like about the gon is that it doesn't have a bezel
<devyn> bezel where?
<ELLIOTTCABLE> otay irccloud is broken
<ELLIOTTCABLE> this conversation about keyboards came from noooowhere
<ELLIOTTCABLE> what about DAS KEYBOARD?
<joelteon> it's just a plate of metal with keys mounted on it
<joelteon> i think it's beautiful
<ELLIOTTCABLE> browns?
<joelteon> blues or reds
<joelteon> probably reds
<joelteon> no, not blues
<ELLIOTTCABLE> what are reds? so confus
<joelteon> clears or reds
<joelteon> reds are linear, no click
<devyn> ohh that's kinda cool
<joelteon> clears are stiff tactile, no click
<joelteon> blues are soft tactile with click
<devyn> <3 mah browns
<purr> Let it be known that devyn hearts mah browns.
<joelteon> blues would drive my boss insane and he sits next to me
<joelteon> so that influences my choice
<joelteon> but gon provides spring customization
<joelteon> so i could make my clears less stiff
<devyn> joelteon: the caret on that GON's is fucking gigantic
<joelteon> yeah, gon doesn't sell keycaps
<joelteon> that's the DSA dolch set
<devyn> oh
<joelteon> i love the font face except for the weird caret
<joelteon> and the fact that it has "windows" keys
<devyn> upside down windows 98-era flags, even
<joelteon> yep
<joelteon> hopefully we can get around that one
<joelteon> i ordered my dolch keycap set already, actually
<ELLIOTTCABLE> browns? reds? blues!?!?
<joelteon> because i knew i'd want those regardless of what keyboard i bought
<ELLIOTTCABLE> SO CONFUS
<joelteon> the only problem now is clears vs reds
<joelteon> :(
<joelteon> honestly i'm not sure about browns
<joelteon> i have browns right now but i don't know if i like them
<joelteon> maybe i'll put o-rings on them to stop bottoming out
yorick has quit [Remote host closed the connection]
<ELLIOTTCABLE> … does nobody make high-budget keyboards like this with *low* keys?
<ELLIOTTCABLE> I fucking hate IBM M-style high-ass keys.
<ELLIOTTCABLE> worst to type on.
<ELLIOTTCABLE> I gave my Das Keyboard to, uhh, I think nexxy, because of that.
<joelteon> well the keycap has to cover the switch
<joelteon> i suppose you could get a keyboard with low keycaps but it would have to be really thick
<ELLIOTTCABLE> not with these switche
<joelteon> right
<joelteon> well
<ELLIOTTCABLE> these are obviously built for tall keycaps
<joelteon> good luck
<ELLIOTTCABLE> I just mean, Apple-like keyboards from a third party
<joelteon> dunno man
<joelteon> maybe you could spearhead that effort
<devyn> frankly I really like both
<joelteon> yeah, i'm leaning toward reds
<devyn> but typing on tall keycaps with browns is just so much more… satisfying
<joelteon> they're so nice
<joelteon> the brown doesn't have enough of a tactile bump
<joelteon> i want either no bump or lotsa bump
<devyn> haha
<joelteon> i'm pretty sure the noise from the blue is influencing me
<joelteon> a silent blue would be something different
<joelteon> silent blue aka clear
<devyn> nah a clear isn't a silent blue
<devyn> the click of the blue isn't purely audible, you can feel it too
<joelteon> i know
<devyn> solely*
<devyn> and clears are also stiffer
<joelteon> it's like a "pop"
<joelteon> brown is like a "thunk"
<devyn> the tactile bump on the browns and the blues is identical, it's just that blues have the click too
<joelteon> no way
<joelteon> wow maybe it is
<joelteon> i have a switch tester
<devyn> they have the same actuation force and the shape of the little bump inside is the same
<joelteon> it just arrived this morning
<joelteon> it's a lot of fun
<joelteon> brown is just blue without the white thing i guess
<devyn> yep
<joelteon> yeah i think it's gotta be red
<joelteon> no i think they're slightly different because you can also feel the clicking of the thing
<joelteon> talk about bikesheds though
<joelteon> holy shit
<ELLIOTTCABLE> wow.
<joelteon> it matters ec it matters
<ELLIOTTCABLE> devyn: my solution wasn't very good.
<ELLIOTTCABLE> devyn: basically was thinking about making [] return a "hole", and passing that hole to something as a resumption-vaue activated it, and made the thing passed-to the only thing able to resume you
<ELLIOTTCABLE> and then having a library function to free that up
<ELLIOTTCABLE> solves coproduction.
<ELLIOTTCABLE> foo[][a][b][c]
<ELLIOTTCABLE> can't be interloped
<ELLIOTTCABLE> but meh. a mess for anything else and ruins the good-parts of coproduction
<ELLIOTTCABLE> honestly, not convinced anymore that it's a problem
<ELLIOTTCABLE> another thing that's starting to look like it can be solved by abstraction.
<ELLIOTTCABLE> maybe what we *really* need is a better way to abstract over responsibility-like concepts.
<ELLIOTTCABLE> this stuff should be buildable libside.