►
A
Before
my
computer
died
on
me,
so
okay,
so
here
we
need
to
add
the
overlay.
So
so
I
was
wrong
when
I
was
going
in
the
path
of
this
overlays
applied.
This
is
bad
bad,
bad,
bad.
A
A
Okay,
that's
much
better,
so
this
should
be
coming
out
and
thought
it
was.
An
early
attempt
figured
out
okay.
So
what
really,
in
fact
happens
is
that
the
we
were
onto
something
here.
A
We
need
to
basically
take
these
output
operations
and
we
need
we
need
to
use
the
concept
of
our
system
context
which
we
were
playing
with
here.
We're
originally
thinking.
Let's
use
the
system
context
and
we
switch
back
and
we
thought.
Let's
did.
I
turn
this
off
now.
Okay,
great,
then
we
thought
okay,
great,
let's,
let's
just
run
it
with
the
data
flow.
A
Let's
keep
it
simple,
can't
remember
what
state
the
system
context
stuff
was
in
pretty
sure
we
got
it
to
a
wait
alice,
but
I
can't
remember
so:
we
just
went
with
this
safe
approach.
We've
made
this
work
before
so
object.
Having
overlays
applied
to
it
so
function
we
want
to
wrap
currently
requires
type
hints
to
make
operation
okay,
so
this
is
basically
write
text
and
then
then
we're
just
gonna
fill
in.
A
Then
we
are
going
to
make
where
kw
args
is
we're
going
to
have
the
expansion
of
overlay
to
apply
of
objects
having
overlays
applied
to
it.
A
So
if,
if
it's
a,
if
it's
a
data
flow
or
if
it's
one
of
these
classes,
which
we're
treating
as
a
data
flow
right,
we're
going
to
basically
do
like
we
do
with
the
op
decorator
and
we're
going
to
just
put
a
little
dot
like
we
have
dot,
op
and
dot
amp,
we're
gonna,
put
we're
gonna
put
like
dot,
sys
ctx
and
then
within
ctx.
A
We
have
overlay
upstream
orchestrator,
and
so
then
we're
going
to
put
within
overlay
we're
going
to
put
a
overlay
set
and
an
overlay
set
config
we're
going
to
have
installed
within
within
the
within
the
installed
set
or
let's
see
the
installed
set,
would
just
be
a
data
flow.
A
Okay-
and
we
can
do
that-
all
within
the
overlay
decorator
or
the
overlay
yeah
within
this
decorator
here
the
overlay
dot
after
and
then
and
then
this
is
the
game
plan
for
this,
and
so
after
we
do
that
with
overlay.
After
then,
we
we're
going
to
go
in
where's
the
code.
A
A
Okay,
so
overlays
overlay
equals
overlays.present,
equals
overlays.during,
okay,
so
we're
treating
okay.
So
this
note
here
is
telling
us
that
so
we're
kind
of
running
this
context,
overlays
applied
to
it
okay,
so
this
is
telling
us
so
so
so
the
notes
say
basically
so
so,
after
as
it
is
right
now
becomes
present
and
then
after
is
it
right
now
becomes
present
and
then.
A
Is
also
the
same
as
during
and
then
then
the.
A
And
then
we
only
return
the
context
right
because
now
we're
able
to
watch
multiple
contexts.
So
we
only
return
the
context
from
the
ones
which
which,
which
is
the
main
one,
the
object
having
no
relate
applied
to
it
in
the
executing
of
that
operation,
and
then
just
we
build
just
this
little
ad
hoc
operation,
right
which
then
we
just
grab
the
outputs
from,
as,
as
you
know,
some
unique
value
definition
or
something,
and
then
we
or
let's
see
no,
we
already
figured
out.
A
A
A
No,
you
do
object,
having
overlays
applied
to
it
as
a
processor,
a
processing
stage,
and
then
you
have
another
duplicate
and
the
duplicate
is
the
output
and
that
just
pulls
the
same
and
returns
the
same
okay.
So
it's
just
a
copy,
so
we
just
copy
the
op
on
it
and
when
we
copy
the
op
on
it,
we're
going
to.
A
A
And
the
context
that
we
started
is
going
to
trigger
our
output,
operation,
okay
and
then
everybody
else.
If
you
want
to
run,
if
you
want
to
trigger
any
output
operations,
then
you
better
or
let's
see
yeah
because
it'll
watch.
So
if
you're,
if
you're,
if
your
output
operation,
if
you
you
would
have
to,
you,
would
have
to
copy
the
input
set
context.
So
that's
the
isolation
at
the
orchestrator
context
level.
We
have
the
isolation
on
the
input
set
context
the
orchestrators,
the
the
operation
implementation
network
context.
A
A
So
unless
you
were
to
share
the
ictx
you're
not
going
to
end
up
accidentally,
yielding
your
results
that
you
didn't
expect
from
a
child
flow,
okay
great
at
least
that
should
be
what
happens
so,
okay,
so
all
right!
A
A
Oh
put
it
in
overlay,
put
it
in
overlay,
put
it
in
dfml
dot
overlay
right,
then
call
rename
after.
A
Let's
give
myself
a
checklist
here:
time
check,
1205,
okay,
so
we're
15
minutes
in
okay.
So
we
have
a
plan.
We
took
15
minutes
to
establish
the
game
plan
and
now
we're
going
to
attempt
to
execute
over
the
next
about
oh
and
40,
then,
okay,
so
okay,
so
actually
we
should
try
to
do
about
40
minutes.
Okay,
we
should
try
to
do
this
about
40
minutes,
okay,
so
so
by
one.
A
So
let's
try
to
do
this
by
one
and
if
we're
not
done
by
one,
then
I'm
gonna
reassess
where
we're
at
okay
so
rename
after
the
present.
Okay,
okay,
so.
A
Hey
decorate
child
okay,
now,
okay,
so
decorate
decorate,
overlays
overlay
classes
in
alice.cli,
for
please
contribute
recommended
community
standards.
A
A
A
Present
present:
okay,
I
don't
know
how
to
spell
okay,
so
decorate
overlay
classes
in
lsclifford.
Please
contribute
recommended
community
standards
using
overlays.present,
okay,
so
decorate
that
makes
sense,
okay,
so
and
then
to
do
we'll
put
you
know
this
is
later.
A
So
don't
let
me
do
this
now,
okay,
yell
at
me.
If
I
do
this
now,
okay,
so.
A
A
Overlays
should
add.
Overlays
to
overlay
set
over
overlays.after
should
add
overlays
to
overlay,
set
dot
config
dot.
What
did
we
say
installed
installed.
A
A
And
so
this
is
the
recommended
tasks
that
you
have
installed
to
execute
in
the
future
after
you
execute
the
overlays
on
the
present.
Okay,
so
should
add
sure,
which
is
also
the
same
as
future
is
the
same
as
after
the
future,
all
right,
okay
and
then
so
here
then
decorate
overlay
classes
in
a
cli,
for
please
contribute
recommended
community
standards
using
overlays.present.
A
A
So
add
similar
to
dot
or
at
op,
adding
dot
imp,
dot,
op,
slash
imp.
A
To
op
amps
operation
implementations
the
combined
form
there
abbreviation
so
similarly
to
op,
adding
up
dot
op,
slash,
m2,
op
amps,
like
very
close
all
right
somewhere
to
I
don't
know
we
add
dot,
sis
ctx.
A
A
A
This
is
done
on
data
flow
instantiation
when
we
duplicate
observing
conflict
class
on
upstream,
interesting,
okay,
so,
similarly
to
op,
adding
dot
op,
slash,
m2,
op
amps,
we
add
sys
ctx,
where
upstream
points
to
a
data
flow
that
with
only
that
operation
in
it,
okay,
operation
implementation
in
it,
okay,
so
similar
to
at.
Let's
not
worry
about
the
other
part,
so,
similarly
to
add
up
adding,
because
we
don't
have
time
for
that.
A
Similarly,
to
adding
add
opt
slash,
imp
to
op
ctx,
where
upstream
points
to
a
data
flow
with
only
with
only
that
operation
implementation
in
it.
Okay,
then,
I'm
not
going
to
go
over
that
because
I'm
not
sure
what
it
is
right
now,
but
I
think
it's
I
think,
we'll
get
to
it
later.
So,
okay,
so
we're
streaming
points
to
default
with
only
that
operational
implementation
in
it.
B
A
A
I'm
just
gonna
push
it
with
only
that
operational
implementation
in
it.
Okay,
so
then
we
we
have
a
config
with
an
installed.
A
Or
would
you
want
to
modify
where
you
need
to
lock
it?
Well,
you
can
lock
the
parent
object.
You
can
lock
the
parent
object
of
its
definition,
so
you
could
lock
the
parent
object,
just
replace
the
whole
config
property.
Then
you'd
have
a
new
instance
technically
of
the
parent
object,
so
it
should
be
a
name
tuple
yeah,
so
which
is
a
name
tuple.
So
no
okay,
which
is
the
data
class.
A
Yeah,
it's
a
name
tuple.
Okay,
we
have
a
favorite
insult
property,
which
is
a
name
tuple
with
a
config
with
an
install
property,
which
is
the
name
tuple.
Okay,
it
has
fields.
A
It
has
fields:
okay,
okay,
present.
A
Present
future
okay,
so
past
past,
before
the
only
merge,
no
execute
okay,
I
don't.
I
don't
know
what
to
do
with
that
right
now,
but
we'll
deal
with
that
later.
Okay,
so
we're
that's
basically
describing
the
simple
case
that
we're
doing
now
pretty
sure.
So,
okay,
so
put
it
in
dfmo,
overlays,
overlays,
okay!
Let's
do
it
all
right!
Okay,
so.
B
A
A
Projected
not
fast
forward
okay,
so
it's
already
there
so
yeah.
So
she
tried
to
contribute
to
read
me
and
we
need
to
get
her
an
account.
Okay,
so.
A
A
A
It
needs
to
work
today,
okay,
so
and
then
we
have
a
pull
request.
Okay,
great!
Thank
you.
Thank
you
very
much,
all
right.
Okay,
so.
A
A
A
Okay,
so
this
we,
I
don't
think
we
need
all
this.
This
is
great,
but
it'll
be
in
the
history
so
or
the
hurst
right
now.
So,
okay,
so.
A
A
Okay-
and
this
should
probably
go
here-
is
that
already
there
with
review
comments.
A
Thanks
john
for
the
review,
no
problem,
john,
all
right,
okay,
I
guess
that's
me
right
now,
all
right.
A
A
A
A
That's
just
mad
she's
already
she's
already
there,
okay,
so
you
know
what,
let's
just
add
an
overwrite
flag
on
that
one.
A
A
A
Okay
alice,
please
contribute
amended
unity,
standards,
okay,
so
alice
operation
or
overlay
operations
get
or
wait.
What
is
this
issue
create
github
issue.
A
Okay,
so
alice,
please
contribute
recommended
community
standards.
Overlay
github,
pull
request,
force,
push
in
case
of
existing
branch,
consider
replacing
with
an.
A
With
an
optional
asap,
okay,
preliminary
installed
overlay
registration,
okay,
so
push
okay,
and
it's
still
mad
at
us.
So
why
are
you
still
mad
at
us.
A
A
B
A
A
A
B
A
A
A
A
A
B
A
What
happened?
What
just
happened.