ELLIOTTCABLE changed the topic of #elliottcable to: #ELLIOTTCABLE — do something cool, shove it into throats, everyone thinks it's crap, then it's all amazing.
alexgordon has joined #elliottcable
<cuttle>
ELLIOTTCABLE: IDEA IDEA
<cuttle>
4:47 PM <•alexgordon> omg
<cuttle>
4:47 PM <•alexgordon> internet on planes is the most mindblowing shit ever
<cuttle>
4:47 PM <•alexgordon> you're on a plane
<cuttle>
mcc: hi
<alexgordon>
hi cut
<cuttle>
ELLIOTTCABLE: :(
<cuttle>
hi alexgordon
<cuttle>
alexgordon: how much of "insanities" do you know?
<alexgordon>
cuttle: you mean other than ec?
<cuttle>
alexgordon: i mean the paws error recovery mechanism thing
<alexgordon>
nothing
niggler has joined #elliottcable
<ELLIOTTCABLE>
cuttle: go
<ELLIOTTCABLE>
alexgordon: listen
<cuttle>
ok i'll tell alexgordon about insanities on a high level, because that's how in-depth they've been designed :p then go on to my idea
<cuttle>
so paws programs are basically a big old dependency graph
<cuttle>
with lots of stuff running independent of each other
<cuttle>
and the ownership system is what keeps you safe from inconsistencies
<cuttle>
so, since it's a big ol graph, you can define the exact "light cone"/area of the graph which a particular event has affected at a particular point in time
<cuttle>
so wrongness can be tracked
<cuttle>
"insanity"
<cuttle>
is what we called it
<cuttle>
so you track it, stop it from reaching certain areas, know what you have to redo to fix things, etc.
<cuttle>
so my idea:
<cuttle>
insanities imply some sort of mechanism for allowing more than just plain values to propagate through the network, without having to explicitly add support for that in all your code
<cuttle>
a thing I didn't realize was similar until just now:
<cuttle>
if you have implicit distribution over a network, you also have metadata invisibly accompanying values, this time things like IP headers and shit
<cuttle>
so: unify those two mechanisms
<ELLIOTTCABLE>
Slow down
<ELLIOTTCABLE>
Re-explain
<ELLIOTTCABLE>
Implies some sort of …
<cuttle>
so like
<cuttle>
you just write x <- 3 + 3
<cuttle>
and then if one of the 3s is wrong
<cuttle>
x is wrong
<cuttle>
yknow
<cuttle>
but you didn't write that when you defined x
<ELLIOTTCABLE>
Hm. There'll have to be *some* definition mehanism, with same defaults
cloudhead has joined #elliottcable
<ELLIOTTCABLE>
"<this> can tolerate <this much error>”
<ELLIOTTCABLE>
“<other> is currently broken, and spawns <this much insanity>”
<cuttle>
well we could have ways to like seal off parts of the program
<cuttle>
OH OH WORKS FOR SECURITY TOO
<cuttle>
remember how you don't pass plaintext password over network
<cuttle>
so you seal off parts of the program from certain wrongness
<cuttle>
and also from insecurity
<cuttle>
and also from unsanitized user input
<ELLIOTTCABLE>
Hm. I'm *really* afraid to use the word security.
<cuttle>
not security
<cuttle>
but like
<ELLIOTTCABLE>
Call it partitioning or seperation of concerns, not security
<cuttle>
yeah
<cuttle>
partitioning
<ELLIOTTCABLE>
Hmmm. Slow down.
<ELLIOTTCABLE>
More communication, less ideas, would be a good phrase of thumb for you, young Padawan ;P
<ELLIOTTCABLE>
So. Interesting relation to plaintext network.
<cuttle>
lol k
<purr>
lol
<ELLIOTTCABLE>
Starting to triangulate lower-level specifics now.
<ELLIOTTCABLE>
Your unified system, definitely very paws.
<ELLIOTTCABLE>
I'd rather not open it up directly, though.
<alexgordon>
this turned into a lot of jargon very quickly
<alexgordon>
we need to finish the spec
<ELLIOTTCABLE>
But *the language design*, if not the user, can definitely leverage this approach in multiple ways.
<alexgordon>
so I can understand half of what you to talk about
<alexgordon>
*two
<ELLIOTTCABLE>
Alex: no way in hell this is going in the spec. Obviously very errrrrr nebulous right now
<alexgordon>
ELLIOTTCABLE: but I don't understand what any of it means
<ELLIOTTCABLE>
… you say that as if you're under the misapprehension that *we* understand more than half of what we mean.
<cuttle>
ELLIOTTCABLE: no i honestly think we should expose it
<cuttle>
let people hook into it
<cuttle>
and use it everywhere for things like user input sanitization and stuff
<cuttle>
alexgordon: don't worry, we do understand what we mean
<cuttle>
alexgordon: i need to just sit down and explain paws to you in terms you know
<ELLIOTTCABLE>
Sorry. Micah got distracted into conveying his idea to me, instead of explaining insanity at a high level
<alexgordon>
cuttle: yes... a spec
<ELLIOTTCABLE>
Re: input sanitization …
<ELLIOTTCABLE>
You know Ruby's safety-level?
<ELLIOTTCABLE>
That.
<cuttle>
i do not know it
<ELLIOTTCABLE>
It's super fucking simple.
<ELLIOTTCABLE>
Iirc, there's like three integer values for $SAFE, or something
<ELLIOTTCABLE>
Higher levels disable, *provably*, particular aspects of the language. Like writing to disk or processes.
<ELLIOTTCABLE>
You can make $SAFE global a bigger number, but not a smaller one.
<cuttle>
ELLIOTTCABLE: USE THIS FOR IPP QUARANTINE AS WELL
<ELLIOTTCABLE>
So once something, somewhere, says “I'VE GOT UNSAFE DATA COMING IN,”
<ELLIOTTCABLE>
then the rest of the program forever, WHATEVER that data does, is quarantined
<ELLIOTTCABLE>
so.
<ELLIOTTCABLE>
We're talking about:
<ELLIOTTCABLE>
Generalizing that, and then making it smarter (that is, building it on top of our inherent graph-knowledgeable was.)
<ELLIOTTCABLE>
knowledgeableness+
<ELLIOTTCABLE>
Here's the mild plans I've got formulating:
<cuttle>
ELLIOTTCABLE: AND UNIFY WITH OWNERSHIP
eligrey has joined #elliottcable
<ELLIOTTCABLE>
The equivalent of $SAFE, but inherited with the tree. Immutable once set. An API to associate a particular Thing (probably, usually, a symbol) with a particular Execution.
<ELLIOTTCABLE>
Then, that Thing is forever associated with every Execution that is affected by that.
<ELLIOTTCABLE>
I.e. The association-with this particular key-Thing, cascades / infects through the code-graph.
<ELLIOTTCABLE>
Could have: this-code-is-insane key
<ELLIOTTCABLE>
or user-input key
<ELLIOTTCABLE>
or this-data-never-leaves-this-Unit key
<cuttle>
well i mean you should be able to propagate un-wrong-ness
<ELLIOTTCABLE>
Hm. Disagree. At least, until you have a good argument.
<ELLIOTTCABLE>
Here's why;:
<ELLIOTTCABLE>
Better to fix the thing you did wrong, so to speak, and then re-call the thing that went insane.
<cuttle>
well yeah
<ELLIOTTCABLE>
That way, sanity progresses through the same tree as the insanity did.
<cuttle>
the only way things propagate is through calling
<ELLIOTTCABLE>
Yeah. It's Paws. No going back, or undoing, or changing you mind,
<ELLIOTTCABLE>
EXCEPT through timetravel
<ELLIOTTCABLE>
Which is exactly the undo mechanism you want, anyway.
<ELLIOTTCABLE>
if you want to propagate sanity, time-travel back to a point before the insanity surfaced, fix, and re-crawl from that point
<cuttle>
ok i want alex up to speed with us
<cuttle>
alexgordon:
<cuttle>
time to learn paws
<alexgordon>
lol
<purr>
lol
<ELLIOTTCABLE>
I have to go. So that works out. I'll be reading on and off, though.
<cuttle>
ok cool
<cuttle>
ELLIOTTCABLE: fly safe o7 :x ;_;
<ELLIOTTCABLE>
Wish me happies, guys. Wish me so many happies.
<cuttle>
ELLIOTTCABLE: *happy*
<cuttle>
(did you get the joke i was stealing all your emoticons and phrases)
<cuttle>
alexgordon: here is the concrete part of paws:
<cuttle>
data types:
<alexgordon>
-spec @ cuttle
<purr>
cuttle: Paws' half-arsed Version 10 specification <http://ell.io/ihQzs>
<alexgordon>
this is where we got to
<cuttle>
ok
<cuttle>
i want to do a furrow-one-page spec
<ELLIOTTCABLE>
A4!
<alexgordon>
!
<alexgordon>
cuttle: one sheet, two pages :P
<ELLIOTTCABLE>
No you got hit by a car typing that
<cuttle>
haha aight
<ELLIOTTCABLE>
Idea: turn A4 into a PLT competition.
<ELLIOTTCABLE>
“Express your latest cool idea in a fully-functional language. Must fit in <number of words>, on two pages.”
<cuttle>
ELLIOTTCABLE: already happened
<ELLIOTTCABLE>
“Steal promiscuously. Slice, dice, and reduce.”
<cuttle>
ELLIOTTCABLE: alan kay wrote the kernel smalltalk in like a screenful of code, on a bet
<cuttle>
kernel of*
<ELLIOTTCABLE>
Yes but ongoing
<cuttle>
yeah for sure
<ELLIOTTCABLE>
As a teaching-PLT thing
<cuttle>
ok going to write an a4 gist
<cuttle>
ELLIOTTCABLE: the whole hidden-system-data thing, where everything is overtly a list, and numbers, symbols, etc. just have hidden impl data, makes me slightly nervous for network-transport. every value should be network-sendable
<cuttle>
alexgordon: keep in mind this a4 is not the grand vision of paws, but a pale implementable shadow thereof
<alexgordon>
k
<cuttle>
alexgordon: what do you feel about the name "procedure"
<cuttle>
instead of execution
yorick has quit [Remote host closed the connection]
<alexgordon>
cuttle: eh
<alexgordon>
I feel like executions have more baggage than mere procedures
<ELLIOTTCABLE>
cuttle: hm?
<ELLIOTTCABLE>
procedures are what I'm doing in the higher-level language.
<ELLIOTTCABLE>
Fullness has *actual* procedures (more function-like, single entrance single exit)
<cuttle>
oh well i've been calling em procedures in this A4
<cuttle>
it's chill
<alexgordon>
I need to sleep
<alexgordon>
cuttle: ping me tomorrow ya?
<cuttle>
aawwww almmost donenoeneone
<cuttle>
:(:(((::(((
<cuttle>
alexgordon: ok fine
<cuttle>
:<
<alexgordon>
ok 5 minutes :P
<ELLIOTTCABLE>
cool
<ELLIOTTCABLE>
mcc: hi
<ELLIOTTCABLE>
mcc: since alexgordon is leaving, we should teach *you* Paws.
<ELLIOTTCABLE>
or at least, I can tell you about it, until things go down over here.
<ELLIOTTCABLE>
ughighgugh
<ELLIOTTCABLE>
sentence on the internet just inspired micahjohnston-level rage in me
* alexgordon
zzzzzzzzzzzzz
<ELLIOTTCABLE>
“I have a strong "do no harm" ethic, but confusing students doesn't count as harm. :-)”
<ELLIOTTCABLE>
“reduce your language work to a single page,”
<cuttle>
this is exposing all sorts of vagueness :p
<ELLIOTTCABLE>
is “take out the single coolest thing of your language work, trash everything else, and embed that single cool thing in the Ruttiest framework possible, so you can fit it on a single page.”
<ELLIOTTCABLE>
so, Tempus <-> reactive values in a rutty framework,
<ELLIOTTCABLE>
Paws <-> CPS VM with a bunch of rutty bullshit thrown in to make it program-in-able.
<cuttle>
yeah :p
<cuttle>
paws and tempus are sort-of kind-of converging in my head
<cuttle>
so i think maybe i should make
<cuttle>
tempus be 100% non-rut aspirations, and dial back the non-rut aspirations of Paws in my head
<cuttle>
like right now paws is very much patterned after dynamic languages where objects are property-lists with pointer-identity that exist on a heap and stuff
cloudhead has quit [Ping timeout: 265 seconds]
<mcc>
cuttle: also, hi
<cuttle>
mcc: hi
eligrey has quit [Quit: Leaving]
<ELLIOTTCABLE>
hi!
<ELLIOTTCABLE>
cuttle: yeah, absolutely
<ELLIOTTCABLE>
Paws is hugely a compromise.
<ELLIOTTCABLE>
everything went better than expected, by the way.
<ELLIOTTCABLE>
I'm actually alive.
<cuttle>
oh that's great
<cuttle>
don't know what could have gone wrong but
<cuttle>
great anyway :p
<ELLIOTTCABLE>
I feel like there's a substantial chance that I wasn't going to come out of that with all my limbs x:
<ELLIOTTCABLE>
paws, tomorrow. sleep, and unpacking, now.
<ELLIOTTCABLE>
so, so happy.
<ELLIOTTCABLE>
everybody give me happy faces. HAPPYFACES, GO
<cuttle>
ELLIOTTCABLE: :
<cuttle>
ELLIOTTCABLE: 3
<cuttle>
yessssss
<cuttle>
this kick drum is huuuge
<cuttle>
:D
<cuttle>
<3 layering
<purr>
Let it be known that cuttle hearts layering.
<cuttle>
ugh this is turning out to be complete shit
<cuttle>
music is hard
<cuttle>
should i get coffee
<cuttle>
or nap
<whitequark>
ELLIOTTCABLE: Ruby safety level is also one big security hole
<whitequark>
and it got partially killed even in MRI, and rbx/jruby won't support it at all, because it's pointless.
mcc has quit [Quit: This computer has gone to sleep]
fwg has joined #elliottcable
fwg has joined #elliottcable
fwg has quit [Changing host]
<whitequark>
by the way, you were going to teach paws me, and did not!
<whitequark>
at least, non-rutty parts.
Sgeo_ has quit [Read error: Connection reset by peer]
cloudhead has joined #elliottcable
<prophile>
what was
<prophile>
the thing
<prophile>
which fixes syscall results and thread interleavings
Cypher has joined #elliottcable
Cypher is now known as Guest42202
Guest42202 has quit [Client Quit]
<whitequark>
prophile: scribe, the deterministic record-replay engine ?
<whitequark>
the domain was something about violet but my history only suggests ShrinkingViolet from tvtropes.
<whitequark>
velvetpulse.com.
cloudhead has quit [Ping timeout: 248 seconds]
dskuza has quit [Ping timeout: 246 seconds]
silentbicycle has quit [Ping timeout: 246 seconds]
yorick has joined #elliottcable
silentbicycle has joined #elliottcable
dskuza has joined #elliottcable
eligrey has joined #elliottcable
fwg has quit [Ping timeout: 252 seconds]
niggler has quit [Ping timeout: 240 seconds]
cloudhead has joined #elliottcable
niggler has joined #elliottcable
fwg has joined #elliottcable
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
wudofyr has quit [Ping timeout: 272 seconds]
fwg has quit [Ping timeout: 272 seconds]
<cuttle>
whitequark: i can teach you
fwg has joined #elliottcable
<cuttle>
12 hours later :P
<cuttle>
ELLIOTTCABLE: I honestly think, though, that the *most* special thing about Paws can be the whole invisibly-plumbed-along data thing. It gets us a cool IPP system, it gets us quarantining stuff like plaintext passwords and unsanitized user input, it gets us the ability to transparently send things over the network and yet reach in and fix things that go
<cuttle>
wrong there, and it gets us insanities themselves for error handling
<cuttle>
ELLIOTTCABLE: I mean, on top of the already special execution model
<cuttle>
ELLIOTTCABLE: not to mention it also gets us ownership as part of the same system
<cuttle>
and this is not a turing-tarpit reduction, this doesn't make things harder to write
<cuttle>
just more unified
<yorickpeterse>
bah, I don't like it how in Vim it still shows a bunch of default colours even after clearing your color scheme
wudofyr has joined #elliottcable
<cuttle>
ELLIOTTCABLE: ok and no problem with having lots of explicitly interpreter-defined procedures, we just want to make sure that *every* datatype is serializable
<ELLIOTTCABLE>
Wat
<ELLIOTTCABLE>
cuttle: wat?
<ELLIOTTCABLE>
And how does this give us ownership?
fwg has quit [Ping timeout: 272 seconds]
<cuttle>
ELLIOTTCABLE: because ownership is like quarantining
<ELLIOTTCABLE>
No no not at all
<ELLIOTTCABLE>
It's important that A) ownership be undoable in the later times,
<ELLIOTTCABLE>
and B) that it be associated *with an execution*, not with a code-path.
<ELLIOTTCABLE>
say foo()'a got a reference to X inside its body.
<ELLIOTTCABLE>
foo()'s gonna MSR against X, so it takes ownership.
<ELLIOTTCABLE>
With Past (my tentative paws-y name for the immutable infectious code-path metadata thing), if we tagged the code-path with X at that point, then *anything foo caused*, could unsafely screw up foos planned sequential-read.
<silentbicycle>
ELLIOTTCABLE: based on the 'distributed metadata' thing you and cuttle were talking about earlier, you should really take a look at Radul's diss
<ELLIOTTCABLE>
not to mention that it could then never *release* ownership.
<ELLIOTTCABLE>
Sure, hit me
<cuttle>
ELLIOTTCABLE: where did you get the idea that metadata should be irrevocable
<ELLIOTTCABLE>
Quarantine, infectious insanity, all the primary use-cases we're considering designing this to handle, they all work best with it being immutable
fwg has joined #elliottcable
<silentbicycle>
cuttle I spent some time yesterday working through it, unfortunately the code samples aren't arranged topologically so to run the example code you need to cherry-pick stuff out of the next several chapters
<cuttle>
silentbicycle: that's actually exactly where I got a lot of the inspiration!
<cuttle>
and I have linked ELLIOTTCABLE before, though I don't think he read it
fwg has quit [Changing host]
fwg has joined #elliottcable
<silentbicycle>
it seems like there's an elegant combination of constraint logic programming and FRP in there, but I haven't entirely figured out the implementation yet
<cuttle>
the frp thing is kind of separate from the constraints part
<cuttle>
they have constraint networks, and then they repurpose them later in the paper to be frp networks
<cuttle>
ELLIOTTCABLE: well, the inspiration was to handle network packets
<cuttle>
the metadata being packet headers, etc.
<ELLIOTTCABLE>
Also, I kinda forgot, insanity (and obviously quarantine) have to affect data-graph as well as code-graph
<ELLIOTTCABLE>
If you just took an insane datum, and threw it somewhere downwind of a structure that was then handled by a sane algorithm, that algorithm needs to become insane.
fwg has quit [Ping timeout: 265 seconds]
<silentbicycle>
ELLIOTTCABLE: I forget, did you have a question about coroutines or somesuch?
<ELLIOTTCABLE>
silentbicycle: nope, I'd like to tell you about Paws.
fwg has joined #elliottcable
<silentbicycle>
ELLIOTTCABLE: okay. I'm working on other stuff, but will check back from time to time
<ELLIOTTCABLE>
Saw you and mcc talking about continuations, coroutines, PLT, and a synchronicity, and that's all pretty relevant (=
* ELLIOTTCABLE
laughs
<ELLIOTTCABLE>
'k
<ELLIOTTCABLE>
when you have a couple hours' free time, come say hi <3
<cuttle>
idek we need some concrete stuff to discuss this
<niggler>
cuttle not a fan of intellectual masturbation?
<silentbicycle>
well, I have a bit of context, and I'm mucking about with PLT stuff right now too
<silentbicycle>
so probably one of the better times I guess
<silentbicycle>
(working on a VM for an APL-ish thing)
<cuttle>
silentbicycle: oh really? neat!
<cuttle>
I have a soft spot for array based languages
<silentbicycle>
cuttle it's sort of an offshoot of http://github.com/kevinlawler/kona, but I want to see what happens if you add Erlang's actor/supervision hierarchy/etc. stuff to a ragged array language
<ELLIOTTCABLE>
Ragged array lang? Never heard of that.
<ELLIOTTCABLE>
Don't know much (read: anything) about APL, though.
<ELLIOTTCABLE>
cuttle: what sort of concrete?
<silentbicycle>
ELLIOTTCABLE: "ragged array" means that the arrays aren't "square" on dimensions; instead of a 4x3x2 matrix it can be an array of 4 arrays with different lengths, or something. k is like that, J is not.
<cuttle>
ELLIOTTCABLE: idk
<ELLIOTTCABLE>
I want to brb:food.
<ELLIOTTCABLE>
Somebody acquire me a gods
<ELLIOTTCABLE>
damned
<ELLIOTTCABLE>
alexgordon
<ELLIOTTCABLE>
and we'll teach him all about my ideas for insanity when I get back :D
<ELLIOTTCABLE>
And maybe tell silentbicycle about Paws, too.
<silentbicycle>
one of my favorite data structures. they have approximately the same asymptotic behavior as a balanced binary tree, but all of the decisions they make are very localized, so you can have multiple threads adding / deleting nodes without stepping on each other very much
<ELLIOTTCABLE>
so what makes skip list distribution so very local?
<silentbicycle>
when you add a new node, instead of looking at the structure as a whole, you just randomly generate the height with a known probability distribution
<ELLIOTTCABLE>
ah, with comparison to b-trees
<ELLIOTTCABLE>
less confused now
<silentbicycle>
half the node are 1 tall, 1/4 are 2 tall, 1/8 are 3 tall, etc.
<silentbicycle>
e.g. you can generate a uint32_t and count the number of consecutive 1 bits from the bottom up
<silentbicycle>
and then you update the forward pointers on the preceding node(s) to link in the new node, and that's in
<silentbicycle>
it
<silentbicycle>
it's like a linked list with express lanes that jump farther and farther ahead as it gets more members
<silentbicycle>
if that makes sense
<silentbicycle>
there's a good diagram on the wikipedia page
<silentbicycle>
to look stuff up, you zoom along the uppermost level until you overshoot, then descend 1 level and repeat until you reach the value or you're at the lowest level and it isn't there
* ELLIOTTCABLE
nods
<ELLIOTTCABLE>
I remember this.
<ELLIOTTCABLE>
cuttle: hey, have alexgordon tweet at me if he logs on, 'k? I'm headed out to eat with the girlfriend.
<ELLIOTTCABLE>
then back to this hotel for NIGHT O' PAWS.
<ELLIOTTCABLE>
silentbicycle: three second coverage of why I brought you here.
<cuttle>
ELLIOTTCABLE: aight
<ELLIOTTCABLE>
working on a programming language I conceived a few years back.
<silentbicycle>
in particular, I think it's fascinating how it can work w/ only local context, yet that global order emerges
<ELLIOTTCABLE>
long story short, it's the first *inherently asynchronous* (at a low level) programming language.
<ELLIOTTCABLE>
think Node.js, at the VM level, instead of at the I/O-framework level.
<silentbicycle>
ELLIOTTCABLE okay. and I'll be in and out of the channel most of the week, probably
<ELLIOTTCABLE>
longer story, even shorter, it's pervasive CPS at the VM level, and working up from there.
<ELLIOTTCABLE>
except not-quite-CPS, but whatever.
<ELLIOTTCABLE>
emergence as a whole is Motherfucking Fascinating™
<silentbicycle>
any relation to dataflow-oriented / "flow-based programming" / etc. kind of stuff?
<ELLIOTTCABLE>
nah
<silentbicycle>
yeah. fascinating™
<ELLIOTTCABLE>
but cuttle has more insights in that direction :D
<ELLIOTTCABLE>
he's working on a neat reactive lang
<ELLIOTTCABLE>
basically everybody in this room has at least one pet eso-lang
<ELLIOTTCABLE>
but we discourage turing tarpits.
<ELLIOTTCABLE>
if you're not actually doing something *usefully cool*, you're wasting everybody's time, imo.
<silentbicycle>
okay, cool. I am very interested in that stuff too, though for the last year and a half I've mostly been learning about hardware / embedded
<ELLIOTTCABLE>
meet whitequark.
<silentbicycle>
ELLIOTTCABLE I've talked with whitequark before :)
<ELLIOTTCABLE>
he's got a really, really neat variant upon Ruby, for embedded development. seems fairly mature, as these pet-projects go, too.
<ELLIOTTCABLE>
ah, excellent.
<ELLIOTTCABLE>
he can be difficult, but I love him <3
<cuttle>
silentbicycle: i like hardware/embedded, and recently want to make my reactive thing extend down to a processor architecture :p
<cuttle>
silentbicycle: also, paws is kinda-reactive
<silentbicycle>
yeah, foundry
<ELLIOTTCABLE>
micah can tell you more. bbl, brushing teeth.
alexgordon has joined #elliottcable
<alexgordon>
hi ELLIOTTCABLE
fwg has quit [Ping timeout: 246 seconds]
<cuttle>
hi alexgordon
<cuttle>
alexgordon: ELLIOTTCABLE said to tweet him when you get in