►
A
A
A
A
Okay,
so
what
are
we
gonna
do
today
right
so
last
time
we
put
a
system
context
on
the
chain
or
we
we,
we
didn't
put
it
on
the
chain.
There
was
really
no
chain.
All
it
was
was
a
link,
and
so
oh,
I
ran
some
ethernet
lines
and
I
found
a
better
way
than
running
it
up
and
across
all
of
the
house.
So
so
we
we
put
a
single
system
context
on
the
chain,
but
now
we
need
to
figure
out
okay.
Well,
how
are
we
going
to?
How
are
we
going?
A
A
all
right,
let's
see
so
we're
gonna
put
all
of
alice
herstory
on
the
chain,
and
to
do
that
we
need
to
put
the
first
version
of
alice
and
then
we
need
to
have
the
second
version
linked
to
the
first
version
and
how
we're
going
to
do
that.
We're
going
to
use
pure
pdids
and
I
realized
so
I
did
so
so
so
so
I
had
a
discussion
around
blockchain
and
I
forgot
that
I
hated
blockchain
a
few
weeks
ago
too,
and
that
you
know
once
I
once
I
well.
A
Okay,
more
than
a
few
weeks
ago
I
was
like
man,
you
know
I
didn't
hate
it,
but
I
didn't
care
right,
but
if
we're
calling
this
web
3
and
we're
calling
blockchain
a
part
of
web
3
and
what
web
3
is
is
actually
just
you
know,
a
bunch
of
asymmetric
keys
and
and
json
blobs
like
I
can
get
on
board
with
that.
So
because,
obviously
this
messaging
stuff
is
great,
we've
been
over
it
right,
so
I
mean
all
we're
really
doing
here
is:
oh
look.
A
A
It's
got
stuff
on
it,
so
basically
we
have.
What
are
these
things?
Well,
they're
they're
asymmetric
keys
right,
so
we've
got
a
public
portion
and
a
private
portion
right,
they're,
just
numbers
very
random
numbers
right,
big
prime
numbers.
I
mean
I
don't
know
what
kind
of
keys
they
are,
but
I'm
assuming
maybe
there
are
s8
keys
right.
So
actually,
typically,
those
are
not
used
with
the
json
web
tokens
because
there's
keys
that
produce
smaller
sizes.
Okay,
but
the
point
being,
you
can
sign
your
messages.
A
You
can
verify
your
messages
because
you've
got
your
asymmetric
keys.
So
you
know
when
you
create
your
linked
list,
you're
making.
You
know
you're
forging
you're
forging
real
strong
that
chain
by
throwing
the
asymmetric
signatures
on
there
or
this
encryption
on
there
right
so
you're,
making
this
really
really
strong
chain
by
by
using
these
asymmetric
keys,
and
so
when
we
have
that
that
really
strong
chain
as
the
the
foundation
for
our
you
know
highway
of
of
information,
then
that's
gonna.
Let
alice
travel
everywhere
right
so.
A
We
understand
the
top
level
system
context
for
a
given
system,
and
then
we
understand
the
system,
context
itself
right
and
so
say,
for
example,
we're
interacting
with
a
esp8266
right,
and
so
this
is
a
little
chip.
It's
got
wi-fi,
you
know.
Maybe
it's
it's
gonna
make
you
coffee.
So
you
know
this
thing
basically
is
gonna
hit
boil
on
the
coffee
maker
right
and
make
the
coffee
in
the
morning.
You
know
at
a
specific
time
or
when
you
say
alice,
you
know,
could
you
please
spoil
the
copy?
A
And
so
then,
what's
gonna
happen
is
essentially
this
the
so
alice
boyle.
You
know
alice.
Please
make
some
coffee
right
and
alice
will
say
basically
she'll
she'll,
take
your
your
you
and
the
environment
as
the
top
level
system
context
right.
So
everything
everything
you
know.
Okay,
so
you
speak
it's
kind
of
like
in.
If
you
talk
in
the
or
if,
if
the
tree
falls
in
the
forest,
doesn't
make
a
sound
right.
A
Well,
if,
if,
if
you
know,
if
something
is
around
a
computer,
that's
running
the
open
architecture,
you
know,
does
it
understand
you?
Well,
the
goal
is
hopefully
right.
You
know
so
so
because
the
core
of
all
of
this
is
about
communication
right,
and
how
do
we
do
this?
You
know
shared
human
machine
communication,
which
is
also
you
know,
a
a
a
part
of
that
is
our
machine
to
machine
communication
and
that's
via
this
open
architecture
right
so
effectively.
A
A
The
devices,
if
you
have
a
device
around
you
that
has
a
microphone
you
know
it
may
be
set
to
a
mode
where
it
would
be
listening
right
and
in
that
case,
and
and
all
of
this
obviously
is
going
to
be
supported
on
your
own
hardware-
is
the
point
of
this
right.
So
you
buy
your
hardware
and
then
you
don't
have
to
give
your
data
to
anybody
right.
A
So
you
know
your
stuff
is
yours
as
it
should
be,
and
so,
basically
you
know
you'll
say
alice,
make
some
coffee
and
so
you've
got
a
few
devices.
You
know:
you've
got
a
few
few
microphones
set
up
around
your
house
right
and
they're
connected
to
your
to
your
wi-fi,
and
you
know
some
some
of
them.
You
might
have
some
of
them
set
to
listening
at
different
times
right
and
you
might
have
your
phone
with
the
ability
to
sort
of
point
over
like
and
look
at
that.
A
A
Yeah,
basically,
you
know
you
just
you,
you
just
grab
the
audio
so
with
dffmel
everything
is
stream
right,
so
you
grab
the
audio
stream.
You
know
you,
you
do
your
feature
extraction
on
the
stream
and
the
the
critical
difference
that
we're
doing
here
is
we're
not
doing
things
sequentially
we're
doing
things
like
in
parallel
and
then
we're
gonna
figure
out.
You
know
within
we're
gonna
understand
within
our
top
level
system
context.
So
the
caller
is
the
top
level
system
context
and
the
callee
is
the
system
context
right,
but
these
are
asynchronous
event
loops.
A
These
are
not
functions.
Right,
like
these
things
may
still
live
on
after
after
the
you
know,
the
core
function
has
been
achieved
for
that
that
time
frame
right
because
it
a
command
right
is
not
necessarily
a
synchronous
request,
and
so,
if
we
say
you
know
alice
make
some
coffee
and
keep
it
warm
right.
A
Then
she's
gonna
keep
she's
gonna
make
some
coffee
she's
gonna,
keep
it
warm
and
then
we're
gonna
say
you
know,
make
me
some
more
coffee
around
around
three,
then
she's
gonna
need
to
go,
make
more
coffee
around
three
right.
So
this
is
not
a
good
example.
What
about
what
about
okay,
so
we're
just
going
to
use
the
example.
I
need
to
stop
using
other
examples,
we're
just
going
to
use
software
because
we
know
software
so
okay.
So
what
are
we?
A
Just
because
it's
easier
than
I've
been
in
the
bash
code.
I
don't
want
to
go
in
the
bash
code
right
now.
No,
thank
you.
No
thank
you
please,
and
no,
not
right
now,
and
so
we'll
just
build
a
little
shell,
we'll
extend
the
one.
We
have
it's
it's
it's
nearly
it's
it's
functional
for,
like
almost
for
a
lot
of
things,
it'll
be
functional
enough
for
us
and
then
we
will
basically
yeah.
So
we
use
this
this.
You
know
the
the
chain
right
of
previous
system
context
to
build.
A
You
know:
alice's
alice's,
train
of
th,
else's
trains
of
thoughts
right,
and
so
every
train
of
thought
will
be
somehow
descended
from
this
first
train
of
thought
right
or
this
first
thought,
and
so
as
far
as
the
chain
is,
is
concerned
right,
so
so
we're
gonna,
we're
gonna,
we're
gonna
strive
to
create
this
unlink,
unbroken
link
of
chains
of
or
unbroken
lineages
of
alice
right,
but
obviously
we're
not
always
going
to
link
it
to
the
to
the
to
the
parent
right.
You
know
you,
it's
always
up
to
you.
A
If
you
decide
not
to
include
the
parent
context,
the
top
level
context,
d,
id
or
yeah
the
the
call.
If,
if,
if
it,
if
a
child
context,
the
child
context
can,
when
it
saves
itself
either
in
code
or
not
in
code,
the
parent
context
right
and
the
parent
context
could
create
an
input
object
which
then
gets
converted
into
a
did
during
serialization
right
and
then
have
just
sort
of
in
the
creation
of
the
input
object
of
the
input
object
is
this:
is
the
energy
drinking?
A
If
the
input
object
is
is,
is
a
system
context?
You
know
it?
Could
that
would
effectively
be
meaning
and
and
they
they
they
put
it
in
a
state
that
was,
you
know.
Please
somebody
execute
this.
You
know
that
that,
in
that
case,
you
would
want
to
do
a
link.
They
would
want
to
do
a
linkage
right
because
you'd
want
to
say
well,
where
does
that
come
from
right?
So
what
we're
going
to
do
is
we're
going
to
map
to
identity.
A
There's
some
discussions
going
on
on
the
spdx
mailing
list
around
around
spdx
ids
right,
and
so
because
we
just
get
this
for
free.
All
we
got
to
do
is
throw
our
inputs
through,
like
all
we
got
to
do,
is
encode
to
we
just
encode
to
pure
d
ids
and
then
all
sudden,
it's
web,
three
and
so
yeah.
So
basically
we're
going
to
forge
this
first
link
in
the
chain
in
in
about
30
minutes
here
and
yeah.
It's
gonna
be
fun
stuff
and
we're
gonna.