purr changed the topic of #elliottcable to: a kind of sludge
eligrey_ has joined #elliottcable
eligrey has quit [Ping timeout: 265 seconds]
eligrey_ is now known as eligrey
eligrey has quit [Ping timeout: 265 seconds]
<purr>
<alexgordon> The penis sheath of a male axis deer is elongated and urine-stained. When rubbing trees with their horns, chital stags sometimes move the penis back and forth rapidly inside its sheath.[8] Male bison and fallow deer have tufts of fur at the end of their penis sheaths.
glowcoil has quit [Quit: Lost terminal]
<alexgordon>
purr: wat.
<purr>
alexgordon: can't find the referenced what.
yorick has quit [Remote host closed the connection]
Rusky has joined #elliottcable
<Rusky>
hey ELLIOTTCABLE
jesusabdullah has quit [Ping timeout: 264 seconds]
eligrey has joined #elliottcable
jesusabdullah has joined #elliottcable
<Rusky>
ec
<ELLIOTTCABLE>
Rusky: I'm *extremely* tired. I'm, like, forty-some hours awake, working on that spec … and then I had ill-advised violently energetic sex. So,
<ELLIOTTCABLE>
Lots of what i'm interested in lines up with that.
<Rusky>
yeah lamdu is cool
<Rusky>
interface Execution has Node advance(), while below there is a description of Combination advance(Object response)
<ELLIOTTCABLE>
ah, yeah, some stuff got out of sync. mistake.
<ELLIOTTCABLE>
fix'd
<Rusky>
I assume the second version is correct
<ELLIOTTCABLE>
meh whatever cleaned that up a bit
<ELLIOTTCABLE>
yeah.
<ELLIOTTCABLE>
the interface headers, and also the TOC, got a bit out of sync with the content in some cases
<Rusky>
so to execute a script you combine nodes left-assoc
<Rusky>
with whatever definition of combination that I haven't read yet
<ELLIOTTCABLE>
there's probably a link, hopefully
<ELLIOTTCABLE>
tried to hyperlink everything pretty obsessively
<Rusky>
they're not working for me, but I'm just confirming that explanation before I move on
gozala has quit [Quit: Connection closed for inactivity]
<ELLIOTTCABLE>
ah shit
<ELLIOTTCABLE>
broken links
<ELLIOTTCABLE>
I dislike Google Docs. But hey, I'm mildly stuck with it now.
<Rusky>
at least it's not tex
<ELLIOTTCABLE>
yeah. gonna move it into Markdown and some CSS later, probably.
<ELLIOTTCABLE>
wasn't work worth doing while the spec was incomplete. ick.
<Rusky>
for digestion purposes, example-first might be easier
<ELLIOTTCABLE>
no examples.
<ELLIOTTCABLE>
by design.
<Rusky>
you have one
<Rusky>
I'm looking at it
<Rusky>
:P
<ELLIOTTCABLE>
of Paws code? in the document? lies.
<Rusky>
of a data structure specified in json and how it corresponds to the paws interface stuffs
<ELLIOTTCABLE>
oh, that's not a code example, because it's a completely made-up syntax.
<Rusky>
I know
<Rusky>
but it's very helpful at explaining this stuff
<ELLIOTTCABLE>
hell, I should remove that anyway, it's super out-of-place, and the same thing could be explained in plain English
<ELLIOTTCABLE>
ew.
<ELLIOTTCABLE>
hm, really? interesting/
<Rusky>
without a concrete example I imagined several things but was completely unsure if they were related at all
<ELLIOTTCABLE>
example of what, by the way? Which specific concept (by name given it in the document, if you can) were you having trouble with?
<ELLIOTTCABLE>
#genuinepigging
<Rusky>
pretty much all of the interfaces
<Rusky>
I wasn't sure what context they were to be used in
<Rusky>
until I had read 10 pages
<ELLIOTTCABLE>
hmmm.
<ELLIOTTCABLE>
stupid ‘interface’
<ELLIOTTCABLE>
blame that on me trying to copy ECMAScript and Scheme R5RS.
<Rusky>
that could probably be solved by better description if you don't like examples
<ELLIOTTCABLE>
'cuz when Is tarted I had no idea “how to write a spec.” :P
<Rusky>
heh it reminds me of DOM spec
<Rusky>
which eww
<ELLIOTTCABLE>
yes, that's exactly what it's copying
<ELLIOTTCABLE>
HTML5 and SVG also got copied in there
<Rusky>
the ownership rules remind me of mozilla rust
<ELLIOTTCABLE>
I've heard lots of good things about Rust. Need to dive in there.
<Rusky>
it's a lot more static/low-level than paws appears
<Rusky>
but they also use ownership/reference semantics to make stuff threadsafe
<ELLIOTTCABLE>
this isn't actually thread-safety, although it stinks of it through-and-through
<ELLIOTTCABLE>
although it trickles down to aiding thread-safety
<Rusky>
right
<ELLIOTTCABLE>
it's solving a higher-level ordering-of-operations problem.
<ELLIOTTCABLE>
but, keep reading, more on all of that later.
<Rusky>
so continuation passing style
<ELLIOTTCABLE>
mmhmm
<ELLIOTTCABLE>
The Paws you're reading about is basically a pseudo-lisp; made inherently asynchronous by replacing EVERYTHING EVERYWHERE with CPS; and then made ascetically obtuse by removing every imaginable feature that can possibly be removed and then re-implemented libside in terms of the remaining features.
<ELLIOTTCABLE>
(That's the Nucleus.)
<Rusky>
you should put that in the intro
<Rusky>
I guess technically you did put most of it there :P
<ELLIOTTCABLE>
I mentioned this above, but before you got here (also, who the fuck is ‘rf’ if it's not you? He's got your name. Dead bouncer?)
<ELLIOTTCABLE>
but there's two things this document explicitly *does not* aim to do:
<Rusky>
that's not my name?
<ELLIOTTCABLE>
- explain how to use Paws,
<ELLIOTTCABLE>
- explain why you would *want* to use Paws.
<ELLIOTTCABLE>
it only explains how to *build* a Paws for people to use.
<ELLIOTTCABLE>
oh my god you're not russfrank, too?
<Rusky>
I think building a paws would at least entail knowing what it would be used for, so you know what to care about
<Rusky>
I have no idea who russfrank is
<ELLIOTTCABLE>
I totally thought you two were the same person, for the last several YEARS
<Rusky>
hahaha
<Rusky>
I popped into irc a couple times several years ago and haven't been back until now
<ELLIOTTCABLE>
will answer that question in a sec, BRB
<Rusky>
just heard about stuff from micah mostly
<ELLIOTTCABLE>
dog needs to go out
<Rusky>
also, how fine-grained is this parallelism intended to be
<Rusky>
3 * 4 + 5 * 6 -> do the multiplies in parallel?
<ELLIOTTCABLE>
undefined.
<ELLIOTTCABLE>
it's a mechanism exposed by the machine, to be exploited however a consumer desires.
<ELLIOTTCABLE>
in your example,
<ELLIOTTCABLE>
that depends on how the language-designer working on top of Paws implemented * and +.
<Rusky>
ah okay
<Rusky>
so nucleus just has the tools to make executions temporally independent
<Rusky>
so the vm can parallelize them
<Rusky>
when the language allows it
<ELLIOTTCABLE>
nailed it.
<ELLIOTTCABLE>
as an example:
<ELLIOTTCABLE>
my own language-of-design, Fullness, is going to be hiding away that entire mechanism; instead of a Fullness user having to explicitly lock and unlock sections of code,
<ELLIOTTCABLE>
Fullness has a ‘Routine’ type built on top of executions, with a little more traditional procedure-call architecture and use-case; and in 99% of cases, routines will be responsible for locking up the mutate-access to whatever thing they're called on.
<ELLIOTTCABLE>
(there's a bit more to it than that, but for the purposes of explaining how responsibility gets used … yeah. good nuff.)
<Rusky>
so being queued with a mask means "lock that stuff kthnx"?
<Rusky>
or more generally, "let me access that stuff without worrying about races"
<ELLIOTTCABLE>
you're halfway there with the latter
<ELLIOTTCABLE>
it actually means, simply, “I need to access that stuff.”
<ELLIOTTCABLE>
I'm realizing a big hole in the spec right now, or possibly in the entire design: There's always been discussion of *two kinds* of responsibility, and somehow that entire bucket of stuff didn't filter through my head into the specification *at all*.
<ELLIOTTCABLE>
but I also just checked my (working) implementation, and there's absolutely no mention of the two kinds in there, either, and I have no idea how that's possible |=
<Rusky>
so what does it apply to in addition to concurrency? memory management or something?
<ELLIOTTCABLE>
anyway, as usual with locking, there's read-acccess and write-access;
<ELLIOTTCABLE>
and as usual, read-access is implicit: as it's a higher-level language, the concurrency-safety of *individual operations* are guaranteed by the interpreter. You don't need any sort of responsibility/locking to read a simple value out of an object, for example.
<ELLIOTTCABLE>
and you clearly need to lock to get write-access, to *mutate* data, to prevent multiple mutations from interfering with eachother
<ELLIOTTCABLE>
but there's another, subtler kind which comes into play with an asynchronous language like this, which also needs locking: multiple-sequential-read. Not sure what that'd be called by anybody who isn't me, but it should be pretty obvious what it means:
<ELLIOTTCABLE>
if some pre-existing operation is expecting to preform more, future read-operations, and the integrity of the overall composite ‘operation’ is dependent upon the future read-operations and the past read-operations being coherent with eachother, then mutate-access must be denied to the data-structure in question.
<Rusky>
meaning you want all the read operations within the composite to be the same?
<ELLIOTTCABLE>
so, yeah. Three kinds of access: atomic-read, sequential-read, and mutate.
<ELLIOTTCABLE>
er, not the same, but, mutually interdependent.
<ELLIOTTCABLE>
okay, example.
<Rusky>
liek if you write it within that composite operation you want later reads to reflect that?
<ELLIOTTCABLE>
Let's say we have an Animal type. It has an ‘age’ property, and a ‘ratio’ property inherited from a given sub-type (blahblahblahobjectorientedeatmydickwhatever).
<ELLIOTTCABLE>
eh, terrible example. easier one:
<ELLIOTTCABLE>
Person type, like the example in the spec.
<ELLIOTTCABLE>
name: {'Elliott', 'Cable'}
<ELLIOTTCABLE>
if we have an algorithm to compose these into a full name, it needs to do the following: read slot one, read slot two, combine the results.
<Rusky>
ah okay, and you want both those reads to be atomic with respect to mutates of name
<ELLIOTTCABLE>
now, elsewhere, that Person's name is being changed to {'ELLIOTT', 'CABLE'}.
<ELLIOTTCABLE>
if we have an algorithm to compose these into a full name, it needs to do the following: read slot one, read slot two, combine the results.
<ELLIOTTCABLE>
but if it gets modified in the middle … yep.
<ELLIOTTCABLE>
then we end up with the result of our combination algorithm being 'Elliott CABLE'. Senseless.
<ELLIOTTCABLE>
So: our combining-names algorithm would need to acquire MSR-responsibility for the Person object it's going to interact with, before beginning the stretch of code where it interacts with that object;
<ELLIOTTCABLE>
and then release it when it's done with that stretch of code. simple locking stuff.
<Rusky>
is msr actually any different than atomic other than that it refers to multiple objects (which could be considered a single object in this example but might not be in other cases)
<ELLIOTTCABLE>
point of having an MSR-access-type that's different from a mutate-access-type,
<ELLIOTTCABLE>
is that multiple blocks of code requesting MSR-access can be granted that access simultaneously.
<ELLIOTTCABLE>
then, when some code requests mutate-access, that acts as a “bottleneck” in execution: all the *already executing* MSR blocks, get to finish what they're doing without being interrupted; and the mutate-access is frozen until they're all done …
<ELLIOTTCABLE>
… but no *new* blocks can acquire MSR, because the mutate's ahead of them in the queue, all those further MSRs queued will have to wait until the mutate is complete.
<ELLIOTTCABLE>
hm? all of these are “atomic access.”
<ELLIOTTCABLE>
two types of atomic access, one type for (macro)atomic reads, one type for atomic writes.
<Rusky>
you differentiated "atomic-read" and "sequential-read"
<ELLIOTTCABLE>
yes, because I'm avoiding the word atomic:
<ELLIOTTCABLE>
*all* of them are technically atomic, with regards to concurrency.
<ELLIOTTCABLE>
Just not in terms of order-of-operations.
<Rusky>
yeah
<ELLIOTTCABLE>
so, the single-read is also atomic, but doesn't need any responsibility, any locking.
<ELLIOTTCABLE>
yeah. need to figure this out and add it to the spec
<Rusky>
oh okay
<ELLIOTTCABLE>
okay.
<Rusky>
reading something on its own is just automatically taken care of, nobody's going to be halfway through writing the value when you read it
<Rusky>
but reading multiple somethings you need to specify the group that needs to be atomic
<ELLIOTTCABLE>
for the moment, the spec is still *functional*, it's just unnecessarily slow, because there's no MSR: *all* responsibility is mutate-responsibility, and even two blocks of code which could both be reading at the same time, aren't allowed to, because the specification doesn't differentiate.
<ELLIOTTCABLE>
yepyepyep
<ELLIOTTCABLE>
it's all about the asynchronicity:
<ELLIOTTCABLE>
we could, theoretically, solve the example above, with Person's name: object, because that happens quickly.
<ELLIOTTCABLE>
But this responsibility system *also* doubles as the scheduling system for a huge network of asynchronous operations.
<Rusky>
yeah
<ELLIOTTCABLE>
if we arbitrarily decide that we need to make a long network-access request, between getting the first name and the second name, that means that our algorithm would be left holding that MSR-responsibility for a (relatively, in CS terms) Very Long Time.
<ELLIOTTCABLE>
also meaning nothing can modify that until the network-request completes.
<Rusky>
so I think the spec got across what it was trying to
<Rusky>
but it could probably be less convoluted
<Rusky>
otherwise it looks good
<devyn>
ELLIOTTCABLE: OMG OMG OMG OMG
<ELLIOTTCABLE>
devyn: FIIIINALLY NOTICED
<devyn>
lol I'm not on computers much lately
<purr>
lol
<devyn>
except for at work
<devyn>
but then I'm so fucking busy
<devyn>
lol
<ELLIOTTCABLE>
WELL
<ELLIOTTCABLE>
IT HAPPENED
<ELLIOTTCABLE>
me too, btw
<devyn>
ok
<devyn>
is it part of the same spec doc?
<ELLIOTTCABLE>
I had a depressive episode,
<devyn>
I had a bit of one too
<devyn>
it wasn't as bad as I thought it would be though
<ELLIOTTCABLE>
and then a sudden (and very unusual for me) manic explosion where I sat down at a computer for the first time,
<ELLIOTTCABLE>
and immediately wrote an entire specification for Paws.
<ELLIOTTCABLE>
lol.
<devyn>
oh my
<ELLIOTTCABLE>
I'm still in some sort of shock. I also still haven't slept since I started.
<devyn>
lol
<ELLIOTTCABLE>
almost crashed about an hour ago, but friend and I are back up out of bed watching TV while I talk to Rusky
<ELLIOTTCABLE>
then definitely crashing and burning hard.
<ELLIOTTCABLE>
BUT HEY THERE'S A SPEC, IT'S VERY COMPLETE FOR WHAT IT IS :D
<Rusky>
speaking of
<ELLIOTTCABLE>
It completely describes a Paws machine, sans distribution, which we haven't figured out yet
<Rusky>
I better sleep now
<ELLIOTTCABLE>
Rusky: awww (=
<ELLIOTTCABLE>
Rusky: come back and talk to me more, I want to coerce you into building a Paws. (=
<Rusky>
I'm workin on a graphical programming interface for making games
<ELLIOTTCABLE>
three observations on my part, that I *hope* give me some credence:
<devyn>
"homoiconic combinator algebra"
<ELLIOTTCABLE>
1. I may be building a goddamn spaceship, but at least that spaceship doesn't involve an operating system or text editor. It's *all* a programming language, just one with several layers.
<whitequark>
grmpf
<ELLIOTTCABLE>
2. I'm actively putting effort into making sure my concepts, and tools, and variables, have *more* comprehensible and standardized names, not *less* comprehensible ones.
<devyn>
you sure you have no desire to make everything incomprehensible random 4-letter words, supposedly to fit within a 32-bit register?
<devyn>
I shit you not
<devyn>
that was the reason I was given
<ELLIOTTCABLE>
3. I'm building a work of interactive art, an *interface*, a *design*. Not something that I claim is better, or more academically sound, or more performant, in any measurable way than anything extant.
<purr>
<glowcoil> so adding features is a crapshoot whether it fits right in or requires radical restructuring
<devyn>
I'll add my feature
<devyn>
it might fit right in
<devyn>
it might require radical restructuring
<devyn>
but I know you'll like it
<devyn>
:3
<ELLIOTTCABLE>
devyn: :D
<whitequark>
oooh, last kill la kill episode
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
<whitequark>
she is a giant butterfly with eyes instead of wings, ok
eligrey has quit [Quit: Leaving]
eligrey-space has joined #elliottcable
<whitequark>
... a mass suicide?
eligrey-space has quit [Remote host closed the connection]
eligrey-space has joined #elliottcable
<whitequark>
what the *fuck*.
<whitequark>
literally wearing the body of your daughter?!
<whitequark>
...
<whitequark>
now they're all naked
<whitequark>
...
<devyn>
glowcoil! come back :c
<devyn>
I have
<devyn>
something to show you
<whitequark>
"when are you going to quit monologizing" THSI
<whitequark>
*THIS
<whitequark>
wow, now they are literally *all* naked
<whitequark>
every single human on earth
<whitequark>
... they really do lack understanding of a human's terminal velocity
<whitequark>
"THE END"
<whitequark>
did not disappoint.
eligrey-space has quit [Ping timeout: 265 seconds]
Sgeo_ has joined #elliottcable
Sgeo has quit [Ping timeout: 265 seconds]
prophile has joined #elliottcable
malia has joined #elliottcable
malia has left #elliottcable [#elliottcable]
yorick has joined #elliottcable
<purr>
<gkatsev> alexgordon: you aren't even on the right continent
<whitequark>
well, not yet made, just drawn a blueprint and wrote gcode
<whitequark>
I've yet to launch the actual job
<whitequark>
ugh, it's going to be milling for 30 minutes
prophile has joined #elliottcable
<ELLIOTTCABLE>
prophile: hi!
<ELLIOTTCABLE>
got a new electronics project!
<ELLIOTTCABLE>
toy jellybean sorter!
<prophile>
neat
<ELLIOTTCABLE>
that wasn't directed at you
<ELLIOTTCABLE>
just sudden realization
<ELLIOTTCABLE>
prophile: Paws! You! Hi! Me!
<prophile>
incredibly busy
<prophile>
:(
<ELLIOTTCABLE>
BAH
<ELLIOTTCABLE>
okay.
<joelteon>
type systems
<joelteon>
they're hard
<joelteon>
wait, no
<joelteon>
i'm just stupid
<ELLIOTTCABLE>
wat
nuck has quit [Ping timeout: 265 seconds]
PLejeck has joined #elliottcable
glowcoil has joined #elliottcable
glowcoil has quit [Client Quit]
glowcoil has joined #elliottcable
glowcoil has quit [Client Quit]
glowcoil has joined #elliottcable
<glowcoil>
ELLIOTTCABLE: i reconstructed my higlightwin myself
<glowcoil>
ELLIOTTCABLE: i'm proud of myself
<ELLIOTTCABLE>
hm?
<glowcoil>
i started irssi and there wasn't one
<glowcoil>
so i made i
<glowcoil>
t
<ELLIOTTCABLE>
hahaha
PLejeck has quit [Ping timeout: 265 seconds]
<glowcoil>
UGGGH in rainbows is so fucking good
PLejeck has joined #elliottcable
<ELLIOTTCABLE>
ew
<eligrey>
wow ec
<ELLIOTTCABLE>
eligrey: ?
<ELLIOTTCABLE>
eligrey: by the way, nigger, Paws has a spec.
<eligrey>
yeah i saw it
<eligrey>
also wow re: hating in rainbows
<ELLIOTTCABLE>
I really don't like their music. It's quite bad.
<glowcoil>
ELLIOTTCABLE: wHAT
<glowcoil>
i can understand you not liking the first couple albums
<glowcoil>
but i cannot understand you disliking kid a onwards
<glowcoil>
so much Warp in there
<glowcoil>
autechre etc.
<glowcoil>
in rainbwos is like
<glowcoil>
drugs
<ELLIOTTCABLE>
uh
<glowcoil>
perfect tactile sensations
<ELLIOTTCABLE>
it's not like I've *listened* to all of those
<glowcoil>
PERFECT production
<ELLIOTTCABLE>
I listened to maybe two radiohead songs ever, probably in the early naughties, and said ‘fuck this’
<glowcoil>
yeah you probably listened to the earlier stuff because i think you specifically would be genuinely interested in their later stuff
<ELLIOTTCABLE>
I'm not really one to give artists or genres (or, really, anything in life) a second chance. Too many *new* things to try. *shrug*
<purr>
¯\(º_o)/¯
<ELLIOTTCABLE>
seriously?
<glowcoil>
yeah
<glowcoil>
experimental electronics
<ELLIOTTCABLE>
I don't *do* whiny-sounding-voice guitar-music shit.
<glowcoil>
thom yorke is into the whole uk electronic shit
<glowcoil>
ok well i mean it's still got singing and guitars in the later stuff
<glowcoil>
*shrug*
<purr>
¯\(º_o)/¯
<eligrey>
at least listen to kid a once
<glowcoil>
mean idk
<glowcoil>
yeah
<ELLIOTTCABLE>
I like electronic, I like bass, or I like *creative music* (accredited classical shit, or experimental stuff.)
<eligrey>
you won't regret it
<glowcoil>
kid a is all of those things
<glowcoil>
:p
<ELLIOTTCABLE>
it's experimental electronics?
<ELLIOTTCABLE>
radiohead?
<glowcoil>
yeah
<glowcoil>
yeah
<ELLIOTTCABLE>
are we talking about the same thing? o_O
<glowcoil>
kid a onwards
<eligrey>
i wouldnt call it experimental
<ELLIOTTCABLE>
I remember a, like,
<glowcoil>
thom yorke is a big fan of autechre, aphex twin, etc.
<ELLIOTTCABLE>
well, send me some selections on Spotify.
<glowcoil>
and he's featured on burial tracks
<glowcoil>
ok cool
<ELLIOTTCABLE>
two or three things. you know my tastes.
<ELLIOTTCABLE>
<3
* ELLIOTTCABLE
goes back to code
<glowcoil>
ELLIOTTCABLE: ok so in rainbows isn't on spotify, because they self-released it for pay-what-you-wnat on their site (one of the first people to do that ever, and it caused a major splash)
<ELLIOTTCABLE>
yeah, I heard about that.
<ELLIOTTCABLE>
what do you think about that old-school rap group that's doing the “Work of art”-style release right now?
<ELLIOTTCABLE>
doing private showings, and then selling the entire album to exactly one collector for millions and millions, later?
<glowcoil>
oh yeah
<glowcoil>
wu tang
<glowcoil>
i think it's really cool
<ELLIOTTCABLE>
sounds very cool.
<glowcoil>
because music is so commodified and shit
<ELLIOTTCABLE>
yep
<glowcoil>
really emphasizing how it's the same thing as visual art
<ELLIOTTCABLE>
personally, I don't see why it can't be both:
<glowcoil>
also wu tang are the right people to do it since they're so legendary and influential
<ELLIOTTCABLE>
artists create for *art* instead of *distribution*; they sell the art for big bucks, or little bucks, or whatever, but do it in that sort of format … then people *with the interest in the distribution* buy it and make decisions like that.
<ELLIOTTCABLE>
instead of the artist contracting with them from the start.
<ELLIOTTCABLE>
anyway, CODE
<glowcoil>
cod
<glowcoil>
cod
<glowcoil>
EVERYTHIIIIIIIIIING
<glowcoil>
EVEYTHIIIIIIIIIIING
<glowcoil>
IN ITS RIIIIIGHT PLAAAAACE
<ELLIOTTCABLE>
coding
PLejeck is now known as nuck
<glowcoil>
nuck: hi
<nuck>
hi glowcoil
<ELLIOTTCABLE>
nuck!
<ELLIOTTCABLE>
nuck: I made a thing. (=
<glowcoil>
nuck: [Y/Y] is in rainbows greatest album of all time
<ELLIOTTCABLE>
it's written to teach A) somebody who doesn't know Paws, or B) much about implementing a programming language, how to build themselves a Paws.
<nuck>
"much" is being a bit kind
<nuck>
I know basically fuckall. I've just picked up bits and pieces in here
* ELLIOTTCABLE
grins
<ELLIOTTCABLE>
excellent idea to take this and try writing it in code, then.
<ELLIOTTCABLE>
won't take you long, or shouldn't.
<ELLIOTTCABLE>
implementing it *well* would, but just the basics to code are basically trivial.
<nuck>
hah
<nuck>
I'm not even capable of reading BNF so
<nuck>
yeah
<ELLIOTTCABLE>
copy-paste that into a parser-generator, perhaps.
<ELLIOTTCABLE>
or just ignore that and don't worry about the syntax. cPaws is entirely optional and unnecessary.
<nuck>
Can I literally just copy paste that into a parser generator? I thought they all took weird fucked up wannabe BNF
<nuck>
I've only used yacc I think tho
<ELLIOTTCABLE>
different ones use different stuff. and, nah, unfortunately, because I didn't *serialize* the Unicode set into that.
<nuck>
I really ought to learn how to use a parser generator :u
<ELLIOTTCABLE>
do so!
<ELLIOTTCABLE>
again: this is a perfect chance.
prophile has joined #elliottcable
<ELLIOTTCABLE>
as easy to implement as a 90% Scheme.
<ELLIOTTCABLE>
wtf, irccloud
<nuck>
There's two things I really don't get in programming: (1) unit and integration testing (kind of) (2) generator generator generators
<ELLIOTTCABLE>
a non-concurrent, non-distributing Paws machine should be approximately as easy to implement as a 90% Scheme*
<nuck>
Where (2) is referring to awful things like automake
<nuck>
god I hate automake
<ELLIOTTCABLE>
you don't get unit testing?
<ELLIOTTCABLE>
o_O
<nuck>
I get it kind of
<nuck>
I just... whenever I ask for advice on like, stubbing and shit
<nuck>
The answers I get are effectively repeating the question back to me
<nuck>
Like I once asked "how would I test X properly as a singular unit" and the reply was "stub the method" to which I said "how do I do that exactly?" and they suddenly went silent
<nuck>
I love the *thought* of testing. The incentive of a little green Travis CI badge sounds really nice
<nuck>
(plus fewer bugs)
* ELLIOTTCABLE
nods
<ELLIOTTCABLE>
testing is *definitely* a learned skill, and *definitely* not intuitive in some cases
<ELLIOTTCABLE>
it's a weird animal.
<ELLIOTTCABLE>
I'm a good programmer, but a shitty tester.
<ELLIOTTCABLE>
“Unit testing” is one of the few areas of programming where I would voluntarily *read an actual book*, instead of googling.
<ELLIOTTCABLE>
Something to give me an intuitive understanding of when-to-do-what when testing.
alexthegreat has joined #elliottcable
<ELLIOTTCABLE>
lol alexthegreat
<purr>
lol
<alexthegreat>
true story: my middle name is "the"
<alexthegreat>
glowcoil: here?
<alexthegreat>
ELLIOTTCABLE: I'm working on concurrency stuff, you might like this
<ELLIOTTCABLE>
writin'
<nuck>
ELLIOTTCABLE: I can't find any good books on unit testing sadly
<nuck>
So I'm pretty sure I just have to dive head first and take wild awful guesses
<nuck>
Some of the shit I have to unit test is odd too -- graphical unit testing, for example
<alexthegreat>
I mean it's easy enough if you use a parallel map, that's not the problem, but doing it in _general_ is just a mindfuck and a half
<alexthegreat>
so the root of it is: how do you ensure that callbacks to an async operation are called in order, and how do you do memory management of mutable state for that
<ELLIOTTCABLE>
what language is that
<ELLIOTTCABLE>
filetype is haskell, but it looks nothing like any haskell I've seen
<alexthegreat>
ELLIOTTCABLE: furrow
<ELLIOTTCABLE>
oh. so, what's the issue?
<alexthegreat>
ELLIOTTCABLE: do you get what the code is doing?
<ELLIOTTCABLE>
re-reading it
<ELLIOTTCABLE>
god, I hate syntax so much
<alexthegreat>
LOL
<purr>
LOL
<ELLIOTTCABLE>
having to re-learn everything for mildly different semantics ಠ_ಠ
<alexthegreat>
loop over a list of paths, get their stat(), then if the ctime is before yesterday, insert the path into another list
<ELLIOTTCABLE>
anyway. what's the arrow?
<ELLIOTTCABLE>
asynch s < fs.stat?
<ELLIOTTCABLE>
is async a keyword there, or is that some sort of function call?
<alexthegreat>
ELLIOTTCABLE: the arrow is an implicit callback
<ELLIOTTCABLE>
async(s)?
<alexthegreat>
yeah it's a keyword
<alexthegreat>
just like node really
<ELLIOTTCABLE>
à la ruby's {|abc| def }?
<ELLIOTTCABLE>
what is s?
<alexthegreat>
fs.stat(p, function() { ... })
<alexthegreat>
ELLIOTTCABLE: s is the stat data
<ELLIOTTCABLE>
werd
<ELLIOTTCABLE>
hold on now i'm bent
<ELLIOTTCABLE>
Oh I'm reading it backwards.
<alexthegreat>
LOL
<ELLIOTTCABLE>
write the whole line as JavaScript.