<ELLIOTTCABLE>
… it's 3:15 AM, and I'm not asleep.
<ELLIOTTCABLE>
so idk how *it's* going, but I feel there's a substantial chance that *I'm* not ‘going’ to *it*
<ELLIOTTCABLE>
>,>
<ELLIOTTCABLE>
fuckin' insomnia
<ELLIOTTCABLE>
<,<
<vigs>
lol
<purr>
lol
<vigs>
I just spent 50 minutes playing GTA V with my friend because my JS is throwing a ReferenceError when it really shouldn't
<ELLIOTTCABLE>
LOL
<vigs>
not funny :<
<ELLIOTTCABLE>
that's okay
<vigs>
I have no idea why this is happening and it makes me sad
* vigs
pets purr
* purr
rrrrr
<vigs>
Also I've mostly coded or played guitar this weekend and my right wrist is hurting a bit .___.
<ELLIOTTCABLE>
that's okay
<ELLIOTTCABLE>
:: implementation console print () (implementation version ())
<ELLIOTTCABLE>
currently fails to terminate
<ELLIOTTCABLE>
so,
<ELLIOTTCABLE>
you're better than me, at least you get errors from your mistakes
<ELLIOTTCABLE>
mine just sit there.
<vigs>
so it always prints the version? .__.
<vigs>
lol
<purr>
lol
<ELLIOTTCABLE>
huh?
<ELLIOTTCABLE>
no, like, the program never exits, and I'm not sure why as of yet.
<vigs>
LOL
<vigs>
amazing
<ELLIOTTCABLE>
welcome to Paws.
<vigs>
-didja @ ELLIOTTCABLE
<purr>
ELLIOTTCABLE: didja write a paws yet? didja? didja!?
<vigs>
ELLIOTTCABLE: I dunno, even though I have more to go off of, I don't think I have the better situation. The function that's being called is identical to two others that DON'T throw a ReferenceError
<ELLIOTTCABLE>
vigs: didja
<vigs>
not yet :<
<ELLIOTTCABLE>
doyah
<vigs>
I'm a few weeks behind in Computer Design and a few days or so behind in Advance JavaScript. Once I finish this project, I'll be done with my Intro JavaScript course. So I wanna do that first :<
<vigs>
Having few hard deadlines is __weird__
<ELLIOTTCABLE>
wat
<vigs>
wat wat?
<ELLIOTTCABLE>
wat.
<vigs>
I don't know wat you're watting
<vigs>
what the FUCK
<vigs>
it's not breaking on the referenceerror anymore. Now it can't even load a file
<vigs>
computers, man
<vigs>
(╯°□°）╯︵ ʇdᴉɹɔsɐʌɐɾ
<ELLIOTTCABLE>
lol!
<purr>
lol
<vigs>
this is bullshit .___.
<ELLIOTTCABLE>
hi
<purr>
ELLIOTTCABLE: hi!
<ELLIOTTCABLE>
>:
<vigs>
IT SEGFAULTED
<vigs>
AND NOW IT'S NOT
<vigs>
WTF
<ELLIOTTCABLE>
vigs: lolololol
<purr>
lolololol
<vigs>
wtf does this even mean
<vigs>
FileStream: Too many open files
<vigs>
uncaught exception: Load:"File open failure" (File open failedname=Quiz.js,mode=0,error=24)
<vigs>
Execution error in QuizSystem.js.
<vigs>
what the FUCK
<vigs>
AND NOW IT WORKS
<vigs>
WHAT THE SHIT
<vigs>
JSDB has been shitting it self for 10 minutes
<vigs>
wtf
<ELLIOTTCABLE>
lol
<vigs>
AND NOW IT DOESN'T
<vigs>
ffs I'm so confused
<ELLIOTTCABLE>
so i figured out why it doesn't terminate
<ELLIOTTCABLE>
because it's not supposed to
<vigs>
oh?
<ELLIOTTCABLE>
lol im bad at paws
<purr>
lol
* vigs
pets ELLIOTTCABLE
<glowcoil>
hi guys
<ELLIOTTCABLE>
i *invented* the damn thing and I never remember how it works
<glowcoil>
help me design "hands" or maybe some other name
<ELLIOTTCABLE>
use totp
<ELLIOTTCABLE>
every function-call requires a OTP
<ELLIOTTCABLE>
that'll be user-friendly as all fuck
<vigs>
SAY NO TO POT #420NO
<ELLIOTTCABLE>
and super secure
<vigs>
SAY NO TO TOTP #420NO
<ELLIOTTCABLE>
that's how secureity works
<vigs>
I'm so confused rn
<vigs>
I fucking hate computers sometimes >_<
<glowcoil>
ELLIOTTCABLE: i'm really sorry, i didn't remember to figure things out about it in time
<glowcoil>
ELLIOTTCABLE: i feel really bad :(
<glowcoil>
ELLIOTTCABLE: are you having a good conf time tho
<ELLIOTTCABLE>
I feel vaguely, unfulfilledley good about that
<vigs>
:D
<ELLIOTTCABLE>
idk
<ELLIOTTCABLE>
met a lot of people at the CSSconf pre-party, which was really neat
<ELLIOTTCABLE>
kept having the “run into person, first-name basis, talk about cool shit, then get informed by a third party later that that was **the** FirstName”
<ELLIOTTCABLE>
Felix G, potch, wingolog (andy), couple others
<ELLIOTTCABLE>
and then the ever-entertaining “oh shit, you're *that* Elliott” interaction.
<ELLIOTTCABLE>
never ceases to amaze me how many people know who I am, but have no idea what I do.
<ELLIOTTCABLE>
but most impressively, I had an entire table of random dudes gape-mouthed at my descriptions of Paws (well, general CPS asynchronicity, really, but …)
<ELLIOTTCABLE>
so that's a good feel, and has me a bit fired up again :P
<ELLIOTTCABLE>
omfg I seriously talked to Andy for half an hour before he's all “Oh, I maintain a language that you've probably never heard of, this old thing …” “which one?” “Guile?”
<ELLIOTTCABLE>
really? really?? ಠ_ಠ
<glowcoil>
ELLIOTTCABLE: sounds sweet :D
<glowcoil>
ELLIOTTCABLE: yeah paws is definitely something
<ELLIOTTCABLE>
vigs: u like my new name?
<glowcoil>
ELLIOTTCABLE: also cool terminal stuff
<ELLIOTTCABLE>
is prty
<vigs>
ELLIOTTCABLE: You mean ELLIOTTCABLE?
<ELLIOTTCABLE>
vigs: oh, no, it's ELBACTTOILLE
<ELLIOTTCABLE>
but backwards.
<ELLIOTTCABLE>
;)
<vigs>
wat
<vigs>
oh
<vigs>
I can't think of any reason why this function is not working
<vigs>
`QuizSystem.js:11TypeError: load("Answer.js") is not a function`
<ELLIOTTCABLE>
semicolon.
<vigs>
not necessary…
<ELLIOTTCABLE>
semicolon.
<vigs>
that changes literally nothing
<ELLIOTTCABLE>
semicolon.
<vigs>
or not
<vigs>
wtf
<vigs>
WHAT THE FUCK
* ELLIOTTCABLE
grins
<vigs>
ELLIOTTCABLE: ARE YOU A FUCKING WIZARD
<vigs>
WHAT THE SHIT BRO
* ELLIOTTCABLE
nods
<ELLIOTTCABLE>
-didja @ vigs
<purr>
vigs: didja write a paws yet? didja? didja!?
<vigs>
why the fuck…?
<vigs>
SEMICOMMAS ARE TOTALLY OPTIONAL IN JS
<ELLIOTTCABLE>
You have two options, with JavaScript:
<vigs>
WTF MAN
<ELLIOTTCABLE>
Understand the ASI rules *thoroughly*,
<ELLIOTTCABLE>
or write pervasive, unnecessary semicolons.
<ELLIOTTCABLE>
neither is particularly attractive.
<ELLIOTTCABLE>
Luckily, the ASI rules are *way* less scary than most people think.
<ELLIOTTCABLE>
It's still not *sane*, but … at least it's *approachable*-insane.
<vigs>
I normally write semicommas
<vigs>
but wtf
<ELLIOTTCABLE>
Your next line began with a paren, most likely.
<vigs>
I removed them because I'd left out more semicolons than I'd written
<vigs>
in that file, at least
<vigs>
yeah
<vigs>
it's an anonymous function call
<ELLIOTTCABLE>
Much less likely, it might have begun a bracketed expression, or begun with (what you thought was) a unary operator
<ELLIOTTCABLE>
yep.
<ELLIOTTCABLE>
next time you do that, use this:
<ELLIOTTCABLE>
replace
<vigs>
(function(){…})();
<ELLIOTTCABLE>
(function(){
<ELLIOTTCABLE>
// ...
<ELLIOTTCABLE>
})()
<ELLIOTTCABLE>
with, instead,
<ELLIOTTCABLE>
~function(){
<ELLIOTTCABLE>
// ...
<ELLIOTTCABLE>
}()
<vigs>
O________O
<ELLIOTTCABLE>
~ has three advantages:
<vigs>
what IS that operator?
<vigs>
s/operator/thing
<ELLIOTTCABLE>
A) easy on the eyes; it forces the following function to be parsed as a statement instead of a declaration (which is what the parens do),
<ELLIOTTCABLE>
B) has no effect on the call, because the return-value is discarded *anyway* for an IIFE,
<ELLIOTTCABLE>
and C) has no binary analogue in JavaScript, meaning you don't have to be wary of preceding lines' missing semicolons.
<ELLIOTTCABLE>
bitwise not
<ELLIOTTCABLE>
nothing a sane person will ever use in their JavaScript code
<glowcoil>
ELLIOTTCABLE: so i have a language idea in my head, don't know if it's too different from paws to call it hands
<ELLIOTTCABLE>
something you might as well think of as the IIFE operator, IMO.
<vigs>
ELLIOTTCABLE: IIFE?
<ELLIOTTCABLE>
errrrr, idk, it's what people call that
<glowcoil>
ok my dread about buffering for parsing is gone
* ELLIOTTCABLE
laughs
<glowcoil>
just retwat from irccloud
<glowcoil>
we are in the future folks
<ELLIOTTCABLE>
before you dive into implementation, chat distribution with me real quick
<glowcoil>
ok
<glowcoil>
i feel like we need to force every data type to be serializable
<ELLIOTTCABLE>
or rather, interaction of two code-spaces, because that's the only aspect of distribution I'm worried about considering right now
<ELLIOTTCABLE>
no, *not* doing so is the explicit purpose of Paws
<ELLIOTTCABLE>
i.e. the DOM
<glowcoil>
oh
<glowcoil>
right
<ELLIOTTCABLE>
I mean, I **will** allow serializable types, but
<ELLIOTTCABLE>
… if I'm being completely purist and pedantic, a ‘perfect’ Paws system as I envisioned it would never send any serialized types over the wire.
<ELLIOTTCABLE>
anything that can be transferred should ideally be represented in *transparent* structures (i.e. constructions of nested Things … think structs/objects/lisp lists), instead of opaque structures (i.e. hidden data).
<ELLIOTTCABLE>
that's clearly not 100% possible. For instance, a string.
<ELLIOTTCABLE>
and I'm open to any pragmatic usage of native types for a purpose that could *conceivably* be implemented purely libside, that couldn't *practically* be so done … and obviously those types should be serializable / transferrable.
<vigs>
I AM AN IDIOT BECAUSE I RENAMED A FILE BUT DIDN'T MARK THAT CHANGE IN THE CODE
<vigs>
FUCK
<ELLIOTTCABLE>
sorry. will shut up.
<ELLIOTTCABLE>
SO, GLOWCOIL, OMFG, POINT IS:
<ELLIOTTCABLE>
three conceptual ways of ‘connecting’ two object-spaces/code-spaces/separation-of-concerns-spaces.
<vigs>
ELLIOTTCABLE: so how'd you learn so much about language design?
<vigs>
books, I'm assuming?
<ELLIOTTCABLE>
I know fuckall about language design lol
<purr>
lol
<ELLIOTTCABLE>
I'm a designer trying and failing to build a programming language and getting bored and antsy and wanting to go play with nodecopters.
<vigs>
…wait, are you a designer by training? .____.
<ELLIOTTCABLE>
A) merging (complete, indiscriminate access to the data in the second space, by anything in the first space.)
<ELLIOTTCABLE>
I'm a nothing by training. I have approximately the formal schooling background of a turnip.
<ELLIOTTCABLE>
-turnip
<ELLIOTTCABLE>
-find turnip
<purr>
ELLIOTTCABLE: Found: turnips
<ELLIOTTCABLE>
-turnips
<purr>
ELLIOTTCABLE: turnips are a rüt vegetable.
<vigs>
lol wat
<ELLIOTTCABLE>
hurr hurr hurrr
<vigs>
man all you smart nerds out there and I'm just here wasting hours chasing down one character T__T
<ELLIOTTCABLE>
I had this conversation today
<ELLIOTTCABLE>
“Hurr I wanna build a programmen language whiff distributes its stuffs, yarr?”
<vigs>
this one we're having? or one you're about to tell us about?
<vigs>
oh
<ELLIOTTCABLE>
“… there's lots of very interesting hurdles involved in building a distributed programming language. How are you planning to overcome some of them?”
<ELLIOTTCABLE>
“oh shi— I think I heard that other dude calling my name OH SHIT SPILLED MY BEER BRB”
<vigs>
._____.
<vigs>
wtf
<glowcoil>
what channels does whitequark lurk in these days
<ELLIOTTCABLE>
B) ACL/delineated access to particular sections of the foreign object-space (basically, “restricted” and “public” lines on the data-graph, in Paws-esque terms)
<glowcoil>
i want to ask his opinion on my language
<ELLIOTTCABLE>
#Ruby
<ELLIOTTCABLE>
vigs: yeah, that really happened, lol
<purr>
lol
<glowcoil>
ELLIOTTCABLE: i feel like making it more explicit is the way to make it a less leaky abstraction
<ELLIOTTCABLE>
yayaya agreed
<glowcoil>
ok go on what's C)
<ELLIOTTCABLE>
C) single-point-of-entry, Node.js-module-esque
<ELLIOTTCABLE>
or in paws terms, if we visualize the two object graphs, having them touch at exactly one node
<ELLIOTTCABLE>
so, I despise A, and it doesn't play well with my goals for the language,
<ELLIOTTCABLE>
and I've come up with two systems I quite like, one each for the high-level B and C concepts.
<glowcoil>
cool, let's hear them
<ELLIOTTCABLE>
for multiple-point-of-entry, I have a conceptual system based on, errrrrrr, fuck, what're they called,
<ELLIOTTCABLE>
capabilities, yah, those
<glowcoil>
oh yeah
<ELLIOTTCABLE>
got super-excited when I discovered those, they're right up the alley of what I was thinking originally
<ELLIOTTCABLE>
we'll call this system B.
<ELLIOTTCABLE>
basically, every piece of data has a “host site” at any given time.
<ELLIOTTCABLE>
a B API allows the host site to generate ‘capability pairs’ for a given node in its data-graph: two native objects, one of which can be given away, and the other of which gives an interface for controlling the one that's been given away.
<ELLIOTTCABLE>
the one given away is, obviously if you're familiar with capabilities, something we can create with various privileges: at the most basic, read vs. read/write; but certainly more powerful things as well (access-native-procedures-on-my-host, much?)
<glowcoil>
ooh so like virtual particle pairs that get separated on each side of an event horizon
<ELLIOTTCABLE>
yep
<glowcoil>
(also similar to rust chan objects)
<ELLIOTTCABLE>
'cuz this is Paws and we hint data-structures, capabilities would traverse the host site's data-graph along ownership edges
<ELLIOTTCABLE>
capabilities can be copied by the foreign site and shared further (thus lending the first hints of our federation plans),
<ELLIOTTCABLE>
and the host-site can revoke or further empower that capability as it desires, with its' control-pair
<glowcoil>
and the thing you give away has some kind of token?
<glowcoil>
oh you could do like priv/pubkey shit in the most heavy duty of situations?
<ELLIOTTCABLE>
this also ties into my distribution plans, vaguely … I don't know enough Meaty Science behind distribution to know how useful it is (LOL, RIGHT AFTER PREMATURE LANGUAGE-DESIGN OPTIMIZATION BIT ME ONCE, I"M DOING IT AGAIN. SMART ELLIOTT.),
<purr>
LOL
<ELLIOTTCABLE>
but I very much assume that that could inform the realization-flow stuff.
<ELLIOTTCABLE>
glowcoil: I am *not* talking about security.
<ELLIOTTCABLE>
Any time anything I discuss here *sounds* like security, I want it to be completely and explicitly clear that I am only talking about **encapsulation**.
<ELLIOTTCABLE>
Because lots of concepts useful to secure systems *also* apply to well-encapsulated systems …
<ELLIOTTCABLE>
… but I do **not** have the security background to make any sort of claims as to my design's security properties, whatsoever, and I do not even want to *discuss* that lest I generate some delusions of seceur or some shit.
<ELLIOTTCABLE>
anyway! C!
<ELLIOTTCABLE>
take two:
<ELLIOTTCABLE>
much less complex / integrated-into-the-overall-design, so not as tasteful to me, (you know I like stuff that's tightly-coupled into our small-core design, so,)
<ELLIOTTCABLE>
a Unit ‘exports’ particular nodes in its graph. these ‘exports’ (lol the name already gives it away, thanks Nodejs) are implicitly stored on an intangible “exports” object.
<purr>
lol
<vigs>
brb gonna go shower
<ELLIOTTCABLE>
a foreign unit that acquires-reference to us then, through whatever API call gives it access, receives that exports object, with copies of whatever data we've exported.
<ELLIOTTCABLE>
presumably, some sort of mutation could be achieved, but I haven't thought option C through far enough to get super-excited about the possibilities there.
<ELLIOTTCABLE>
so: some key differences.
<ELLIOTTCABLE>
C is pretty explicitly pull-semantics.
<ELLIOTTCABLE>
B is more vaguely push, although there will clearly have to be *some* sort of pull-component.
<ELLIOTTCABLE>
C is conceptually simple and accessible. B is probably more scary, but also more flexible.
<ELLIOTTCABLE>
related notations scribbled in the margin of my brain:
<ELLIOTTCABLE>
acquisition of reference is its *own* Entire Thing, that the more I think about it, the more I think it is *completely irrelevant*.
<ELLIOTTCABLE>
I'm pretty sure i'm gonna outsource that entire problem as a whole.
<ELLIOTTCABLE>
basically, describe the Unit interface, from the point of view of two Units running *on the same implementation*, but then leave a hole for “adapters” to be dropped in:
<ELLIOTTCABLE>
shipping, presumably, with a filesystem adapter that loads frozen Units from filesystem paths on the disk,
<glowcoil>
I like B
<ELLIOTTCABLE>
but also could be augmented with, say, a network adapter? … or a package-manager adapter (P2P repository of registered identifiers, that automatically downloads/verifies libraries your code uses?) …
<ELLIOTTCABLE>
but either way, it boils down to:
<ELLIOTTCABLE>
“acquire reference” to a Unit, and then “ask for a directory of available capabilities.”
<ELLIOTTCABLE>
presumably one of the most basic capabilities, being ‘authenticate me for more advanced capabilities.’
<ELLIOTTCABLE>
it seems pretty Rut, but at the moment, my only *real implementation* thoughts for B, is:
<ELLIOTTCABLE>
unit directory(<opaque unit descriptor>) -> a list of Labels, each corresponding to an advertised capability,
<glowcoil>
i feel like it's way more explicit and powerful than most existing rust systems for distribution
<ELLIOTTCABLE>
unit acquire(<descriptor>, Label<identifier>) -> <capability>
<ELLIOTTCABLE>
oh, and of course, some important notes on the implementation there:
<glowcoil>
rut*
<glowcoil>
haha
<ELLIOTTCABLE>
an object for which you have foreign capability shouldn't be distinguishable from a Thing.
<ELLIOTTCABLE>
I still haven't quite got error-handling worked out, you know me, but … whatever the error-handling system is for trying to stage() a Thing, it'd be a similar error to try to preform any operation you don't have the capability for, on a foreign thing.
<ELLIOTTCABLE>
OOO SUDDEN IDEA:
<ELLIOTTCABLE>
aroeghjr2pionjkdgrq
<ELLIOTTCABLE>
dnhu3qridhtjlnwtpkonklfpto3wglrkdv
<vigs>
back
<vigs>
r u ok
<ELLIOTTCABLE>
how's this for a mind-bender:
<ELLIOTTCABLE>
“Capability” === native ⋃ thing
<vigs>
the only time I've seen capabilities in code are when initializing an Appium driver so they mean potatoes to me
<ELLIOTTCABLE>
vigs: oh, that's easy.
<vigs>
yeah
<ELLIOTTCABLE>
in Paws, instead of modernstupidPawsthatidontevenloveanymore,
<vigs>
no idea what you mean by "capability" here
<ELLIOTTCABLE>
they'd be called Keys.
<ELLIOTTCABLE>
a capability is like a car-key.
<ELLIOTTCABLE>
most computer authorization stuff is focused on *identification*. (“Who you are.”)
<vigs>
like the kind you bake into a pie or give a best buddy value to hang out with?
<ELLIOTTCABLE>
capabilities are a very rare, nowadays, but old, idea, of *instead* securing things by *posession*. “what you have.”
<ELLIOTTCABLE>
think about an old classic car: you've got the master key, the valet key, the trunk key …
<vigs>
…my car has the first two of those
<ELLIOTTCABLE>
each one has different abilities ‘baked into’ it. If I give the valet dude a vkey,
<ELLIOTTCABLE>
he can give it to his boss, if he needs to go off-shift,
<ELLIOTTCABLE>
the boss can give that to your wife if she takes the ticket up,
<ELLIOTTCABLE>
etc. whoever's holding the key, can turn on the car.
<vigs>
mhm
<ELLIOTTCABLE>
but none of them can open the *trunk*.
<ELLIOTTCABLE>
and crucially, none of that system requires in-band authentication: the *car itself* doesn't have to worry about who's who.
<ELLIOTTCABLE>
trust and authentication are handled out-of-band: you trusting the corporation that runs the restaurant to have sane hiring policies. the employee trusting his boss. the boss seeing the valet-ticket.
<ELLIOTTCABLE>
it's A) more granular: this isn't the physical world, and we're not limited to a reasonable number of unique kinds of keys. We can generate any particular key with an arbitrarily large <set> of capabilities, to all the myriad APIs and abilities that the system granting-capbility can provide, and then generate a completely different one for the next
<ELLIOTTCABLE>
‘customer’
<vigs>
right, I think I follow you
<ELLIOTTCABLE>
it's B) more flexible: they can be copied and transferred and conveyed in other means; and they can be granularly revoked.
<ELLIOTTCABLE>
(the traditional example here is that (the-alternative-to-‘capabilities’) an ACL can, if not exactly gracefully, handle Bob quitting your company and losing access to all your sensitive information …
<ELLIOTTCABLE>
by deleting his *identity*. No more bob, and bob can no longer log-in, so the files bob has ACL'd access to are safe from bob.
<ELLIOTTCABLE>
but ACLs are notoriously terrible at handling the issue where bob *transfers* within your company to another department, and should no longer see the Biohazard Death-Ray files, but still needs access to the Nuclear Engineering files.
<ELLIOTTCABLE>
without deleting his whole identity, you have to sift through and find anywhere in the system that he's got read-access to … blahblahblahblah
<vigs>
mhm
<ELLIOTTCABLE>
whereas the *identity* doesn't *matter* with keys. you just revoke the keys you gave him.
<ELLIOTTCABLE>
anyway. done. capabilities are cool in a security context.
<ELLIOTTCABLE>
and, point is from my point of view, is that *as always*, security concepts carry well, when used as encapsulation-methodologies in a programming language.
<ELLIOTTCABLE>
a set of capabilities sez, by its very existence: “Here's my API.”
<ELLIOTTCABLE>
“Stay out of these bits,” and “don't do this to those bits.”
<vigs>
that's cool, yeah
<vigs>
wow that's super rad o__o
<ELLIOTTCABLE>
so.
<ELLIOTTCABLE>
what we were talking about above, is basically this:
<ELLIOTTCABLE>
in JavaScript terminology, you say:
<ELLIOTTCABLE>
require('unit-identifier')
<ELLIOTTCABLE>
in Node, you'd get an Object with all the available APIs for the library in question, already in it. Here, there's an extra step: instead, you basically get a “sparse object”, if we're thinking JavaScript: the keys, but no values yet.
<ELLIOTTCABLE>
so, a list of keys.
<ELLIOTTCABLE>
then, you, perhaps,
<ELLIOTTCABLE>
require('unit-identifier', 'key')
<ELLIOTTCABLE>
this being a bit like doing require('unit-identifier')['key'], in Node …
<ELLIOTTCABLE>
except the keys can refer to more granular things than just, say, a function. Theoretically there could be separate capabilities for Foo()-read-mode, and Foo()-write-mode, or even Foo()-superuser-mode or knowing-that-Foo()-exists-mode …
* vigs
nods
<ELLIOTTCABLE>
anyway. So, the second call, whatever's required to make it, is a *negotiation* with the foreign library. In JavaScript terms, there might, I suppose be a callback that's called when somebody requires this particular ‘key’ of the library.
<ELLIOTTCABLE>
This is the library's chance to verify that it does, indeed, want to share this key that it advertised the availability of, with this requesting Unit. At this point it will generate an actual key, thus gaining also the revocation powers over that key (by way of a second object that remains linked to that particular set of capabilities henceforth) …
<ELLIOTTCABLE>
and send the key over to the requestor.
<ELLIOTTCABLE>
now, a key (he he hehe he) part of this whole concept is that the key **is** the action, in a programming system.
<ELLIOTTCABLE>
this doesn't play too well with our car analogy … but in this case, I suppose you could say that the entire car's engine fits in the key you carry around. So you're giving the engine *and* the permission to start it, to the valet, at the same time.
<ELLIOTTCABLE>
var Foo = require('unit-identifier', 'capability-name')
<vigs>
I think I follow
<ELLIOTTCABLE>
Foo()
<vigs>
…
<ELLIOTTCABLE>
so, in our imaginary capability-enabled JavaScript, ‘capability’ objects are indistinguishable from normal, locally-created ones …
<ELLIOTTCABLE>
but they also carry around with them, invisibly, the abilities they've been allowed.
<ELLIOTTCABLE>
with me?
<vigs>
right
<ELLIOTTCABLE>
oooo excellent example, in fact, 'cuz JavaScript.
<ELLIOTTCABLE>
what's the closest example to you giving the restaurant your valet-key, in the programming world?
<ELLIOTTCABLE>
passing your callback into an API.
<vigs>
suuuuure?
<vigs>
suuuuure?
<vigs>
whoops
<ELLIOTTCABLE>
so let's say we got Map() from a utilities library of some sort. We have the capability to run it, but not to mutate the code.
<vigs>
meant to up-enter into iTerm
<ELLIOTTCABLE>
because *we* have the ability to invoke Map(), anybody we pass our Map *to* has the ability to invoke it, as well.
<ELLIOTTCABLE>
so we can pass it in as our call-back:
<ELLIOTTCABLE>
handle_data(data_whee, Map);
<ELLIOTTCABLE>
presumably, handle_data is also outside our purview, say, from *yet another* library … perhaps it, itself, is even a capability, then …
<ELLIOTTCABLE>
and we've just given that other library the ability to execute Map, without having to do any weird API calls to jump through hoops and authorize them to use that data.
<vigs>
whoa that's rad
<ELLIOTTCABLE>
there's a lot of consequences to that in a truly-secure capabilities-based OS, but that's al beyond what I care about here.
<ELLIOTTCABLE>
there's a couple other little notes,
<ELLIOTTCABLE>
oh, another example.
<vigs>
(heads up: I'll need to head to bed soon—just realized it's 2:30 and I wanna be up in 3.5 hours)
<ELLIOTTCABLE>
lolk
<purr>
lolk
<ELLIOTTCABLE>
what if we want to pass Map, during an invocation thereof (so it's got some sort of state … say, since you know JS, it's got Map.arguments or something),
<ELLIOTTCABLE>
to a higher-level function-abstraction library.
<ELLIOTTCABLE>
it doesn't need to **run** Map, it's just going to introspect its state and give you some other useful product thereof. (Mapping of arguments to a new local scope, perhaps? mehwhatever.)
<ELLIOTTCABLE>
with capabilities, you can *subset* your own set-of-abilities when copying a capability.
<ELLIOTTCABLE>
it's like I'm walking around with my car-keys, and want my friend to go get it: I can pull out my key-ring, place my key in my palm, do some voodoo magic that involves my key glowing a *badass* neon blue, and then out pops a smaller, valet-version of the key.
<vigs>
lol
<ELLIOTTCABLE>
and then later, the boss who has that valet-key, needs one of his underlings to go fetch my wife's purse out of the garage for her … so he subsets it into *just* a door-key for the underling.
<vigs>
righ
<vigs>
t
<ELLIOTTCABLE>
anyway. cool stuff.
oldskirt has quit [Ping timeout: 255 seconds]
<ELLIOTTCABLE>
glowcoil disappeared.
<ELLIOTTCABLE>
I am exhausted.
<ELLIOTTCABLE>
>:
<ELLIOTTCABLE>
half past six AM. fuck me.
<glowcoil>
hi ELLIOTTCABLE
<ELLIOTTCABLE>
or, half past five. hm. my clock chained by an hour when I wasn't looking.
<ELLIOTTCABLE>
glowcoil: harro.
<glowcoil>
you should sleep :c
<vigs>
yick
<ELLIOTTCABLE>
lol for … two hours?
<vigs>
go to bed, ELLIOTTCABLE
<ELLIOTTCABLE>
at most?
<vigs>
yeah
<ELLIOTTCABLE>
ick.
* glowcoil
is super engrossed in reading harry potter
<glowcoil>
:p
<vigs>
That's what I'm gonna do
<ELLIOTTCABLE>
I'm **terrible** at getting up.
<ELLIOTTCABLE>
like, what's most likely to happen, is me sleeping through the whole conf. >,>
<vigs>
I don't have class until 2, but I wanna go to work at 7:30 or so, so I have time to do grocery shopping before class
<ELLIOTTCABLE>
so … implementation …
<glowcoil>
in that case then i guess you should stay up all the way through
oldskirt has joined #elliottcable
<glowcoil>
and blast through the day on dangerous amounts of coffee
<glowcoil>
I HAVE A FULL TIME JOB STARTING IN 2 WKS FOR THE REST OF SUMMER
<glowcoil>
:D
<glowcoil>
gona have moneyy
<vigs>
:D
<vigs>
ugh maybe I'll finish this project tomorrow
<vigs>
yeah that's it
<vigs>
ugh but I won't have time to work on my cpu
* vigs
sobs
<vigs>
oh well, I should bed
<vigs>
night, all!
<ELLIOTTCABLE>
bah
<vigs>
humbug?
<ELLIOTTCABLE>
so, all that aside,
<ELLIOTTCABLE>
I guess the Paws abstraction over this stuff is:
<glowcoil>
night vigs
<ELLIOTTCABLE>
native API that, given a node in the data-graph, can generate A) a ghost-copy of that node, that can be shared with foreign Units when a handle on a foreign-unit is available, and B) a new opaque local node(?) that can be used with another set of APIs to manage the ghost-copy …
<ELLIOTTCABLE>
call it first() …
<ELLIOTTCABLE>
then an API for *subsetting* (because presumably the local copy starts with all possible abilities? and thus the only meaningful operation is removing ability?) abilities,
<ELLIOTTCABLE>
again, the relevation for me here is that abilities == native procedures, basically, unless I'm missing something,
<ELLIOTTCABLE>
second()
<ELLIOTTCABLE>
and finally, an API that (modulo an arbitrary ‘mediator’ that can *find* another Unit on the back-end) can generate a request-for-capability …
<ELLIOTTCABLE>
hrm. hazy.
<ELLIOTTCABLE>
idk.
<ELLIOTTCABLE>
sleepies. I guess. wish me fuckin' luck. /=
<glowcoil>
ELLIOTTCABLE: good luck!!
<glowcoil>
ELLIOTTCABLE: set billions of loud alarms
<glowcoil>
ELLIOTTCABLE: wake up calls in the hotel
<ELLIOTTCABLE>
wall-of-text. I feel mildly sick after trying to write all that.
<ELLIOTTCABLE>
but ugh I felt it needed to be said.
<alexgordon>
ELLIOTTCABLE: holy SHIT
<alexgordon>
ELLIOTTCABLE: tbh I don't think anybody is going to read all of that
<ELLIOTTCABLE>
I expect the people cc'd in the original tweet/issue will.
* alexgordon
needs a custard cream before he gets started
<alexgordon>
ELLIOTTCABLE: what's the context on this?
<alexgordon>
some code of conduct guide I see
<ELLIOTTCABLE>
linked at the top
<alexgordon>
yeah
<alexgordon>
but
<alexgordon>
what's the context REALLY
<ELLIOTTCABLE>
errrrr
<ELLIOTTCABLE>
wat
<alexgordon>
I honestly can't determine which position either of you are taking
<alexgordon>
probably because I just wandered into this internet argument 5 minutes ago
<alexgordon>
ELLIOTTCABLE: anyway if you want constructive comments, well you already know what I'm going to say: make it shorter
<joelteon>
my left teeth hurt
<katlogic>
"Based on the judge's verdict, the Zionist manager of Facebook...should report to the prosecutor's office to defend himself and make compensation for damages,"
<katlogic>
Hmmm, how exactly Facebook serves the noble cause of zionism eludes me.
<eligrey>
nobody is being specific enough in my issue tracker but it sounds like safari 7 has a Blob interface but it doesn't actually work
<eligrey>
without apple products (which I would never be caught dead buying with my own money) i'm not sure if this fixed it
<joelteon>
RIP
<joelteon>
guys, are there any free services like airbrake
<joelteon>
oh, airbrake's backend is open source
<joelteon>
hehe
prophile has joined #elliottcable
eligrey has quit [Quit: Leaving]
eligrey has joined #elliottcable
<ELLIOTTCABLE>
hi
<purr>
ELLIOTTCABLE: hi!
<ELLIOTTCABLE>
i am so tired
* ELLIOTTCABLE
pats eligrey
<glowcoil>
hi
<purr>
glowcoil: hi!
<glowcoil>
ELLIOTTCABLE: did you sleep at all
prophile has quit [Quit: The Game]
prophile has joined #elliottcable
Sgeo has joined #elliottcable
<eligrey>
ELLIOTTCABLE: why didn't you /ns set property Human No on purr?
<ELLIOTTCABLE>
wat.
<eligrey>
it's eligrey's standard way for labelling bots
<ELLIOTTCABLE>
glowcoil: no.
<glowcoil>
ELLIOTTCABLE: :(
<eligrey>
/ns info sephr and you'll see that I have Human=Yes
<eligrey>
since I'm not a bot
<eligrey>
or at least that's what I claim
<ELLIOTTCABLE>
that's nice, eligrey's standard way of being a butt
<ELLIOTTCABLE>
oh burn
<ELLIOTTCABLE>
glowcoil: crashing right about nw.
<ELLIOTTCABLE>
ditching the big event of the week, the pre-conf party (last night's was great, but that was just the CSSconf peeps; this is several times as many people, and out on the beach)
<ELLIOTTCABLE>
'cuz no sandles, 'cuz haven't slept in literally going on forty hours, and 'cuz,
<ELLIOTTCABLE>
just 'cuz.
<ELLIOTTCABLE>
talked a lot of Paws with a lot of people. very strange.
ELLIOTTCABLE changed the topic of #elliottcable to: a _better_ cult
<eligrey>
inferiour cultists
<eligrey>
inferior*
yorick has quit [Read error: Connection reset by peer]