►
Description
@Davidad delivers a very impromptu 'lightning talk' about IPLD research and the future directions it could take.
A
The
grand
vision
that
I
have
for
IPL
de
is
towards
a
decentralized
programming
environment
and
what
I
mean
by
programming
environment
is
it's
in
the
sense
of
Unix.
Some
people
talk
about
the
core
of
the
UNIX
philosophy
being
having
composable
utilities
that
you
can
put
together
to
do
a
big
job
but
I
think
the
real
core.
The
content
of
the
UNIX
philosophy
is
more
succinctly
captured
in
this
quote
that
a
file
is
a
sequence
of
bytes.
A
We
can
do
those
efficient
accesses
of
different
semantic
pieces,
different
chunks
of
a
file,
and
we
can
do
lazy
access
patterns
where
we
can
load
a
data
structure
and
have
it
appear
transparently,
as
though
we're
in
memory.
But
in
fact,
when
we
follow
pointers
where
we're
following
hash
links
on
the
back
end,
some
of
the
use
cases
for
these
kinds
of
computational
filters
that
you
might
want
to
put
on
top
of
a
an
IP,
LD,
dag
and
say
now.
This
is
a
new
dag,
but
it's
not
an
actual
thing:
an
IP
FS.
A
For
example,
decompression
we
might
want
to
do
transparent,
decryption
conversion
between
different
formats,
different
sorts
of
views,
slices
lenses,
looking
up
things
in
an
index,
so
you
can
sort
of
give
an
identifier
to
do
an
expression
that
looks
up
a
key
and
a
key
value
block,
or
even
more
advanced
kinds
of
queries
like
with
relational
algebra
or
even
generalized
sort
of
data
analyses
where
I
want
to
be
able
to
reproduce
the
data
analysis
and
instead
of
putting
the
results
of
the
analysis
on
IP,
FS
and
saying
trust
me
I.
Did
this
analysis
on
this
data?
A
I
put
the
actual
code
on
there
and
you
answer
you:
can
you
can
recompute
it
yourself
or
you
can
get
it
from
a
cache
etcetera,
but
the
things
we
desire
from
this
kind
of
thing?
We
want
a
pure
deterministic
reproducible
semantics,
because
we
want
to
be
able
to
cache
that
we
want
some
kind
of
a
query
planner
to
be
able
to
say.
Oh,
this
sub
expression
has
been
computed
before
by
someone
you
trust,
or
it's
been
computed
in
a
verifiable
way
or
you
computed
it
yourself.
A
A
And,
of
course
we
want
the
core
of
this
to
be
easy
to
implement.
So
we
want
to
build
as
many
of
the
features
of
this
as
possible
on
top
of
other
features
so
that
at
the
bottom
that's
a
very,
very
simple.
The
untyped
lambda
calculus
is
the
ultimate
version
of
this
we're
trying
to
get
as
close
to
that
as
we
can
and
wide
platform
support,
leveraging
webassembly,
so
I'm
gonna
run
through
in
my
remaining
30
seconds,
a
whole
bunch
of
different
steps
on
the
way
to
a
decentralized
programming
environment.
A
So
there's
data
definition,
a
static
language
of
value,
literals,
sort
of
JSON
style,
serialization
lenses,
actual
formats
that
you
can
represent
values
in
these
schemas
and
all
sorts
of
different
ways
with,
depending
on
what
your
application
needs
of
selectors
or
like
maps
and
filters
queries
where
you
can
bind
variables
to
do,
recursion
an
object
model
for
exposing
those
kinds
of
queries
as
api's,
giving
them
human
readable
names
and
such
database
style
indices.
Then,
beyond
immutable
data,
see
Rd
T's
capabilities
actors
and,
ultimately,
will
get.