►
Description
Originally recorded during the Lisbon Hack Week from May 21-25, 2018.
A
This
sock
will
briefly
go
through
lipid
EP
interfaces
and
it'll
actually
begin
with
a
look
at
how
Lapita
pee
ends
up
getting
used
in
other
programs
first
and
how
we're
architecting
things
and
then
we'll
go
through
kind
of
the
current
direction
that
we're
thinking
about
sanitizing
interfaces
across
the
project.
This
part
is
this
kind
of
cast
in
terms
of
ipfs
for
a
moment,
but
foul
coin
is
the
same
thing
and
other
systems
might
do
the
exact
same
thing
here.
A
A
The
way
that
we've
architected
things
is
that
the
programmatic
interface
is
here
for
the
clients
get
expressed
in
terms
of
an
API,
a
programmatic
API,
which
then
we
use
a
commands
library
in
go
I,
think
JavaScript,
I,
don't
know
what
you
guys
do,
which
then
gives
us
all
the
stuff
like
which
gives
us
some
tooling
around
having
an
RPC
library
to
call
those
commands
from
anywhere
so
think
of
this
as
kind
of
G
RPC
equivalent.
It's
not
your
PC,
but
it's
kind
of
that
this
could
be
over
HP,
sockets
and
so
on.
A
This
could
actually
be
any
lipid
opie
transport,
which
enables
us
to
expose
a
client
API
to
anything
and
then
that's
kind
of
how
other
programs
end
up
calling
into
these
the
system.
Now
the
protocol
side
is
implemented
by
having
a
lipid
open,
node
embedded
into
you
know.
Whatever
the
system
is
and
setting
some
handlers
for
the
protocols,
then
the
each
of
these
is
the
actual
code
from
those
protocol
implementations
speaking
to
their
counterparts
over
some
Lapita
piece
stream.
These
are
then,
of
course,
MUX
together
or
something
like
that.
A
A
So
this
this
ends
up
being
some
manual
implementation,
and
this
is
implemented
by
by
each.
So
you
know
the
HT
implementation
or
pops
up,
and
so
on.
That's
what
in
the
lipid
B
project
this
would
be
on
a
client
of
lipid
okay,
so
where
we're
headed
is
to
break
apart,
the
interfaces
of
the
systems
that
we
use
and
use
an
interface
definition
language
to
define
what
the
center
phases
actually
are
and
the
types
of
those
interfaces
so
that
we
can
all
agree
on
what
the
function
calls
should
actually
be,
and
so
that
we
can
check.
A
You
know
things
like
interface
compliance
now
there
might
be
a
mapping
like
you
might
choose
to
do
something
more
idiomatic
to
a
language,
so
you
might
think
about
how
to
do
that
and
and
and
support
mappings
of
some
sort.
But
with
this
interface
definition
language
allows
to
do
is
to
then
and
ending
up
with
you
know,
kind
of
like
code
Jenning
out
stubs
for
implementations.
A
Now
here
I
represent
the
p2p
as
one
interface,
but
in
reality
there
will
be
one
for
like
the
core
of
loopy
and
then
one
for
each
of
you
know,
DHT,
pub/sub
and
so
on.
You
know
they
can
Emily
did
see
flood
sub
and
all
those
kinds
of
implementations
and
I'll
show
you
I'll
jump
in
in
a
moment
into
the
kind
of
interfaces
that
I'm
describing.
A
And
so
you
know
once
those
stuffs
are
generated,
then
people
can
just
implement
them
now
again.
This
can
mutate
and
change
over
time
and
eventually
diverge
to
some
extent.
Ideally
not.
We
would
like
to
keep
everything
the
same,
because
that
makes
it
easier
to
reason
about
and
test
so
that
clients
of
these
systems
can
write
against
these
interfaces
and
then
expect
that
these
implementations
match
them.
But
you
know
there
are.
There
are
potentially
some
cases
where
this
might
need
to
change.
B
B
B
C
C
A
So
what
I'm
gonna
show
you
is
a
draft
version
of
what
we're
working
on
so
don't
take
any
of
these
types
too
too
strongly
to
too
hard
or
whatever
I'm
gonna
define
these
very
quickly.
These
are
kind
of
like
external
type,
so
we're
gonna
pull
into
loop.
It
appear
and
then
out
of
this
we're
gonna
construct,
Lib
poopy.
A
We
used
to
be
able
to
just
get
away
with
multi
hash
for
PR
IDs,
there's
a
reasoning
that
we
might
need
encoding
as
well,
but
other
than
that
you
know
you
can
really
think
of
like
these
two
being
the
main
things
that
we're
importing
from
the
outside
world.
They
send
ends
up
getting
used
by
something
else,
like
the
record
store
which
I
may
not
even
go
into
today.
So
kind
of
don't
really
need
to
think
about
too
much.
D
A
D
A
We're
thinking
of
this
is
the
main
interface
for
now
again.
Don't
get
too
sold
on
these
types.
Just
yet,
but
a
lipid
open
node
would
have
an
ID,
which
is
the
PID
we'd
have
an
associated
key,
which
would
be
a
signing
key
I'll
get
into
what
that
means.
In
a
moment
it
would
have
a
peer
store,
which
is
the
ability
to
understand
information
about
Pierce.
It
would
have
a
switch
within
it.
A
A
Those
peer
things
are,
the
peer
IDs
is
like
the
content
dress
of
a
key.
So
you
know
multi
hash
here.
If
it's
CID,
then
it's
a
little
bit
more,
but
that's
that's
about
it.
The
peer
store
is
just
some.
You
can
think
of
it
just
being
a
map
from
peer
ID
to
these
peer
infos.
There
might
be
other
stuff,
I
think
the
go.
Implementation
in
the
jobs
for
invitation
have
other
things
in
there.
It's
not
clear
those
need
to
be
part
of
the
interface.
A
A
Pure
discovery,
really
it's
just
an
interface
that
has
a
function,
discover
Pierce,
you
know
a
Russ
trade
or
something
that
gives
that
you,
pure
just
pure
infos,
just
AM
its
period
post
on
its
own.
That's
all
it
does
so
an
example
of
this
would
be
local
DNS.
You
can
be
sitting
listening
in
local
DNS
and
it
emits
peer
infos
to
you.
Pure
info
is
the
peer
ID
and
the
address.
A
A
A
Hey
other
people
for
a
moment
you're
like
that
kid
in
the
front
of
the
class
I
static
list?
Absolutely
we
could.
This
is
like
the
bootstrap
set
of
notes.
A
static
list
would
would
totally
implement
this.
How
about
DNS?
We
could
have
a
specific
set
of
DNS
servers
that
could
return
records
that
have
this
like
text
records
that
that
could
point
us
that
what
else
what
other
things
could
be?
He
is
what
is
BitTorrent
use
for
peer
discovery.
C
A
Random
walk
discovery.
We
turn
it
uses
thing
called
PEX
peer
exchange
and
have
you
ever
heard
of
this?
All
it
does
is
randomly
other
BitTorrent
nodes
will
tell
you
about
other
Batory
nodes,
they're,
not
even
guaranteed
to
care
about
the
same
torrents
you're.
Looking
at
you
just
find
out
about
other
nodes.
What
other
things
might
admit?
The
thing
emit
peers.
C
A
Yeah
so
so,
let's
look
at
peer
writing
for
a
moment
and
then
that'll
that'll
distinguish
them.
So
a
peer
router
is
an
interface,
so
it
just
has
a
function
called
find
peer
where
you
give
it
up
here:
ID
and
a
returns
a
peer
info,
so
so
this
means
that
the
client
of
a
peer
editor
is
explicitly
telling
this
thing.
I
have
this
pure
ID.
Please
return
me
a
way
of
connecting
to
this
pier.
A
A
A
A
Arp
is
effectively
this
just
at
ethernet
layer,
right
ARP
is
saying:
hey
who
has
this
IP
address?
Sorry,
who
has
the
IP
address
and
then
a
MAC
address
responds
I've
got
it,
that's
it.
So.
The
idea
here,
though,
is
that
these
interfaces
can
be
implemented
by
much
more
concrete.
Things
like
a
DHT
does
all
of
these,
but
but
the
important
thing
is
to
issue
it's
useful
to
think
about
it.
Kind
of
like
a
matrix
where.
A
Peer
routing-
and
so
mdns
gives
you
this.
It
gives
you
this.
A
DHT
gives
you
this
gives
you
this,
but
of
course,
like
gives
it
to
you
with
completely
different
guarantees
right
like
of
discoverability
and
efficiency
and
all
sorts
of
stuff
right,
and
so
the
recent
peer-to-peer
systems
have
to
do
all
this
stuff
is
that
they
have
to
use
as
many
advantageous
tools
as
possible
to
try
and
work
in
a
variety
of
contexts
right.
A
So
something
like
firechat
is
supposed
to
be
a
capable
of
finding
other
phones
and
communicating
across
other
phones,
which
is
only
capable
of
doing
things
locally.
It
doesn't
necessarily
have
access
to
a
global
DHT
right,
so
so
one
inside
of
the
pp
is
to
issue
instead
of
only
thinking
about
implementing
distributed
systems
or
Piter
Piter
systems
in
terms
of
each
of
these
protocols
horizontally,
which
is
vast.
This
is
how
BitTorrent
other
things
think
about
it.
It's
actually
think
about
it
in
terms
of
what
you
need.
You
need
a
system
that
can
do
peer
discovery.
A
A
Could
just
have
to
ask
an
HTTP
server
right,
I
might
have
a
huge
cash
somewhere
that
we
agree
on
and
I
could
ask
that
cash
to
just
give
me
like
the
last
version
of
something
that
they've
seen
or
if
you
know
that
you
have
a
long
live
address,
you
could
write
it
into
a
blockchain
like
you
could
do
that
for
some
addresses
like
a
tourist
hit
a
service,
you
would
do
that.
You
would
take
up
here
ID
and
bind
it
to
a
tor,
hidden
service
and
like
commit
to
it
forever.
A
A
It
might
make
sense
for
a
moment
to
step
into
it
and
look
at
like
the
network,
because
that
that
might
be
kind
of
where
some
of
the
interface
questions
are
right.
Now
this
is
kind
of
what
the
network
is.
There's
a
connection,
there's
a
local
endpoint
in
a
remote
endpoint
and
a
transport
of
choice.
For
that
connection,
an
endpoint
is
just
an
ID.
I
can
associated
key
an
associated,
signing
key
and
I'm
sorry
Eddy
key
and
then
a
an
address
that
is
pointing
to
that
end
point:
you
have
encrypted
connections.
A
A
We
have
a
concept
of
a
dialer
with
a
concept
of
a
listener,
whether
it
comes
of
a
transport
transport.
You
know
a
lot
of
C
to
dial
into
things
or
listening
to
things,
and
then
we
have
a
switch
and
the
switch
is
what
that's
the
heavy
lifting
in
terms
of
the
interfaces
in
the
network
stack,
and
so
that's.
This
is
again
internal
flippity.
A
Most
people
don't
ever
have
to
worry
about
this
unless
you're
implementing
it,
but
this,
which
is
what
handles
a
node
binding
to
multiple
interfaces,
multiple
transports
and
multiple
interfaces,
dialing
and
doing
like
the
protocol
muxing
any
questions
so
far
on
this.
This
is
like
a
lot
embedded
into
this
I
wanted
to
talk.
So
we
talked
a
bit
about
pure
routing.
A
We
haven't
talked
about
IP
NS.
We
what
were
the
other
things
specs
and
compliance.
So
what
we
want
to
end
up
with
is
a
single
file.
That's
like
this
for
the
coral
lip
to
pee
and
then
a
file
for
some
of
these
things
like
a
DHD.
It's
not
necessarily
the
core
of
loopy,
but
peer
routing
and
peer
discovery
is
Gordon
loopy.
So
we
would
have
one
file
that
like
describes
the
interfaces
that
we
agree
on
and
then
find
some
way
of
making
sure
that
in
implementations
and
interfaces
match
to
that
from
a
client-side.
A
And
then
we
need
the
same
from
a
protocol
layer.
Standpoint
like
we
want
the
protocols
to
be
interoperable
and
we
need
to
find
a
good
way
of
writing
a
language
in
the
pen
test
suite
that
does
that
so
I
think
that
we'd
wrote
about
this
of
creating
traces
of
packets.
That
would
that
could
then
be
replayed
against
an
implementation
just
to
make
sure
that
it
works
correctly.
E
D
So
I
don't
know
how
much
you
want
to
do.
Presentation
versus
kind
of
discussion,
but
I
think
it
like
I
think
it
would
be
great
to
hear
feedback
from
the
audience
positive
or
negative
about
this
whole
concept
that
basically
a
set
of
dot
go
files
like
this
would
replace
the
specs
repo
in
effect
like
this,
would
become
the
standard
to
measure
conformance
against
the
Lib
Lib
p2p,
and
it
would
be
interesting
to
hear
what
Jas
and
rust
think
about
that
if
they
have
any
reactions.
D
Yes,
you're
right
replaces
I
think
was
the
wrong
word
supplement
or
but
this
would
be
the
the
beginning
of
the
specter
ago,
and
then
it
would
be
followed
by
textual
descriptions
of
what
what
these
mean
and
what.
What
behaviors
expected
for.
G
G
D
C
A
A
G
C
C
C
C
A
C
A
The
other
things
are
about
modular
interface
agreement,
which
is
if
somebody
else
wants
to
write
a
thing
that
could
be
plugged
into
a
lip
PDP
node.
They
need
a
set
of
standard
interfaces
that
they
need
to
match
against,
to
be
able
to
mount
that
protocol
into
into
things
right.
So
in
go
for
example,
if
if
somebody
wants
to
write
a
new
DHT,
they
can
totally
do
that
and
as
long
as
they're
they
have
something
that
exposes
the
right
interfaces.
A
G
G
A
A
So
we
should
I
think
we
that
we
should
discuss
that
more
in
detail,
because
it
is
an
explicit
goal
of
lippy
to
enable
parties
to
implement
things
that
are
pretty
hard
to
implement
like
a
whole
DHT
or
something
and
enable
people
that
are
application
developers
to
just
write
against
these
interfaces
and
allow
a
separate
person
all
together
to
easily
plug
those
two
together
without
requiring
recompiling
anything
necessarily
or
without
requiring
modifying
code
anywhere.
Maybe
recompiling
libraries,
but
like
if
I'm
reporting,
those
libraries
and
I'm
going
to
recompile
it
in
my
program.
A
D
C
D
C
D
A
Summary
of
like
IP
LD,
you
have
content
address
things,
so
you
have
byte
sequences
which
represent
nodes
in
a
graph.
This
graph
is
linked
through
hashes.
These
hashes
are
expressed
as
byte
sequences
called
multi
hashes
that
express
the
function
that
you
use
the
hash
function
they
use
to
compute
it
and
and
how
to
move
forward.
A
We
I
peel
these
a
set
of
libraries
and
formats
to
be
able
to
read
arbitrary
data
structures
that
follow
this
hash
linked
thing
to
be
able
to
traverse
through
links
across
different
domains.
So,
for
example,
there
there's
a
cool
talk
where
Jeremy
shows
ingesting
all
of
the
Z
cache
chain
into
ipfs
and
then
is
able
to
traverse
the
Z
cache
chain
with
a
path
notation
similar
to
how
you
would
in
a
file
system
and
that's
kind
of
done
through
Y
field.
A
All
IP
NS
is,
is
a
name
system,
we're
mapping
a
key,
so
a
public
key
regret
public
key
and
we're
treating
that
as
a
name
pointing
to
a
value
that
can
change
over
time,
and
the
idea
is
that
we
need
some
place
to
write
those
records
right.
So
if
I
want
to
mutate
a
name
over
time,
I
need
to
be
able
to
construct
a
record.
A
So
I
need
to
have
my
private
key
associate
with
a
public
key
write
the
value
and
then
write
the
signature
on
that
value
and
take
bundle
that
up
and
put
it
somewhere
that
somebody
else
can
look
at
it
to
be
able
to
find
it
and
resolve
it
right.
So
this
is
kind
of
similar
to
DNS
in
a
way
that
DNS
is
not
secure
and
it's
not
signed,
but
it
it
has
the
same
idea
of
like
putting
little
bit
little
pointers
somewhere,
where
you
can
use
a
name
to
resolve
the
name
and
get
the
value
right.
A
A
So
the
address
record
would
be
a
node
advertising
to
the
world
that
it
has
a
specific
set
of
addresses
and
being
able
to
place
that
somewhere
in
the
world,
where
you
can
find
it,
the
provider
record
is
a
node
advertising
that
they
are
storing
and
are
willing
to
distribute
some
piece
of
content
and
the
third
one
is
a
node.
Is
that
advertising
the
next
value
in
some
some
pointer
right,
like
that?
A
A
So
it's
very
similar
to
the
content,
but
it
has
a
different
semantic
thing
right
and
so
in
epicness
land
we
end
up
using
a
DHT
for
a
lot
of
the
stuff,
but
the
basic
abstraction
is
you
have
all
these
little
bits
of
information
that
help
groups,
coordinate
and
they're
usually
signed
and
they're?
Usually
the
expectation
is
they
can
like
exist
somewhere
and
there's
gonna
be
a
lot
of
them
and
they're
transient.
So
we
have
a
thing
called
a
record
store,
which
is
what
is
really
like
fix
like
addresses.
All
of
that.
A
So,
given
a
record
store,
which
is
just
like,
you
can
treat
up
a
record,
it's
just
like
again
and
I
feel
the
thing
it
point.
It
could
point
to
other
stuff,
it
could
be
signed,
and
so
anything
could
be
validated
has
like
a
specific
interface
that
that
needs
to
be
met,
given
that
you
can
implement
naming
freely
trivially
by
just
setting
the
value
and
then
posting
it
to
whatever
record
store
you're
using.
So
in
the
DHT
case,
it
would
be
a
my
PFS.
A
Node
has
a
key
signs
of
value
crafts,
a
record
and
then
throws
it
on
to
the
DHT
at
the
right
spot,
and
so,
if
you
want
to
resolve
it,
you
ask
the
DHT
for
that
record,
and
then
you
find
the
record
and
then
now
you
can
use
the
name
now.
You
have
there's
a
whole
bunch
of
questions
there
around.
Are
you
getting
the
last
version
of
that
record?
Are
there
others?
Is
it
getting
silenced?
A
There's
a
whole
whole
bunch
of
security
questions
in
embedded
in
there
and
they're
also
performance
questions
at
the
HP
resolving
over
a
DHT
kind
of
sucks,
it's
pretty
slow
and
if
you
also
disappear,
your
record
may
not
be
republished
for
you.
So
a
DFC
is
good
for
some
of
the
use
cases,
but
it's
not
good
for
like
it's
really
high
performance
stuff
and
it's
not
useful
for
long-term
persistence.
So
for
long-term
persistence
you
could
easily
take
those
records
and
put
them
somewhere,
really
persistent
ie,
something
like
a
blockchain.
A
You
could
actually
throw
these
records
straight
into
a
blockchain
and
write
a
you
could
write
a
record
store
on
top
of
any
blockchain,
and
you
know
throw
these
records
on
etherium.
It's
already
people
already
doing
this
I
think
you
port
experimented
with
us
and
they
have
like
an
IP
NS
thing
where
you
map
and
I
theorem
address
to
to
a
name.
A
So
that
gives
you
participants,
but
not
the
high-performance.
The
high-performance
thing
you
could
actually
treat
pub/sub.
That's
a
really
weird
record
store,
you
could
say:
I
was
gonna,
take
the
latest
value
and
just
propagate
it
or
a
pub
sub
channel,
and
if
somebody's
listening
great
and
if
not
whatever
it's
just
a
very
memorable,
it's
gone
after
after
I
sent
it
out.
So
now
with
the
name
system,
if
I'm
updating
my
name
I,
could,
if
I
want
to
this
update,
to
persist
for
a
very
long
time,
I
put
it
on
something
like
a
blockchain.
A
If
I
want
this
name
to
persist
for
a
medium
amount
of
time
and
I
and
I,
don't
care
that
much
about
performance
I,
throw
it
on
a
DHT
or
if
I
want
things
to
be
really
fast.
If
I'm
gonna
make
a
lot
of
updates
really
quickly,
I
don't
want
to
do
either
of
those
I
want
to
throw
them
out,
throw
it
over
pops
up
to
people
that
are
interested
in
this
name
right
now,
and
so
that's
how?
If
we
write
this
one
interface,
then
the
rest
of
the
stuff
can
can
flow
out
of
that.
A
A
E
A
A
C
A
H
E
A
A
A
Not
one
of
them
works,
one
of
them
worked.
So
that's
that's
like
non
human,
readable
names
right,
because
those
are
keys.
I
think
that's
also
has
the
ability
to
use
DNS,
that's
the
name
system,
so
this
how
Pierre
pad
these
are
our
websites
work?
So,
if
you've
been
to
any
of
our
website,
it's
like
Pierre
pad.
That
is
not
a
normal
HTTP
server.
A
A
A
A
A
D
A
A
A
J
B
A
I
I
A
I
Not
a
question,
but
there
is
are
in
the
ipfs
organization.
We
just
moved
the
DNS
link
to
today
activist
organization.
So
if
you
want
to
set
it
up
with
your
own,
like
records
your
own
DNS
and
stuff,
you
can
find
the
tool
in
the
ipfs
organization.
Thank
you,
Scott
Deanna,
sim
Oh.
Do
you
know
string
or
something?
If
you
just
go
through
organization,
we
would
see
the
this.
A
I
A
E
F
I
A
F
F
D
A
E
A
A
So
current
promise
of
idns
on
the
DHD
sucks
for
whole
variety
of
reasons,
which
is
why
right
now,
there's
an
experimental
flag
in
go
IVFs
to
do
use
pop
sub
for
really
fast
updates,
but
that
is
that
doesn't
work
if
you're
not
around
and
long
term.
You
want
it
to
be
persisted
into
into
a
blockchain
or
something
like
that
to
allow
long
term
naming
to
to
happen.
That's
a
whole
other.
That
just
is
like
a
just
like
a
little
pie.
We
should
get
these
different
publishers.
A
With
a
normal
DNS
name,
then
it
falls
whatever
access
policy
DNS
pass.
So
if
you
can
change
the
DNS
record,
then
you
can
change
the
name
with
the
other
one
that
the
key
name,
which
is
not
human
readable.
Then
it's
whoever
has
a
private
key.
So
in
this
case
it's
my
node,
so
my
I
have
the
key
here.
You
just
have
to
share
that
key
to
another
party.
I
Yep
keys,
you
can
publish
the
IP
NS
record
too.
First,
you
have
the
node
identity
T,
which
is
probably
what
almost
using
before.
But
then
you
can
also
can
write
new
keys
right
because
if
you
I
think
if
you
use
the
same
node,
ID
key
or
multiple
nodes,
that
kind
of
gets
confused.
But
if
you
generate
a
new
key,
you
can
share
that
here
and
multiple
people
can
use
that
key
to
to
update
like
the
same
website.
But.
E
A
I
A
A
This
is
stuck
because,
while
it's
walking
the
DHD,
it's
setting
up
a
whole
bunch
of
new
connections
and
some
of
those
nodes
are
not
viable
and
right
now
that
dial
operation
can
potentially
take
a
very
long
time,
because
it'll
try
a
number
of
addresses
until
it
stops.
So
that's
what's
making
it.
This
is
totally
brain-damaged
like
it
could
be
way
way
way
way
faster.
It's
just
stuck
waiting
the
that
and
quick,
and
a
number
of
other
things
will
like
vastly
speed
this
up.
So.
A
Hasn't
finished
Republic
we.
A
E
A
A
We
have
learned
the
very
hard
way
that
shree
mixers
are
not
easy
to
implement
and
they
are
quite
tricky
when
you
have
hundreds
to
thousands
of
streams
and
in
a
long-lived
connection
and
most
implementations
that
we've
ever
found
our
buggy
in
some
ways
we
fix
the
number
of
them.
We've
we've
done
poor
requests
in
most
implementations
that
we
found.
A
So
we
hope
that
quick
will
solve
a
lot
of
this,
because
quick
is
a
standard
that
a
lot
of
people
are
moving
to
I,
wouldn't
bet
on
any
h-2b
to
implementations,
because
I,
don't
think
htv-2
implementations
are
put
through
hundreds
of
thousands
of
streams
like
we
would
do
I,
don't
think
I
mean
what
I'm
saying
is.
We
can
try
that
out,
it
is
likely
the
implementations
we
use
will
be
buggy
and
so
it'll
just
be
a
long
haul
of
fixing.
Those
bugs
which
we
can
do
is
just
a
matter
of
finding.
C
C
C
D
A
Of
all
you
could
so
tour
I,
don't
really
I,
don't
think
tour
does
stream
multiplexing,
which
were
you
get
one
reliable
stream,
but
this
is
something
that
they
would
likely.
If
people
use
tor
extensively,
they
would
end
up
sinking
that
into
into
a
lower
layer,
and
so
it
would
be
the
sort
of
thing
where,
like
tor,
you
may
have
access
to
the
keys
that
you
use
with
tor
and
you
that
may
give
you
stream
muxing.
A
So
you
don't
need
to
pipe
some
other
stream
box,
or
on
top
of
that,
so
so
we
need
to
walk
into
a
lot
of
this.
Acknowledging
that
stream
muxing
is
a
big
part
of
connections
across
the
board
and
the
implementations
will
vary,
and
sometimes
the
lower
level
protocol
will
give
it
to
you,
and
sometimes
you
won't
like
SCTP.
If,
if
we
used
real
SCTP
connections
like
rah,
instead
of
like
through
work,
we
would
have
access
to
a
street
marks
are
right
away
and
there
are
other
other
transfer
protocols
to
do
this
too.
E
B
C
A
And
and
then
the
browser
vendors,
because
the
renders
are
the
ones
core
like
yeah,
actually
gonna,
do
the
work
of
standardizing
and
implementing
and
they'll
be
so
I
wouldn't
expect.
All
of
that
to
happen
for
a
couple
years,
like
I,
think
we're
gonna
get
quick
to
use
and
go
and
node,
and
we
will
get
quick
underneath
the
hood
in
Chrome
and
Firefox,
but
not
in
a
way
that
we
can
use
it
nicely.
C
C
C
F
A
F
A
A
little
bit
difficult
right
now
to
we
would
have
to
think
about
the
semantics
of
transitioning
a
lie
be
able
to
like
move
over
protocol
by
protocol
like
if
we
set
up
two
connections,
then
moving
like
DHD
screens
like
if
there's
a
stream
in
flight
or
something
we
can't
easily
interrupt
it.
Because
then
we're
messing
with
the
semantics
of
the
of
the
higher
level
protocol.
So
we
would
have
to
like
be
able
to
pause
the
stream
exactly
and
then
resume
8:00
in
the
other
side,
or
just
say
that
that
stream
sticks
on
that.
A
C
C
C
A
D
C
A
Liberty
is
one
where
there's
a
lot
of
really
cool
things
that
aren't
not
really
dependent
a
lot
of
our
other
stuff.
So
a
lot
of
ipfs
things
end
up
like
depending
on
something
on
appeal
deal
and
or
in
something
in
liquid
appeal
and
so
on,
and
so
it's
pretty
hard
to
actually
lend
them
Lipitor
piece
full
of
ideas
that
are
pretty
self-contained
and
it
can
be
built
on
their
own.
So
you
know
it's
almost
of
that.
A
I
wrote
they're
like
building
a
Bluetooth
transport
for
for
go
lipid,
OJ's,
lipid,
feed,
or
something
like
that
is
something
that
could
be
like
completely
self-contained
and
then
build
it
ship
it
and
you
know
if,
if
ipfs
imports,
it
that's
a
separate
question
and
so
the
we
it's
it's
a
hope
of
mine
that
we
can
get
lippy
to
be
to
a
point
where
we
get.
We
have
what
we
call
these
IDs
and
so
on,
and
then
people
can
like
attack
some
of
those
over
time.
D
A
D
A
A
A
Really
because
of
this,
given
a
record
store,
I
can't
implement
a
content,
router
or
a
peer
router
or
peer
discovery,
and
so
on
on
top
of
any
record
store,
and
so
it
becomes
a
pretty
like.
If
a
system
implements
the
record
store
interface
and
you
can,
then
you
can
get
almost
everything
else
and
look
at
a
peak
out
of
that.
So
it
becomes
kind
of
like
a
a
worst-case
scenario.
You
can
get
everything
you
so
wanted
out
of
that.
So.
A
And
also
the
other
way
like,
for
example,
a
DHT
is,
gives
you
peer
discovery.
Out-Of-The-Box
gives
you
peer
routing
out
of
box
and
gives
you
a
record
store
out
of
the
box.
It
doesn't
give
you
content
discovery
out
of
the
box.
We
just
implement
that,
on
top
of
it
by
putting
content
discovery
records
onto
those
record
server.
That's
the
idea.
I.
A
Rabbit
so
funny,
Lee
I
feel
he
exists
because
of
this
thing.
So
we
were
thinking
about
this
stuff
and
we're
like
oh
man.
Suddenly
you
have
different
records
and
they
might
be
signed
by
different
keys
with
different
like
validity.
Algorithms,
like
you
know,
name,
is
signed,
but
like
a
content,
discovery
thing,
you
might
want
to
proof
that
it's
that
you
have
the
content
beyond
just
hashing
and
you
might
actually
want
to
be
able
to
generate
a
proof.
A
So
a
lot
of
possibilities
open
up
when
you
can
point
to
code
from
the
records,
and
so
we
can
put
into
code
from
the
records.
Then
you
want
to
authenticate.
You
want
authenticated
data
structures,
and
so
you
want
to
be
an
IPL
deal
and
right
away
and
then
that's
what
is
okay
halt?
Let's
go
figure
this
out
and
then
come
back
to
do
this.
So
that's
kind
of
like
where,
where
this
came
from
so
let.
D
F
A
It
becomes
easier
to
write,
get
things
like
dhts
to
like.
Sometimes
the
HP's
have
certain
conditions
and
being
able
to
define
them
on
a
record
and
have
all
that
taken
care
of,
for
you
would
easy
now,
I
think
the
hard
part
here
is
we're
trying
to.
We
have
a
little
bit
now
and
we
want
to
use
it
now
and
all
this
IP
all
these
stuff
is
like
not
there
yet.
So
that's
that's
the
issue
like
if
we
had
IPL
DNA
was
nice
and
and
and
s
blessing
and
say
protobuf
they'd
be
like
yeah
sure.
A
You
can
still
use
that
API.
What
I
mean
is
this
was
blocked
in
Stephen
and
I,
and
others
figuring
out
like
ideal
language,
l0
to
then
be
able
to
like
guess
what
what
you
really
want
is
to
be
able
to
to
write
something
like
this.
Oh,
my
god,
where
am
I.
A
You
wanna
be
able
to
like
define
something
like
this,
where
oh,
actually,
it's
just
a
signed
record
and
like
I
guess,
that's
almost
it
given
the
sign
record,
I
capable
with
signature
checking
and
then
like
you
would
have
like
a
DHD
that
is
able
to
like
just
implement
some
function
around
that
and
I
said.
This
is
not
a
great
example.
Maybe
this
so.
A
A
D
You
see
the
perspective
I'm
coming
at
it
from
it's
like
I
want
live
he
to
P.
Do
I
want
to
be
very
explicit
in
the
specs
about
a
conformant
implementation
of
Lippe
to
be
must
do
must
implement
a
B
and
C
may
implement
XY
and
Z.
You
know
like
this
and
I'm
just
wondering
if
the
record
store
thing,
it
puts
a
lot
of
bulk
into
the
must
category,
and
maybe
it
should
be
in
the
NA
category
or
yeah
yeah.
E
D
A
D
A
D
A
A
D
A
A
E
D
C
C
A
D
D
C
C
I
I
I
D
I
Are
the
test
failing?
You
need
to
fix
this
like
as
soon
as
possible,
but
they're
normal
bill
will
still
compile
that
version
that
they
were
using,
but
we
still
make
it
available,
so
they
can
use
that
thing.
But
it's
also
tricky
like
we
are
having
many
different
languages
with
it
with
Cori
implementations.
It's
easy
because
we
usually
are
by
HTTP
IPR
that
we
can
cannot
follow
in
a
like
a
not
interface
way,
but.
A
G
C
I
Yeah
I
guess
you're
right
right.
One
program:
we
can
do
CLI
tests
to
make
sure
that
zero
is
the
same.
We
can
make
HTTP
tests
to
make
sure
that
the
HTTP
API
is
the
same.
But
when
we
were
doing
like
the
core
definitions
like
the
the
programmatic
API,
that's
when
we
either
have
to
like
compile
to
that
language
or
like
inventor
on
DSL,
with
like
Jam,
oh
and
I'm
bright
or
own
kind
of,
like
generator
of
test
cases
that.
E
D
E
C
H
D
A
Yeah,
it
gets
hard
to
test
a
programmatic
interface
in
a
language,
because
that's
when
a
language
implementation
will
want
to
use
idiomatic
conventions
and
yeah,
what
we
could
do
is
define
here's.
What
we
could
do.
We
could
define
a
a
standard
interface
that
we
can
test.
That
is
just
a
bit
of
glue
on
top
of
whatever
the
idiomatic
interface
is
so
like
a
language.
Implementer
writes
the
idiomatic
thing,
and
then
we
write
a
small
wrapper
around
that
that
presents
all
the
right
methods,
and
so,
if
they
can't
satisfy
those,
then
there's
something
missing.
D
D
I
A
Well,
I
mean
when
I
was
proposing
not
quite
in
the
sea
life
but
like
I,
think
you
got
it
where
yeah
there's
like
the
automatic
version
that
people
use
and
this
other
one
other
version,
which
is
just
one
small
file
that
just
Maps
things
and
maybe
massages
the
types
a
little
bit
but
should
be
able
to
pass
the
tests.
And
if
that
passes
the
test,
then
it's
unlikely
that
the
underlying
implementation
is
wrong.
So.
C
A
C
A
H
H
H
F
E
F
D
G
G
E
G
I
Doesn't
already
the
HTTP
and
the
CLI
tests
kind
of
like
infer
that
the
core
implementation
already
has
the
available
methods
right
like?
Why
are
we
trying
to
achieve
with
the
core
interface
programmatic
thing
right
for
JavaScript?
It
make
sense
that
the
API
and
the
core
protocol
and
the
the
actual
code
you
can
call
the
same
methods
but
across
languages
what's
not
even
make
sense.
The.
A
Reason
is
a
if
somebody
is
an
application,
writer
and
they're
writing
across
something
across
languages.
They.
It
would
be
useful
for
them
to
have
the
same
matching
interfaces
across
languages
to
be
able
to
easily
port
their
application
from
one
language
to
the
other,
without
having
to
learn
an
entirely
new
set
of
instructions.
But.
E
D
A
A
I
A
B
A
I
Gonna
end
up
writing
something
like
a
demon,
but
it
works
over
a
UNIX
sockets
in
stuff
or
whatever
like
in
the
end.
We
were
gonna
have
to
expose
something
that
the
test
can
call
right,
won't
be
the
HTTP
API
right
and
under
for
multi
formats
need
to
read
same
right,
like
multi.
Hash
need
to
have
either
I
API
that
test
and
call
or
a
CLI
like
a
simple.
A
I
I
J
E
F
A
D
F
D
G
E
D
A
G
A
F
I
A
F
F
D
I
Don't
know
like
see
my
voice,
my
cells,
it
should
be
interface,
your
cells
as
well,
but,
unlike
the
the
test
cases
themselves,
can
be
written
in
in
JavaScript
or
whatever,
and
then
they
call
the
interfaces
that
we
have
in
the
core,
implementations
and
I.
Think
that
will
be
enough
to
assert
the
behavior
of
the
core
implementation
I.
A
A
It
so
we're
living
at
me
right
now.
We
don't
have
it
so,
whether
we
weren't
planning
to
create
a
demon
for
liberty,
yeah,
it's
just
library
in
order
to
use
this
kind
of
structure,
we'd
have
to
then
make
every
implementation
map
their
interface
to
HTTP,
as
opposed
to
which
they're
gonna
have
to
then
do
two
things.
A
One
is
map
their
implementation
to
a
standard
way
of
doing
it
and
then
map
the
center
way
of
doing
it
to
HD
in
every
language,
and
so
what
what
this
is
suggesting
is
have
these
simple
functions
and
then
map
your
idiomatic
thing
to
this,
and
then
it
this
handles
all
of
the
the
rest
of
the
stuff,
like
the
the
converting
from
this
into
having
an
RPC
thing
over
HTTP
or
whatever
you
want
to
do,
and
it
does
all
of
that
heavy
lifting
for
you
anyway.
We're
gonna
have
to
bike
share.
F
F
A
A
mapping
could
be
really
small,
I
think
it
mapping
could
be
a
single
file
of
like
less
than
a
hundred
lines.
So
I
don't
think
it's
that
much
to
ask
what
you
figure
out.
It
was.
How
would
the
all
the
other
pieces
work
if
we
have
that
mapping
and
could
we
could
we
get
to
a
point
where
we
can
test
everything
reliably?
If
we
can't
do
that,
then
we
shouldn't
be
even
exploring.
This
was
very
out
of
that
as
possible,
but.
D
A
D
A
A
Okay,
it's
testing
it
and
testing
it
for
completeness,
because,
okay,
the
test,
the
test
will
check
that
it's
correct
and
will
also
check
that
you
have
all
functions
defined
and
if
you're
missing
some
functions,
you're
not
gonna
pass
some
little
tests
yeah.
So
it
really
checks
and
make
sure
that
you
have
all
the
features.
F
B
F
I
I
E
A
I
I
B
B
B
A
E
I
A
I
E
A
B
C
A
I
I
A
A
A
I
I
A
Mean
do
you
think
that
do
you
think
this
is
like
a
good
summary.
C
A
F
C
I
I
Can
express
this
in
my
cache
more
concise
way,
as
well
as
have
the
long
description
because,
like
there
are
two
different
things
here,
we
want
compilers
to
check
the
stuff
works
in
which
this
works
well
for
yeah.
But
then
there
is
the
other
side
of
the
story,
which
is
people
wanting
to
understand.
Why
or
what
so.
A
E
F
A
C
A
A
A
H
A
D
D
I
C
A
E
H
D
H
A
Listen
is
the
symmetric
equivalent
of
that
which
is
do
some
setup
and
I'll
wait
a
connection
and
then
get
ready
to
accept
connections.
Connect
here
is
actually
ambiguous
and
says:
I,
don't
care
how
you
do
it,
whether
you
dial
out
or
listen
in
just
connect
to
this
peer?
If
you
already
have
a
connection,
this
just
returns
right
away.
H
A
A
Yep,
especially
the
protocol
like
what
what
how
do
people
want
to
write
protocols
and
up
of
it,
we
have
one
implementation
of
that
that
is
kind
of
modeled
after
HTTP
servers
and
go
specifically,
it's
not
necessarily
the
best
way
to
do
it,
actually
it
to
be
serviced
and
go
and
JavaScript
callbacks.
So
it's
a
callback
oriented
thing
may
not
necessarily
be
the
best
one.
A
E
A
J
A
No
no
good
and
go
with
anything
high-performance.
You
do
not
want
to
use
channels
because,
if
they're,
actually
quite
expensive,
unfortunately
go
channels
are
quite
expensive.
The
version
one
of
lipid
opinion
go
was
with
channels
and
we
would
take
a
packet
like
this
all
started
with
trying
to
make
it
packets
which
at
the
beginning-
and
we
take
a
packet
and
send
it
through
channels
and
so
on
and
like
do
all
this
kind
of
stuff
in
the
and
then
deliver
a
packet
to
the
protocol.
All
in
in
normal
idiomatic
go
stuff,
it
was
horrendously
slow.
A
D
A
D
E
D
A
F
A
A
Probably
within
for
most
things
within
an
order
of
magnitude
of
C
and
most
in
most
things,
less
I'm
nor
demented
most
things
that
are
IO
bound,
won't
like
go
will
be
fine,
I
think
go
doesn't
do
as
well
when
you
have
a
lot
of
function,
calls
and
you're,
manipulating
like
goroutine,
stacks
and
potentially
switching
from
over
routines.
But
if
you're
dealing
with
io
it's
gonna
be
probably
close,
we
should
benchmark
it
and
see
how
it
goes.
Yeah.
B
A
A
C
A
D
A
A
We
have
a
really
painful
thing
where
in
TCP
has
originally
designed,
you
can
send
and
receive
from
the
same
port,
and
if
you
do
that
and
the
mat
that
you're
dealing
with
it's
not
fully
symmetric,
then
after
you
dial
out
a
couple
times
you
can
receive,
you
can
observe
the
same
address
from
the
outside
and
then
you
know
what
your
address
outside
of
the
mat
is.
So
then
people
can
dial
you.
This
is
how
hole
punching
works.
So,
okay,
we
do
like
lazy
hole
punching
in
that,
as
you
dial
out
you're
gonna
hole
punch,
oh.
A
Been
to
work
the
way
good
in
go,
the
network
stack
does
not
allow
you
to
reuse
the
same
port.
Actually,
it
does
not
allow
you
to
bind
on
a
TCP
outgoing
port
if
that
is
already
bound
to
a
listener,
but
the
kernel
lets
you
do
that,
and
so
you
have
to
set
a
kernel
flag
like
at
this
call
flag
and
currently
so.
D
D
A
E
A
I
D
D
D
A
A
D
I
H
I
D
I
A
Gem
so
there's
some
a
main
dot
html'
here
that
is
gonna,
pull
in
dot,
slash
out,
slash,
mange,
is
and
dot
slash
mage
is
mage,
is
here,
defines
greet
equal
to
wasn't,
bind
young
and
then
calls
it
has.
A
function
called
run
app
which
calls
greet,
and
then
it
has
wasn't
bind
Jen
something
something
then
run
app,
so
it
calls
wasn't
bind
Jen,
which
is
a
function
imported
somewhere
and
then
after
that
calls
run
app
alright.