►
From YouTube: IPFS Fetch - Mauve
Description
Software consultant with a focus on local-first tech and creator of js-ipfs-fetch, Mauve, joins our November meetup to talk about the design decisions behind the CLI command, as well as share a nifty demo.
For more information on IPFS
- visit the project website: https://ipfs.io
- or follow IPFS on Twitter: https://twitter.com/IPFS
Sign up to get IPFS news, including releases, ecosystem updates, and community announcements in your inbox, each Tuesday: http://eepurl.com/gL2Pi5
A
I'm
move
nice
to
meet
everyone,
and
today
I'm
going
to
be
talking
about
ipfs
fetch.
Specifically,
I
want
to
look
at
how
I've
combined
some
of
the
usual
webby
interfaces,
we're
used
to
with
some
of
these
cool
peer-to-peer
interfaces
we're
used
to
in
ipfs.
A
So
there's
my
intro
stuff,
that's
for
it
later.
I
wanted
to
talk
about
how
the
web
is
good.
I
really
love
the
web.
I
think
it's.
A
It
really
kind
of
changed
me
as
a
developer
years
ago,
when
I
started
using
web
tech
migrating
from
crazy
stuff
like
java
and
c
plus
plus,
and
it
was
just
so
much
easier.
I
could
just
slap
together
a
text
file
put
some
html
on
a
page,
put
a
little
javascript
and
jquery
stuff
together
just
to
make
something
work
and
then
suddenly
everything
worked
cross-platform.
I
didn't
have
to
worry
about
like
sending
people
executables
worrying,
about
which
platform
they're
on
and
making
sure
everything
actually
displayed
properly.
A
However,
the
web,
as
it
is
right
now,
is
also
tied
with
something
that
I
think
is
not
as
cool
and
that's
servers.
I
think
servers
are
bad
on
one
hand.
They
enabled
us
to
build
up
these
networks
of
sharing
information,
but,
on
the
other
hand,
as
an
individual,
a
server
is
a
barrier
to
entry.
It
requires
more
expertise
in
order
to
get
anything
started.
A
For
instance,
you
either
need
to
like
have
your
own
machine
running
locally
or
have
some
sort
of
virtual
machine,
and
then
you
need
to
think
about
like
what
kind
of
web
servers
you're
going
to
host
and
all
of
this
stuff,
especially
with
the
with
servers
and
the
web.
Everything
is
kind
of
hinging
around
these
servers.
If
I
made
some
sort
of
cool
like
blog-
and
I
want
to
share
it
with
my
friends,
I
have
to
go
through
a
server
if
that
server
goes
offline.
A
Suddenly,
my
friends
can't
access
it
or
if
say
somebody
doesn't
have
internet
or
can't
afford
a
fancy
internet
connection
or
say
you
know,
twitter
goes
down
again.
Suddenly,
all
of
that
data
is
gone.
It's
kind
of
a
pain
and
I
feel
like
it's
holding
people
back
from
the
stuff
that
they
can
create.
A
So
one
thing,
that's
kind
of
been
popping
up:
lately
is
third-party
services
that
offer
hosting
for
a
small
fee.
So,
instead
of
me
having
to
like
set
up
my
own
server
and
configure
it
and
make
sure
everything
is
online,
I
can
pay
money
or
pay
data
to
some
third
party
and
then
they'll
kind
of
do
everything
for
me,
which
is
great
except
then
the
thing
isn't
really
totally
mine.
If
say
it's
a
google
product,
it'll,
probably
you
know,
die
within
a
few
months
or
get
deprecated
later
on
or
say.
A
If
it's
any
other
tech
thing
it
might
just
change
under
my
feet
or
run
out
of
business
and
suddenly
any
sort
of
community.
I
built
anything
that
I
did
with.
That
is
just
gone
because
it's
too
hard
for
me
to
set
up
it'd
be
nice.
If
none
of
this
stuff
was
a
problem
like
I
want
the
web
without
all
of
these
servers
and
all
of
this
extra
crust.
A
So
with
that
in
mind,
I
think
peer-to-peer
is
kind
of
the
thing
that
changes
everything.
So
obviously
this
is
an
ipfs
meetup,
so
I
think
most
people
are
comfortable
with
peer-to-peer,
but
just
to
reiterate
with
the
server
situation,
everyone
connects
to
this
one
central
source
with
peer-to-peer
people
connect
directly
to
each
other.
A
So
if
I
want
to
make
a
blog,
I
can
send
a
link
to
a
friend
and
then
they
can
download
that
blog
directly
from
me
and
then,
if
a
third
person
wants
to
view
my
blog,
then
they
can
download
it
directly.
For
me
and
my
friends
and
anyone
else
that
has
a
copy
and
what's
cool
is
I
didn't
need
to
set
up
a
server,
hopefully
to
get
this
running.
A
Centralized
server
based
apps
can
do
these
use
cases,
but
it's
a
lot
harder,
whereas
when
you
build
on
peer-to-peer
first,
it's
only
way
easier.
So
what
is
peer-to-peer
and
the
web
combined
good?
What
would
that
even
look
like,
for
instance,
right
now?
Let's
think
about
like
how
people
actually
interact
with
the
web
on
a
slightly
lower
level.
A
So
the
web
right
now
is
made
on
http,
which
is
a
protocol
that
servers
speak.
It
uses
urls,
so
links
to
to
resources.
It
uses
http
methods,
which
is
like
phrases
that
you're
saying
to
the
server.
For
instance,
I
want
to
get
some
data.
I
want
to
post
some
data
to
the
server.
I
want
to
delete
this
data
different
kind
of
actions
that
you
want
the
server
to
do
for
a
given
url
and
then
normally
how
we
interact
with
this.
A
Is
we
load
a
web
page
or
we
load
a
video
or
we
load
some
javascript
in
a
web
page?
That
does
something
interesting
developers.
These
days
use
an
interface
called
fetch.
So
if
you
have
some
sort
of
fancy
react
app,
it's
a
pretty
good
chance
that
somewhere,
underneath
that
stack,
there's
a
call
to
this
fetch
api
in
the
browser.
A
So
with
that
in
mind,
I
want
to
propose
what
a
peer-to-peer
web
might
look
like.
So
what?
If
the
same
way,
we
could
get
data
from
http
we
could
get
data
from
ipfs
or
ipns.
For
instance,
I
take
an
ipfs
link
with
a
hash.
I
shove
it
in
my
browser
or
I
shove
it
in
my
application,
and
then
it
can
load
the
data.
Similarly,
I
wanted
to
resolve
mutable
data
through
ipns
automatically
and
that's
actually
something
we
kind
of
have
already
via
stuff,
like
ipfs,
companion
and
various
gateways
and
integrations
into
apps.
A
So
kind
of
the
new
thing
I
want
to
introduce
here
is
the
idea
of
posting
to
ipfs.
So
right
now,
if
you
want
to
add
stuff
to
ipfs,
you
need
to
use
one
of
these
apis.
You
either
need
to
talk
to
some
sort
of
http
server
again
through
an
interface
or
you
need
to
use
a
pure
javascript
implementation
or
you're,
using
a
go
library
or
rust
or
whatever
else.
They
all
have
these,
like
their
own
way
of
speaking
to
ipfs
with
the
web.
A
A
It
lets
you
take
a
name
of
some
sort
of
key
that
you
own
and
then
it
lets
you
publish
those
together
and
gives
you
a
special
ipns
url,
which
is
kind
of
like
an
ipfs
url
that
can
change
over
time.
So
I
think
these
tools
are
fairly
accessible
and
in
fact,
what
I've
done
is
I've
integrated
it
into
a
web
browser
called
aggregor.
A
So,
in
fact,
that's
what
I'm
using
to
load
this
presentation
right
now,
I'm
not
loading
the
presentation
from
ipfs,
so
I'm
cheating
a
little
bit,
but
I
could
so.
My
idea
is
what,
if
we
can
take
all
of
these
different
peer-to-peer
protocols,
for
instance
the
hypercore
protocol,
which
I'm
using
to
load
my
slides,
ipfs
and
ipns
for
storing
data,
maybe
ethereum
in
the
mix
for
interacting
with
blockchains
what
we
can?
A
A
A
A
There,
let's
request
my
vlog,
because
it's
less.
A
A
So
we've
made
a
request.
We
see
this
time,
it
didn't
fail,
which
is
great
and
what
we
can
do
is
actually
get
the
contents
of
my
blog's
homepage.
So
we've
just
got
an
html
string
with
a
bunch
of
junk
doesn't
matter
so
now
that's
cool!
How
do
we
translate
that
to
ipfs
so
right
now,
if
I
want
to
use
ipfs,
I
need
to
import
a
bunch
of
libraries,
even
though
they're
really
great
and
it's
been
a
joy
to
work
with
them,
but
it's
like
a
new
thing
to
learn
as
a
web
developer.
A
What
if,
instead
of
importing
jsi
pfs
or
some
native
library,
I
can
just
fetch
directly
from
ipns,
say
I
want
to
get
the
ipn
ipfs
homepage.
So
again,
I
do
the
request.
It
will
take
a
little
bit
longer
to
load
because
my
cache
isn't
hot
if
that
makes
sense.
But
subsequent
requests
are
a
lot
faster
so
that
first
delay
there.
It
was
fetching
data
from
ipfs
onto
my
browser
and
then
just
now
it
was
serving
it
from
cache,
and
so
it
should
be
available
offline.
A
The
exact
same
way
that
you
would
with
with
http,
and
it's
the
exact
same
thing
that
you
would
use
with
images
or
videos
or
whatever
else,
instead
of
having
to
have
a
special
plugin
to
load,
something
from
say
a
gateway
or
loading
in
memory
or
doing
something
crazy
like
what
webtorrent
does,
where
it
downloads
chunks
on
the
flies
and
builds
up
a
video
stream
in
javascript
whoa,
we
can
just
paste
the
link
in
the
exact
same
way
that
we're
used
to
with
regular
web
apps.
A
So
next
I'm
going
to
showcase
the
super
difficult
challenge
of
getting
stuff
onto
ipfs,
which
is
going
to
be
really
hard,
many
lines
of
code.
All
we
got
to
do
is
again.
We
do
a
fetch
request
and
this
time
we're
going
to
say
ipfs
and
what,
since
we
want
to
upload
a
file
to
ipfs,
we
don't
actually
have
a
domain
name
that
we're
uploading
it
to
we're
just
going
to
say.
A
Ipfs
colon
slash
and
then
add
a
new
slash
and
say
index.html
and
then
we're
going
to
say
that
the
http
method
we're
using
is
post
the
default
was
get
because
this
time
we
want
to
upload
some
data
and
we're
going
to
say
that
the
body
is
some
html.
A
A
I
look
at
the
response
from
the
ipfs
protocol
and
here
I
have
a
regular
old
ipfs
url,
so
this
might
be
a
little
bit
different
from
what
you're
used
to
in
terms
of
urls
because
it
doesn't
start
with
qm.
A
That's
because
we
have
to
use
a
different
encoding
for
web
pages
because
they're
case
insensitive,
whereas
the
default
ipfs
multi-hash
encoding
is
case
sensitive.
So
now
that
we
have
this
url,
what
if
we
want
to
update
our
mutable
ips
url?
So
similarly,
we'll
do
another
fetch
request
and
this
time
we're
going
to
do
a
publish
request
on
ips.
A
So
in
ipfs
fetch
you
can
just
make
up
whatever
you
want
for
your
ipfs,
sorry,
ipns
name.
This
will
generate
a
secret
key
under
the
hood,
for
that
name
and
it'll
generate
an
ipns
url
for
you.
So
this
is
useful
as
an
application
developer,
because
you
don't
have
to
manage
keys
yourself.
You
just
make
up
a
name
and
then
the
protocol
handler
does
it
for
you.
So
let's
call
it
my
blog
and
then
we'll
say,
method,
publish
and
the
body
will
be
our
ipfs
url
that
we
just
created
so
we're
gonna.
A
Do
that
wait
for
a
bit
and
then
we
can
see
our
new
ipns
url
by
looking
at
the
response
whoa.
So
that's
a
live
demo.
I'm
not
going
to
push
my
luck
to
go
further,
but
you
can
see
that,
with
this
interface,
the
same
stuff
that
web
developers
are
used
to
using
for
getting
data
from
http,
we
can
do
with
ipfs
and
uploading
and
loading
data
is
super
simple
and
it's
using
the
exact
same
web
metaphor
that
we
have
for
all
other
files
in
web
apps.
A
Some
of
the
things
they've
been
seeing
a
lot
in
the
hypercore
community
is
webs
web
apps
that
kind
of
modify
themselves
or
create
themselves
by
kind
of
writing
to
their
own
data,
and
I
think,
it'd
be
really
cool
to
see
more
stuff
with
ipfs.
That
does
similar
things
like
say,
a
blog
publishing
platform
which
doesn't
send
anything
to
a
server
which
doesn't
touch
any
extras
file
system.
It's
just
a
web
app.