►
Description
A
Let's
see
where
are
we
and
and
where
are
we
going?
Let's,
let's
do
a
recap,
I
think
we
could
walk
through
the
let's
walk
through
the
the
the
engineering
log,
videos
and
and
just
just
talk
a
little
bit
about
about
about
where
we've
been
and
where
we're
going.
So
all
right,
so
you'll
recall
that
just
just
to
just
to
to
set
the
stage
remember
we're
building
alice
right,
that's
what
this
is
about.
A
Yeah,
basically
yeah
the
the
the
point,
the
point
being.
We
can
apply
overlays
to
be
cross
project,
cross
organization
or
granular
on
on,
like
the
the
level
of
granularity
around
applying
policy,
to
build
or
run
time
for
any
given
code
base
right
and
remember,
we're
not
so
much
focusing
on
code
bases
anymore,
because
we
don't
really
care
what
language
anything
is
written
in
right.
We
care
about
the
architecture
because
alice
will.
I
mean
code
is
code
right,
so
we
can
just.
A
We
can
just
write
some
serialization
code
for
the
underlying
whatever
language
it
needs
to
be
in
right,
it's
just
bindings!
So,
okay,
let
me
let
me
try
this
again.
Okay,
so
recap,
month
of
may
so
we're
building
alice.
We
suspect
that
the
did
and
peer
id
format
gives
us
everything
that
we
need
to
to.
It
provides
us
with
a
primitive,
a
storage,
a
serialization,
primitive
right
that
allows
us
to
then
serialize
and
deserialize
from
arbitrary
representations
into
this
common
representation
right,
and
so
why
why?
A
Why
is
this?
You
know
what
why
are
we?
Why
are
we?
Why
are
we
playing
around
with
this
stuff
right?
Why
are
we
investigating
this?
Well,
this
primitive,
the
the
the
properties
of
the
primitive
are
identifier
right
document
with
schema
and
then
links
to
other
documents
right
so
that
maps
very
well
to
our
concept
of
the
manifest
which
we
wrote,
the
shim
layer
for,
and
we've
been
talking
about.
I
mean
I
don't
know
how
long
we've
been
talking
about
the
manifest
it's
been
about
a
year,
or
at
least
well.
A
Let's
see
when
was
okay,
so
this
was
december
but
yeah,
I
think
you
know
yeah
december.
We
were
talking
about
the
manifest,
but
yeah.
Oh
we've
been,
I
mean,
we've
been
doing
the
second
party,
so
the
second
party
stuff
was
even
before
the
oh
yeah,
so
we've
been
doing
the
second
party
stuff
for
a
while.
So
basically
what
we
were
doing
is
we
were
like
okay.
Well,
we
need
to
split
out
the
plugins
right.
A
A
We
know
we're
playing
with
ideas,
we're
we're
feeling
this
thing
out
and
you
know
we've
explored
our
our
general
web
3
landscape
as
the
because
that
that
that
seems
like
a
a
good
way
to
go
because
then
the
web
3
landscape
would
provide
seems
the
community
seems
to
be
enthused
about
providing
web
2
to
web
3
proxies
right.
So
if
you
just
speak,
if
we
just
speak
web
3
they'll
show
up
and
and
do
the
web
2
to
web
3.
For
us
it
sounds
like
right.
A
That
sounds
like
that's
the
deal
and
obviously
will
help.
So
you
know
it's
a
community
effort.
So
then,
beyond
that
right,
so
that's
our
serialization
format
and
but
beyond
that
right.
We're
going
to
leverage
that
serialization
we're
going
to
leverage
that
serialization
format
propose
it
as
an
option
right
for
for
the
general
methodology,
which
is
to
describe
the
overall
architecture
of
an
arbitrary
application
right.
And
why
do
we
want
to
do
that?
A
Well,
we
want
to
do
it
because
we
want
to
analyze,
and
if
we
can
analyze,
then
alice
can
analyze,
and
if
alice
can
analyze,
then
she
can
put
together
alternate
programs
right
so
and-
and
she
can
potentially
understand
intent
right
and
so
next
week
on
saturday
at
2,
30
p.m.
Oh
right
now
so
a
week
and
a
day
from
today,
john
wyman
and
I
will
be
presenting
on
living
throughout
models.
So
john
john
will
take
us
on
a
deep
dive
of
the
situation
around.
A
You
know
threat
models,
and
you
know
how
our
thread
models
are:
are
currently
dead,
threat
models
right
and
how
we
might
bring
our
threat
models
to
life
and
then
I'll
touch
on
a
bit.
You
know
about
how
how
alice
can
can
help
bring
those
to
life
right
and
and
will
be
bringing
alice
to
life
along
the
way.
So.
A
That's
out
of
order,
okay,
what
else?
Oh
yeah,
we
potentially
discovered
time
travel
in
a
way
I
mean
to
be
honest:
okay,
anyway,
so
yeah,
and
then
we
also,
you
know,
figured
out
how
to
integrate
the
system
context.
Well,
we
we
we
got
clarity
with,
so
we
got
clarity
on
what
is
the
system
context
right?
A
The
system
context
is
the
upstream
overlay
in
the
orchestrator,
and
so
remember
our
our
overlays
are
our
ways
of
essentially
doing
like
programmatic
forks
of
upstream,
with
dynamic
policy
based
on
context,
and
so
that
that
was
fun,
and
then
we
also
got
into
oh
yeah.
We
also
explored
potential
architectures
for
distributed
ci
cd,
leveraging
attestation
of
build
artifacts
and
source
code
via
hardware
security
modules,
aka
tpms,
and
how
that
might
pair
with
a
did
based
architecture
and
a
pure
did
based
architecture.
A
A
Obviously,
you
know
we
hoped
to
get
a
lot
of
work
done
as
well,
but
it
ended
up
being
mostly
planning,
which
is
fine,
that's
that
that
was.
That
was
what
it
was
supposed
to
be,
but
yeah.
So
I
think
we
can
expect
so
so
for
next
week
and
for
june,
we
can
expect
that
we'll
continue
work
with
the
system
context
right,
we'll
we'll
continue
to
flush
out,
overlays
and
upstream
and
their
application
and
their
granularity
thereof,
as
well
as.
A
As
well
as
getting
a
start
on,
you
know
generating
some
something
more
than
just
raw
feature
data
and-
and
you
know
some
some-
maybe
some
some
living
threat
models
right
so
that
that
can
be
disc
that
can
describe
the
the
a
code
base
and
that
alice
can
generate
for
us.
I,
I
really
would
love
to
serialize
to
peer
d
ids.
A
Hopefully,
now
that
we
have
the
system
context
and
we
can,
if
we
can
figure
out
how
to
get
the
system
context
chain
happening,
then,
hopefully
we
can
jump
into
dc
realization
very
quickly.
We
were
going
to
do
data
flow
as
class
as
the
as
the
mechanism
by
which
we
implemented
the
input
networks
for
serialization
and
deserialization,
as
well
as
communication
of
you
know,
with
arbitrary
chains.
I
think
we're
ready
to
go
on
that
now.
A
We
just
need
to
iron
out,
there's
a
there's
a
little
bit
of
ironing
out
and
it
needs
to
be
done
on
the
deployment
environment,
but
I
think
we
got
the
default
deployment
environment,
so
we
can
always
just
throw
a
data
flow
in
there
without
specific
operations.
So
I
think,
I
think
we're
we're
pretty
much
ready
to
roll
on
that,
let's
see
so
yeah,
so
we
should
go.
Try
once
once
we
get
should.
I
think
we
should
just
go.
Do
that.
That
should
be
one
of
the
first
things
we
do.
A
Let's
go
do
that,
let's,
let's
okay,
so
where's
the
code
before
I
get
ahead
of
myself.
This
always
happens
so,
okay,
where
were
we
yeah?
We
were
trying
to
tie
together
the
cli.
I
think,
if,
if
I
don't
stop
trying
to
tie
together
the
cli
next
next
week,
someone
told
me
to
stop
doing
that,
because
I'm
getting
a
little
bit
too
in
the
weeds
and
I'm
trying
not
to
but
yeah.
You
know
it
can
be
easy
to
convince
yourself,
sometimes
that
it's
a
good
idea
so.
A
Yeah,
other
than
that
you
know,
I
think
I
think
you
know.
Hopefully
we
see
some
serialization
and
deserialization
and
communication
with
that
different
chains
and
then
hoping
to
see
hoping
to
see
soon.
Is
it
well?
We
started
with
that,
so
I
I
don't
want
to
you
know
I
I
hope
to
see
that
hoping
definitely
going
to
see
some
a
living
threat
model
of
some
kind
get
generated,
and
what
else
are
we
looking
at
for
june
here.
A
A
Oh,
oh,
that's
right
so
for
next
week
and
for
yeah,
so
for
next
week
we'll
publish
the
open
architecture
set
of
adrs
which
will
workshop
into
a
rfc,
probably
by
late
july
august
time,
frame.
I'd
like
to
see
us
rfc
that
and
the
which
will
cover
you
know
the
methodology
of
which
serialization
to
dids
and
pdids
is
one
serialization
mechanism.
But
generally
the
methodology
will
be
focused
on
manifest
right
and
this
idea
of
you
know
you
know
what
are
our
touch
points.
A
What's
the
schema
and
then
what
are
the
side
effects
in
an
asynchronous
nature?
And-
and
so
one
of
those
could
be
basically
immediate
return
value
essentially
or
you
know,
error
conditions
that
derive
from
that
which
would
be
asynchronous
so
yeah,
so
open
architecture
adrs
next
week
living
through
models
next
week
and
then
probably
pure
d
id
so
more
getting
into
system
context
a
little
more
the
week
after,
hopefully
connecting
a
few
a
few
more
connecting
some
system
context
links
and
then
you
know
towards
the
end
of
june.
A
We
might
get
into
serialization
and
deserialization,
even
though
I
want
to
do
that
immediately
now.
So
I'd
really
like
to
to
see
us
trade,
the
flows
on
top
of
tb,
tb,
tb
dex,
so
that
will
require
serialization
is
deserialization.
So
if
anybody
wants
to
jump
on
that
tb
dex
trading,
you
know
please
reach
out.
If
you
haven't
already,
I
will
reach
out
again.
A
So
you
know
reach
out
if
you
want
to
get
involved,
and
hopefully
there'll
be
some,
you
know,
but
better
commenting
ability
than
the
thread,
but
for
now
you
know,
we've
just
got
the
thread,
so
I'm
hoping
to
dump
this.
You
know
you
all
have
seen
me
try
to
go
through
and
dump
this
several
times
now.
So
you
know,
there's
always
something
else,
so
so
I've,
I'm
def,
it
will
be
dumped
by
next
week.