►
From YouTube: IPLD Tutorial - DAGs, Roots, and UnixFS
Description
Follow along with this activity, published at https://pl-strflt.notion.site/DHT-Overview-e4bc573eaf094efc8a0781de47262db6 to get a deeper understanding of the IPLD project including DAGs, Roots, and UnixFS
A
B
So
the
background
to
this
is-
and
I
I
I
allow
outlining
that
page
there-
the
the
way
I
thought
about
it
is
dags
they've,
a
very
abstract
idea,
and
we
are
we're
asking
we're
asking
people
to
picture
graphs
in
their
heads
and
then
and
then
use
that
as
as
to
build
this
their
understanding
of
ipld
and
that's
not
quite
fair
for
a
lot
of
people.
Some
people
are
really
good
at
that
kind
of
thing,
but
but
a
lot
of
people,
it's
very
much
more
practical.
So
the
idea
was
we
need.
B
So
it's
it's
like
this
is
this
is
so
common.
This
is
table
stakes
for
us
at
the
company
and
we
can
demonstrate
it
this
way
and
and
we
can,
we
can
poke
it
ipld
with
the
ipf
with
go
ipfs
on
the
command
line.
So
so
great
now
we
have
a
few
websites
in
the
company
that
are
published
via
flick,
so
flick
is
that
they
publish
on
ipfs
yeah.
B
Yeah
and-
and
so
the
main
one
I
interact
with,
is
the
ipld
website
and
and
so
every
every
commit
to
master
produces
a
new
version
of
the
website
and
it
handles
the
whole
ipns
dns
link
updating.
So
when
you
go
to
ipld
to
io,
you
are
sort
of
resolving
a
the
latest
one
via
ipfs
and
then
pulling
that
into
the
whatever
gateway
or
browser
like
if
you're,
using
a
browser
to
do
it.
That
has
like
inbuilt
ipfs
support.
B
A
B
That's
that's
a
good
question,
I
don't
quite
know,
but
flick
will
have
some
kind
of
pinning
arrangement
so
either
they're
pinning
it
to
their
nodes
or
they're
using
a
pinning
service,
like
maybe
they're,
using
pinata
something
else,
but
but
they're
they
are,
they
are
they
publish
it
on
their
own
on
their
own
machines
like
they
compile
the
site,
and
then
they
publish
it
to
ipfs
the
dht
on
their
machines
and
then
so
when
they
take
it
like
you
do
a
pull
request
to
github.
They
take
it.
B
They
put
it
on
the
dht
and
give
you
a
cid,
and
then
you
can
fetch
that
cid
and
that
it's
whole
dag
locally
on
back
on
your
computer,
which
is
a
really
neat
workflow,
because
you
you're
not
having
to
build
the
the
dag
or
you
know,
ipl
dfi
files
or
publish
to
the
dht.
It's
all
done
for
you
and
you
just
get
to
poke
at
the
dag
and
have
a
look
at
it
and
say:
well,
you
know
what
we've
got
here.
So
that's.
B
That's
a
really
neat
feature
that
shortcuts
the
whole
dag
creation
thing
and
it
lets
us
jump
to
just.
Let's
look
at
a
dag
so
so
that
there's
two
parts
to
this
one
is
well,
let's
just
look
at
what's
what
is
already
there
and,
and
the
other
part
is,
let's
make
a
a
an
edit
to
it.
So
the
first
steps
I've
got
like
I've
got
them
in
steps
here.
The
first
step
is
to
let's
look
at
the
dag
on
the
website.
B
Let's,
let's
figure
out
how
we
can
get
this
website
in
our
local
guy,
pld
node,
so
so,
there's
two
different
ways:
I've
put
there
and
there's
actually
additional
ways
to
do
this
too,
but
I've
only
put
two
there,
but
if
you
yeah,
I
build
you
the
I
o.
If
you,
if
you
run
you
say,
if
you've
got
ipf,
go
ipfs
installed
on
your
computer,
then
you
can
run
ipfs
resolve.
That's
that
command
in
the
in
the
thing.
A
B
A
A
B
Line,
if
you
can
do
command
line
ipfs,
that's
all
we
need
to
do.
That's
all
I'm
caring
about
for
this
okay.
There
is
some
additional
things,
though,
in
here
like
it's
going
to
be
best.
If
you
have
the
jq
command
installed
on
that
lightweight
virtual
machine,
so
it
can.
Can
you
so
if
you,
if
you
go
back
to
that
terminal
you
had
and
and
if
you
can
control
c,
that
ctrl
c
and
now
do
run
sudo
snap
install.
B
B
B
B
C
B
A
B
B
No,
not
quite
because
of
the
publishing
so,
but
if
you
go
to
ipld.io
and
like
open
up
a
new,
oh
there
you've
got
there,
then,
basically,
all
of
the
subdirectories
there
are
listed
in
that
so
like
if
you
go
to.
If
you
go
to
documentation,
you'll
see
them
so
click
on
documentation,
because
this
is
the
splash
page
which
is
really
annoying
on
the
left.
There
you've
got
docs
and
if
you
scroll
down,
you've
got
specs
specs
there
and
is
there
another
one?
B
B
B
Yeah
yeah,
the
specs
and
docs
sections
of
that
website
are
the
most
complex
so
that
if
you're
going
to
explore
them,
then
those
two
will
lead
you
to
more.
You
know
a
lot
more
depth
and
then
the
the
interesting
thing
to
point
out
here
is
that
the
pages
they're
all
index.html,
but
that
you'll
note
they're,
also
links.
So
you
have
to
jump
from
you're
in
a
directory
now.
But
if
you
see
the
index.html,
you
have
to
jump
to
that.
B
B
So
you,
the
previous
one,
is
the
directory
and
now
now
you're
like
three
links
deep
into
your
dag
just
to
get
to
a
page
so
which
which-
and
this
is
one
of
the
counter-intuitive
things
about
ipfs
and
and
dags
and
stuff
is.
Is
we
give
we
say
to
people?
Here's
the
ci,
here's
the
cid
for
my
website,
but
what
you're
giving
them
is
is
the
root
of
a
very
complex,
dag
and
and
people.
B
I
don't
think
many
people
really
internalize
that
complexity,
that
you're
just
giving
them
a
a
c
id
of
a
very
small
block
relatively
that
then
links
to
other
blocks
that
links
to
other
blocks,
so
the
whole
site
is,
could
be
thousands
and
thousands
of
blocks,
but
you're
just
using
the
roots.
The
idea
as
the
reference
and
then
you're
parting
through
it,
and
so.
A
B
A
B
A
B
B
Okay,
so,
okay,
now
what
what
it's
done
here
so
because
you've
got
the
ipfs?
What
do
you
call
it?
The
desktop
thing
installed
as
an
add-on
in
your
browser.
It's
it's
skipped
touching
our
gateway
and
it's
it
said:
okay,
we're
going
to
talk
to
the
we're
going
to
talk
to
our
local
node.
So
so
you
fetch
that
now
in
your
local
node
and
loaded
all
of
the
pieces
on
it.
So
your
the
domain
now
is
all
changed
to
a
cid
v1
and
it's
got
localhost
in
it.
But
that's
the
see.
That's!
B
That
is
the
cid
that
you
you
fetched
from
your
command
line
and
put
in
there.
But
if
you
didn't
have
the
the
add-on
enabled
in
your
browser,
then
you
would
go
straight
to
our
our
gateway.
In
fact,
you
can
turn
it
off
yeah
you
could
this.
I
think
you
can
just
go
into
it
and
disable
it
if
you
click
on
it.
Click
on
it
in
your
little
thing
there
just
on
the
left,
yeah
click
on
that.
I
think
you
can
turn
it
off.
B
We'll
see
oh
yeah,
I
think
it's
loading
there
you
go
and
it's
preserved
that
crd.
So
that's
really
neat.
Actually
that's
working
way
better
than
I
thought
it
would.
That's
great
and
cool,
and
so
you've
now
got
that
version
of
the
website.
That's
published
now
and
you
could
potentially
go
back
in
time
and
use
old,
cids
but
yeah.
What.
B
D
B
Hugo,
no,
this
is
view
press.
No,
no,
it's
eleventy,
it's
eleven,
oh
so,
but
I
had
a
pull
request
in
yesterday
to
upgrade
to
version
one,
and
I
didn't
intend
that
for
that
to
be
merged,
but
somebody
might
have
merged
it
overnight,
so
that
could
explain
that
difference.
That's
okay!
Anyway!
That's
neat
that
it
works,
because
that's
that's
much
better
than
previously.
I've
looked
at
this
thing
is.
B
A
B
Yeah
yeah,
I
I
can't,
I
think
we
had
this
conversation
before
about
statics,
like
generators
and,
in
my
opinion,
they're
all
equally
terrible.
I
don't
know
why
this
problem
is
not
solved.
Okay,
so
this
this
here,
so
the
the
other
part
of
that
little
first
step
is
to
actually
use
dig,
which
is
a
dns
lookup
command
to
actually
look
at
the
dns
link
name.
So
if
you
run
that
in
there
you
should
see
that
does
a
dns
lookup
of
that
and
you
can
see
a
ci
the
cmc
id
is
is
in
there.
B
Flick
manages
this
for
us,
which
is
neat
so
normally
when
you,
when
you
manage
your
own
site,
and
you
want
to
use
dns
link
to
do
this
conversion
so
that
the
cloudflare
gateway
will
do
it
all
that
sort
of
stuff.
You
would
have
to
manage
that
text.
Entry
yourself,
but
flink
is
really
neat
because
it
just
handles
it
for
you
publishes.
It
then
updates
the
dns
link.
You
don't
even
have
to
think
about
it,
but
it's
interesting
to
see
that
this
is
for
people
who
are
new
to
our
ecosystem.
B
Dns
link
is
like
the
bridge
between
web
2
and
web
3
for
us,
so
it's
pretty
pretty
cool
okay,
so
that's
the
same
cid
now
in
in
in
the
next
section.
What
am
I
doing
in
the
next
section
I
so
using
ipf
the
ipfs
dag
api
to
inspect
the
dag.
So
if
you,
if
you
run
ipa
ipfsk
and
then
put
that
cid
in
that
you
found,
you
could
copy
it
from
that,
just
above
there
in
dns
link
that
one
there
just
to
the
start
of
the
cid
yeah.
B
If
you
do
that,
you'll
see
a
whole
lot
of
garbage
okay.
So
that's
just
this
is
the
debt.
This
is
that
that
node,
that
block
in
dag
json
format.
So
it's
taken
the
dag
pb
block,
which
is
very
difficult
to
read
as
because
largely
binary,
and
it's
outputting
it
as
dag
json.
This
is
the
default
for
ipfs,
dag
get
command
now.
C
C
B
B
B
A
B
B
B
So
every
page
gets
a
new
cid
which
is
really
annoying
for
this
example,
because
in
in
the
pure
version
of
this
example,
we'd
change
one
page
and
everything
else
would
stay
the
same,
and
then
we
could
talk
about
that
process,
but
I
do
have
a
way
of
talking
about
it,
because
one
thing
that
doesn't
change
is
images.
So
these
image,
all
these
image
cids
they
stay
stable
if
they're,
not
if
they're,
not
edited,
but
the
structure
around
it
does
and
those
changes
bubble
up
to
the
top
of
the
root
will
always
change.
B
If
you
change
anything
underneath
it,
because
that's
the
nature
of
merkle
trees,
because
a
change
in
in
one
block,
the
hash
is
then
linked
in
the
previous
block,
which
has
changed,
and
then
that
has
changes
all
the
way
up
to
the
top.
So
that's
why
we
always
get
a
new
root
cid,
no
matter
what?
How
tiny
the
changes
we
have
in
the
in
the
whole
dag
underneath
it
yeah.
B
Actually,
I
try
and
demonstrate
this
in
here.
Okay,
so
there's
some
notes
in
there
about
what
we're
seeing
when
we
pipe
that
through
jq
and
how
some
of
the
quirks
of
doug
jason,
because
presenting
cids
is
a
bit
awkward
in
dak
jason.
We
get
this,
you
know
the
quote.
Slash
thing:
try
encourage
not
people
not
to
be
too
distracted
by
that.
The
quote.
Slash
is
actually
not
in
the
data.
B
It's
just
the
presentation
thing,
and
so
each
of
these
things
here
is
a
link
to
a
new
block,
so
we're
looking
at
the
root.
We've
got
links
to
the
top
level
blocks
and
then
what
I,
what
I
want
to
do
is
the
next
stage
is
load
one
of
the
pages
by
pathing
to
it
from
the
root.
So
in
in
this
next
one
we're
going
to
go
to
the
index.html
page
and
you
can
see
in
your
yeah.
B
B
B
You
could
do
ipfs
dag
get
okay
on
the
like
you
just.
You
could
run
that
now
and
and
you'll
see
a
lot
of
garbage,
because,
because
that
is
a
page,
so
you're
seeing
all
the
bytes
of
the
page
as
base
64.
okay.
So
I
I
I'll
show
you
later
how
you
can
actually
look
at
the
page,
but
that's
that
just
shows
you.
It's
a
lot
of.
B
B
B
B
C
B
Now
now
the
the
quirk
that
I
have
to
explain
at
this
point
is
is
to
do
with
unix
fs,
because
in
ipfs
the
in
go
ipfs
unixfs
has
a
special
case.
It's
it's
a
special
case
format
because
we
deal
with
files
so
that
path
when
when
ipf
go,
ipfs
sees
that
path
and
it
tries
to
load
the
root
block
and
then
it
says:
oh,
this
is
unix
fs
data.
I
know
what
this
is:
it's
dag
pb.
B
B
Yeah,
so
it
special
cases,
but
we
can
escape
out
of
that
to
to
get
into
it.
So
in
the
next
section,
what
am
I?
How
am
I
explaining
this
yeah
in
the
next
section?
I
explained
the
dag,
so
I've
got
like
the
root
cid
and
then
the
index.html
cid,
and
then
you
can
like
you
did
before
when
you
said,
ipfs
dag,
get
the
root
and
then
ipfs.get
and
then
the
index.html
cid.
B
So
right
there,
if
you
go
to
actually
now
scroll
up
to
oh
there's,
two
pages
on
dag
pb,
so
go
scroll.
Look
there,
you
go
see,
dag
pb,
just
at
the
top
there
there's
this.
I
think,
respect
for
it
is
better
there's
a
spec,
but
this
yeah
the
spec
is
down
but
bit
below.
But
this
is
eric's
words
about
it.
So
go
to
the
spec
and
then
and
go
down
pb
specification.
B
And
then,
if
you
go
down,
you'll
see
the
there's
two
things:
there's
a
serial
format
in
protobuf,
which
many
programmers
will
be
used
to
looking
at
and
then,
if
you
go
down
to
the
logical
format,
scroll
down
a
little
bit
more
this
this
bit
here.
This
explains:
what's
in
a
thing,
so
you
can
see
in
that
in
a
dag,
pb
block
you
have
links
which
is
an
array
of
links
and
data
which
is
just
lights
so
they're
the
main
two
things
you
see
when
you're
looking
at
that
dag
pb
block.
A
B
I
it's
we've
got
these
two
layers
of
protobuf
things
which
is
really
annoying
to
explain,
but
what
we're
seeing
when
we're
inspecting
the
block
on
the
terminal?
Is
this
thing
right
in
front
of
you
here?
So
it's
that
structure
there,
where
we've
got
that's
all
a
tag,
pb
node?
Is
it
doesn't
matter
what
sort
of
files
it
contains?
What
directories?
B
Okay,
so
so
yeah
this
section
here.
This
is
what
I
was
saying
before
about
how,
when
you
go
slash
index.html,
it's
doing
something
a
little
bit
funky
under
the
hood,
which
is
slightly
annoying,
but
it's
just
explaining
that
it's
it's
making
that
jump
from
the
root
to
the
next
block.
So
we've
got.
We've
now
got
a
dag
of
two:
we've
got
a
root
and
a
link
to
another
block
which
is
great
and
we're
already,
navigating
it
and
and
and
that
little
bit
of
terminal
stuff
is,
I
can
get
it
via.
B
A
B
That
that
one
there
is
the
one
I
get
just
if
you
just
where
it's,
where
the
little
notion
thing
is,
with
the
little
toolbar
thing,
just
above
an
index.html,
see
that
cid
there
that's
the
one
I
use
for
so
so
it
just
in
that
the
after
the
first
command.
I
got
the
cid
of
index.html,
and
then
I
put
that
cid
in
for
the
second
command.
So
I
manually
went
from
root.
B
Okay
figured
out
what
the
next
link
was,
and
then
I
got
that
one
and
I
got
exactly
the
same
thing
as
if
I
put
slash
dot
index,
html,
yeah,
okay,
let's
just
explain
to
x
now
this
next
bit
is
where
we
get
interesting
into
ipl
d
parting,
because
this
is
this
is
like
raw
ipld.
So
we
can
escape
out
of
this.
Go
ipfs
unix
fs
magic
by
putting
slash
iplb,
slash
in
front
of
the
cid
that
we
want
to
fetch,
and
then
that
says
to
I
go
ipfs.
B
B
And
then
go
slash,
ipld
slash
and
then
put
the
root
in
you
just
just
press
enter
enter.
You
don't
need
to
jq
that
one
just
and
it's
it's
exactly
the
same
thing
as
if
you
didn't
have
ipld,
but
now
we
can
use
ipld
pathing.
So
if
you
just
run
that
same
command
again
and
then
go
slash
and
then
links
with
a
capital,
l.
A
B
C
B
B
I
might
get
glossary
f
g
h.
I
then
maybe
it's
seven.
Actually,
let's
try
some,
because
I
think
image
is
in
there
there
you
go
bingo.
So
what
we've
done
here
is
we've
passed
into
the
block
and
we've
said
I
just
want
this
little.
This
little
node
of
the
block
we
haven't
jumped
blocks.
We've
just
gone
into
that
block,
which
is
neat
right.
B
Yeah
so
now
now
the
neat
thing
with
the
dags
is
that
we
can
jump
from
block
to
block
so
we've
got.
We've
got
the
element
of
the
links
array
we
want.
Now
we
want
to
jump
to
that
block
and
that
cid
is
has
the
name
is
in
the
property
hash,
so
that
hash
is,
is
the
it's
the
cid.
So
if
you
run
that
command
again
but
put
slash
hash.
B
Yep,
so
that's
that
okay
now
we're
in
a
new
block,
because
what
we
did
is
we
we
passed
down
into
the
block.
It
hit
a
cid
where
it
found
hash
and
they
said
I
got
to
load
that
block
and
it
loaded
it.
And
then
that
was
the
next
thing
we
saw
so
like
you
could
do
another
thing
you
could
do.
You
could
actually
look
at
the
raw
data,
so
this
is
the
next
step
of
the
tutorial.
Let's
do
it
in
terminal
here
without
going
through
the
page,
so
go
go,
no!
B
A
B
You
change
that
links
to
data
capital
d,
so
links
and
data
are
the
two
top
level
things
in
the
dag
pv
block.
You
can
scroll
up
and
you
can
see
all
you've
got,
and
this
is
another
quirk
of
showing
this
is
jason.
It's
going
to
have
a
slash,
sorry,
a
quote:
slash
at
the
top.
There
you
go
and
then,
but
it
says
bytes,
but
what
you're
looking
at
is
actually
raw
bytes.
This
whole
thing
is
raw
bytes.
A
B
B
No.
No
one
word,
I'm
sorry,
but
then
sorry,
it's
dag
space
get
yeah.
It's
just
the
way
that
go
works
there.
You
go
so
there's
one
flag
here:
one
main
flag
which
is
output,
codec,
okay,
so
the
default
is
json.
That's
why
we're
seeing
this
crazy
jason
that
doesn't
because
jason
doesn't
represent
bytes
properly,
so
our
dag
json
codec
has
this
convention
of
doing
it
as
base64,
which
is
just
terrible
for
looking
at
the
bytes.
B
But
if
we
switch
the
codec
from
dag
jason,
we
could
there's
a
bunch
of
codecs
we
could
use
like.
We
could
use
dag
cbo.
It
wouldn't
be
very
interesting,
but
we
can
use
the
raw
codec
which,
which
the
raw
codec
only
only
works
if
you're
piping,
if
you're,
giving
it
bytes
and
it'll
just
spit
the
bytes
out.
B
So
this
is
this
is
the
index.html
and
you
can
scroll
up
to
the
top
and
you'll
see
the
the
header
and
stuff.
So
this
is
the
index
or
for
the
whole
site.
There
you
go
yeah,
so
it's
got
head
and
it's
ipld
whatever
it
is
under.
You
could
just
turn
your
cursor
apl.
The
data
model
of
the
content
addressable
web.
So.
B
Yeah
and
yeah-
and
this
only
worked
because
we
navigated
to
a
node
in
a
block
that
was
only
bytes.
If
you
tried
that
on
the
lynx
thing,
it
would
say
no,
I
can't
I
can't
turn
an
array
into
bytes
or
I
can't
do
in
whatever
interbytes.
So
it
worked
because
we
did
that
so
so
now.
This
is.
This
is
what's
happening
under
the
hood
when
a
gateway
or
your
browser,
if
it's
ipfs
enabled
that's
what
it's
doing
when
it's
loading
the
html
page.
C
B
C
B
B
I
they
could
be
variants,
I'm
not
sure
that
they
are
like.
This
is
part
of
the
unix
of
speak.
I
think
no,
no.
I
think
this
is
actually
a
a
protobuf
thing
so
that
there
would
be
virus
involved,
but
it's
things
like
it's
properties
of
the
file.
It's
like
permissions
or
attributes
of
the
file,
because
this
is
a
file
we're
dealing
with.
B
A
B
B
B
Is
it
three?
I
got
four
different
ways,
four
different
ways
of
fetching
the
same
block
of
this
and
the
same
data.
So
if
you
scroll
down
a
bit
you'll
see
in
my
in
this
code
block
here
yeah.
So
first
of
all,
this
is
a
neat
trick.
I
haven't
shown
explore
and
I
was
wondering
whether
this
should
be
introduced
earlier,
but
it's
it's
using
ipfs.get
with
an
ipns
prefix
which
lets
you
skip
putting
the
cid
and
you
tell
ipfs.
B
B
B
A
B
Actually
this
this
is,
this
is
probably
going
to
be
a
problem,
the
difference
between
ipld
and
ipfs
passing
and
this
whole
slash.
Ipld
thing.
I
don't
think:
we've
got
that
clearly
documented
and
it
was
only
really
formalized
in
like
go
ipfs
version
010.
So
it
was
not
that
long
ago
that
we
formalized
and
said
hey
we're
going
to
make
this.
It's
already
already
sort
of
been
there
we're
going
to
make
it
official.
So
we
don't
really
have
a
doc
for
that.
That
explains
the
difference,
and
maybe
we
should
oh.
A
B
Now,
to
build
to
build
that
path,
I
had
to
go
into
each
of
those
those
those
blocks
and
figure
out
which,
which
you
know
docs
is
the
third
and
codex
is
the
first
and
then
known
as
the
first
and
then
no
not
in
first.
Second,
sorry,
I'm
out
by
one
and
then
dag
pb
is
the
third,
etc,
etc.
And
then,
oh
once
you
get
into
dagp,
I
want
to
get
to
the
index.html.
B
Yeah
yeah,
that's
right,
so
this
is
this
is
using
that
whole
dagp
name
field.
So
when
I
say
slash,
docs
go
ipfs,
says:
okay,
I
found
a
dagp
block,
I'm
gonna
look
for
a
link
named
docs,
but
normally
in
ipld
links,
don't
have
names,
they're
just
links
yeah,
but
in
dag
pb.
We
have
this
formalized
structure
for
this
element
of
the
array
has
a
link,
and
it
has.
It
also
has
a
name.
So
that's
just
a
quirk
of
ipfs
so
same
same
block
same
data
now,
the
next
one.
What
is
the
next
one
doing?
B
Is
so
actually
before
you
run
that
one
go
back
to
your
terminal
and
then
press
up
and
on
the
path
get
rid
of
the
slash
hash
and
then
what
that
will
do
is
shows
us,
the
yep
I'll
actually
get
rid
of
the
head.
The
the
head
c
c
45
thing
to
do
we'll.
Just
look
at
the
output
just
get
rid
of
the
pipe
completely
okay,
so
this
is
the.
B
B
Yeah
ipf's
day
get
and
then
that
provide
that
and
then
pipe
it
to
head
c45
or
you
can
just
just
put
the
output
you'll
see
the
whole
page.
It's
just
gibberish
base64
gibberish,
but
that's
the
next
stage
from
page.
That's
exactly
the
same
as
what
the
other
outputs
have
given
you,
but
you've
navigated,
how
many
levels
into
a
dag?
It's
it's
from
the
root
one,
two,
three
four
five
six
levels:
deep
into
this
dag
to
get
that
page.
Okay,.
C
B
A
B
A
good
reason
there's
a
good
reason.
I
chose
45
because
if
you
run
any
one
of
those
again
and
actually
no
no,
so
you
can't
run
anyone.
You've
got
to
get
the
dart.
The
data
element,
so
you've
got
to
go.
Use
use
one
of
the
commands
that
had
ipld
pathing.
So
you
could
use
that
one
if
you
want
to,
but
you've
got
to
put
flash
ipld
at
the
beginning.
B
B
B
B
C
B
B
B
Was
that's
obviously
an
html
yeah
yeah,
so
we
got
to
the
bytes,
and
this
is
this
is
what
the
gateway
is
doing.
This
is
what
what
a
browser
enabled
with
ipfs
is
doing.
It's
jumping
six
labels,
deep
in
a
dag
finding
that
data
element
decoding
it
the
bytes
and
presenting
it
to
his
html
so
and
but
it's
all
hidden
by
slash
docs,
slash
known
codec,
slash
whatever
it's
all
hidden
behind
that
magic
of
ipfs.
D
B
B
Now
you
want
to
propose
it:
you'll
have
to
you'll,
have
to
yep,
that's
fine
all
right
and
then
create
create
pull
request.
So
you've
just
done
a
fork.
I
think
yeah
you've
done
a
fork,
great
pull
request,
and
I-
and
I
I'd
suggest
this
in
the
tutorials.
In
fact,
I
and
you
can
encourage
people
who
are
doing
this
to
do
this,
just
make
it
clear
and
they
pull
rest,
of
course
not
to
merge,
and
it's
like
yeah.
I
can
close
it
because
I've
got
one
of
these
pull
requests
up
as
well.
B
A
B
So
yeah
it's
a
good
question.
I
was
asking
eric
for
permission
yesterday.
Apparently,
we've
got
to
ask,
I
don't
know
whoever
our
enabling
overlords
are
in
in
the
what
is
it
called?
I
don't
know
whatever
the
organization
organization
that
handles
infrared
stuff.
So
apparently,
apparently
we
have
an
organizational
level
fleek
account.
So
you
you
log
into
the
fleet,
account
and
then
you
add
the
repo
and
then
fleek
takes
care
of
setting
it
all
up
for
you.
You.
B
Like
that
yeah
yeah,
you
need
to
give
a
permission,
but
then
you
need
to
tell
it
things
like
what
is
the
build
command
and
what's
where's
the
output,
because
this
repo
has
a-
and
I
don't
know
I
haven't-
seen
those
settings
because
I
couldn't
get
access
to
it
yet,
but
there's
a
make
file
in
here
right.
There
there's
a
make
file,
it's
like
make
it
just
make
and
it
make
installs
and
builds
the
whole
lot.
B
B
B
B
So
that's
that's
kind
of
interesting,
but
the
more
interesting
thing
is
the
next
one.
So
if
you
go
back
just
hover
your
mouse
over
the
next
one
hold
your
mouse,
you
can
see
see
that
url
that
showed
up
now
go
in
details
on
details.
Hover
your
mouse
now
look
down
the
bottom
of
your
browser.
Oh
that's!
Fine!
We've
gone
to
it
now,
so
it
has
built
the
site
and
it's
published
it
on
a
sub
domain
of
fleek.com.
B
B
Now
we
notice
the
difference
already.
This
is
a
cidv1,
because
it's
baffy
blah
blah
and
the
other
ones
were
all
cid
v0
which
were
qm
the
reason
for
that
it
in
functionally.
It
doesn't
matter
that
we
can
treat
them
the
same
for
what
we're
doing,
but
the
reason
that
we're
given
a
cid
v1
here
is
because
you
can't
use
because
it's
case
insensitive
urls
are
case.
Insensitive
and
cidv0
is
case
sensitive.
So
that's.
B
Why
that's
why
it
gives
you
a
cidv1
which
is
fine,
so
you
can
copy
that
url
sorry
copy
that
that
that
copy
that
that's
the
id
and
we
can
go
back
to
our
terminal,
because
now
they've
they've
helpfully
published
it
to
the
dht,
so
they've
pinned
it
wherever
they're
pinning
it
you
could
go
into
the
ipfs
explorer.
You
could
do
it
on
the
command
line.
You
can
do
whatever
you
want.
So
in
that
terminal,
where
you
were
running
ipfs.
B
B
B
Let's
ignore
that
for
now,
because
this
is
this
is
ipfs
network
issues
so,
but
you
could
figure
out
where
that
cid
is
is
located,
but
you
want
to
do
ipfs,
dag
get
on
so
so
yeah
so
to
go
back
there
and
just
do
ipfs,
dag
get
and
then
just
just
give
it
that's
the
idea.
You
have
to
do
that
and
and
it's
just
it's
the
same
thing
again
you
pipe
to
jq
it's
a
it
is
the
top
level
of
that
site.
B
B
You
got
to
do
that.
You
have
to
do
docs
because
you're
already
one
level
deep
into
docs.
Now
you
need
to
go
another
level
deep
into
testing.
Now,
there's
an
index.html.
This
is
this
is
the
site
site
builder,
even
though
you
made
a
testing
m.m.d
it'll
make
a
directory
and
then
put
a
file
in
it.
So
now
you've
got
one
more
level,
so.
C
B
C
B
B
C
B
C
B
B
C
B
B
C
B
A
B
Now,
if
you
scroll
up
now
there
you
go
lindsey
test
page,
it
says
right.
There,
you've
got
your
content
and
right
at
the
bottom
of
it,
and
your
header
at
the
top
will
have
your
yeah.
So
lindsay
says
page
hello!
Well
done
so
you
it's
built
a
page
for
you
and
you've,
just
navigated
to
it
with
ipld
parting.
B
And
it's
not
published,
it's
like
ipld.io
is
left
unmolested
now.
The
other
part
of
is
beyond
that.
What
I
there's
a
bit
down
the
bottom,
where
it
talks
about
how
this
is
that
snapshot
thing
where
we've
made
a
new
snapshot
of
the
website,
and
this
we've
now
got
two
different
routes.
You've
got
your
new
one,
we've
got
the
old
one
and
they
refer
to
different
dags,
but
there's
a
lot
of
overlap
in
the
dag.
B
So
the
dags
don't
overlap
as
much
as
I'd
like
them
to
so
every
every
cid
in
the
path
you've
just
navigated,
is
going
to
be
different
to
the
old
one.
You
navigated,
because
of
this
reason,
indicate
in
the
case
that
we
didn't
have
that
cache
busting
thing
the
parts,
the
subsets
of
the
site,
all
of
the
whole
graph
that
we
didn't
touch.
They
would
still
have
the
same
cids.
B
A
B
Yeah,
exactly
that's
exactly
that.
There
is
a
way
to
demonstrate
that,
and
I
so
you
use
section
11
to
explain
how
that's
annoying
for
this
site,
because
it's
a
whole
new
whole
new,
dag,
but
actually
in
the
bottom
of
section
11.
You
can
look
at
a
a
image
in
the
on
the
site
and
I've
got
an
example
there
of
there's
an
there's,
a
particular
image,
that's
sort
of
deep
down
in
this
in
the
side
that
doesn't
change
between
the
two
versions
that
you've
got.
B
B
So
let's
say
that's
the
old
route,
the
current
one!
It's
not
quite
that
it's
good
enough,
so
the
qm
2k
2tk
that
that
that's
let's
say
that's
the
cid
for
ipl
to
I
o
as
it's
published.
Now,
let's
just
say
that
that
it's
not
quite
because
we
know
it's
changed
overnight
since
I
wrote
this
this
little
tutorial,
but
that's
the
published
one
and
you
can
see
in
your
list
of
files
here
that
the
wonder
with
the
png
content,
addressable
archives.png,
take
note
of
that
cid.
Just
look
at
the
last
few
characters
of
it.
B
B
A
B
Exactly
and
which
means
that
we've
de-duplicated
the
images.
So
even
though
we've
published
a
whole
new
dag,
we
haven't
published
whole
new
versions
of
the
images,
so
there
it
is
y7s
it's
exactly
the
same
block
on
on
ipfs,
so
we've
made
a
whole
new
dag,
but
we've
de-duplicated
all
of
the
images
because
we
didn't
change
any
of
them.
So
we
haven't
wasted
storage
space
with
just
every
pull
request,
just
copies
all
the
images.
No
because
I
ipfs
says
no,
I
already
know
that's
the
id,
so
I'm
not
going
to
republish
it.
I've
already
got
it.
B
A
B
Perhaps
yeah
being
out
explainers
will
be
fantastic
because
I
think
this
is
this
gets
to
the
power
of
ipld,
but
also
ipfs,
because
this
right
here
we
haven't
wasted
space
with
images
they're
the
biggest
resource
on
this
site,
but
yeah
they
haven't.
Most
of
these
images
haven't
changed
since
we
launched
this
new
site
and
so
we're
still
using
the
same
cids
from
the
beginning,
yeah.