►
A
A
So
we
added
overlays,
it
looks
like
okay,
so
it
looks
like
what
did
we
do
last
time
we
added
this
dataflow
definition
within
the
data
flow
type
once
again
we're
going
to
unify
all
the
types,
but
for
now
you
know
we're
doing
our
we're
we're
just
we're
trying
to
get
get
to
the
point
here.
So
so
we
created
oh
yeah,
we
were
going
to.
A
A
As
plugins
okay,
let's
jump
on
over
into
the
overlay
infrastructure
overlay
overlay
and
we're
just
going
to
add
a
default
method
to
that
great,
and
actually
it's
a
class
method
right.
So
now,
when
we
call
so
then
class.load
dataflow,
we
already
have
okay
great.
So
then,
at
the
end
of
this
return
return
the
overlay
done.
Oh,
you
can't
see
me.
A
A
All
right,
so
what
do
we
got?
So
we
changed
things
in
two
different
spots.
So
let's
just
go
ahead
and
amend
good,
add
dfml,
high
level
amend
right,
so
we'll
go
ahead.
We'll
just
amend
that
one
right!
So
now
we
only
have
that
overlay.default
in
there
and
then
you
know
so
this
is
overlay.default,
maybe
the
overlay
class
overlay.load.
A
Maybe
we
could
get
the
overlay
class,
this
method
and
it'll
be
run
or
something.
I
think
this
is
going
to
end
up
being
we're
going
to
tr.
This
will
transform
into
an
operation
right
eventually,
but
let's
go
in
there
and
grab
it
right
now.
So.
A
If
given
or
installed,
okay-
so
maybe
instead
of
overlay
is
none,
we
should
say:
overlay
is
load
default
right.
So
let's
use
what
is
this?
This
sentinel
value
is
what
they
call
these
load
default
right
and
then
we
can
just
create
ourselves
a
little
class
load
default
and
we
can
do
what
the
nice
folks
in
the
data
class
library
did.
A
And
we
just
say:
load
default
equals
an
instance
of
load
default
right.
So
now,
when
we
now,
we
can
use
the
is
keyword
and
we
can
pass
in
specifically
overlay
of
load
default
right
and
then
that
will
be
the
default
value
here.
So
let's
go
change
the
default
value
right,
so
overlay,
optional
data
flow
equals
none
equals.
A
Let's
just
go
here
before
we
lose
it
sure
we
lost
it.
Where
did
it
go.
A
Even
this
can
be
a
data
flows
class
and
this
would
be
an
operation.
We
do
a
data
flows
class
for
an
operation
and
then
we
do
a
yeah.
We
do
an
operation
which
the
body
is
just
to
supply.
We
do
a
data
flows
class
for
it
and
then
we
do
a
yeah.
And
then
we
do
a
data
flows
class.
That's
it
that's
it!
Okay,
and
then
I
guess
this
overlays
a
specific
instance.
A
A
A
A
A
So
so
you
can
have
load
default,
you
can
have
none
load
default
or
data
flow
okay.
So
if
you
pass
none,
then
you're
going
to
get
no
overflows.
If
you
pass
low
default,
which
is
the
default,
then
it's
gonna
load.
The
install
default
installed,
overlays
right.
A
A
A
A
A
A
A
All
right,
so
we
look
at
the
last
commit
here.
The
last
commit
was
this
overlay
one
so
we'll
do
ahead
and
give
ourselves
that
amend
again
and
we're
gonna
say
get
log
dash
p
and
we're
going
to
check
that
out.
Okay.
So
this
is
what
our
new
you
know,
overlay
keyword
argument,
patch
looks
like
looks
pretty
clean.
So
basically
we
add
this
default
that
we
allow
for
setting
the
you
know
the
default
is
to
to
load
the
system
installed.
A
You
can
override
that
and
say
don't
use
any
overlays
or
you
can
provide
your
own
data
flow
to
use
as
an
overlay
which
is
just
going
to
run
it
right
before
so.
Okay,
so
doing
this
doing
this
at
the
run
stage.
A
A
Yeah,
I
think
this
is
right.
Is
this
right?
Okay
or
we
should
be
putting
this
here?
Is
the
question
right?
Should
this
go
within
the
system
context
itself?
No,
the
system
context
itself
is
just
whatever
data
flow
you're
going
to
run
right,
so
we're
effectively
creating
a
new
system
context.
Let's
make
a
note
of
that.
A
A
Okay,
so
this
thing,
so
what
we
just
learned
is
basically
this
should
maybe
we
could
do
a
little
ascii
diagram.
A
A
A
A
A
If
we
can
see
that
so
alex
l's
prioritizer,
let's
run
operation,
okay,
yeah
we'll
never
be
able
to
see
in
here
it's
way
too
small,
but
we're
going
to
update
the
diagram
so
clean
it
up
later
so
execute
on
prioritizer
or
go
ahead.
Let's
open
ctx
run
operation.
Outputs
of
operation
become
inputs
to
other
operations.
A
Okay,
so
this
is
the
prioritizer
okay.
So,
basically,
what
we're
saying
is
before
even
the
prioritizer.
A
A
A
Execute
system
context:
okay,
new
system,
context,
execution,
house,
okay,
so
actually,
okay,
so
new
system
context
explore
collaboration
opportunities,
get
align
system,
contacts,
context
on
system
context
received
time
answer;
okay,
so
where
do
the
overlays
fit
in?
So
we
want
to
put
overlays
on
before
we
execute
system
context.
A
A
Irrelevant
overlays
all
right
so
apply
relevant
overlays.
So,
basically,
when
we
spin
up
a
network
we
are
going
to
or
like
you
know,
when
we
are,
you
know
when
we've
got
multiple
anytime,
you
have
multiple
alices
right
or
alice
and
bob
in
this
case
right.
A
A
One
thing
that
will
be
interesting
is
revocation
because,
as
you
issue
new
versions
into
the
network,
you
should
basically
say:
oh
yeah
well
they're,
basically
going
to
come,
knocking
on
your
door
every
time
they
want
an
asset
and
and
the
service
the
the
thing
that
you
know
whatever,
whatever
part
of
alice,
that
holds
your
assets
for
incentivizing
reward
that
the
versions
which
exist
out
there
in
the
network
they
will
just
the
problem
is
the
problem
is
when
you
put
stuff
when
we,
when
we
put
stuff
into
this
format-
and
we
say,
execute
based
off
this
format,
alice
is
going
to
just
sit
out
there
and
sort
of
like
be
alive
like
there
is
nothing
particularly
stopping
these
things
from
executing
right.
A
Anybody
can
pick
up
any
of
them
and
execute
them
if
they
wanted
to,
because
you're
just
putting
you
know,
you're
just
putting
a
reference
to
some
code
effectively
right
and
the
code
is.
Is
this
system
context?
So
so
you
know
if
you
went
and
tried
to
execute
it.
Basically,
you
know
any
anything.
Anything
that
did
you
know.
Asset
movement
would
say:
oh,
this
is
an
old
version
right
of
this.
You
know
smart
contract
effectively
right
this
alice.
A
It
is
your
smart
contract,
and
so
you
know
we'll
have
to
we'll
have
to
manage
assets
appropriately.
There
that'll
be
interesting,
so
we'll
have
to
do
some
kind
of
revocation
right.
Relocation
is
going
to
be
central
to
this
yeah
because
you
know
okay,
interesting,
okay,
so
apply
relevant
overlays
kant
and
overlays.
A
Right
so
it
looks
like
we're
just
basically
going
to
add
this
stuff
in
as
an
operation
eventually,
so
we
don't
have
you
know
once
we
basically
so
once
we
split
out
think
about
the
memory
that
the
stuff-
that's
in
df
memory,
we're
going
to
split
that
all
out
into
dataflow
as
class,
which
means
everything
is
going
to
be
its
own
operation
rate.
So
everything
will
just
be
functions
and
it'll
all
be.
You
know,
data
flow
based
and
then
we
will.
A
Via
the
data
flows
class
stuff,
and
then
you
know,
we
can
we'll
basically
just
take
this
overlay
stuff
and
apply
it
right
or
well.
We'll
have
a
default
overlay
as
a
part
of
the
default
overlay.
A
Right
so
basically,
what
we're
saying
is
that,
because
we're
treating
everything
as
an
operation,
we
can
just
simply-
and
everything
is
an
overlay
when
we
do
our
top
level
application
of
the
overlay.
You
know
our
initial
instantiation
of
alice,
which
is
a
running
you
know
running
on
some
system
right.
We
within
that
overlay
say:
okay,
apply.
A
You
know
over.
You
know,
make
sure
that
every
other
operation,
when
it
gets
run
every
other
top
level
system
context
when
it
gets
executed
right
from
its
perspective
or
sort
of
right.
So
every
other
system
context
you've
initiated
a
system
context
right,
so
you're
providing
overlays,
and
so,
when
you
initiate,
when
you,
when
you,
when
you
run
the
other
like
any
operation
that
you
run,
you
can
look
at
it
as
a
system
context.
A
When
you
run
it,
do
you
want
to
apply
the
overlays
right
you
should
you
should
do
that
within
your
overlay
at
the
top
level
or
you
could?
If
you
wanted
to
right,
you
could
have
done
it
already.
If
you
want,
it,
doesn't
really
matter
you're,
just
wrapping
operations
right,
so
it's
it's
all
the
same,
and
then
you
know
you
you're.
Also,
wrapping
with
your
prioritizer
right,
so
we
should
also
say
you
know
to
do.
A
A
A
So
what
was
this?
Do
we
have
any
changes
that
far
right
now.
A
A
Okay,
so
where
is
okay,
so
there's
overlay,
so
get
add
your
file
overlay
and
did
we
add
okay?
So
we
added
the
default
and
the
plugin
type.
Usually
that's
what
we
do
when
we
add
a
new
plugin
type.
We
usually
add
the
you
know
the
dffml
name,
slash
name
and
then
you
know
as
well:
dfml
slash
name
slash
whatever
the
plugin
type
that
we
added
and
then
in
this
instance
we
added
dfml.
A
A
A
Okay,
so
we
load
the
overlay.
Okay,.
A
A
A
A
A
I
found
this
great
this
adx,
this
blue
sky
thing
looks
great,
we'll
check
this
out.