►
A
Zero
sugar,
okay,
fantastic!
So
what
was
I
thinking
about
the
overlays
okay,
so
the
overlays
are
going
to
be
how
we
track
upstream
programmatic
tracking
of
upstream.
So
this
is
basically
like
your
ruby.
If
you
do,
if
you
do
or
did
ruby,
I
think
was
it
rails
did
rails?
Have
the
migrations
built
in
I
think
rails
did
have
the
migrations
built
in
if
you
did
migrations
like
this
concept,
if
you're
familiar
with
this
concept
of
like
database
migrations.
A
Then
you
can
think
of
overlays,
like
database
migrations
for
your
code,
so
that
it
always
tracks
upstream-
and
it
applies
to
you
to
whatever
policies
that
you
want
to
like
put
on
that
code
right.
So
you
can
say
okay
from
some,
so
we're
going
to
put
all
this
information
on
chains
right.
So
so
what
is
input?
Origin
input?
Origin
is
our
way
of
doing
input
validation.
A
A
A
What
do
I
know
about
the
top
level
system
context
and
how
it's
similar,
maybe
to
previous
context,
either
via
programmatic
match
or
like
via
trained
model
matching
or
via
you
know,
manually
input
operations,
so
you
could
then
say:
hey
you
know
when
I'm
running
alice
connected
to
this
discord.
Remember
because
alice
is
the
entity
in
the
architecture
both
right.
So
when
I'm
running
alice
on
my
iot
device,
you
know
maybe
a
camera
or
something
that.
A
A
In
that
case,
basically
we're
using
these
overlays
ruffles.
Where
are
you
going
we're
using
these
overlays
to
apply
organizational
policies
which
are
context
aware,
which
you
can
basically
think
of
as
like
are
back
on
everything
right?
So
if
you
always
execute
through
this
interface,
this
interface
being
the
system
context
and
some
kind
of
tooling
right.
So
we're
writing
some
tooling
right
now.
A
A
A
Yeah,
so
the
overlays
they
allow
us
to
apply
our
organizational
policies,
fun,
fun
stuff,
so
this
is
what's
gonna
allow
us
to.
Basically,
this
is
like
a
prioritizer
right,
so
this
is
like
the
prioritizer
on
kickoff
sort
of
thing
right,
so
we
can,
we
can
use,
we
can
use.
This
is
our
strategic
plans
right.
So
this
is
our
context
that
we're
strategic
plans
so
this
year,
strategic
plans
which
are
a
part
of
the
data
flow
right.
These
are
just
part
of
the
feedback
mechanisms.
These
are
just
part
of
the.
A
A
So
strategic
man's
plans
may
already
be
in
the
architecture,
if
represented
as
a
data
flow
right
or,
if
represented
as
something
else.
But
let's
see
so,
if
it's
representative
as
data
flow,
then
you
can
use
overlays
to
apply
more
strategic
plans,
because
what
do
we
do
we
com,
so
we
load
all
the
overlays
right.
A
We
load
them
all
and
then
we
combine
them
and
then
we
pass
in
the
new
data
flow
and
then
we
run
the
combined
overlay
and
we
give
it
the
the
new
data
flow,
which
is
the
one
that
we
want
to
apply
the
overlays
to
then
by
running
this
overlay,
this
merged
overlay
flow
and
passing
it
the
input
being
the
data
flow
being
overlaid
also
referred
to
as
to
this
data
flow,
then
that
gives
us
the
resulting
system
context
right.
So
this
is
also,
if
we're
doing
tb,
dex
flows
and
we're
trading
system
context.
A
This
is
our
align
system
context
right.
So
if
we
go
back
to
that
bob
and
alice
diagram,
if
we
go
back
to
that
bob
and
alice
diagram
here,
I
don't
okay,
so
this
one.
Obviously
we
didn't
finish
this,
but
remember
this
okay.
So
this
is
the
tv
dex
flow
overlaid,
so
we
took
the
dffml
execution
architecture
we
put
one
for
alice,
we
put
one
for
bob.
This
is
just
the
default
dataflow
architecture.
A
A
A
A
A
A
A
Okay,
so
we
ask
for
a
particular
con
system
context
to
be
executed.
We
receive
a
contingency
additional
conditional
offer
from
the
pfi
aka
bob
alice
issues
the
offer,
except
with
the
aligned
system
context.
This
is
the
system
context
which
we
applied
our
organizational
overlays
right
and
we
came
up
with
a
resulting
system
context.
This
is
the
system
context.
Did
the
did
for
this
system
context
we
place
in
the.
A
A
Two
days
ago,
lib,
let
me
just
you
know
what
oh
oh,
this
is
the
repo
this
is
or
this
is
the
computer
that
blows
up.
If
you
clone,
I
get
repo
on
it.
Okay
upset
links
like
slang,
slang,
slangs,
so
don't
want
details,
I'm
saying,
okay,
helen.
Can
we
just
talk
to
you?
Please
did
oh
that's
right.
There's
this
contributing
for
the
oh
pfi
mock.
I
don't
think
I
saw
that.
A
A
A
A
A
A
The
let's
see
so
if
we
can
use
it
so
if
we
can
use
the
abd
this
like
blue
sky,
was
it
blue,
sky's
social
network?
It's
like
this.
They
have
this
adx
or
something
some
kind
of
protocol
for
a
social
network
based
on
this
dwn
did
stuff.
So
that
could
be
our
primary
communication.
Layer
that'll
probably
also
facilitate
a
review
system,
I'd
bet
and
let's
see,
and
then
we
just
use
tbdx
for
the
trades.
So
that
would
be
what
I'm
seeing
is
ideal
right
now.
A
A
A
A
A
To
apply
this
overlay
list
to
this,
so
we
could
have
you
know
a
little.
All
of
these,
I
think
are
none
of
these
are
async
right.
So
this
is
a
data
flow
which
we
could
go
execute.
We
could.
We
could
just
go
execute
this
right,
so
we
can
make
something
that
allows
us
to
execute
this
statically
statically
overlay
without
the
async
stuff
right,
but
the
generic
case
is
async,
so.
A
A
A
A
A
A
A
A
A
Okay,
and
what
did
we
do?
We
did
this
overlays
installed
and
this
is
actually
yeah.
Okay,
so
this
is
the
interesting
part
on
this
is
is
when
we
do
expand.
We're
gonna
basically
disregard
the
type
hint
there.
So
I
wonder
if
we're
gonna,
because
if
we
say
expand,
we're
saying
this
thing
returns
this
type,
maybe
we
should
say
yeah,
we
should
say
list
okay,
so
we
should
make
it.
A
A
A
B
B
A
A
A
A
A
A
A
A
A
A
A
A
A
It
gets
called,
and
it
just
keeps
iterating
over
its
list
that
it
has
there
that
it's
sitting
on
it
grabs
that
class
that
load.
It
saves
it
as
this
iterator
that
it
instantiates
on
like
on
con,
like
on
on
on
data
flow
initialization
and
so
on,
operation,
implementation,
initially
initialization.
It
opens
that
iterator
right
and
then
every
time
it's
called
it
just
iterates
once
and
that
way,
and
you
you
seed
with
a
output
from
merge.
A
You
seed
with
an
output
from
merge,
yeah,
and
then
you
also
so
you
modify
the
flow.
You
need
to
do
that.
Dataflow.Update,
you
modify
the
flow
you
seed
for
one
of
these
things
to
be
merged
and
then
the
plugins
installed
accept
it.
It'll
do
the
iteration
it'll
output,
another
one,
and
then
that
way
you
can
control
the
flow,
and
so
you
could
obviously
wrap
that
in
a
subflow.
So,
okay
document,
if
you
want
to
define
the
order
in
which
overlays
are
applied,
you
could
overlay
the
default.
A
A
To
the
the
operation
so
right
now
we're
doing
class.load
and
then
expand
right.
So
basically,
if
you
just
had
a
single
operation
that
didn't
do
expand
right
or
basically,
if
you
just
didn't,
set,
expand
right,
then
or-
and
you
didn't
return
a
list
right,
so
you
turned
to
single
one
return
to
single
one,
and
then
you
take
that
you
also
take
the
output
of
merge
as
an
input.
Then
you're
able
to
you
know
roll
it.
Whatever
way
you
want
in
terms
of
whatever
the
next
thing
that
gets
let
out
for
merges.
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A
All
right
and
then
you
can
have
an
operation
called
another
operation
right
or
trigger
another
operation,
so
you
could
have
trigger
a
whole
subflow
or
something
within
the
parent
flow
again,
okay,
so
invalid
syntax.
And
since
it's
a
live
lifetime
of
the
class,
you
might
have
another
method
called
another
place
and
then
they're
interacting
with
each
other.
Okay,
so.
A
Okay,
so
basically
we
take
this
main
package
overlay.
We
overlay
a
data
flow.
We
overlay
a
list
of
data
flows,
the
only
one
in
it
being
this
plug-ins
installed
right,
which
will
be
the
source
of
our
and
the
source
of
you
know
that
the
other
classes
which
the
data
flows
which
actually
get
applied
in
the
next
one
right,
and
then
we
run
this
next
one.
This
overlay
batch
apply
and.