►
From YouTube: Architecting Alice: Volume 0: System Context: Part 65:
A
Oh
yes,
back
when
we
didn't
know
about
what
output
operations
are
just
a
few
days
ago,
system
context
I'll
see,
live
version
equals
okay,
so
us
version
cli,
okay,
so
version
equals.
A
So
what
do
we
want
now?
It's
version
cli.
So
what
do
we
want
from
this
system
context?
Well,
we
want.
A
A
All
right
so
entertain
us
okay,
so
let's
entity,
name
entity
version,
okay,.
A
This
version
is
garage
from
institute
version.
Okay,.
B
A
It
ended
up
in
alice
conversation.
Okay,
so
that'll
need
to
go
into
the
main
package,
but
we'll
use
it
for
now.
Okay,
we'll
probably
just
put
it
in
the
main
package.
Okay,
so
we'll
return
atlas
for
now.
A
Okay,
so
these
are
auto
start
operations
right,
so
they
will
run
by
default
when
a
context
starts
now,
if
it
context
is
a
deployment
and
the
deployment
has
been
made
specifically
for
a
given
operation,
then
we're
going
to
attach
conditionals,
basically
we're
going
to
overlay
we're
going
to
overlay
effectively
something
that
says
you
know,
run
this
operation
and
then
it
only
only
that
operation
will
run
basically.
C
A
A
C
A
A
Okay,
so
now
this
is
system
context.
Okay
system
contacts-
us
have
some
contacts,
cli
version,
okay,
so
this
is
where.
A
A
You
know
we
might
also
find
define
some
dynamic
config.
You
know
where
we
should
load
save
models
from
we'll
get
into
all
that.
So.
A
Okay,
and
so
we
can
just
write
these
as
regular
functions,
we
should
be
able
to
without
even
decorating
them
system
context
is
not
defined.
A
A
A
A
A
A
A
A
A
A
A
A
A
B
A
A
A
C
A
C
C
A
C
C
C
C
A
C
A
To
do
now
well,
we
want
to
serialize
and
deserialize
the
system,
context
to
dids
and
pdids
and
did
methods.
So
what
are
we
currently
trying
to
do
so?
I
think
we
should
ditch
this
python
api
stuff
right
now,
yeah,
I'm
pretty
sure
that
we
can
just
close
the
day
on
this
one,
because
we
don't
really
need
to
with
this
right
now.
A
This
is
not
a
critical
path,
so
you
know,
I
think
what
we
did
is
we
proved
that
we
made
a
plug-in
and
we
can
install
system
contacts
right,
so
we
can
install
and
load
them.
What
what
we
do
with
them
is
you
know
async
iterate.
Basically,
at
this
point
so
and
we
haven't,
we
haven't
wired
up
the
output,
which
is
really
just
grabbing.
I
think
we
just
need
to
grab
all
of
the
outputs
which
are
not
consumed
anywhere
else,
I
think
by
default.
A
Otherwise
we
will
grab
for
a
specific
deployment
environment.
We
would
grab
the
outputs
of
that
operation
and
that's
right.
We
were
going
to
maintain
pre-overlaid
deployment
environments
right
now
we're
going
to
how
do
we
do
that
we'll
run
the
overlay?
Well,
we
don't
need
to
run
the
overlay,
we
can
do
a
static
overlay
yeah.
We
don't
need
to
do
an
async
overlay.
We
can
do
a
static
overlay
for
deployment.
A
A
We
would
just
record
it
as
a
chain
being
links
being
upstream
after
upstream.
A
C
A
A
A
All
I'm
going
to
do
is
set
alice
as
the
upstream,
and
this
is
the
overlay
and
then
I'll
update
her
within
the
overlay
to
create
my
customized
entity
right
for
my
given
deployment
environment
or
whatever
job
this
entity
has
right,
or
maybe
it's
just
another
version
of
alice.
My
internal
version
of
alice
right
might
just
be
it.
It
might
just
be
alice
with
an
overlay
on
top.
So
let's
try
that
right
now
and
that
way
we
can
support.
You
know
a
dffml
specific
version
of
alice
and
a
generic
version
of
alice.
A
A
Apply
an
overlay
onto
okay
onto
the
name
command,
so
make
sure
that
there's
a
name
command
and
a
version
command,
provided
this
works
overlay
onto
the
name
and
version,
and
maybe
we
could
have
an
info
which
calls
both
name
and
version
and
that
way
in
the
overlay.
A
We
could
just
format
the
data
slightly
differently
and
use
a
different
value
for
the
entity
name
and
then,
hopefully
that
will
be
what
we
need
to
personalize
an
entity
and
then,
as
we'll
see,
you
know
our
models
and
so
forth
should
fit
right
into
these
serialized
system
contexts
so
that
we
can
have
entity
state.
A
An
ntt
state
can
be
loaded
dynamically,
of
course.
So
let's
go.
Let's
do
it
come
on
and
then
after
that,
then
we
will
pursue
serialization
via
did
because
we'll
be
able
to
yeah
seriously
via
the
id,
and
then
we
need
to
think
about
actually
before
we
think
about
serialization.
Via
did
we
need
to
go
back
into
system
context.
A
And
we
need
to
make
it
so
that
the
active
context,
the
active
system
context,
which
is
usually
what
we
would
see
as
the
context,
all
caps
context,
class
property
on
a
base-
data
flow,
facilitator,
subclass
we
need
to
because
they
all
follow
the
double
context:
entry
right
and
usually
the
top
level.
One
is
called
the
object
and
the
second
level
one
is
called
the
context.
A
But
with
this
it's
already
called
the
system
context.
So
this
the
the
sub
level
down
is
the
active
system
context
right.
So
we
have
a
system
context
which
is
basically
just
me.
Okay,
it's
ready
to
go
in
an
active
system
context
which
is
like
you
know,
checking
out
that
orchestrator
for
that
data
flow
and
getting
ready
to
run
it.
A
A
C
A
Populate
installed
system
context
by
sitting
by
registered
in
true
point
name.