►
From YouTube: Architecting Alice: Volume 0: System Context: Part 54: Eureka! Upstream, Overlay, and Orchestrator
Description
https://github.com/intel/dffml/discussions/1369#discussioncomment-2823067
Time (combination of the upstream and the overlay with orchestration specified). Tick begins execution, remembrance, hypothesis, tock ends.
A
All
right,
so
I
had
a
little
eureka
moment
and
I
discovered
that
did
I
I
said
you
know
well
what
is
the
system
context
and
I
was
so
I
set
it
back
to
myself
and
I
said
well,
the
system
context
is
the
the
data
flow
and
then
I
was
like
okay.
Well,
it's
the
the
architecture
right
and
then
I
was
like
well,
it's
really
more
like
the
upstream
right.
A
A
Trying
to
think
about
that
as
a
you
know,
a
data
structure
and
what
is
really
the
the
right
fields
to
be
in
there.
You
know
to
build
that
thing
and
I
think
that
it
really
comes
down
to.
We
don't
need
those
inputs
separately
right,
because
we
hadn't
been
populating
them
and
quite
honestly
putting
them
in
there.
Statically
is
not
great
like
why
are
they
laying
around?
A
There
is
a
weird
place
for
them,
so
something
felt
wrong
there
right
and
so
by
put
it,
but
by
putting
them
by
saying
basically,
instead
of
the
inputs
we
have
the
over,
but
it
kept
being
like.
Okay,
well,
where's,
the
overlay,
you
know,
how
does
that
come
in?
We
just
put
it
in
the
system.
Context
right
so
run
usually
takes
a
data
flow,
but
now
we're
imagining
a
run.
It
takes
a
system
context.
A
I
wonder
I
think
python
has
like
actual
operator
overloading
stuff
rather
than
like
the
weird
hacky
ways
that
you've
probably
seen
me
do
it.
I
don't
know
I
just
sort
of
you
know
I
do
whatever
whatever
gets
by
right,
so
we
should
probably
check
that
out,
but
let's
see
so,
we
could
potentially
overload
the
run
to
take
the
system
context,
and
when
we
did
that,
then
this
is
the
thing
that
we
would
pass.
You
know
maybe,
on
this
top
level,
run
yeah.
A
A
Yeah,
okay,
so
we
were
looking
at
this
right
and
we
were
looking
at
okay.
What
happens
when
we
say
you
know
hi
alice
or
no,
we
say
alice
what's
up
right
because
we're
starting
our
commands
with
alice,
because
we're
gonna
have
a
little
check
here.
That
does
basically
does
this.
The
phrase
start
with
that,
whatever
the
entity's
name
is,
and
so.
A
A
Okay,
I
was
thinking
about
okay,
the
upstream.
What
is
the
system
context?
The
system
context
is
the
upstream,
the
overlay
and
the
orchestrator.
The
orchestrator
can
also
be
basically
yeah.
The
orchestrator
is
also
effectively
another
system
context
where
the
default
context
is
to
start
the
orchestrator
and
then
yeah.
So
we
do
the
execute
on
the
orchestrator.
So
when
we
execute
a
system
context,
aha,
okay,
when
we
execute
a
system
context,
how
did
we
were
talking
about?
How
do
we
load
a
file?
You
know
how
do
we
load
arbitrary
things
from
disk?
A
Okay,
so
say
we
were
looking
at
this
as
if
it
was
a
file
right,
so
we
have
a
yaml
file,
we're
going
to
put
in
this
emo
file.
You
know
plugin
system
context,
then
config
and
then
within
config,
we'll
have
upstream
overlay
orchestrated
right
and
those
themselves
will
also
be
system
context
right.
Okay,
so
now,
when
we
execute
we
come
in,
we
say
we
load.
We
we
load
the
file.
This
is
the
shim
right,
the
shim
loads,
the
file.
It
says,
okay.
A
Well,
what's
the
format
name
for
my
version,
you
know:
what's
the
schema
of
this
thing?
Okay,
it's
a
system
context
right
so
now,
what's
the
and
what
version
of
it
is,
what
version
of
it
is
it
and
what
you
know
whatever
right?
So
then
we
jump
to
the
next
base,
parser
right,
so
this
this
parser
for
this
system
context.
This
is
it
I'm
stoked,
okay,
this
system
context
for
the
this
deployment
environment
right,
but
to
do
that?
Okay,
so
so
the
top
level
system
context.
A
Different
command:
cli
command.
Okay.
So
where
was
that
here
it
is
okay
here
on
set,
and
u
so
from
line
290
through
nine
line
301.
This
is
where
we
were
running
the
system
context
right.
So
what
did
we
see
here?
Okay?
Well,
we
had
a
run
call
right
with
implicitly
we're
saying
that
this
is
the
memory
orchestrator
right,
so
so
remember,
remember
that
we
said
the
run
so
the
system
context.
So
let's
imagine
this
imagine
this
as
if
new
hold
right.
A
Okay,
so
now
imagine
this!
Take
this
function
now,
transform
it
right
and
think
about.
Where
did
the
data
go
when
we
did
this
right?
Think
about
think
about
the
data
as
it
moves
as
if
you're
looking
look
at
all
that
all
the
pieces
of
data,
all
these
assets
that
you're
you're
you're
we're
taking
we're
taking
all
of
our
concepts
right
and
we're
making
them
these
little
data
points
right
and
then
we're
linking
them
right.
So
we're
saying,
and
so
we
know
that
the
system
context
is
the
upstream,
the
overlay
in
the
orchestrator
right.
A
A
What
are
we
doing
right
now?
Okay,
there's
a
there's,
several
we're
we're
like
10
videos
into
a
stack
of
we're
trying
to
we're
we're
trying
to
to
yeah
we're
like
okay,
it
doesn't
matter,
I'm
not
I'm
not
sure
where
this
started,
but
we're
in
like
a
sub
thread,
and
we
eventually
found
out
that
we
needed
the
system
context
and
because
we
were
going
oh,
we
had
to
do
the
turtles
all
the
way
down
thing
where
we
have
to
keep
the
context
all
the
way
down.
If
we're
really
gonna.
A
B
A
Yeah
we're
going
to
do
call
as
a
class
method.
So
what
we're
going
to
do
is
we're
going
to
create
a
system
context,
meta
class
and
we're
going
to
implement
the
call
on
it,
because
you
can't
do
it,
you
can't
do
a
you
can't
do
an
a
a
class
method.
Decorator
on
a
call.
I
don't
think
I
think
you
have
to
do
it
in
the
meta
class.
We'll
try
it,
but
I
I'm
pretty
sure
you
have
to
do
them
out
of
class.
A
A
A
I
don't
think
we
really
cares.
This
is
for
on
the
command.
This
is
for
labeled
sources
and
labeled
effectively.
This
was
for
supporting,
like
a
more
lightweight
layer
between
list
items
like
it.
It
was
for
supporting
a
less
verbose,
syntax
on
the
command
line,
and
this
is
why
we
need
the
at
entry
point
because
of
some
unit
tests.
A
A
A
A
A
We
won't
want
to
lose
any
any
of
the
any
of
the
context,
so
okay,
so
why
is
it
important?
Why
was
this
important
it?
It's
important
that
we're
shifting
from
this
idea?
Okay,
so
what
do
we
want?
We
want
rce
everywhere,
basically
right,
and
why
do
we
want
it?
Well,
we
we
have
good
intentions
with
rce
everywhere
right,
because
we
want
to
sandbox
everything
and
it's
fundamentally
about
having
you
know.
If,
if
your
your
data.
A
Through
the
network
in
some
way
and
alice,
is
sort
of,
like
you
know,
she's
like
protecting
it
as
it
moves
through
the
network
right,
which
means
that,
like
she
needs
to
be
in
control
of
how
it
moves
through
there
and
that's
why
we
have
to
have
rce
on
everything,
because,
basically
we
it's
not
necessarily
that
we
have
to
have
rce
on
everything.
It's
that
via
the
provenance
information
and
the
trusts.
The
chains
of
trust
that
we
build.
A
We
can
we
can
say
that,
like
we
want
to
do
the
job
right
in
in
and
and
this
should
be
acceptable
people
basically
alice
and
people
will
agree
for
different
parameters
of
different
jobs.
What
is
an
acceptable
completion
criteria
right
for
these
jobs,
and
these
are
the
strategic
principles
and
the
strategic
plans
right?
So
so
these.
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A
B
B
A
I
understood
at
the
time
it
all
was
clear,
but
I
don't
think
I
understood
fully
like
the
other
day
when
we
found
out
that
you
didn't
need
the
output
out
operation.
After
all,
you
just
have
to
set
the
stage
that
that's
what
I'm
talking
about
here.
That
made
me
sort
of
question
I'm
like,
and
not
that
I
didn't
know
what
I
was
doing
when
I
was
writing
it,
but
I
didn't
know
how
to
use
it
in
the
most
ergonomic
way
right.
A
A
A
Okay,
because
we
went
to
do
the
get
thing
where
we?
That
was
the
time
traveling
thing,
and
then
we
realized
that
if
we
were
going
to
do
that
set
file
contents.
That
date
we
needed
like
a
configurable
subflow,
which
we
then
attempted
to
define
with
a
system
context
which
we
were
modifying
op
or
writing
decorators
for
to
make
the
api
like
is
as
small
amount
of
boilerplate
as
possible.
Okay,
so
yeah!
So
that's
how
we
got
here.
A
A
A
D
A
A
A
A
A
This
was
the
old
run
command
right,
so
we
pass
the
data
flow.
Give
us
some
inputs,
we
give
it
the
overlay.
We
get
the
results
great
fantastic.
Now
we're
like
well,
okay.
So
what
we
would
like
is
we
would
like.
We
were
playing
with
overlays
and
then
we
were
like
okay,
well,
we'll
put
an
overlay
and
a
system
context,
and
then
we
were
like
okay.
Well,
let's
put
base
entry
point
on
the
system
contracts.
Well,
that
means
that
we
can
do
system
context.load,
which
means
we
can
load
it
from
a
serialized
repos
or
note.
A
A
So
we
said
okay,
well,
how
would
we
call
the
system
context
that
you
loaded
right
and
then
we
came
in
here
and
we
said
okay
well,
this
is
how
your
cost.
So,
if
I
did,
if
I
had
loaded
this
a
system
contacts,
this
is
a
loaded
system
context
right
here,
then
I
would
just
call
it
like
that
right
and
then
it's
like
okay,
wait
great
well!
A
We're
gonna
deal
with
the
basic
four
in
a
minute.
So
then
we
thought
well,
okay.
So
what
are
we
even
trying
to
do
here
and
then
I
kind
of
just
like
kind
of
just
felt
it
out
right
and
I
was
like
well
what
do
we
want
to
do?
We
want
to
load
alice
right,
we
want
alice,
and
so
then
we
want
you
know
to
run
alice.
Okay.
Well,
then
that
will
return
the
white
house
all
right.
So,
oh
there
we
go
here
now.
A
We
can
basically
just
do
that
all
in
one
statement,
right,
okay,
so
well,
then,
let's
play
with
a
little
more
because
I
mean
come
on
this.
Is
this
ugly
to
have
parental
paren
right
dot
load?
What
is
this
right?
So?
Okay?
Well,
let's
play
what
what
if
we
loaded
this
cli
right,
because
we
know
that
we
can
execute
a
system
context
by
passing
it
to
load
where
we
put
the
inputs.
We
just
embed
those
in
the
overlay
right.
There's
no
reason
I
mean
for
they're
they're
convenient
if
you're
calling
a
data
flow
correct
directly.
A
But
if
you
want,
if
you
want
the
more,
if
you
want
to
just
pass
the
system
context,
just
put
them
in
the
overlay
right,
you
can
overlay
and
put
them
in
the
input
set
if
it
wants
to
so
and
then
we
started
playing
with
okay.
Well,
how
would
we
get
the
parent
input
object
and
I
don't
think
we've
sold
out
one
yet
and
then
oh
then
we
were
trying
to
determine.
A
Should
the
input-
oh
because
it
has
parents
and
the
system
context-
needs
the
access
to
the
parents
and
since
the
system
context
is
itself
an
input
object,
it
was
like
well,
you
know,
then,
are
we
going
to
have
access
to
the
parents?
You
know?
Could
we
use
this
container
of
type
mechanism
and,
let's
see
then
we
realize
that
the
base
context
that's
already
in
here-
is.
A
A
Run
operations
for
ctx,
where
are
you
base
context
handle?
Where
is
this
base
context,
handle
what
makes
you
different
than
a
base
input?
Oh
a
base
input.
What
makes
you
different
than
a
base
input
set
context
base
context
handle
great.
I
have
no
idea
what
that
is.
It's
been
so
long
since
I
looked
at
this
code
just.
B
A
A
A
A
A
A
A
B
A
A
A
A
A
A
A
A
A
This
train
of
thought
we
explored
it.
It
led
us
to
some
really
woefully
out
of
date
base
classes
as
well
as
the
realization
that
everything
is
the
system
context,
because
the
system
context
can
represent
everything
that
the
system
context
is
the
upstream,
the
overlay
in
the
orchestrator,
because
we
can
embed
the
inputs
into
the
overlay.
A
We
came
up
with
our
way
that
we're
going
to
be
able
to
import
system
context,
which
is
basically,
we
can
do
a
we'll
do
an
init
where
the
we
just
go
through
and
do
a
a
load
for
any
active
overlays
right.
So
yeah
we'll
just
go
through
and
load
any
active
overlays
any
installed
overlays
that
is
and-
and
this
will
basically
be
another
plug-in
right.
So
if
you
install
this
plug-in,
which
is
the
importable
right,
so
we
can
say.
A
A
A
B
A
B
A
A
A
A
B
A
A
A
And
so
the
question
is
variable:
name
should
that
come
from
above
from
the
caller?
I
think
it
needs
to
come
from
the
caller.
I
think
it's
from
the
top
parent
system
context.
Yes,
the
variable
name
comes
from
the
parent
session
context.
If
we
were
to
look
at
this
as
a
system
context,
the
variable
name
would
need
to
come
from
the
parent
system
context,
so
we're
back
in
the
same
problem
where
we're
like,
where
are
the
parents?
Okay,.
A
C
A
A
C
A
C
C
A
C
C
C
A
A
A
A
A
So
you
he
talks
about
how
basically,
like
everything,
is
a
controlled
hallucination,
effectively
like
what
we
think
of
as
reality
as
a
controlled
hallucination
and
so
and
and
that's
just
because
our
brain
is
just
like
our
brain.
Like
is
hallucinations,
because
that's
what
I
mean,
what
the
is
that
it's
it's
all
just
your
brain
right
I
mean
it's,
it's
it's
not!
A
A
Can
you
really
say
you
know
something
until
you
can
teach
it
well
do
you
you
know:
do
we
really
know
that
we
can
be?
Do
we
really
know
how
to
be
human
if
we
can't
teach
it
and
so
to
do
that?
We're
gonna
have
to
teach
you
know
ourselves
and
each
other's
and
we're
going
to
teach
alice,
and
it's
very
important
that
we
teach
ourselves
and
each
other's
because
alice
is
using
our
behavior
as
input
data,
so
obviously
with
guardrails
on
it.
But
you
know
day-to-day
things.
A
You
know
you
you,
you
know
we,
we
will
add
our
guardrails
via
strategic
plans
but
general
behaviors.
It's
like
you
know
it's
it's
it.
It's
like
when
people
hang
out
with
each
other.
They
pick
up
each
other's
like
phrases
and
stuff
you
know,
and
and
based
on
the
fact
that
that's
the
input
data
you
know,
because
that's
the
input,
data
that
you're
seeing
right
and
so,
for
example,
the
whale
if
the
whale
has
just
seen
nothing.
A
Somebody
had
some
tweet
the
other
day,
saying
like
how
many
you
know
million
frames
per
second.
Will
you
consume
right
by
age
whatever,
and
so,
but
but
the
whale?
The
thing
is
that
a
human's,
a
human's
input
set
that
data
set
that's
collected
is
just
like.
I
would
I
mean
I
would
suspect
astronomically
more
interesting
than
whales
like
there's
just
if
it
has
a
larger
brain
like
it's.
A
You
know
yeah,
I
mean
effectively
you,
and
this
is
like
the
chaos
metric
right
in
the
dock.
We
talk
about
the
chaos
metric
and
the
chaos
metric.
Is
this
idea
that,
like
you
know,
if
nothing
interesting
is
happening,
and
this
is
like
the
system
where
there's
another
thing
about
the
system
requires
entropy
right.
So
if
nothing
interesting
is
happening
there,
if
nothing
interesting
is
happening.
There's
no
like
that
brain
the
brain.
That
is
the
entity
which
is
alice,
which
is
all
these
models
and
strategic
plans
that
are
learning.
You
know
doing
this
active
learning.
A
A
It's
just
so
it's
so
so
something
to
reduce
it
to
a
data
set
states
of
consciousness.
Well,
it
I
guess,
that's
what
they
are.
So
it's
all
a
data
set
to
alice
right
because
we
have
this
representation
where
everything
is
basically
data,
okay,
so
aka!
So
I'm
going
to
write
it
here.
Anyways
aka
states
of
consciousness.
A
A
Everything
needs
and
a
parent
is
a
very
general
term.
Basically
you
have
to
tell
me
something
about
where,
where
you
came
from,
because
I
don't
know
what
to
do
with
you,
I
have
no
trust
in
random
that
flies
around
the
internet
like,
and
neither
should
anybody
else
and
alice
will
definitely
not
right.
That's
a
no
from
me
so
and
I
think
from
the
rest
of
us
as
well
right,
so
she's
gonna
be
hyper,
critical
and
she's
gonna
say
you
know
where?
Where
did
you
get
this
information?
A
Okay,
okay,
information
which
landed
on
my
doorstep,
where
the
hell
did
you
come
from
right
and
and
can
I
trust
you
or
you
know
and
and
yeah
and
and
do
I
need
to
you
know-
maybe
do
I
don't
need
to
trust
you
right,
but
I
need
to
know
something
about
it
right.
So
maybe
you
know
we
know
something
about
it,
because
it
is
a
did
method
and
it
signifies
that
it
was
the
output
of
some.
A
C
A
A
A
You
found
a
new
article
alice
found
a
new
article
online
we
wake
up
in
the
morning
we
say
alice,
you
know
what
what
have
you
been
thinking
about
and
she
says
well,
you
know
I
heard
that
on
on
the
world
wide
web
that
as
she
was
off
searching
you
know
throughout
the
night
and
she
might
say
well
I
heard
on
the
world
wide
web
that
ruffles
he
should
actually
be
eating.
Half
the
amount
of
food
that
you're
giving
him
oh
well
alice.
A
I
mean
that,
what's
the
likelihood
that
that's
going
to
you
know,
make
ruffles
way
too
skinny
well,
okay,
so
she
should
have
run
that
as
well
right,
but
but
maybe
she
doesn't
know
that
right,
so
maybe
she's
like
I
just
found
this.
Maybe
we
haven't
added
that
logic.
Yet
right
she's,
just
saying
I
found
this
article
on
the
internet,
I
thought
you
might
like
it
right,
but
we
know
right
off
the
bat
that
we
don't
like
this
thing
if
it
doesn't
have
some
kind
of
image.
A
So
maybe
this
is
like
maybe
one
of
the
default
overlays
we
have
applied,
which
is
this
trust
flow
right,
and
so
this
basically
like,
don't
don't
don't
deal
with
any
information
that
I
don't
have
x
degree
of
trust
on
right,
and
this
is
going
to
be
basically
something
where
we
filter
by
origin.
I
think
in
the
input
origin.
So
we
also
need
to
know
the
origin,
okay,
so
yeah,
so
the
parents
is.
C
A
A
Okay,
so
let's
go:
let's
go:
let's
go
mess
with
the
system
context.
So
let's
make
this
links
yeah,
okay,
so
it's
not!
Nothing
is
direct.
Sending
descendant
we're
just
saying
here's
some
links,
you
know
you
want
to
figure
it
out.
You
go
figure,
it
out.
Go,
go
talk
to
these
links
right,
I'm
just
telling
you
I'm
somehow
for
some
reason.
I
think
this
might
be
related
to
me
right.
That's
all
links
does
right.
A
It
will
have
upstream
it
will
have
overlay
and
it
will
have
orchestrator
and
those
will
be
open
architecture
or
wait
a
minute.
No,
those
will
themselves
be
system
context
yeah.
Those
will
themselves
be
a
system
context.
Yes,
okay,
yes,
those
will
themselves
be
a
system
context
and
they
will
link
to
the
parent
object,
which
is
the
system
context.
Okay
and.
A
A
A
A
A
A
A
A
Imagine
that
I
feel
like
I
lost
something
here,
I'm
not
sure
what
it
was
we'll
just
pop
back
our
stack
and
see
how
far
we
can
go.
So
I
think
what
did
we
learn?
Well,
everything
is
the
system
context.
The
system
context
doesn't
have
parents,
it
has
links.
The
system.
Context
is
a
did
method.
The
system
context
takes
the
system.
Context
holds
links
the
upstream,
the
overlay
and
the
orchestrator,
which
are
themselves
system
context
which
will
have
in
their
links
the
parent
system.
A
Context,
which
is,
in
that
case,
a
parent,
and
how
are
we
going
to
use
this
information?
Well
we're
going
to
load
those
system
contacts
and
then
we're
going
to
call
a
we're
going
to
call
a
method
on
them.
So
basically
we
load
the
system
context
and
we
say,
and
then
what
do
we
do?
What
do
we
do?
What
do
we
do?
So
we
call
a
static
function
right
or
not:
a
static
function.
Well,
yeah.
A
A
A
A
B
D
A
A
A
No
we're
just
I
was
gonna
like
I
don't
we're
in
the
middle
of
doing
this.
We're
not
gonna
we're,
not
gonna,
no
we're
gonna.
Do
it
we're
gonna
finish
it:
okay,
so
system
contacts
config,
oh
wow,
it's
everywhere
already.
Okay,
look
at
that!
So
it's
the
upstream
nope,
it's
the
links,
which
is
what
more
system
context
config.
A
A
D
A
Yeah
this
thing
just
just
doesn't
know
this
thing
doesn't
know
what
it's
called.
It
doesn't
know
what
its
id
is.
It
can
figure
out
its
id
by
traversing
the
links.
If
you
asked
it,
it
could
figure
out
its
id.
Basically,
if
you
ran
a
flow
in
this,
if
you
applied
the
overlay
to
the
upstream
random
flow
with
the
orchestrator,
if
you,
if
you
use
the
orchestrator
to
apply
the
overlay
to
the
upstream
and
ran
it,
and
you
ran
a
flow
which
was
get
your
d
id,
then
this
thing
could
traverse
links.
A
A
Okay,
and
that
way
the
overlay
can
have
the
ability
to
you
know,
make
the
dataflow
use
it
if
the
data
flow
wants
or
if
we
decide
the
dataflow
needs
it
right.
So
the
orchestrator.
Okay,
thanks
upstream
overlay
orchestrator.
This
has
been
fantastic.
Okay,
it
was
truly,
it
was
truly
eureka.
I
didn't
realize
I
thought,
is
it
still
going?
We
are
still
going.
I
thought
this.
I
didn't
realize
how
exciting
this
was
going
to
be.
A
A
A
That
would
be
great
and
then
she
can
just
go
through
and
delete
them,
fantastic,
all
right
and
she'll
archive
them,
obviously
as
well.
So,
even
when
we're
like
this
because
remember
we're
creating
this,
these
links
we're
creating
this
chain
of
everything.
So,
even
though
we're
just
working
in
memory
right
now,
she'll
still
have
all
this.