►
From YouTube: This Month in IPFS - Feb 2023
Description
Join Daniel, Developer Advocate and guests from the IPFS ecosystem for This Month in IPFS, which will be streamed to YouTube and IPFS Twitter.
Timestamps:
00:00:24 - Welcome
00:02:05 - Alex joins
00:43:34 - David joins
In February’s episode, we’ll have two guests:
- **David Aronchick, Compute over Data Lead, will join us to discuss the [Bacalhau](https://www.bacalhau.org/) project**
- **Alex Potsides, IPFS Steward and Helia lead, will join to give us a sneak peek into [Helia](https://github.com/ipfs/helia), the new IPFS implementation in TS/JS**
The live stream will cover a wide range of topics related to IPFS, including live coding sessions, demos, guest interviews with IPFS contributors and developers, and updates on the latest developments in the IPFS community and working groups.
There will also be a Q&A session, so come with all your IPFS questions!
A
Welcome
to
this
month
in
ipfs,
our
February
edition
of
this
live
stream
drop
us
a
line.
Let
us
know
where
you're
joining
us
from.
We
can
see
it
all
in
the
chat
and
yeah.
Today
we
have
two
great
guests
who
are
going
to
join
us
to
talk
about
some
interesting
stuff
and
developments
that
are
happening
in
the
ipfs
ecosystem,
and
specifically,
we
have
David
Aaron
chick
who's,
leading
the
compute
over
data
initiative
at
PL
and
he's
going
to
join,
to
talk
about
the
bakalao
project.
A
I
hope
I'm,
not
mispronouncing,
that
it
is
a
Portuguese
word,
so
forgive
me
and
we
also
have
Alex
possides
who's.
The
lead
for
Helia
he's
also
done
a
lot
of
work
on
JS
lip
P2P
and
JS.
Ipfs
Helia
is
a
sort
of
the
new
Reincarnation
of
the
ipfs
implementation
in
JavaScript,
so
hello,
Alejandro.
Thank
you
for
joining
it's
good
to
have
you,
and
so
with
that.
A
A
So
you've
been
hard
at
work
on
Helia,
which
we
announced
already
last
year.
I
remember
I,
think
it
was
around
November
last
year
that
we
published
the
state
of
ipfs
in
Js
and
tell
us
a
little
bit
about
like
Helia
I
know
you
have
a
presentation
prepared
but
like
tell
us
a
little
bit
about
your
work
in
ipfs
land
and
specifically
in
the
JS
ecosystem.
B
Yeah
so
I'm
I
work
for
PL
I'm
on
the
East,
the
IP
stewards
team
and
I.
Look
after
most
of
the
most
of
the
JavaScript
stack
I
think
would
be
fair
to
say,
and
so
the
work
with
Helio
is
to
attempt
to
kind
of
play,
applies
and
learnings
that
we've
had
for
the
past
few
years
on
jsavia,
first
to
a
new
implementation
that
will
be,
you
know,
make
you
stronger
faster
and
more
productive.
A
All
the
demos
and
also
quick
reminder
that
we
have
a
raffle
going
on
all
you
need
to
do
in
order
to
participate,
is
go
to
the
community
calendar.
The
ipfs
community
calendar
I'll
drop
a
link
to
that
right
now
and
you
need
to
click
on
the
Subscribe
button.
Once
you
subscribe,
then
you'll
join
the
raffle
all
right,
and
now
we
have
Alex's
presentation.
So
with
that.
A
A
A
B
A
B
B
B
Taylor
is
a
new
implementation
of
ipfs
all
done
in
JavaScript.
It
needs
to
be
lightweight
and
it's
yeah,
it's
going
to
be
lovely.
It's
going
to
be
very
minimal.
It's
going
to
get
out
of
your
way
it's
going
to.
Let
you
extend
it
guys
here.
So
what
is
it
through
this?
It's
so
the
API
being
here
is
very
simple.
B
I
mean
most
of
the
things
in
here
are
a
response
to
perceived
deficiencies
in
JS
ipf
first
and
one
of
the
things
people
always
talk
about
is
the
fact
that
it's
big
and
one
of
the
things
that
makes
it
big
is
that
it
has
an
expansive
API,
which
is
very
hard
to
understand.
When
you
first
see
it
there's
lots
of
ways
to
do
lots
of
things,
lots
of
repetition
and
duplication
and
that's
kind
of
that's.
B
You
know
it's
bad
for
users,
it's
bad
for
maintainers,
it's
just
generally
bad,
so
the
idea
with
Helio
is
very
much
to
have
a
minimal
API.
That
gives
you
the
the
very
like
the
smallest
amount
of
stuff
that
you
would
need
to
do
pretty
much
anything,
and
that
is
basically
like
what
I
mean.
What
is
what
is
ipfest
when
it
when
it
comes
down
to
it?
One
of
the
one
of
the
definitions
is
a
way
of
moving
the
blocks
behind
cids
around.
So
you
have
blocks
so
what's
a
block.
B
So
a
block
is,
when
you
add
a
file
to
ipfs,
you
chunk
it
up
into
blocks.
Each
block
has
a
CID
and
a
file
can
be
made
up
of
multiple
blocks.
If
it's
very
big,
so
you
need
somewhere
to
put
that
book.
So
you
need
a
block
store.
So
when
you
import
your
file
and
it
gets
turned
into
chunks,
they
all
go
into
the
blocks
tomorrow.
B
That's
great
because
you
can
put
blocks
in
you
get
a
block
cell.
You
don't
have
the
block,
then
what
well,
then
you
need
to
go
to
the
network
so
the
way
ipfs
fetches
blocks
from
other
pairs
as
bits,
one
so
bit
swap
of
wraps
The
Block
store.
So
if
the
block
that
you're
requesting
isn't
present
in
The
Block
store,
then
bitsop
will
try
to
pull
it
from
the
network
that
involves
sending
your
one
list
or
the
peers
or
doing
a
DHD
query
for
providers
of
the
Cod.
B
But
it's
all
it's
all
transparent
to
the
user.
What
else?
So
you
need
a
data
store.
The
data
store,
holds
application,
specific
data.
So
if
you're
doing
things
like
publishing,
ipns
records
you'll
store
those
ipns
records
in
your
data
store.
If
you
are,
you
know,
if
you're,
if
your
Liberty
to
P
node
is
doing
things
like
persisting
peer
information
or
DHT
records,
all
those
things
need
to
live
somewhere,
so
they
live
in
the
data
store.
So
you
need
a
data
store.
What
else
do
you
need?
B
Well,
you
kind
of
need
pinning,
because
if
your
blog
store
grows
very
large,
maybe
you
want
to
trim
it
a
little
bit.
So
you
need
to
be
able
to
tell
you
which
tags
are
important
and
which
ones
are
not,
and
the
ones
that
aren't
important
will
get
deleted.
So
you
need
pinning
and
garbage
collection
and
then
to
do
all
the
network
stuff,
the
real
magic
of
ipfs
you
need.
B
B
B
B
There's
pull
request
number
36
on
the
Helio
repo,
which
is
linked
to
where
I
did
a
whole
bunch
of
benchmarking
of
performance,
for
it
all
came
about
from
garbage
collection
wanting
to
make
garbage
collection
fast
and
so
part
of
that
those
benchmarks
involve
adding
blocks
and
adding
pins
and
then
all
this
kind
of
stuff.
So
it's
actually
generated
a
bunch
of
secondary
metrics.
B
So
this
is
benchmarking
that
the
pr
of
Helia
against
the
latest
version
of
Kubo-
and
you
can
see
that
because,
because
kilos
block
import
apis
are
basically
one
at
a
time
you
know.
Obviously
you
can
parallelize
by
the
way
Helio's
done
it,
it's
totally
on
its
head
and
it's
allowed
the
implementation
of
The
Block
store
to
control
the
concurrency.
B
B
The
same
thing
with
pins,
so
depending
situation
in
Cuba
is
what
the
one
inches
used
to
be,
which
is
all
pens
are
stored
in
an
enormous
tag
and
every
time
you
change
things
you
have
to
update
this
time,
which
means
that
the
more
pins
you
have
the
longer
it
takes
to
pin
something,
or
at
least
the
longer
it
takes
to
add
that
number
of
pins
and
the
way
healer
is
doing
it
is
the
pins
are
not
related
to
each
other.
So
it's
I
mean
there's.
B
And
then
the
result
of
all
this
is
the
garbage
collection
speed.
So
this
is
like
you
can
see.
I
was
running
this
on
my
laptop
right
and
so
I
was
doing
other
things.
So
the
way
the
lines
are
a
little
wavy,
but
hopefully
the
the
trend
line,
kind
of
makes
it
clear
that
over
time,
this
idea
of
storing
I'm
not
using
a
dag
to
store
pins
instead
healer
uses
reference
counting.
B
A
A
B
And
when
we
remove
a
block
from
The
Block
store,
we
decrement
the
count.
So
if
the
count
is
zero,
then
we
just
say
well,
there's
nothing!
That's
referring
to
this
anymore,
and
so
garbage
collection
just
becomes
a
case
of
looping
over
the
blocks
and
just
saying
do
we
have
a
record
for
for
the
reference
count
for
this
block,
if
not
delete
it,
which
makes
it
much
faster?
Because
you
know
this
is
already
in
JavaScript
as
well,
which
is
typically
not
a
very
CPU
friendly
language.
B
B
A
B
B
So
yeah
what
else
so
Unix
so
we've
got
a
library
shipped,
that
is
the
Unix
versus
implementation
for
Helio.
It
extends
Helia
rather
than
adding
methods
to
it.
But
we'll
see
more
of
that
in
the
demo.
But
you
know
basically
I
think
the
thing
I
want
to
emphasize
is
is
attempts
to
make
it
have
an
ergonomic
API,
so
the
existing
IBS
apis.
B
B
So
people
end
up
doing
things
like
dropping
down
to
the
object,
API
to
like
add
a
file
or
a
folder
to
a
directory
which
it
takes
you
away
from
that
that
file
system,
abstraction
and
suddenly
your
knee-deep
and
dags
and
or
you
know
this
other
stuff
that
you
don't
really
want
to
think
about.
If
you
just
want
to
deal
with
files,
so
the
universe,
API
and
Helio
is
very
much
focused
on
making
you
like
allowing
you
to
use
familiar
constructs.
B
It
will
make
more
sense
in
the
demo
I
think
so.
Mfs
has
one
Roots,
the
ID
that
is
persisted
in
the
data
store
and
all
your,
but
it's
hidden
from
you
and
all
your
operations
are
done
using
string
pods
on
the
dag
that
that
CID
represents,
whereas
this
doesn't
have
that.
So
you
could
actually
like.
So
with
this.
Whenever
you
mutate,
a
dag
by
adding
a
file
or
a
folder
or
something
you'll
get
a
new
CID,
but
there's
the
root
of
that
DAC.
Okay,.
A
So
it's
a
bit
like
persistent
data
structures
that
you
like
immutable,
persistent
data
structures
right
where
you
can
sort
of
mutate
them,
but
every
time
you
do
a
mutation
you
get
a
new
Sid,
except
in
this
case
you're
not
sort
of
operating
on
a
global
namespace.
That
is
like
the
MFS
fruit
right.
You
can
do
this
on
individual
SIDS.
B
A
A
A
Let's
see
demo
gods
are
not
with
us
today,
so
bear
with
us
I
see.
There's
nine
people
still
here
appreciate
you
joining
Okay
Christian
is
asking,
can
I
run
Helio
with
ipfs
cluster
or
would
I
run
it
without
it?
Okay,
so
ipfs
cluster
right,
that's
the
way
that
you
can
scale
a
basically
a
Kubo
deployment.
You
can
have
multiple
Kubo
nodes
that
are
sort
of
syncing
with
each
other,
the
same
pin
set,
and
so
so
the
question
is
like:
can
you
run
Helio
with
it?
Well,
Helia
is
interoperable.
A
So
if
you
have
Helia
running
say
on
node.js-
and
you
have
a
a
bunch
of
kubernodes
that
are
part
of
an
ipfs
cluster,
then
they
do
interoperate
and
they
can
sort
of
switch
blocks
in
between
them,
but
I
guess
it
comes
down
to
a
question
of
what
are
you
trying
to
do?
I
think
if
you're
trying
to
sort
of
scale
a
a
a
like
an
ipfs
deployment
to
more
than
one
node,
then
I
don't
I'm,
not
sure
that
Helia
would
probably
be
your
best
bet.
A
B
A
B
B
There's
nothing
no
special
configuration
here
and
then
you
create
your
Helio
node.
So
there's
just
a
function,
create
Helio,
plus
Box
Store,
Play,
Store,
load
piece
of
pen
I'm
not
going
to
start
it
because
I'm
not
doing
any
network
operations
right
anyway.
So
unixfs
is
a
function.
It's
exported
from
the
Unix
FS
module,
so
I,
just
I
invoke
it
I
pass
in
Helio
and
suddenly
I
have
an
apartment
of
units
that
at
my
fingertips,
so
what
am
I
going
to
do
right?
Well,
let's
start
with
creating
an
empty
directory.
B
A
A
B
Is
it,
though,
it's
a
different
CID?
The
reason
it's
a
different
CID
is
because
we're
trying
to
push
modernization
here.
So
the
first
thing
that
you'll
notice
is,
it
doesn't
start
with
qm.
This
is
a
V1
CIT
and
not
not
a
v
zero
CID.
So
you
can,
if
you
wish,
if
you
so
wish,
you
can
go
old
school
and
specify
Cid
v0,
in
which
case
yes,
now
you've
got
this
very
familiar.
B
Looking
CID,
this
is
one
of
the
cids
I
may
get
a
little
excited
and
tattoo
down
the
inside
of
my
arm
one
day
because
it's
so
it's
so
iconic
unless
it's
in
V1,
in
which
case
no
one
recognizes
it.
Maybe
that's
a
terrible
idea:
I'm
not
going
to
do
that.
That
would
be
awful
okay.
So
what
else
are
we
going
to
do
right?
So
the
next
thing
we
can
do
is
we
can
like
make
a
directory
instead
of
this,
so
we've
got
like
an
updated
ceid
equals
L8,
FS,
so
they're
going
to
make
a
directory.
B
C
B
B
If
you've
used
any
async,
iterators
or
you'll
recognize
it
from
it
all
so
all
it
does
is
because
because
these
directions
can
be
absolutely
enormous,
there's
essentially
no
size
limit
on
a
Unix
device
directory
because
it
can
be
a
Shard.
So
you
could
have
yeah.
A
very
large
number.
You
don't
ever
want
to
store,
like
you're,
only
want
to
return
like
an
array
of
files,
because
that
array
at
some
point
will
be
bigger
than
the
surface
of
the
planet
so
yeah.
B
B
A
And
just
return
it
and
and
one
thing
that
I
wanted
to
pause
there.
If
you
can
hover
again
over
the
dot,
LS
I
think
it's
worth
pointing
out
that
Helia
is
actually
written
completely
from
the
ground
up
in
typescript,
which
means
that
even
if
you're
writing
just
JavaScript
code
consuming
this
in
vs
code,
you
get
all
of
the
type
annotations.
A
B
Absolutely
so,
if
I
run
my
thing
see
what
happens
so
look
so
we,
this
is
the
first
CID
there's
nothing
in
it
and
then
in
the
update
is
CID.
We've
got
a
directory,
its
name
is
Foo,
which
is
what
we
we
added
and
we
have
some
extra
metadata.
So
we
can
list
the
directory
contents
and
then
we
can.
We
can
interrogate
the
actual
unixfs
encoding
of
the
of
the
directory
route
very
nice.
B
What
else
can
we
do
so?
We
can
do
things
like
add
a
file,
so
that's
FS
all
right
update.
Another
final
final
final
day
did
equals
await
FS
dot.
Well,
actually,
let's,
let's
create
our
file
first,
so
file
CID
equals
08.
Fs,
add,
let's
just
add
bytes.
So
this
is
just
a
convenience
that
just
lets
me
pass
in
one
unit.
B
Eight
array
on
the
other
methods
are
available,
so,
for
example,
I
could,
if
I
wanted
to
I
could
do
FS,
byte
stream
and
I
could
create
a
read
stream
of
a
file
on
the
file
system
or
anything
else
that
can
that
can
iterate
by
so
now,
I
have
a
file
CID
and
then
I
can
copy.
What
I
can
copy
my
file
CID,
where
into
my
updated
DSC
ID
with
a
name?
A
B
A
B
B
A
B
B
Exactly
so
yeah
so
I
have
I.
Have
my
I
have
my
file
and
I
have
my
directory
and
these
CDs
and,
of
course,
all
of
the
CID.
All
the
blocks
that
correspond
to
these
cids
are
still
in
the
Block
store,
so
I
can
essentially
go
backwards
in
time
and
look
at
look
at
earlier
versions.
I
haven't
actually
lost
anything.
B
What,
if
you
don't
want
them
in
the
Block
store,
then
you
might
want
to
run
garbage
collection,
so
you
can
wait
nearly
dot
GC
and
that
will
run
garbage
collection,
but
how
you
know
how
you
know
what's
going
on?
Well,
you
can
pass
in
objects,
and
so
one
of
the
things
that
you
can
pass
in
is
this
on
progress.
B
B
So
on
progress
is
a
kind
of
a
standard
way
of
doing
things,
we're
trying
to
introduce
into
the
whole
heliostat.
So
you
can
see
things
you
see
what's
happening,
so
you
get
these
events
and
then
you
need
to
use
some
kind
of
disambiguator,
so
type
equals,
and
so
we
have
this
Helia
DC
deleted
event
type
which,
through
the
magic
of
typescript,
it's
told
us.
This
is
one
of
the
kind
of
events
that
we
can.
We
can
expect
to
receive.
B
A
B
It's
opt-in
at
all
times
because
it
is
an
expensive
operation.
So
it's
not
the
kind
of
thing
that
you
want
to
just
run
by
accident
or
have
you
know
in
the
middle
of
your
very
important
thing
whatever
it
is,
your
application
is
doing
so
it's
very
much
an
opt-in
operation.
It's
not
like
a
garbage
collected
language
anyway,
so
running
that.
So
you
can
see.
I
have
my
my
folder
I
had
my
file
and
then
I've
deleted
all
the
cids,
so
I've
received
these
as
events.
A
B
B
Then
I
had
the
dialogue
yeah.
This
is
all
very
much
underdevelopment
yeah.
So
when
you're
pinning
a
dag,
you
need
to
know
how
to
you
need
to
know
how
to
recurse
through
a
block
and
find
linked
cids
in
that
block,
and
each
codec
has
a
different
way
of
doing
it.
So
if
you
look
at
a
CID,
a
v1cid
has
three
interesting
Fields.
It
has
a
version
which
is
version,
one
has
a
codec
and
has
a
multi-hash,
and
so
the
multi-hash
is
the
hash
of
the
block.
B
A
But
maybe,
while
you're
doing
that,
I
can
also
share
the
CID
inspector
just
to
kind
of
like
unpack
a
little
bit
of
what
you
said
there.
So
you
were
referring
to
how
Sid
can
have
like
a
bunch
of
these
functions,
and
one
of
the
things
it
has
is
the
multi-codex.
So
here
I
just
dropped
a
sid.
This
is
literally
just
a
sid
off
a
of
an
image
that
is
stored,
and
this
is
basically
the
Merkel
dag
protog
protobuf.
That's
the
codec
that
you
were
referring
to
right.
C
B
Exactly
like
helium
will
likely
ship
with
some
of
these
by
default,
because
the
United
versions
are
pretty
common
or
perhaps
when
you
create
your
Unix,
the
first
more
likely
it
will
add,
it
will
add
the
dark
Walker
to
Helio
transparently
anyway,
right,
as
you
can
see,
there's
a
dog
walker.
It
has
a
walk
function.
It
takes
a
block,
you
use
wpb
to
decode
the
block
and
then
all
the
links-
and
it
just
yields
all
the
links,
the
hashes
from
all
the
links
on
the
Block
and
the
hashes
are
cids.
So
if
we
run
this
again.
A
That's
great
so
one
final
question,
I
guess,
I
have
is
and
and
I
also
want
to
open
this
up.
If
there's
any
questions
from
the
audience,
I'm
sort
of
tracking
here
the
questions
in
the
chat
but
ipns
integration,
there's
Helia
ipns
right
and
also
follows
this
kind
of
similar
modular
and
composable
pattern
where
you
sort
of
you
instantiate
Helia.
And
then,
if
you
want
to
do
ipns
like
mutability,
essentially
to
have
these
mutable
pointers,
then
you
pass
Helia
into
that.
So
just
like
from
a
high
level.
B
B
A
B
Awake
Helia
lip
b2p
keychain
create
key
my
key.
So
what
this
is
going
to
do
is
it's
going
to
create
a
it's
going
to
create
a
key
pair.
It's
going
to
store
it
securely
in
the
lip
to
be
keychain
which
encrypts
it
inside
the
data
store.
So
it's
encrypted
rest
and
very
secure
I'm,
going
to
unsecure
it
by
exporting.
B
B
So
what
I
can
do
is
now
because
I
have
the
name
system:
I
can
name
dot,
publish
the
peer
ID,
the
CID,
which
is
the
value
empty,
there's
the
ID,
and
that
will
publish
that
will
publish
a
micros
record
for
this.
This
key
that
points
to
the
CID.
At
the
moment.
It's
not
going
to
publish
it
anywhere.
You
need
to
pass
some
routers
in
they're.
One
of
the
one
of
the
routers
that
you
can
pass
in
is
the
DHT
router.
B
B
This
ipns
record
for
this,
this
key
for
the
CID,
but
don't
take
my
word
for
it
because
you
know
it
might.
It
might
not
be
true,
so
what
I
can
do
is
I
can
pass
in
a
non-progress
Handler
and
we
can
see
what's
happening
so
here's
the
event
and
then
type
equals
and
look
at
all
these
events
there's
all
the
stuff
that
can
happen
so
you've
got
publish
events,
routing
events,
so
the
there's
a
whole
bunch
of
steps
that
we'll
go
through.
So
it
will
create
the
record.
B
So
it
will
start
the
publishing
and
then
it
will
put
the
record
onto
your
local
data
store
and
then
it
will
try
to
publish
the
record
on
any
routing
systems
that
are
configured
so
we've
got
the
DHT
and
we've
got
Pub
sub
here.
So
I'm,
just
gonna
I'm,
just
gonna
log
out
the
event
ebt.type
and
we
can
see
what's
happening
so
some
things
I
will
need
to
do
is
I
will
need
to
start
The
Helio
node.
B
Very
true,
so,
in
order
to
actually
do
any
in
order
to
do
any
operations,
you
need
appears
to
send
the
data
to
and
when
the
node
first
starts
up
it
may
not
have
appears
so
I
can
actually
just
run
it
and
it
will
fail
because
there
weren't
there
won't
be
enough
pairs.
Yet
so
normally
you
want
to
wait
a
few
seconds.
A
A
A
A
This
is
great:
I
dropped
a
link
already
in
the
chat,
so
you
can
check
it
out.
It's
in
the
ipfs
examples,
GitHub
org
and
there's
a
there's
a
whole
Reaper.
There
called
heli
examples
and
we'll
be
adding
more.
You
can
also
open
an
issue
there
right
if
you
have
a
specific
example
that
you
want
to
explore.
A
There's
already
a
pull
request
that
I
opened
on
just
connecting
to
another
pair
like
I,
was
testing
connecting
to
a
Kubo
peer,
and
you
know
making
sure,
because
there's
a
bit
of
not
all
basically
protocol
transport
protocols
that
are
supported
by
Kuba
are
supported
by
Helia
right
I
mean
you
have
web
sockets
web
trans.
Well,
web
transport
isn't
supported
by
by
node.js,
because
it's
built
on
top
of
quick
and
quick
isn't
supported
either
right.
So
it's
mostly
limited
to
TCP
and
web
sockets
and
webrtc.
B
A
B
Yeah,
the
idea
is
it's
going
to
be
runnable
everywhere,
so
we're
trying
very
much
not
to
depend
on
core
node
apis.
We
want
browser
first,
like
everywhere
as
much
as
possible
anywhere
we
do
use,
call
node
apis.
The
idea
is
you'll
be
able
to
swap
out
whatever
is
being
used,
it
will
be
isolated
and
you
can
swap
out
for
another
implementation
that
works
on
the
platform
that
you
have,
but
we
very
much
want
web
crypto
first
and
no,
no
more
like
crazy,
enormous
JavaScript,
implementations
of
things
and
that
kind
of
stuff.
B
Just
that
I'd
love
people
to
get
involved.
So
please
do
check
out
the
Healer
repo
I'd
love,
help
like
putting
some
of
the
examples,
and
you
know
expanding
like
the
fasting
support,
because
you've
noticed
there's
no
Unix
of
this
support
in
and
here
is
cool,
it's
a
it's
a
module
that
gets
added
on,
so
you
could
then
have
other
file
systems.
A
B
B
B
A
C
C
Well,
I'm,
pretty
boring,
actually
I
like
I,
do
probably
do
most
of
my
stuff
in
Python.
It's
just
so
approachable
the
the
project
you're
about
to
see
is
written
in
Co
and
and
I
help
do
a
lot
of
that
work.
Go
is
really
well
designed,
I
like
it,
but
like
most
folks,
I'm
just
obsessed
with
rust,
like
I
I'm,
the
guy
who,
like
really
like,
really
loves
type
safety
and
really
loves
like
strongly
type
language
I,
just
think.
C
If
a
computer,
a
compiler
is
gonna,
be
smarter
than
me.
It
just
is
and
if
I
can
give
compilers
intelligence
about
what
my
intent
is
then
do
it
for
me
and
make
me
help
me:
make
less
mistakes
because
I'm,
a
disaster
and
and
that's
another
I
mean
don't
get
me
wrong,
like
you
know,
JavaScript
typescript,
it
brings
us
very
far
away.
There
strongly
tight
python
brings
us
there,
but
like
rust
and
memory
handling
and
things
like
that,
you're
just
like
holy
crap.
C
A
C
B
B
A
A
Appreciate
that
and
and
it's
just
the
beginning,
I
I
sense-
you
you've
actually
been
involved
in
in
some
really
important
developments
in
in
scalable
compute.
You
know
with
your
work
on
on
kubernetes
and
kubeflow
right.
You
were
the
co-founder
of
kubeflow
and
you
were
the
product
manager
for
kubernetes
and
kubernetes.
Some
people
may
be
very
familiar
with
it.
Some
people
don't
even
realize
just
how
broad
of
an
adoption
it's
reached
at
this
point.
C
C
It
was
just
kind
of
like
insane
the
journey
and-
and
that
was
five
years
ago
six
years
ago.
So
it's
been,
it's
been
progress
and
so
much
progress.
We've
been
yeah
for
those
that
don't
know
kubernetes,
you
know
it.
It
inherited
a
lot
from
the
way
that
that
Google
used
containers,
but
it
was
not
a
Google
project.
It
was
very
much
done
in
collaboration
with
red
hat
and
IBM
and
core
OS
who
ended
up
becoming
both
red
hat
and.
B
C
And
a
lot
of
other
things
like
that,
but
it
was
just
you
know
the
the
problem
of
how
you
take
a
a
a
binary
package,
in
this
case
a
container
and
distribute
and
run
it
in
a
reliable
way.
Where
you
don't
have
to
think
about
networking.
You
don't
have
to
think
about
mesh
and
you
don't
have
to
think
about
ports,
and
you
don't
have
to
think
about
like
a
space
on
a
machine
or
whatever
just
let
the
system
solve
that
for
you
and
you
can
just
focus
on
packaging.
C
C
C
What
we're
doing
here
is
flipping
everything
on
its
head.
So,
instead
of
saying
well
we're
going
to
have
this
Central
orchestrator
for
how
to
run
all
these
things,
we're
going
to
instead
have
a
distributed
state
right,
which
is
what
you
know.
The
world
is
moving
to
distributed
consensus
around
what's
going
on
here
and
so.
C
Have
10
nodes
and
I
want
node
number
10
or
no
number
seven
to
pick
up
a
job
today
you
might
have
a
central
orchestrator
say
that
in
the
future
you
can
imagine
a
situation
where
all
the
nodes
agree
and
say:
oh,
hey
number,
seven,
you
have
the
you
know
space
to
do
this
you're
volunteering
to
take
that
no
one
else
is
volunteering
great
you!
You
take
the
job.
We
all
agree
that
that
you
know
the
job
has
been
picked
up
and
is
being
run
to
completion.
C
If
it's
not
we're
going
to
check
on
that
and
make
sure
that
the
network
you
know
is
reliable
and
you
know
number
four
picks
up
the
job
if
seven
fails,
but
instead
of
ever
coming
back
or
ever
having
a
Central
State
server
we're
doing
that
distributed.
So
that's
you
know:
I'm,
not
smart
enough
to
come
up
with
new
playbooks
in
many
ways
with
kubernetes
this.
You
know
it
was
like
this.
You
know
State
and
running
jobs.
Kubeflow
was
was
State
and
running
ml
jobs,
and
now
you
know
I'm
on
to
decentralized.
C
C
C
C
A
C
This
is
the
essence
of
background
exactly
what
we
described
so
I'm,
laying
out
an
architecture
here.
What
you'll
have
is
a
generally
a
CLI
like
this.
Just
you
know
you
know
really,
even
though
I
say
CLI
here,
it's
actually
quite
General.
We
offer
websock
and
support
and
other
things
like
that,
but
you'll.
What
you'll
do
is
you'll,
communicate
to
call
a
requester
node
and
a
requester
node
is
not
a
central
function.
I
think
a
question
node
is
something
that
sits
on
every
single
I.
Don't
know.
C
Each
of
these
functions
sit
on
every
single
node,
where
the
requester
node
receives
the
request
by
the
CLI.
So
that's
again
right,
distributed
load
balanced
across
the
entire
network.
It
will
find
a
node.
It
will
communicate
with
that
node
and
say:
hey
I
have
a
job
the
job
or
the
requester
node
then
publishes
to
the
entire
network.
C
C
Asking
well,
why
am
I
on
you
know
ipfs
this
month?
The
reason
is
is
because
this
all
sits
on
top
of
ipfs
as
a
data
distribution
Network,
and
it
makes
it
very
very
easy
to
interact
with
ipfs
in
a
really
straightforward
way,
because
all
your
job
is
doing
is
accessing.
You
know
absolutely
vanilla,
posix
interaction,
so
any
language
anything
you
have
today
that
wants
to
interact
with
ipfs
can
act
as
though
it
was
hosted
locally.
Now
again,
one
of
the
things
is
that
I
should
stress.
C
Your
data
does
need
to
be
on
ipfs
and
available
to
these
particular
nodes,
which
is
not
always
the
case,
and
so
there
is
a
question
of
how
do
you
do
that?
So
what
let
me
actually
show
you
how
to
upload
something
to
this
uploads
tobacco
Yao,
but
but
all
right
excuse
me:
it
uses
I
faculty
out
to
do
the
upload,
but
at
the
end
of
the
day
it's
just
hosted
on
ipfs.
So
we
have
many
many
examples
here.
You
can
go
to
our
website
docs.org
in
order
to
look
at.
C
Perfect
so,
but
in
each
of
these,
you
can
actually
run
the
job
right
here
in
collab.
I
won't
do
it
I'll,
do
it
via
the
command
line,
just
to
show
you
what
it
looks
like,
but,
for
example,
let's
say
I
wanted
to
upload
something
to
ipfs
right,
I
would
say:
Docker
run.
Docker
is
the
engine
that
you
use
to
run
things
here.
We
also
support
wasm
and
we're
looking
at
improving
this
API
to
just
make
it
more
generic
or
it
might
be
Docker
run.
C
C
A
A
C
Absolutely
now,
there's
there's
a
little
bit
of
subtlety
in
what
you
described
there
and
I'll
get
into
exactly
how
that
works
in
just
a
second,
but
with
just
a
small
number
of
steps.
Yes,
you
could
do
exactly
what
you
described.
Okay,
so
just
to
show
you
like
uploading
something
simple
here.
We
have
lots
and
lots
and
lots
of
functions
here.
Unfortunately,
you
know
almost
almost
too
many
at
this
point,
but
you
can
see
here.
C
C
That
we'll
do
is
we'll
do
a
live
search
here,
we'll
do
images.google.com
and
we
will
search
for
cheese
pictures
there.
We
are
and
because
we
are
good
citizens
of
the
world,
we
are
going
to
use
correct
license
rights,
create
comments.
Please
do
this
so
now,
let's
say
I
like
this
right
here.
This
is
a
previous
comments,
picture
I
copy
the
link
address
and
we'll
go
back
here
and
I'll
give
it
that
URL.
Even
though
it's
big
and
ugly,
it
is
still
the
URL
that
we
want.
C
C
Maybe
my
network
connectivity
is
not
so
good,
but
I
will
I
ran
this
earlier
today,
just
grabbing
the
repo,
so
I'll
go
and
show
you
what
this
looks
like
so
we'll
do
that.
Oh
file
exist.
Sorry,
because
I
I
already
did
this
earlier
today,
but
you
can
see
here.
I
downloaded
the
readme
from
from
our
back
of
the
network,
just
an
experiment-
and
you
can
see
here
it
is
oops
yeah.
So
this
is
oh
now,
that's
the.
What
do
you
call
it
read
me.
C
C
So
anyhow,
the
point
is,
though,
that
that
again
now
this
is
on
back
of
Yao
itself.
Excuse
me
not
just
back
yeah.
This
is
on
just
generic
ipfs
itself,
meaning
you
know
without
me
having
to
do
anything
ipfs
ad
or
anything
like
that.
I
can
just
swap
over
and
do
that
and
to
your
question.
You
know
it
doesn't
just
have
to
be
a
single
file
here.
For
example,
You
are
downloading
the
and
extracting
an
entire
F3
bucket
on
Tobacco
yeah.
Here
you
know
we
have
a
simple
command
to
do.
C
This,
I
mean
we
wrote
a
script
to
do
it,
but
it
downloaded.
You
know
all
of
these
various
images
or,
or
things
hosted
in
an
S3
bucket
to
this,
and
it
it
gives
you
a
resulting
data
set
and
that
those
data
sets
can
be
reused
in
any
various
ways.
But
here
you
can
see
each
one
of
these
things.
One
at
a
time
was
uploaded.
C
C
You
know
in
a
container
or
anything
that
you
can
run
as
a
script
can
be
run
on
here
and
I
know
we're
out
of
time
I'm
more
than
happy
to
kind
of
talk
more
about
it,
but
my
recommendation
for
anyone
listening
would
be
just
go
and
check
out.
You
know
our
Network.
We
have
stable
diffusion,
we
have
OCR,
we
have
Bloom
for
audio.
These
are
all
just
examples
in
our
Network
showing
you
how
to
do
it
molecular
Dynamics
model
training,
you
name
it
so.
A
So
I'm
really
curious
to
hear
it.
So
how
would
you
compare
like
Buck,
allow,
to
other
say,
batch
processing
tools
or
like
just
these
kind
of
like
generalized
compute
tools,
and
where
do
you
think
like
is
bakala
a
new
category
of
tooling
essentially,
and
and
what
do
you
think
are
some
of
the
great
use
cases
for
it.
C
C
That
said,
it
can
do
a
lot
more,
but
one
thing
that
we
see
over
and
over
again
is
that
a
batch
today
is
something
that
is
often
hand
rolled
and
very
unreliable
right
like
if
you're
I
don't
know
have
20
nodes,
you
might
run,
you
know,
run
a
single
SSH
command
across
those
20
nodes
to
try
and
figure
it
out,
and
you
have
all
kinds
of
like
crazy
error
handling
and
got
to
make
sure
like
what
happens.
If
you
can't
connect
to
the
nodes.
B
C
Can
happen,
you
can't
do
this.
What
happens
if
you
can't
do
that?
You
can
run
privately
your
own
back
of
the
Yahoo
network
on
your
own
machines
and
just
watch
it
and
and
again
the
state
is
maintained
by
the
entire
cluster.
So
you
know
you
don't
have
to
set
up
your
own
Hadoop
or
spark
or
a
desk
or
anything
like
that
in
order
to
do
it,
the
network
that
you've
set
up
knows
how
to
start
and
maintain
and
run
those
things
now.
C
That
said,
this
isn't
a
replacement
for
those
it's
a
compliment,
because
in
a
lot
of
ways
those
centralized
servers
serve
a
very
specific
and
important
function
in
your
network.
What
the
the
they
are.
The
high
performance
they're
high
throughput
they're,
like
designed
for
lots
of
people
to
collaborate
together
and
things
on,
but
they're
being
reused
for
a
lot
of
things
that
are
pretty
straightforward
and
boring
and
not
not
high
throughput
and,
and
that
means
that
they
are
very
costly
to
maintain.
C
They
often
have
way
too
much
data
in
them,
and
things
like
that,
if
you
could
instead
flip
that
and
run
the
jobs
on
the
nodes
where
you
are
actually
available,
and
you
know
either
idle
compute
or
the
data
is
there
or
the
data
was
generated.
You
can
see
that
that
makes
those
Downstream
clusters
much
much
more
efficient
because
now
they're
just
doing
the
thing
that
they
are
great
at
rather
than
being
reused.
You
know
kind
of
like
using
the
end
of
a
screwdriver
to
you,
know,
hammer
a
nail
in.
C
C
C
If
I
can
run
my
job
right
next
to
where
the
data
is
being
stored,
then
that
is
a
home
run
and
and
we
schedule
with
first
class
ipfs
constructs
live
CID,
so
you
can
say:
I
want
to
run
this
against
that
CID
and
then
network
will
figure
it
out
for
you,
no
translating
it
into
well.
The
CID
was
hosted
on
this
node
in
this
particular
share
and
so
on
and
so
forth.
If
it's
available
to
a
node
and
it's
available,
it's
it's
identifiable
via
ipfs,
you
can
schedule
a
job
against
it.
A
C
A
C
If
the
data
is
on
public
ipfs
but
privately
encrypted,
then
you
would
do
exactly
what
you
would
do
with
ipfs
today,
meaning
you
would
you
would
schedule
your
job
to
a
node
that
had
this
data
on
it
and
then
you
would
figure
out
a
way
to
encapsulate
the
decryption
or
whatever
key
into
that
in
again,
according
to
your
attack
service
and
there's
many
things
that
you
need
to
think
through
there,
you
know,
do
I
trust
the
node
that
it's
running
on
do
I
trust
the
network.
How
do
I
get
them
information
there?
C
C
Even
then,
by
the
way
you
still
have
to
trust
on
people
to
do
it.
That
way,
but
like
more
often
than
not,
what
you
see
is
people
say
well,
look,
there's
too
much
stuff
there
and
it's
too
much
change
for
me
to
do
it
in
that
way.
I'd,
rather
just
explicitly
trust.
You
know
these
three
providers
over
here
to
go
and
achieve
this
and
then
go
do
it,
and
so,
if
you
want
to
do,
you
know,
set
up
your
own
background.
C
Ipfs
cluster
in,
for
example,
AWS
that
only
you
controlled
or
in
gcp
that
only
you
controlled
or
spread
across
multiple
clouds
that
only
you
controlled.
You
could
do
that
this,
the
the
execution
framework,
the
constructs
everything
like
that
are
the
same.
It
just
so
happens
that
only
you
have
access
to
that
cluster.
A
C
You
know
we
have
a
lot
a
lot,
a
lot
of
people
out
there
doing
experimentation
probing
with
the
network
we're
doing
more
than
we
have
a
public
network
out
there
right
now
already
you
can
join
with
your
own
machine
to
see
what
it's
like
you
can
also,
you
know,
run
your
own
jobs.
We
have
more
than
60
000
jobs
a
month
being
executed
across.
C
B
A
C
Yeah,
it's
exactly
what
I
would
say.
You
know
Watson's
pretty
insane,
because
you
know
I
I
was
a
pretty
big
skeptic,
not
that
it
wasn't.
You
know
useful,
but
like
again,
my
my
previous,
my
previous
experience
with
JavaScript
and
so
on.
It
just
made
me
question
like
well
really.
Why
do
we
need
this?
But
then
watching
the
designers
go
through
and
really
take
a
very,
very
aggressive
position
on
what
was
going
to
be
backwards
compatible
and
and
how
to
build
this
thing
in
a
truly
encapsulated
way.
C
You
know
as
much
as
I
love
Docker
it's
and
containers.
Generally
it.
You
know,
there's
still
a
lot
of
os
and
other
dependencies.
What
you
know
innervated
all
the
way
through
it.
So
when
you
think
about
it
right,
like
the
fact
that
you
talked
about
all
the
ways
of
packaging
and
virtualization
and
and
walking
all
the
way
up,.
C
There
were
some
things,
particularly
around
networking
that
were
kind
of
Inky
as
I
try
to
move
over,
but
the
containers
that
they
stood
were
pretty
compatible
right
with
the
underlying
stuff.
I
thought
that
this
was
going
to
be
a
disaster
for
for
wasm.
The
fact
that
there
were,
they
had
actively
chosen
to
I
won't
say,
break
backwards,
compatibility
but
certainly
not
included
in
the
box,
but
because
there
were
so
many
things
happening
that
really
didn't
require
posits
either
in
browsers
or
on
phones,
or
things
like
that.
C
Anchoring
on
that,
but
it
goes
all
the
way
up
and
down
the
stack
it.
You
know
it
forced
a
lot
of
people
to
rethink
things
or
or
they
were
they
had
already
read
things
the
thought
things
and
what
you
see
is
like
an
insane
amount
of
compatibility,
so
I
take
my
go
or
I.
Take
my
rest
or
I.
Take
my
JavaScript
I,
take
my
whatever
and
I,
compile
it
to
Watson,
and
then
it
runs
everywhere
like
just
everywhere.
That
has
a
browser
period
or
a
JavaScript
engine
right,
and
that
is
that's
kind.
C
Now
to
me,
it
feels
a
lot
like
2014,
where
you
had
this
great
packaging
tool
and
now
it's
up
to
the
community
to
figure
out
how
to
run
a
bunch
of
them.
How
do
I
run
them
in
series?
How
do
I
run
them
in
parallel?
How
do
I
create
a
dag
between
them?
Things
like
that
these
are
things
that
are
handled
by
your
OS
scheduler.
If
you're
just
running
natively
or
you're,
you
know
virtual
machine
scheduler
or
your
or
kubernetes
and
other
container
orchestrators.
How
are
we
gonna?
C
Do
this
with
lozen
I
think
the
community
is
still
figuring
it
out,
and
you
see
a
lot
of
really
great
stuff,
I
can't
say
enough
about
fission
and
and
what
they're
doing
to
drive
some
of
the
specs
around
ucan
and
other
things
like
that.
There
are
a
lot
of
Standards
groups,
standards,
bodies,
working
on
things
around
things
like
Wazi
and
so
on.
An
invocation
like
how
do
you
standardize
against
invocation
across
all
these
things?
C
B
C
B
C
Is
not
and
whatever
Orchestra
they
come
up
with,
is
not
going
to
replace
kubernetes
right.
What
you'll
see
I
think
is
a
collaboration
between
the
two
communities
where
wasm
is
the
executor
and
kubernetes
inherits
or
or
supports
execution
of
these
like
a
complex
wasm
constructs,
you
know
tying
them
all
together.
C
B
C
A
good
friend
you
know
was
was
quite
obsessed
with
serverless
for
the
longest
time
and
it
kept
bugging
me
because
it's
like
well,
you
know
all
right,
I
get
it,
but
like
really
all
service
serverless
is,
is
a
billing
model
right.
You
could
have
serverless
as
a
VM
right,
for
example,
but
but
just
bill
by
the
microsecond.
A
C
But
one
thing
that
serverless
really
forced
us
to
do
was
to
think
was
to
force
people
to
think
about
truly
stateless
things
or
where
State
really
lives.
You
know,
when
you
spin
up
your
machine
right
now,
there's
so
much
complexity.
You
have
stayed
in
disk.
You
have
stayed
in
memory,
your
state
in
the
like
execution
pattern
of
your
program
so
and
so
forth.
Serverless
forces
you
to
say
like
well
now,
I'm
really
going
to
draw
clean
lines
and
I.
C
Think
wasm
is
the
natural
extension
of
that
into
a
package
not
telling
you
not
to
use
State.
Just
telling
you
like,
hey
I,
want
you
to
explicitly
break
these
things
up
because
it'll
help
you
be
more
scalable
over
time,
but
we're
not
going
to
get
there
until
you
know
you
get
those
orchestrators
and
as
well.
You
get
tooling
that
really
like
makes
this
much
much
easier
to
run.
B
C
C
B
C
C
An
expert
in
the
field-
and
you
know
I'm
with
you
it's
funny
because,
like
in
a
lot
of
ways,
wasm
to
come
back
to
your
question,
wasm
kind
of
solves
this
for
you
because,
instead
of
pulling
I
mean
like
yes,
it
pulls
everything
in,
but
it
only
does
it
once
and
then
it
pins
everything-
and
you
know
it's
that
normally
that
would
be
like
horrifically
insecure
but,
like
you,
don't
even
get
networking
by
default.
So
it's
like
that.
C
A
C
Right
right,
no
look
I'm
completely
with
you
I.
You
know
not
to
get
too
philosophical
here,
but
the
other
ultimate
problem
is
humans.
Of
course,
right
systems
know
how
to
do
this
really
well,
but
somebody
came
along
and
said.
Well,
what
we
really
need
is
a
URL,
because
people
need
to
know
how
to
spell
where
they're
going
and
you're
like
well
fine,
but
humans
are
messy
and
like
irregular
and
I'm
going
to
want
to
type
in
whatever
you.
C
Why
combinator.com,
rather
than
trying
to
figure
out
exactly
what
web
page
I
was
supposed
to
go
to
and
so
on,
and
but
one
is
deterministic
like
I
guarantee.
If
I
go
to
this
Sid
I
either
get
nothing
or
I
get
the
Sid
right.
I
get
the
content
that
I
was
expecting
There's
No
Going
to
news
on
why
combinator.com
and
every
day
it
changes
like
the
same
URL
different
content,
which
is
like
a
disaster
from
my
Computing
perspective
right
so.
B
B
C
C
Is
one
of
the
reasons
why
Dr
Yao
is
so
powerful
as
well?
Instead
of
you
saying
well
I'm
going
to
execute
this
job
on
this
share
I'm
going
to
execute
this
job
against
this
data
set
you
figure
out
where
it
is
and
go,
execute
it,
and
it
is
really
a
a
very
different
way
to
approach
it,
and
so
you
know
again
the
end
of
it
comes
all
the
way
back
to
what
you
said
at
the
beginning.
C
You
know
I
I
really
do
think
this
is
something
super
powerful
in
in
the
kubernetes
world.
The
reason
I
came
to
work
at
protocol
labs
in
the
first
place
was
in
the
kubernetes
world.
I,
don't
know
literally
the
third
or
fourth
feature
I
ever
wanted
was
hey.
Don't
make
me
think
about
how
to
store
my
data
across.
C
Why
do
we
allow
people
to
think
about
these
VMS
and
the
storage
in
a
unified
way
and
a
lot
of
very,
very
smart
people
inside
Google
who
I
was
talking
to
and
inside
the
kubernetes
community
would
say
like
that's
way
way
harder
than
you
think
and
that's
true.
They
were
absolutely
right.
It
was
way
harder
than
you
think.
How
do
you
think
about?
You
know
eventual
consistency.
C
C
C
C
So
one
of
the
things
that
we
really
want
to
nail
is
figuring
out
how
to
balance
not
just
date.
Dedicated
input,
data
but
also
dedicated
chart.
Excuse
me
cids
around
functions
and
code,
but
also,
but
also
parameters
right.
So
each
one
of
these
things
will
have
a
unique
hash
or
CID
excuse
me
associated
with
them,
and
that
will
enable
us
to
you
know
ensure
that
something
that
you
know
that
has
been
run
before
can
be
run
again
now.
C
A
A
C
C
C
You
know
curling
anything
that
access
to
the
network,
anything
that
accesses
time
any
or
time
and
date,
anything
that
accesses
Randomness
and
some
kind.
Those
are
non-deterministic,
and
so
you
can't
get
to
verifiability
until
you
are
running
on
determined
supports
now.
The
convenient
part
is
like
wasm.
In
all
its
wisdom.
By
by
shutting
everything
down,
does
give
you
the
ability
to
turn
off
non-deterministic
things.
C
C
C
A
C
A
C
At
the
end
of
it,
we
allow
you
to
select
your
verifier
of
choice
and
we
have
a
deterministic
verifier
already
built
in
and
what
that
means
is
that
we
can
say
you
know
how
did
this
run,
and
you
tell
us
if
this
is
deterministically
correct?
Now
there
are
a
bunch
of
different
ways
to
attack
that
the
the
deterministic
verifier
we've
run.
Basically,
just
does
a
a
chief
and
cheerful
concurrency
check.
C
A
C
C
That
is
a
way
to
achieve
the
same
thing
or
only
running
the
job
once
and
get
you
know
one
to
the
I.
Don't
know
it's
like
one
to
the
hundredth
power
or
ten
to
the
100th
power
probability
that
that
this
was
the
job
that
you
ran
and,
and
that
I
think
will
be
very,
very
powerful
as
well.
There's
a
lot
of
work
to
do
there,
not
on
the
coding.
Actually,
the
lurk
is
a
fantastic
language
and
I
love
the
direction
they're
going
it's
more
like
there's.
A
C
A
A
C
C
Where
everything
is
listed
and
at
1.0,
the
thing
that
is
most
important
to
us
is
really
achieving.
Api
stability,
we're
still
very
much
saying
like
hey
look,
if
you
use
it
expect
breaking
changes,
but
at
1.0
it's
it's
API
stability
and
a
defined
deprecation
path
for
for
any
functions
that
are
in
there.
But
there
are
many
many
other
things
that
are
on
in
Flight.
B
C
C
You
can
go
to
our
blog
and
see
some
really
cool
demos
about
using
Macao
for
streaming,
workloads
which
I
didn't
even
think
was
possible,
but
we
have
a
demo
of
it.
We
have
a
brand
new
feature.
I
announced
a
couple
weeks
ago
called
insulated
jobs,
that's
being
worked
on
where
two
orgs
that
don't
necessarily
trust
each
other
can
submit
functions
back
and
forth,
and
then
audit
the
the
input
and
the
results
as
they
come
out.
C
So
that's
really
powerful,
we're
doing
a
bunch
of
things
for
on-premises
and
other
detached
workloads
and,
in
the
spirit
of
you,
know,
determinism
and
verifiability,
and
things
like
that.
We're
also
doing
a
bunch
of
work
on
something
called
octostore
and
octo
store
is
an
idea
of
recording
everything
that
goes
through
your
on-prem
back
in
the
network
or
the
public
one
in
a
deterministic
and
verifiable
way.
So
I'm
really
excited
about
that
as
well
and
tons
and
tons
of
other
features.
C
B
C
Ipfs
nodes
will
have
to
opt
into
this
and
run
our
agent,
but
that
should
be
incredibly
trivial
if
they
don't
run
it
by
the
way.
But
your
data
is
available
on.
If
you
pass
and
someone
else
does
will
Auto
fetch
it
for
you
from
ipfs,
and
then
you
know
it's
still
available
on
ipfs
but
you're
operating
in
yourself.
C
A
A
So
some
of
you
may
have
heard
of
Blue
Sky
social
Blue,
Sky
social
is
a
social
network
that
was
started
by
Jack
Dorsey
and
the
idea
was
there
was
to
create
something
that
would
be
much
more
of
a
protocol
than
a
specific
platform
that
is
operated
by
a
company.
So
the
exciting
thing
is
that
they
already
have
a
beta
going
and
I
just
installed
this
yesterday
and
the
reason
that
I
mentioned
well.
Let
me
bring
my
screen
up,
so
that's
blue
sky,
social.
A
That's
the
website
for
Blue,
Sky
I'll
drop
a
link
to
that
and
the
reason
that
I
mentioned
this
is
because
they're
actually
using
ipld
under
the
hood
and
if
you're
new
to
ipld,
you
can
think
of
ipld
as
the
data
layer
of
ipfs
and
and
filecoin
and
many
of
other
systems,
and
we
just
in
case
you're,
sort
of
even
curious
about
ipld
and
and
what's
its
role.
We
also
recently
just
published
a
blog
post
earlier
this
week.
A
So
let
me
share
that
too
yeah.
This
is
the
blog
post.
It
just
went
out.
This
was
originally
published
by
Michael
Rogers,
who
was
leading
the
project.
Some
of
you
may
know
him
from
the
node.js
space,
but
I
think
this
is
a
great
introduction
to
the
very
nature
of
of
of
linked
data
SIDS
and
how
that
all
relates
to
ipfs.
A
You
can
just
drop
your
email.
There
I've
already
been
trying
it
on
my
phone
and
it's
pretty
cool.
What
else
do
we
have?
We
have
oh
yeah.
This
is
something
I
found
this
morning,
so
someone
has
written
a
library.
So
one
of
the
things
I
was
discussing
with
David
was
using
private
data
on
ipfs,
and
you
know
what
maybe
I'll
just
share
this
whole
tab
yeah.
A
So
one
of
the
things
I
was
discussing
was
Private
data
on
ipfs,
and
we
just
had
this
blog
I
just
discovered.
This
blog
post
that
comes
with
a
GitHub
repository,
so
it's
an
npm
package
that
essentially
does
asymmetric
like
AES
encryption,
and
it
essentially
just
gives
you
a
an
API
to
do
the
encryption
and
to
upload
to
web3
storage,
which
is
a
nice
way
if
you're
working
with
private
data
on
ipfs.
A
A
Okay,
I'm
back,
so
these
are
the
ipfs
socks,
as
you
can
see,
they're
ipfs
branded
and
they
have
the
nice
ipfs
theme
and
lattice
on
them
and
in
order
to
participate
in
the
raffle,
as
I
mentioned,
you
have
to
just
sign
up
to
the
community
calendar.
You
can
do
that
by
going
to
ipfs
dot
FYI
calendar
and
you
can
drop
a
link
there
yeah.
You
should
be
able
to
see
the
Subscribe
button.
If
you
go
there
and
I'm
gonna
actually
do
the
raffle
right
now.
So
I've
got
like
this
whole
spreadsheet
set
up.
A
Okay,
I
see
some
people
have
signed
up.
We've
got
some
more
people:
okay,
so
I'm
gonna
copy.
All
the
people
who
subscribe
I'm
gonna,
give
you
a
couple
more
moments
to
do
it.
If
you
haven't
already
and
I'm
gonna
put
this
into
the
special
spreadsheet
that
I've
set
up
in
order
to
do
the
raffle
and
okay,
we
have
a
winner
and
the
winner
is
Electro
Cloud.
So
someone
who
signed
up
with
that
name,
Electro
Cloud
I'll,
be
sure
to
drop
you
an
email
to
get
your
postal
details
and
send
you
this
yeah.
A
I
will
try
to
find
some
links
if
I
can
and
share
them
in
the
chat
and
then
finally,
we
have
ipfs
things.
So,
if
you're
actively
involved
in
the
ipfs
community
in
building
ipfest-
and
you
may
have
heard
about
ipfs
thing-
this
is
an
event
that
is
targeted
at
the
implementer
community.
There's
going
to
be
talks,
workshops,
discussion,
circles,
hacking,
time
and
whatnot
and
it's
a
great
chance
to
meet
all
of
the
fellow
ipfs
implementers.
So
that's
the
website.
You
can
already
have
a
look
at
some
of
the
schedule.