►
Description
Follow the latest from NEAR Protocol on:
Website: https://near.org/
Discord: https://near.chat/
Blog: https://near.org/blog/
Twitter: https://twitter.com/NEARProtocol
GitHub: https://github.com/near https://github.com/nearprotocol
#Blockchain #FutureIsNEAR #NEAR #nearprotocol
A
Good
afternoon,
everyone,
I
would
like
to
welcome
you
to
this
afternoon
of
the
second
day
of
the
neocon
2021
in
lisbon.
For
this
afternoon,
I
would
like
to
introduce
joel
thorstensen,
who
is
the
ceo
of
a
three
box
lab
who
is
here
to
talk
about
the
internet's
user
table.
Let's
greet
him.
B
So
three
box
labs,
the
company
which
I
co-founded
has
created
something
called
ceramic
network
and
it's
really
kind
of
like
a
laying
foundational
infrastructure
piece
for
this
type
of
application.
So,
let's
let's
jump
into
it.
B
So
if
you
imagine
you're
building
like
a
web
2
application,
you
usually
want
to
store
some
user
data
right
because
you
want
to
onboard
a
bunch
of
users
and
the
more
users
you
have.
The
larger
kind
of
your
network
effect
becomes
and
the
more
valuable
your
platform
or
product
becomes,
and
so
most
kind
of
web
2
applications
have
this
user
table
in
which
they
store.
B
B
They
have
a
huge
lock-in
effect
and
they
also
you
start
extracting
a
bunch
of
this
data
or
a
bunch
of
the
value
out
of
the
data
from
the
users
and
the
users
are
kind
of
like
stuck
because
they
can't
just
go
to
another
platform,
because
all
of
their
friends
or
connections
are
on
the
existing
platform.
So
they're
kind
of
really
stuck-
and
this
is
really
the
kind
of
opposite
of
what
we
want
to
create
with
web3.
So,
instead,
what
we
want
to
do
is
create
something
that
looks
a
little
bit
more
like
this.
B
This
kind
of
solar
panel
vision
of
some
really
kind
of
open
system
where
users
have
kind
of
full
control
over
their
data.
The
data
is
not
locked
into
any
particular
application
or
platform,
and
we
kind
of
have
this
of
of
every
piece
of
content
that
we
generate.
So
how
do
we
get
there?
Well,
you
could
think
of
like
a
how
well
dapps
today
kind
of
are
going
towards
something
like
this,
so
we
have
the
smart
contract
layer.
B
It's
actually
shared
like
like
I
proposed,
but
still
a
lot
of
applications
being
built
today
have
a
backend
of
user
data,
so
it's
mostly
kind
of
the
financial
layer
that
we've
managed
to
decentralize,
but
the
user
data
layer
is
still
centralized
and
then
we
kind
of
still
have
this
lock-in
effect
of
the
user
data,
but
maybe
not
on
the
financial
data.
So
we
need
to
kind
of
take
a
step
step
further
and
actually
from
the
user's
wallet,
not
only
store
the
financial
aspects
in
a
decentralized
way,
but
also
the
all
of
the
users
content.
B
B
B
But
there
are
some
kind
of
nuanced
problems
with
just
this
kind
of
simplistic
approach.
So,
first
of
all,
we
need
to
have
some
kind
of
use
of
unified
user
identities.
B
We
need
this.
This
user
table
this
data
ecosystem
to
be
anti-fragile,
and
what
I
mean
by
that
is,
if
you
have
application
a
and
application
b,
and
they
both
have
a
column
and
this
this
database.
That
is
like
a
name
and
app
a
thinks.
The
name
is
just
a
string.
A
b
thinks
the
name
is
an
object
that
has
the
first
name
and
a
last
name,
and
now,
if
I
go
to
application
a
create,
my
account
then
go
to
application
b.
B
Application
b
could
break
because
of
that,
because
it's
expecting
something
different
than
what
the
first
app
put
there,
and
this
is
obviously
going
to
cause
huge
problems
for
creating
like
an
interoperable
data
ecosystem.
So
we
need
some
way
to
kind
of
come
to
agreement
or
consensus
about
what
data
we
put
into
this
globally
shared
user
table.
B
Another
aspect
of
this
and
the
fragility
is
that,
if
app
a
disappears,
appb
should
still
be
able
to
get
access
to
the
data,
and
the
data
should
not
be
like
locked
into
any
servers
that
might
be
censored
or
it
should
not
just
disappear
when
the
application
disappears.
So
we
need
some
form
of
like
censorship,
resistance
or
persistence.
B
And
finally,
one
of
the
big
benefits
we
get
if
we
can
have
this
globally
shared
user
table
across
all
of
web3
is
that
we
can
create
shared
network
effects
and
so
a
simple
example
of
what
this
means
is
that
I
might
build
an
application.
I
create
some
data
model
where
I
store
data
about
the
user
and
I
onboard
10,
000
users
and
now
a
different
application
comes
along
and
it
it
sees
that
this
data
model
that
was
created
by
me.
B
It
was
like
super
good
and
they
actually
want
to
use
that
in
their
application
and
they
they
started
using
it.
Now
they
have
like
10
000
users
that
are
already
kind
of
like
onboarded
to
their
application,
and
so
now
they
start
onboarding
users
themselves
and
it's
super
successful.
It
has
like
100
000
users,
and
that's
super
good
for
me
because,
like
now,
I
have
access
to
like
a
lot
more
uses
than
I
had
just
because
I
created
data
model
that
was
useful
for
someone
else's
application.
B
So
we
get
this
kind
of
like
shared
network
effect
and
once
we
actually
start
scaling.
This
we'll
have
a
problem.
A
B
B
They
will
actually
be
unable
to
to
compete
with
us
and
and
we'll
have
like
a
strong
kind
of
incentive
for
any
application
to
just
like
use
this
open
user
table,
and
so
we
have,
with
ceramic,
created
a
framework
called
self
id
which
allows
you
to
actually
store
data
in
in
a
way
which
the
user
has
control
over
the
data
and
also
in
this
kind
of
globally
shared
way.
B
B
That's
mutable
and
owned
by
a
user
or
controlled
by
the
user's
identifier,
and
so
it's
essentially
like
a
ledger
or
commit
log
of
signed
commits
and
when
a
user
creates
an
object,
it
becomes
cryptographically
kind
of
linked
to
their
identity
and
then
anytime
they
update
it.
They
sign
an
update
and
that
also
gets
anchored
into
the
blockchain,
and
so
so.
This
object
has
a
persistent
identifier
that
never
changes,
but
the
state
of
this
object
changes
over
time
and
we
can
see
the
entire
history
of
the
object
and
inspect.
B
What
was
the
history
of
this
object
at
some
previous
point
in
time?
So
this
can
work
as
like
a
very
powerful
primitive
to
have
mutability
of
content
all
across
the
web,
and
so
what
we're?
Building
with
this
is
self
id.
So
self
id
can
be
thought
of.
As
this
user
table,
where
we
have
an
identifier
called
a
did,
as
is
short
for
decentralized
identifier,
it's
essentially
a
way
to
represent
a
user
id
in
a
completely
kind
of
agnostic
way.
B
It
could
be
like
an
account
on
the
blockchain
like
we
have
on
top
and
that
could
be
like
any
blockchain
or
it
could
be
380,
which
is
an
dad
method.
We've
created
to
essentially
make
it
easy
to
connect
multiple
accounts
on
multiple
blockchain
into
one
single
identifier,
and
so
like
actually
letting
the
user
bring
their
data
across
these
different
ecosystems
and
then
each
column.
B
Here
you
can
see
that
it
has
a
data
model
on
each
column
and
this
data
model
is
created
by
developers
and
this
data
model
actually
gets
a
unique
identifier,
so
there's
no
kind
of
like
oh,
I
claimed
the
column,
that's
called
name
that
would
be
kind
of
not
great,
because
then
people
would
kind
of
compete
to
get
like
particular
names
in
these
columns,
but
instead
it's
like
a
unique
identifier.
That's
based
on
some
hashing
algorithm
and
then
so.
Data
model,
one
we
can
see,
is
probably
like
a
name
data
model.
B
Two
is
some
other
kind
of
metadata
about
the
user.
Here
data
model
3
looks
like
there's
some
encrypted
data.
That's
stored
there,
so
it's
up
to
the
kind
of
the
user
to
decide
which
applications
get
right,
access
to
this
column
and
which
application
can
kind
of
get
read
access.
So
if
we
look
at
a
particular
user's
row
in
this
table,
the
user
has
full
control
over
their
entire
row,
and
that's
kind
of
like
a
draw
itself
is
an
object
in
ceramic
and
then
for
each
data
model.
B
There's
a
separate
object
that
is
also
controlled
by
the
user,
and
I
think
this
this
aspect
of
the
user.
Being
control
of
this,
the
cell
in
in
the
piece
of
the
user
table,
is
really
important,
because
if
the
application
were
the
ones
that
were
controlling
it,
then
you
could
still
kind
of
get
this
lock-in
effect
where
the
application
can
kind
of
choose
who
which
other
application
gets
accessed.
But
if
the
user
controls
it,
the
user
is
always
the
user
always
can
decide
which
applications
can
read.
B
The
data
which
applications
can
write
to
the
data,
and
so
it
kind
of
like
unbundles
and
unlocks
the
data
for
for
the
entire
web3
ecosystem.
B
And
now,
if
we
look
at
a
particular
data
model,
there's
some
important
aspect
to
consider
here.
So
data
model
has
a
bunch
of
metadata
like
a
name
and
description
so
that
other
developers
can
look
at
it
and
understand
kind
of
what
it
does.
B
It
wouldn't
be
able
to
put
it
there,
and
this
is
really
useful
for
the
kind
of
problem
I
talked
about
before
with
anti-fragility,
because
now,
if
I'm
a
developer,
I
start
when
I
use
a
particular
data
model.
I
know
that
the
data
I'm
pulling
out
of
it
will
always
conform
to
this
specific
schema,
and
so
I
have
this
kind
of
guarantee
of
like
what
the
data
would
look
like
and
then
never
kind
of
break.
My
application
all
right.
B
So
I
think,
once
we
have
now
this
shared
global
user
table
and
we
start
kind
of
building
adding
more
data
having
more
applications
share
data.
Within
this
we
start
creating
some
kind
of
user
data
common
and
this
user
data
commons
is
essentially
a
place
where
we,
as
I
guess
humanity
can
put
our
data
into
it.
B
It's
not
locked
into
any
any
web
to
platform
or
anything
like
that,
and
so
the
the
business
model
that
web
2
platforms
have
had
was
like
getting
all
the
user
data
and
extracting
as
much
value
as
possible,
won't
really
be
possible
because
if
they
do
that
they
create
their
their
machine,
learning,
algorithms
and
things
to
to
optimize
user
behavior
in
a
certain
way.
B
Why
would
I
choose
to
do
that
if
they're,
just
extracting
all
the
value
and
giving
me
like
a
bunch
of
bad
content,
essentially
when
I
can
just
move
to
a
different
application
that
uses
the
same
data?
I
have
the
same
connections
in
this
graph
and
I
can
actually
just
choose
consciously
to
use
applications
that
provide
as
much
value
to
me
or
to
my
community
as
possible.
So
we
can
actually
start
having
news
feeds
and
recommendation
engines
that
are
aligned
value
aligned
with
our
communities
rather
than
some
random
organization
that
is
just
profit
driven.
B
A
You
meant
you
mentioned
that
the
recommendations
in
the
feed
wouldn't
be
based
on
the
like
the
value
that
the
company
extracts,
but
you
said
it
would
be
based
on
the
community.
How
exactly
would
that
work
technically
as
an
like?
How
would
database
how,
because
that
it's
still
the
application
would
be
managing
it
right
like
it
would
just
use
the.
B
B
Yeah,
I
mean,
I
think,
exactly
how
the
feed
would
be
generated
would
be
kind
of
like
up
to
an
application,
but
it's
more
about
the
incentives
that
are
involved.
So
if,
if
I'm
an
application,
I
have
all
the
users
data
in
in
my
user
table,
I
can
kind
of
do
whatever
way
I
want
like.
If
I'm
facebook
I
can
do
whatever
I
want
with
that
data
and
the
user
can't
kind
of
like
escape
and
go
somewhere
else,
but
now
they
could.
B
Actually,
if
the
data
is
stored
in
this
shared
table,
they
could,
if
you,
your
application,
is
just
like
extracting
and
not
giving
you
like
a
good
feed
or
like
a
good
experience.
You
can
just
go
to
another
application
that
uses
the
same
data
but
actually
provides
more
value
to
you
as
an
individual
or
to
you
and
your
community.
B
Yeah
and
the
incentive
is
there
just
because,
like
the
users
wouldn't
want
to
use
an
application,
that's
just
like
exploitative
right
yeah.
I
think
I
think
actually
like
this
is
a
model
where
we
can
actually
stop
having
some
of
the
kind
of
incentive
misalignments
that
lead
to
kind
of
the
poisoning
or
like
the
the
corruption
of
our
information.
Ecology
like
how
we
spread
information
is
very
right.