►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Hi
everyone,
my
name
is
chris.
This
is
my
myself
and
my
co-founder,
gordon
brander.
He
wishes
he
could
be
here
today,
but
I
wasn't
in
the
cards
gordon
and
I
are
former
browser
engineers,
gordon
just
previously
at
mozilla,
and
we
had
the
good
fortune
to
run
into
each
other
and
work
together.
While
at
google
chrome-
and
I
say
we
are
former
web
browser
engineers,
because
now
we're
scummy
native
app
engineers.
A
A
When
I
first
wrote
this
talk
until
about
two
hours
ago,
I
thought
I
was
going
to
be
presenting
to
a
bunch
of
folks
who
were
like
I'm
interested
in
writing
an
app
using
ipfs,
and
I
feel
like
I'm
actually
talking
to
a
bunch
of
people
who
know
a
whole
lot
about
ipfs,
probably
way
more
than
me
and
want
to
know.
What's
so
hard
about
writing
an
app
with
ipfs.
A
So
I'm
going
to
do
something
that
I
didn't
intend
initially
for
this
talk
and
that
I
don't
ever
do
for
talks
and
encourage
a
lot
of
interruption
as
I'm
going
through,
so
that
we
can
just
maybe
talk
about
what
I'm
talking
about,
and
maybe
you
can.
You
know
pick
my
brain
about
what
my
thought
process
was,
and
I
can
pick
your
brain
about
how
I
can
do
things
better.
A
A
A
One
is
just
through
what
you
might
think
of
as
a
hyperlink
where
one
document
references
another
another
form
of
linking
is
it
calls
transcludes
where
one
document
would
like
interleave
another
document,
so
you
actually
have
like
content
from
one
document
showing
up
in
another
document
and
you
can
think
of
subconscious
as
trying
to
establish
a
similar
system.
So
subconscious
users
have
notebooks.
A
Notebooks
are
lists
of
notes,
notes
can
link
to
other
notes
and
also
transclude
other
notes,
and
that
includes
notes
that
are
in
other
users
notebooks
and
there's
no
central
control
over
naming
and
no
central
control
over
storage,
and
so
this
is
sort
of
our
journey
towards
ipfs,
I
would
say,
is
trying
to
figure
out.
How
can
we
put
together
the
pieces
that
are
going
to
give
us
these
properties
in
our
application?
A
And
what
this
looks
like
you
know,
sort
of
in
visual
terms
with
subconscious
is
like
here:
I've
got
somebody's
notebook
and
it's
got
a
transclude
in
it
and
zooming
in
you
can
see
at
the
bottom
there's
an
annotation
of
the
provenance
of
that
transclude
and
for
us
this
is
what
we
think
of
as
a
link
through
subconscious
space.
It's
you
know,
sort
of
analogous
to
a
hyperlink,
but
it's
for
our
own
little
data
domain
and
the
link
looks
like
this.
A
It's
sort
of
like
an
at
if
you're
familiar
with,
like
in
discord
or
slack
like
I'm,
adding
gordon
and
then
I'm
sub,
addressing
into
his
notebook,
using
slash
evolution
and
by
doing
that
and
putting
that.
In
my
note,
I
get
a
fancy
little
transclude
from
somewhere
in
the
ether
and
so
to
get
a
system
with
these
properties.
We're
designing
a
thing,
we're
loftily,
calling
new
sphere
a
protocol
for
thought
and
what
it
really
is
is
sort
of
a
series
of
ip
fs
adjacent
constructs.
A
So
it's
an
ipld
data
structure,
it's
public
key
infrastructure,
it's
a
decentralized
authorization
scheme
and
what
is
called
what
we
call
a
hyper
local
peer-to-peer
network.
Topology
and
just
to
sort
of
level
set
when
I
say
hyperlocal,
I
actually
borrowed
this
from
a
thing
called
nunet
gnu
net.
I
don't
know
if
any
of
you
are
familiar
with
it,
but
they
their
new
net
is
like
a
dns
compatible
named
system,
or
at
least
they
want
to
be.
A
That
proposes
a
hyper
local
topology,
where
you're
essentially
managing
like
your
own
zone
file
for
the
entire
network.
So
it's
hyper
local
because
you're,
you
have
like
primary
agency
over
the
names
in
the
name
system,
all
right,
so
we
started
with
rust.
So
all
of
our
you
know,
ipfs
adjacent
stuff,
is
using
rust
ecosystem
crates.
A
Our
prototype
client,
as
dietrich
suggested
earlier,
is
an
ios
app
and
actually
it's
mostly
built
with
swift
ui,
but
even
on
the
ui
side,
we
have
some
places
where
we're
really
just
wrapping
rust
code
with
swift,
ui
wrappers,
but
primarily
what
we're
using
rust
for
is.
You
know
all
of
the
ipfs
adjacent
stuff.
A
A
A
Having
like
a
full-fledged
ipfs
implementation
would
have
helped
us
get
started,
but
isn't
really
necessary
for
a
use
case
for
authorization
we're
using
ucans,
and
I
think
everybody
in
this
room
probably
is
familiar
with
them
at
this
point.
Anybody
anybody
not
familiar
with
you
kent
at
this
point
after
the
last
day.
Okay
brook
brook,
doesn't
really
know
what
you
can's
are.
So
I'm
gonna
explain
you
know
they're
an
authorization
scheme
they're
based
on
json
web
tokens.
A
They,
basically
let
us
do
authorization
without
you
know
any
kind
of
centralized
authority
which
is
really
nice.
We
wrote
the
rust
crate
for
ucans,
it's
currently
tracking
the
0.8
version
of
the
spec.
I
know
0.9
is
in
the
works
and
we
have
some
distance
to
travel
before
we're
compatible
with
that,
but
we're
trying
to
track
it
closely.
I'm
also
happy
to
say
that
protocol
labs
has
given
us
a
dev
grant
to
pursue
work
on
ours.
You
can
so
very
excited
about
that.
A
A
A
At
the
root
and
at
the
leaves
of
our
data
structure,
we
have
this
construct.
We
call
a
memo,
so
a
memo
is
intended
to
be
this
open-ended
data
structure
that
encodes
three
things.
One
is
body
content
body
content,
free
form
can
be
whatever
you
want.
Two
inline
headers,
which
is
essentially
free
form
metadata
about
that
body
content
and
then
three
is
a
parent
pointer
to
a
previous
version
of
the
memo,
and
what
this
gives
us
is
sort
of
basic
backwards,
chronological
history
for,
for
example,
notes,
but
also
for
your
entire
notebook
history.
A
A
If
we
only
had
some
kind
of
name
system
where
we
could
publish
you
know
a
correlation
between
a
did
and
a
sid,
we
could
then
say:
okay
for
some
human,
readable
name
in
my
notebook.
I
can
get
a
key
and
I
can
go
look
in
that
name
system
and
resolve
that
key
to
some
sid
in
somebody
else's
notebook
and
from
that
notebook.
I
can
resolve
some
sub
path,
like
slash
evolution,
to
a
concrete
note,
and
so
essentially,
by
having
this
sort
of
symmetry
across
notebooks
in
terms
of
the
data
structure.
A
Obviously,
we're
not
going
to
be
running
ipfs
full
nodes
in
our
client.
This
is
what
our
sort
of
network
network
infrastructure
looks
like.
I
would
say,
the
main
conceit
of
this
is
we
require
that
there
is
a
user
owned
server
in
the
mix.
Oh
sorry,
yes,
there's
a
user
owned
server
in
the
mix.
We
call
this
the
gateway
server.
A
The
gateway
is
essentially
responsible
for
things
like
syndicating
data
to
ipfs
or
interacting
with
the
dht.
It
also
is
able
to
pull
extra
weight
since
we
have
it
in
in
the
mix.
So
like
another
thing,
our
gateway
server
does
is,
when
you
synchronize
your
notes
to
the
gateway,
it
generates
an
html,
hypertext
web
version
of
your
notebook
and
makes
that
available
on
the
hypertext
web
sort
of
looking
at
a
cross
section
of
this
infrastructure.
But
by
the
way,
are
there
any
questions?
So
far,
I'm
sure
you
guys
are
thinking.
A
A
The
server,
in
turn,
talks
to
dht
to
publish
names
and
also
talks
to
an
ipfs
node,
and
this
can
be
any
ipfs
block
api.
We're
not
you
know
letting
any
kind
of
prescription
that
the
user
necessarily
owns
that,
because
we're
really
just
using
it
for
block
syndication
the
gateway
server
and
the
client
are
both
currently
caching,
all
the
blocks
for
the
notebook
to
enable
things
like
offline
local,
first
use
cases
so
yeah,
that's
you
know.
This
is
sort
of
like
the
evolution
of
what
our
name
system
went
through.
A
A
So
we
did
not
pursue
that
route,
even
though
it
was
kind
of
interesting
for
a
prototype
and
worked,
and
now
we're
using
lib
ptp,
which
I'm
happy
to
say
actually
has
a
very
nice
rust
implementation,
and
you
know
they're
going
to
be
pitfalls
at
least
their
pitfalls,
I'm
aware
of,
as
somebody
who's
fairly
new
to
this
space
that
we're
going
to
run
into
relying
on
a
dht.
For
this
I'm
actually
very
curious
about
the
pitfalls.
I'm
not
aware
of
like.
A
A
C
A
Yes,
I
mentioned
hyper
local
name
system,
which
you
know
is
sort
of
the
arrangement
we're
hoping
to
achieve
we
are
intending.
I
should
just
caveat
to
offer
a
managed
service
where
people
can
sort
of
pay
for
infrastructure,
and
one
of
our
is
sort
of
you
know
both
a
conceit
for
the
sake
of
our
you
know
our
own
ability
to
stay
alive,
but
also
to
sort
of
see
the
network
with
content.
So
we
intend
to
pre-seed
every
ios
client
with
a
name
that
points
to
our
address
book.
So
there
will
be.
A
A
I
had
actually
used
or
tried
to
use
ipns
many
years
ago,
and
I
knew
it
was
slow
in
preparing
for
work
on
subconscious.
I
had
done
a
fair
amount
of
research
about
like
how
are
things
now
and
what
I
found
on
github.
Were
you
know
many
center
threads
about
the
slowness
of
ipns
and
sort
of
ongoing
mitigations
to
improve
it.
A
So
the
main
thing
we
lost,
I
mean
a
lot-
loses
a
strong
term.
We
went
from
having
like
a
global
universal
namespace
to
the
hyperloophole
approach
that
we're
using
now
both
does
that
make
the
product
worse.
Actually,
I
think
it's
better
personally
gordon-
and
I
both
have
this
thing
about
sort
of
the
dunbar
scale.
A
Social
group
concept.
It's
like
you,
know
social
groups
past
a
certain
size
start
to
degrade
in
terms
of
their
quality,
and
it's
not
that
we
want
to
like
definitively
limit
the
scope
of
like
a
social
graph
in
new
sphere.
We
don't
want
to
do
that
at
all,
but
we
do
want
to
encourage,
like
I
guess,
more
wholesome
organic
social
connections
and
I
think
a
hyperlocal
name
system
is
actually
better
suited
to
that
than
like
a
single
global
namespace.
A
So
I've,
basically
given
you
the
rundown
of
what
we're
currently
building
we're
hoping
to
open
source,
our
entire
stack
top
to
bottom,
including
the
ios
app.
We
are
shooting
for
the
second
half
of
this
year
to
do
our
first
sort
of
open
source
landing
of
these
projects
right
now,
it's
all
being
done
on
github,
but
it's
private
repos.
A
D
A
A
Which,
I
admit,
is
a
little
hand
wavy,
but
I'm
actually
very
optimistic
that
there's
going
to
be
a
very
flourishing.
You
know
body
of
work
that
comes
out
of
that,
so
we're
tabling
that
strategically
until
we
get
to
a
point
where
the
path
forward
is
more
obvious,
for
us
guys
are
our
notion
of
user
programmability
inside
of
notebooks.
A
So
originally
these
were
envisioned
as
user
scripts.
Essentially
that
work
over
your
corpus
of
notes
and
sort
of
remix
the
notes
and
represent
them.
Both
your
notes
and
the
notes
of
other
notebooks
to
sort
of
give
you
these
sort
of
moments
of
epiphany
or
like
provocative,
prompts
for
producing
more
notes,
but
it
sort
of
as
we
you
know,
thought
about
it
and
evolved.
It
turned
into
more
of
like
a
user
scripting
model
based
around
wasm
and,
like
sort
of
we
could
syndicate
these
wows
and
blobs
over
ipfs
and
wow.
A
A
A
Support
for
new
content
types
right
now,
it's
text
only,
but
you
know
our
ambitions
are
to
become
another
kind
of
web,
so
images,
videos,
3d
models,
lots
of
other
cool
stuff,
hyperlocal
content
moderation.
So
you
know
I
already
described
the
name
system,
but
what?
If
we
could
sort
of
infer
reputational
properties
of
content
based
on
what
your
mutuals,
for
example,
think
about
content
so
as
you're
navigating
through
the
new
sphere
and
you're
running
a
ground
against
notebooks?
A
You've
never
seen
before
links
can
be
annotated
with
like
this
person
and
thought
this
was
like
violent
content
or
dangerous
content.
We
really
like
ideas
like
this,
because
it
seems
like
the
antidote
to
what
plagues
us
a
lot
in
social
media.
These
days,
we're
like
twitter
is
unilaterally
in
charge
of
deciding
what's
acceptable
content
on
their
platform,
but
their
definition
of
acceptable
may
not
be.
A
C
C
C
So
part
part
of
that
is
so
we
heard
from
the
fps
store
machine
that
they
want
to
do
more
stuff
there
as
well,
so,
whether
it's
you
or
vision
or
an
empty
data
storage
or
doing
a
prototype
or
something
like
that
like
we
have,
I
would
like
everybody,
who's
doing
stuff
to
list
a
similar
roadmappy
piece
to
see.
If
we
can
find
overlaps
to
spend
interrupt-
oh
god,
hopefully
chris
will
solve
this.
Hopefully
most
of
them
solve
this.
C
C
A
Isn't
the
same
thing
yeah?
What
do
you
think
about
it?
I
mean
to
some
extent
I
wonder
if
that's
solving
it
at
the
right
layer,
like
maybe
there's
some
identity
or
some
you,
like
some
authorization
capability,
that's
going
to
do
a
layer
above
like
the
specific
apps
that
it's
done,
yeah,
that's
the
portable
part,
but
yeah.
I
mean
it's
quite
possible
and
I
think
you
know
we
want
we've
deliberately
designed
new
sphere
to
be
like
an
open-ended
extensible
thing
like
we
want
to
see
like
one
of
our
success.
A
A
Did
you
evaluate
any
like
authorization
capabilities,
syntaxes
other
than
you
can
so
there
we've
we're
thinking
about
authorization
in
terms
of
maybe
more
web
2
traditional
mechanisms?
The
reason
why
we
light
it
on
the
ukens
at
all
is
because
we
met
with
boris
and
brooke
and
we
were
trying
to
determine.
Can
we
use
fission?
Unfortunately,
as
our
prototype
is
in
native
ios
app?
A
The
answer
is
no,
but
in
that
meeting
they
described
to
us
this
capability
mechanism
that
they're
working
on-
and
you
know
me
being
you
know
the
scrappy
engineer
that
I
am
I
was
like
well,
I
would
love
to
use
vision.
We
can't
today,
but
I
know
I'm
going
to
build
a
web
client
and
I
know
that
they're
working
to
sort
of
solve
the
mobile
use
case.
So
how
can
I
maintain
as
much
coherence
with
their
approach
as
possible?
So
for
me
it
really
started
with.
A
A
A
These
seem
to
me
like,
like
really
hard,
they're
hard
constraints
of
the
system,
but
they're
also
things
that
could
be
smoothed
over
it
shouldn't.
It
sounds
like
at
least
a
handful
of
people
have
reinvented
the
same
mitigations
over
and
over
again,
we
shouldn't
have
to
be
doing
that
right,
like
yeah
yeah,.
A
A
B
A
B
D
B
A
C
C
A
A
A
Why
are
these
sort
of
separate
bodies
of
code
and
not
really
like
considered
part
of
core
ipld,
because
it
seems
like
I
can't
in
practice,
use
itld
with
block
size
limit
like
I
can't
like?
If,
if
I
knew
nothing
about
ipld
and
somebody
was
like
here,
you
can
just
serialize
this
thing's,
you
know
ipld
compatible
things,
I'm
thinking,
okay,
here's
like
a
list
of
a
thousand
things
and
I'd
run
a
ground
against
hard
corners
right.
B
B
I
think
our
open
questions,
because
a
part
of
probably
people
that
age
of
the
emergence
of
it
yeah-
I
I
personally
have
I'm
I'm
fully,
admittedly
underexperienced
with
videos-
I
don't
I
too
would
have
looked
at
them
and
it's
nice
to
see
you.
I
feel
the
spec
laying
out
hey.
These
are
layers,
and
you
work
your
way
up
to
this,
but,
like
I've,
never
managed
to
get
high
enough
on
the
masala
and
higher
heat.
D
A
Actually,
yeah
yeah,
I
guess
it
just
seems
to
me,
like
you
need
a
hashrate
map
tree
like
you
need
it.
There's
no
question
about
it
right
and
not
only
do
you
need
it
but
like
for
the
way
immutable
data
works,
it's
a
thing
you
should
be
very
intimately
familiar
with.
It
should
be
like
a
basic
tool
in
the
box.
You
should
not
be
thinking
of
things
in
terms
of
like
you're,
just
like
a
traditional
hash
map
or
whatever,
because
it
doesn't
have
the
properties
you
need.
So
I
don't
know.