►
Description
Ceramic—created by 3Box—builds on IPFS and other open standards to create a general-purpose protocol for computing and processing data, with flexibility as to where data is stored and what stack and data formats developers choose to use. Learn more about the project in this session.
A
Of
course,
if
we
want
to
build
kind
of
decentralized
applications,
so
today
I'm
going
to
be
talking
about
the
internet's
user
table
and
basically
how
we
can
build
a
database
and
a
user
network
that
we
can
eventually
out-compete
any
kind
of
incumbent,
big
tech
company,
all
right.
So
what's
the
user
table?
Well,
it's
essentially
used
this
kind
of
database
that
contains
like
I
it's
user
information,
so
you
might
have
an
identifier
for
a
user.
A
You
kind
of
have
the
incentive
to
create
a
large
user
table
as
possible,
because
then
you
get
kind
of
network
effects
and
that's
kind
of
how
you
win
the
web
2
game.
You
cap,
the
proprietary
user
table
that
logs
people
into
your
your
application,
but
what
that
kind
of
game
and
competition
eventually
creates,
is
something
that
looks
like
this.
A
You
have
these
big
companies
that
have
huge
silos
of
user
table
data
or
like
user
data,
and
they
end
up
just
using
that
in
their
position
to
extract
as
much
value
from
the
users
as
possible
without
kind
of
any
regard
for
externalities
on
the
users
or
the
the
communities
that
the
users
exist
in
and
really
kind
of.
What
we
want
to
create
in
web
3
and
with
the
technology
and
we're
all
building
is
something
more
like
this.
A
All
right,
so
how
do
we
do
this?
Well,
actually,
I
missed
a
slide,
so
doesn't
like
blockchain
applications
kind
of
solve
this
today.
Well,
the
problem
is
you
have
a
user
wallet
and
you
use
that
to
interact
with
smart
contracts
and
on
the
kind
of
financial
layer.
You
have
mostly
like
this
type
of
interoperability
between
users,
because
any
app
can
kind
of
kind
of
create
a
front
end
for
the
smart
contracts,
but
most
kind
of
more
sophisticated
dapps.
A
Today
that
kind
of
have
more
social
features
and
stuff
like
that,
they
actually
store
their
user
data.
On
a
back
end
and
a
centralized
user
table
you
can
might
sign
in
with
the
wallet,
we
still
have
the
kind
of
same
siloing
effect
of
data,
and
so
how
do
we
solve
this?
Well,
we
need
to
create
a
global
shared
user
table
where
all
applications
can
kind
of
like
store
data.
That's
with
the
user.
A
The
user
has
full
control,
you
can
choose,
which
application
kind
of
get
access
and
and
eventually
essentially
like
let
the
applications
build
networks
effects
together,
and
so
what
would
this
look
like?
Well,
maybe
something
like
this
okay,
so
in
this
kind
of
stupid
example,
you
have
like
an
ethereum
address
that
cryptographically
signs
and
he
updates
to
the
columns
here,
which
is
username
and
emoji,
and
this
could
potentially
be
a
way
to
represent
like
any
user.
Well,
there
are
some
problems
with
this,
though.
A
Firstly,
we
want
we
kind
of
need
a
better
way
to
represent
the
user
than
like
an
ethereum
address.
There
are
many
blockchains,
so
we
definitely
want
you
know
a
user
to
be
able
to
use
different
accounts
that
they
have
on
different
blockchains,
so
they
want
to
be
able
to
link
their
file
coin
address
the
ethereum
address
and
maybe
their
bitcoin
address
to
the
same
identifier
and
use
that
across
applications.
A
Even
then,
even
if
they're
like
using
different
blockchains,
so
you
don't
kind
of
want
to
we,
we
don't
want
to
recreate
kind
of
the
problem
we
have
now
with
the
big
tech
companies
with.
Is
that
big
tech
blockchains
that
cyber
user
data,
because
then
we
end
up
in
the
same
kind
of
problem
and
users
might
also
want
to
have
some
addresses
that
are
more
secure
to
store
kind
of
funds
and
hardware
wallets?
That
might
give
them
access
right
to
adele.
A
A
And
now
you
have
a
problem
right,
because
if
a
user
comes
to
application,
a
they
will
create
a
name
and
then
they
go
to
application
b
and
that
will
maybe
like
break
the
application
b
and
and
vice
versa
right.
So
we
need
a
way
to
kind
of
coordinate
and
about
about
what
data
is
stored
in
which
way.
Otherwise
this
system
would
be
like
extremely
fragile
and
like
wouldn't
really
work
as
a
means
to
share
data.
A
Another
thing
is
that
this
needs
to
be
kind
of.
Data
needs
to
be
like
possible
to
be
kept
around,
so
if
the
data
is
stored
on
some
server,
even
if
that's
like
completely
public
that,
if
the
application,
a
like
relies
on
application
b
and
application
b
disappears,
then
like
application,
a
is
essentially
screwed
because
they
don't
have
access
to
the
data
anymore.
So
this
kind
of
data
needs
to
live
on
some
kind
of
like
open
censorship,
persistent
network,
otherwise
it
will
won't
work
as
well.
A
A
Now
someone
else
comes
along
and
builds
build.
Another
application
and
sees
the
data
model
that
I
had
created
was
super
cool
and
there
they
used
that,
and
now
they
kind
of
already
have
10
000
users,
so
to
start
from
that
are
kind
of
seamlessly
already
onboard
into
their
app.
But
then
they
onboard
like
a
hundred
thousand
users.
A
So
we've
been
working
on
a
framework
on
top
of
ceramic
network
which
is
called
self
id,
and
this
is
essentially
a
way
to
create
this
kind
of
user
table.
That's
shared
across
the
entire
web3
stack,
but
before
I
dive
into
that,
I
want
to
just
give
a
primer
on
like
how
ceramic
works
and
how
data
objects
in
ceramic
works.
So
a
ceramic
object
is
essentially
an
event
log
of
ipld
objects,
so
ipld
is
a
way
to
represent
how
to
link
data.
A
That's
used
in
ipfs
and
filecoin,
so
sram
extreme
is
created
by
creating
a
genesis
commit
which
contains
some
initial
information
like
who's,
the
controller
of
the
stream
and
maybe
some
initial
content,
and
then
that
can
be
anchored
into
a
blockchain
and
that
essentially
provides
a
proof
of
publication,
meaning
a
timestamp
of
like
when
the
creation
happened
and
then
the
controller
of
the
stream
can
keep
updating.
The
stream
by
applying
signature
commits
that
point
back
to
the
previous
object.
Using
a
hash
link
and
the
signature
commit
basically
contains
a
patch.
A
So
if
you
traverse
the
entire
log
you'll
be
able
to
reduce
the
state
of
this
object.
The
neat
thing
is
now:
you
don't
have
to
like
sync,
the
entire
state
of
a
blockchain,
to
get
used
to
the
state
of
like
one
object
on
the
blockchain.
You
can
just
sync
the
state
of
like
this
particular
stream
to
get
the
state
of
the
stream,
so
it's
kind
of
really
like
client
friendly.
A
Each
stream
has
an
immutable
id
which
essentially
allows
it
to
allows
a
user
to,
or
or
like
a
developer,
to
find
what
the
latest
state
of
a
stream
is
given
this
identifier.
Even
if,
however,
many
times
it's
been
changed,
it's
using
the
ids,
which
is
a
kind
of
cross
network,
blockchain
agnostic
way
of
representing
a
cryptographic,
identifier,
yeah
and
nodes
kind
of
choose
which
streams
in
the
ceramic
network
they
choose
to
to
persist
all
right.
A
So,
let's
dive
into
self
id,
so
self
id
can
be
thought
of
a
as
a
user
table
spilled
on
top
of
ceramic
and
kind
of
looks
like
this.
So
we
have
the
d
id,
which
is
the
entity
of
the
user,
and
then
you
have
different
rows
that
contains
different
data.
So
here
we
have
like
data
mode.
One
two
three,
and
so
the
d80
here
you
can
see,
we
have
a
did
pth,
which
is
essentially
a
blockchain
address,
did
nft,
which
is
generally
any
nft.
A
The
current
owner
of
the
nft
is
the
one
that's
allowed
to
like
write
to
this
row
in
the
table.
Three
id
is
the
dnd
method
that
we
created,
because
we
needed
this
kind
of
universal
identifier
aspect,
which
I
talked
about
earlier,
where
we
can
like
link
blockchain
accounts
from
different
blockchains
into
like
one
identifier
or
multiple
addresses
into
one
item
device.
You
can
bring
the
data
across
the
different
ecosystems
in
webv.
A
Each
data
model
in
each
row
here
has
a
data
model,
has
a
unique
identifier.
So,
instead
of
naming
a
column
with,
like
you
know,
name
or
emoji
or
whatever
you
could
that,
because
that
will
cause
conflicts,
each
data
model
gets
kind
of
like
a
unique
hash.
That
is
identifies
that
column.
And
so,
if
you
have
two
different
data
models
for
a
name,
they
would
essentially
just
be
two
different
columns.
A
So
here
we
can
see
like
it
first
looks
like
a
name.
The
second
column
looks
like
some
kind
of
metadata
information
about
the
user,
and
the
third
column
contains
you
some
encrypted
information.
So
then
it's
kind
of
like
up
to
the
user
choose
which
applications
are
allowed
to
write
and
allowed
to
read
this
data.
A
C
C
Welcome
back
everyone
thanks
for
your
patience
again
we're
gonna
change
our
scheduling
a
little
bit,
we're
gonna!
Do
the
tachyon
launchpad
accelerator
update
for
the
second
batch
in
a
few
minutes
just
as
promised,
but
we
are
actually
gonna
be
able
to
go
back.
We
got
joel
again,
so
we're
gonna.
Let
joel
finish
this
presentation
and
we'll
continue
with
our
regularly
scheduled
program
in
a
few
minutes.
Joel
welcome
back.
A
Thanks,
it
seems
like
internet
technology
is,
is
difficult
all
right,
so
I
don't
think
you
lost
too
much
yeah,
so
self
id,
essentially
this
user
table,
so
that
now
let's
look
at
a
particular
row.
So
in
this
row
we
can
see
there's
an
identifier
and
three
cells,
and
so
this
identifier,
actually
cryptographically
controls
the
role
right,
and
so
it's
only
that
user.
A
That's
allowed
to
write
to
that,
because
if
an
application
were
the
one
ones
that
were
allowed
to
write
there,
they
could
start
soloing
data
like
keeping
users
out
from
like
sharing
that
data
with
other
applications,
and
so
the
the
underlying
structure
for
this
in
ceramic.
Essentially,
the
row
is
one
data
object,
then
each
cell
and
the
row
the
points
to
each
cell
in
the
row,
and
so
each
cylinder
was
also
a
data
object
in
ceramic
that
can
be
updated
over
time.
So
the
user
can
kind
of
update
and
change
the
data
as
well.
A
So
this
is
like
important
for
us
to
be
able
to
kind
of
start
sharing
data
without
too
much
coordination
across
different
projects
all
right.
So
I
think,
finally,
kind
of
once
we
start
having
this
shared
global
user
table.
We
onboard
a
bunch
of
users
and
have
them
use
this
in
various
different
type
of
applications,
and
now
we
like
really
grow
this
and
make
it
into
a
commons
of
the
internet
where
we
can
kind
of
all
building
applications
share.
A
You
know
newsfeed
algorithms
and
things
like
that
that
are
totally
value
aligned
with
the
user,
like
with
individual
people
and
but
also
like
communities
of
people,
and
I
think,
that's
really
powerful
and
like
it's
really
gonna
allow
us
to
create
a
information
ecology.
That's
not
hurtful
in
the
way
that
we've
seen
with
social
media
today,
all
right!
So
if
you're
curious
and
want
to
learn
more,
you
can
go
to
self.id
to
create
your
row
in
this
table.