►
Description
This talk was given at IPFS Camp 2022 in Lisbon, Portugal.
A
Awesome
because
we
have
a
very
important
topic
to
talk
about
today,
all
right
so
you're,
very,
very
glad
you
didn't
miss
this,
because
we
are
going
to
talk
about
how
to
safely
store
dog
and
the
background
it
is.
Is
we
we
started
out
building
an
MLP
pretty
similar
to
the
speech
here
before
a
social
app
that
combines
Telegram
and
notion,
so
you
can
easily
create
structured
data
and
we
use
conventional
blockchain
methods
like
authenticate
with
metamask,
and
then
we
built
a
background
orbit
DB,
but
pretty
quickly.
A
A
B
Yeah
so
a
little
background,
some
of
you
maybe
know
what
I
Can
Only
log
database
are,
but
it's
quite
simple.
Basically,
all
your
changes
are
created
through
Ellicott
3..
That's
a
Direct
in
a
diagram
like
this.
So
in
the
start
there's
some
change
and
then
there
are
new
changes
that
are
linked
to
the
old
change
and
this
graph
Builds
on
and
becomes
bigger
and
bigger
and
bigger.
B
And
this
these
three
has
heads
as
you
would
call
it
and
using
those
heads
anyone
can
read
the
log
backwards
and
get
the
whole
data
set
and
what's
powerful
about
this
is
that
you
can
represent
things
with
a
tree.
If
you
read
a
log
in
a
particular
way,
you
can
represent
this
as
a
picture.
It
could
be
like
the
instructions
how
to
draw
the
dog
or
it
could
be
a
database
containing
pictures
of
dogs,
but
for
Simplicity.
B
B
How
do
we
make
sure
that
we
can
store
it
so
that
we
don't
need
to
distribute
it
on
all
devices?
How
can
make
sure
that
we
can
find
the
dog
later?
How
we
can
make
sure
that
when
we
ask
the
computers?
Where
is
the
dog
someone?
Someone
actually
replies
with
answer,
so
this
comes
down
to
the
way
that
we
do
data
sharding.
So
basically
we
need
to
make
a
decision.
B
B
Then
we
take
the
things
back
from
ashes.
Then
we
choose
the
replicators
as
the
adjacent
indices
to
the
dogs,
where
they
end
up
being
assorted
list.
So
in
a
world
where
we
want
two
computers
to
store
and
replicate
this
dog,
you
would
choose
the
two
adjacent
indices
and
since
this
hash
function
is
based
on
the
content,
it
will
be
unique
depending
on
what
you're
gonna
store.
So
if
it's
a
cat
for
now,
it's
going
to
be
different
computers
in
different
ordering,
and
this
in
the
long
run,
makes
content
distribute
evenly
across
your
devices.
Yet.
B
It's
not
super
complicated
to
understand
and
everyone
can
understand
how
this
works,
and
it
also
works
very
well.
If
some
computer
goes
down
you
you
just
redo
the
leader
selection
and
then
what
you
end
up
with
is
urge
to
redistribute
content,
and
when
you
do
this,
you
end
up
in
a
situation
where
you
always
have
the
same
amount
of
replicators,
no
matter
how
many
are
participating
in
a
network.
B
So
with
peer
bit.
We
we
included
this
as
a
core
functionality
of
everything
you
upload
and
you're.
Gonna.
Do
this
so
so
go
so
go
a
little
deeper
in
in
the
technology
and
merging
events
can
happen.
Two
distant
states
can
merge.
Two
imagine
that
you
have
a
ledger
in
two
different
countries.
When
one
makes
a
transaction
one
comes
to
another,
those
two
states
become
dependent
and
we
got
the
same
situation
here.
B
So
imagine
the
dog
graph
here
has
a
graph
ID
called
dog
and
we
have
a
cat
and
we
want
to
merge
these.
It
manages
a
Photoshop
file
or
whatever
we
want
to
make
sure
that
this
is
in
line
with
replication
things
that
I
described
earlier.
So
this
is
kind
of
an
Innovative
step.
We
do
is
that
we
assume
that
the
merge
state
is
either
a
cat
or
a
dog.
It's
not
like
a
mix
like
a
cat
dog
hybrid.
B
So
what
we
do
is
that
we
say
that
the
label
of
the
next
head
is
the
label
of
the
one
who
has
the
longest
chain
so
kind
of
a
proof
of
work
idea
almost
so
what
basically
happens
with
this
case
is
when
the
dog
and
the
cat
tree
merges.
It's
gonna
say
that
the
cat
tree
is
kind
of
shadowed,
so
every
every
computer
who
has
been
responsible
for
storing
a
cat's
state
is
gonna.
Don't
have
to
do
that
anymore
and
in
all
everything
this
is
written
in
a
super
digestible
way.
B
So
what
you
need
to
do
to
write
these
decentralized
apps
is
just
to
use
our
Primitives.
So
if
you
want
to
build,
for
example,
a
collaborative
text
document,
the
only
thing
you
need
to
do
is
to
extend
our
program
framework
and
use
D
string
instead
of
a
string
for
distributed
string
and
when
you
modify
this,
it's
going
to
automatically
replicate
amongst
your
peers
and
you
can
do
like
two
string
or
two
string
remote
to
get
remote
states
of
that
string.