►
From YouTube: Jeromy Coffee Talks - Files API
Description
Jeromy talks about the files api coming ipfs@0.4.0
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
Oh,
this
is
the
second
episode
we're
doing
of
like
I,
PFS
and
coffee,
where
I'm
going
to
sit
here
and
make
coffee
and
talk
about
something.
A
few
vest
related
this
week,
I'm
going
to
talk
about
the
files
API
and
more
like
past,
that,
like
the
NFS
implementation
and
file
system
in
general,
also
I'm
going
to
be
making
coffee
and
what's
called,
connects
it's
a
type
of
for
over
device.
A
If
anybody's
ever
used
those
it's
pretty
good,
it's
what
I
do
pretty
much
every
day
for
coffee,
I
have
water
boiling
and
I
already
grabbed
some
beans.
So,
while
that's
happening,
I
will
start
talking
about
what
the
file
API
is.
So
in
Dubbo
40.
We
have
this
new
thing
called
I
PFS
files
command,
you
can
type
and
it
provides
a
lot
of
unix-like
commands
to
you.
A
So
you
can
do
move
copy,
read,
write
files
make
their
nls
and
it
deals
in
I
PFS
like
objects,
but
it
abstracts
a
lot
of
V
like
busywork
away
from
you
of
dealing
with
hashes
and
worrying
about
like
updating
chains.
So
if
I
change
a
file,
I
also
have
to
update
its
directory
in
the
directory
about
it
and
above
that
and
the
files
AP
guy,
just
abstracts
all
that
way
for
you
and
it
just
does
it.
So
it's
really
cool
it's
also
moderately
fast.
A
A
You
know,
there's
a
lot
of
opportunity
to
see,
can
write
multiple
files
under
directory
and
then
only
have
to
sync
up
once
which
results
in
only
hashing.
You
know
the
trio
once
instead
of
twice
saves
us
a
lot
of
time.
So
there's
lots
of
opportunities
for
different
applications
to
be
built
on
this.
The
one.
B
A
A
It's
really
ugly,
because
I
have
no
design
skills
whatsoever,
I'm
pretty
sure
it's
black
white
and
gray,
and
but
it's
the
cool
thing
about
it,
is
that
you're
able
to
like
in
the
web
browser
be
able
to
click
your
files
you're
able
to
drag
files
into
it,
add
them
to
it
able
to
drag
directories
into
it.
Navigate
through
directories.
A
A
This
file
system
space
and
the
file
system
space
is
like
agnostic
and
then
you
can
mount
I
PFS
things
into
us
like
I,
say
mount
this
I
PFS
hash
onto
a
path
in
this
file
system,
and
then
you
can
CD
into
it,
and
then
you
be
in
I
PFS.
You
can
also
you
could
also
then
mountain
I,
pns
hash
into
the
filesystem
at
some
point,
and
then
you
could
CD
into
it
and
change
files
there.
A
It
would
automatically
note
of
that
I
pns
entry
and
then
you
could
do
things
like
Mount
like
even
make
pipes
was
the
really
cool
thing
I
wanted.
So
you
can
come
make
pipe
in
your
file
system
and
it
would
produce
a
hash
and
anybody
else
who
was
able
to
cat
that
hash
or
write
to
that
hash,
communicate
with
the
same
people.
So
if
I
counted
the
hash
and
David
wrote
to
the
hash,
then
I
would
see
his
dick
data
over
the
network
seamlessly
and
that's
one
of
the
ideas.
A
A
A
Maybe
yeah
that'll
do
so
the
beans
are
in
there.
The
first
thing
you
do
is
actually
like
very
important
part.
Is
you
get
them
just
a
little
bit
wet
and
then,
if
you
probably
want
to
see
it
because
my
you
know,
webcam
is
pretty
bad,
but
the
beans
will
start
to
like
like
puff
up
and
rise
and
stuff,
and
it's
called
a
bloom,
and
this
is
like
all
the
co2
in
the
beans
like
leaving
and
it
has
the
effect
of
kind
of
making
it
all
expand.
A
A
So
I
don't
know
what
it's
really
called
chemex
and
then
once
it
hits
the
top
I
just
pour
slowly
into
the
middle
until
I've
poured
my
water
through,
and
this
makes
about
three
cups
like
not
like
cups,
the
measuring
cups
but
free,
like
cups,
how
much
I,
drink
cups
of
coffee
and
pretty
quick,
easy
to
clean
up
all
you
do
is
take
this
little
paper
filter
right
here
and
toss
it.
Then
it's
pretty
much
clean.
A
Building
these
paths
through
all
these
different
transports
and
pads
and
file
systems
go
hand
in
hand.
So
if
you
build
that
type
of
thing
that
wants
thinking
of
into
a
file
system
you're
going
to
get
a
lot
of
really
interesting
things
and
honestly
it's
something
I
don't
even
know
to
expect
once
we
get
there,
it's
just
kind
of
so
abstract
and
out
there,
but
it's
also
very
close
and
attainable.
It's
just
going
to
take
probably
another
few
months
of
churning
through
work
to
get
it.
Something
like
that
working.
A
A
And
then
every
single
user
can
open
up
the
registry
mere
program
run
there
I
PFS
Damon,
and
then
it
will
you'll
be
able
to
install
packages
from
your
local
Damon
all
the
way,
oh
three
ifs
and
all
three
I
PFS
files,
ap
I,
feel
like
David,
really
wants
to
say
something
right
now,
because
I'm
probably
watching
this.
Did
you
want
to
like.
B
B
Like
note
that
and
are
above
in
the
chain
which
I'm
we
change
the
file
in
the
subdirectory
and
will
we
have
or
every
thought
about
something
like
a
hook
where
we
can
say
each
time,
this
directory
changes,
because
there
is
some
file,
a
data
file
changes,
and
you
need
just
update
this
I
p
NS
record
directly,
so
that
we
don't
have
to
like
force
a
MF
s
to
flush
in
order
to
appetite
that
I
Dennis.
So.
A
That
was
actually
that
exact
functionality
was
in
the
earlier
versions
of
the
files
API
that
I
had
written.
We
took
a
lot
of
that
out
because
it
was
one
PR
and
it
was
massive
and
one
and
I
we're
trying
to
figure
out
what
this
should
look
like
for
the
first
iteration,
so
that
behavior
is
like
definitely
planned
and
it's
definitely
something
that's
going
to
be
there.
So
we
just
got
to
get
around
implementing
it,
put
it
in
the
queue
of
things
to
do
and
hope
it
gets
the
top
quickly.
But
yeah.
A
That's
like
other
way
ahead.
It
was
you
could
mount
so
that
there
was
like
an
IP
FS
back.
Then
it
was
called
NFS
mount
and
that
would
accept
a
it
except
a
couple
arguments.
One
of
them
was
like
the
thing
you're
mounting,
and
one
of
them
was
a
publish
command,
and
so
that's
a
shell
command
that
gets
called
when
when
that
node
needs
to
be
updated.
So
when
you
know,
when
all
the
changes
below
it
bubble
up
to
that
node
the
command
that
you
specify
their
what
was
called
and
then
it
would
do
things.
A
So
you
know
for
I
pns,
you
would
mount
the
IP
NS
thing
and
then
the
update
command
would
be
I.
Pfs
named
publish
the
hash
and
in
other
cases
you
could
just
write
it
to
it.
You
know
right
it
to
your
database
or
you
could
you
know
message
somebody
because
of
it,
and
so
there's
a
lot
of
lot
of
really
cool
applications
you
get
when
you
allow
that
to
be
really
generic.
B
Really
cool,
so
what
other
questions
bring
into
the
discussion?
Is
that,
like
we
have
been
like
posting
here
and
there
about
like
changing
like
removing
cat
and
that
from
my
cassock
or
comment
and
I
just
using
the
files?
One
so
I,
always
using
I
PFS
files
care
because
miles
ads
and
make
those
the
primary
captain
f?
But
that
also
like
that
definitely
gives
users
something
way
more
familiar
than
what
I
with
what
they
I
used
with
normal
file
systems,
but
also
means
that,
like
everyone,
will
start
creating
directories
inside
the
IFS
repos.
B
A
So
one
thing
I
was
thinking
of
similar
lines
like
I,
don't
know
if
we
should
take
IPS,
add
and
cat
out
of,
like
the
main,
you
know
main
command,
but
it's
like
similar
vein.
What
I'm
thinking
when
you
run
I
give
us
add
in
it.
Does
you
know
it
pins
afterwards
right,
but
everybody
always
loses
track
of
the
things
that
they
end.
So
my
idea
is:
every
time
you
add
it
can
okay,
this
isn't
my
idea.
Somebody
in
IRC
mentioned
this
and
brought
it
up.
I
mean
I.
Thought
was
a
great
idea.
A
Every
time
you
add
it
takes
the
name,
the
name
of
the
file
that
you
added
and
maybe
the
date
or
something
then
writes
that
as
entry
into
the
files
API,
so
the
files
API
you
have
like
/
pins,
/,
the
name
of
the
file
date
or
whatever,
and
that
way
it's
really
easy.
Just
to
look
in
there
and
remember:
oh
here,
all
the
things
I
added
I
think
that's
going
to
be
a
great
thing
to
have,
because
that
kind
of
solves
our
long-standing
problem
of
what
the
hell
did.
A
B
Yep
and
then
also
make
a
lot
of
things
easier,
first
of
all,
for
WI
or
station
to
have
the
way
something
where
added
the
network
and
therefore
end-users
will
be
just
like
written
I
can
all
understand
what
they
have
had
attractive
s
note.
They
will
be
able
to
delete
it,
they're,
actually
right,
because
and
being
something
that
you
don't
remember
that
you
pin
it
also
purple
yeah.
A
B
A
So
what
we'd
have
to
do
there
is
we
could
make
delete
like
you
know,
in
the
web
UI
we
could
make
delete
actually
unpin
and
like
delete
those
blocks,
but
we
would
also
have
to
check
to
make
sure
it
wasn't
pinned
by
anything
else.
Otherwise,
you
know
we're
breaking
things
so
like
we
can
say,
delete
and
then,
if
it
removes
that
pin
and
then
tries
to
then
should
check
the
pin,
set
and
say:
hey.
Is
this
pendant
through
anything
else?
A
And
if
it
is,
then
we,
you
know,
give
an
error
to
the
user
and
if
not,
then
we
can
wipe
those
blocks
from
the
block
store,
which
I
think
actually
wiping
blocks
like
that
is
going
to
be
a
good
thing
kind
of
gives
users
a
little
more
feel
for
things
happen,
what
I
want
them
to
so
yeah
files.
Api
is
pretty
cool,
pretty
happy
with
it.
I
know,
David
is
too,
and
you
guys
have
any
other
questions
about
that.
I.
B
Don't
know
if
any
at
the
moment,
though,
or
anything
that
I'm
up
I'm
not
like
remembering
anything
that
you
might
have
missed,
that
will
be
good
to
bring
up
to
discussion
so
yeah
I
think,
like
that's
the
way
I
can
how's.
The
p.I
is
like
one
of
the
things
it
enables
a
lot
of
use
cases
and
actually
like
working
backwards,
is
and
I
like
simple
and
makes
a
lot
of
sense,
Express
and
hit
I
guess
I
clean
for
my
diction
is
very
complicated,
though,
like
all
the
story
but
mobile
homes.
A
Yeah,
the
other
thing,
that's
kind
of
kind
of
related
that
I've
been
wanting
to
do
is
I
wrote
some
code
for
thing
called
I
PFS
pipe
a
while
back
and
I
PFS
pipe
would
basically
just
a
wrapper
around
our
network
layer.
So
you
could
listen
in
on
like
a
service
name
and
then
you
could
dial
up
here
at
a
service
name
through
the
CLI
and
I
never
got
around
to
finishing
it,
because
our
commands
library
had
a
few
limitations
around
that.
A
But
there's
a
PR
somewhat
recently
to
actually
fix
that
and
it
looks
like
it
works.
So
I
want
to
be
able
to
get
that
type
of
functionality
worked
in.
So
you
can
like
create
a
pipe
and
then
have
other
people
connect
to
it,
because
I
want
to
be
able
to
take
that
and
move
it
into
a
file
system
interface
and
how
maybe,
even
once
we
get
pub/sub
which
that's
coming
it's
going
to
happen
once
we
get
pub/sub,
you
could
have
a
pipe
that
just
printed
out
everything
for
pubs
up.
A
B
A
There
are
a
couple
small
ish
things
that
I
want
to
get
done
before
shipping
040,
the
first
of
which
that
I
can
remember
off
the
top
of
my
head
is
when
we
add
a
file,
we
use
a
particular
chunking
scheme
so,
like
we
use
a
certain
layout
in
a
certain
block,
trunking
algorithm
I
want
to
take
that
information
and
write
it
to
the
root
block
of
the
created
file
so
that
in
the
future
you
can
use
that
information
to
recreate
the
exact
same
day,
because
you
know
in
the
future.
Maybe
we
changed
some
default.
A
Jumping
schemes
and
Yuri
add
a
file.
It's
gonna
give
you
different
passion,
that's
weird,
but
if
we
write
the
exact
parameters
used
into
the
file,
then
we'll
be
able
to
recreate
it
exactly,
and
you
know,
provides
a
lot
of
cooler
guarantees.
I
really
important
for
us
to
give
because
it
changes
the
file,
format
and
I
want
that
to
be
in
0
for
0,
because
that's
kind
of
like
almost
a
breaking
change,
but
it
doesn't
break
anything.
It
just
changes
the
hash
values
of
things.
So
that's
one
of
the
things
on
my
list.