►
From YouTube: Weekly Sync 2020-08-14
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.jypdmu4toi6b
A
A
Yeah,
I
can
see
it,
you
might
want
to
try
to
stop
presenting
and
start
representing
or.
A
A
A
A
A
A
A
A
A
A
A
A
A
All
right,
it
looks
like
oh
they're,
already
annotated,
they
have
type
annotations,
so
we
don't
even
need
to
parse
their
docs
string.
That's
perfect!
So
we
can
just
use
the
because
they're
using
the
typing
module.
So
that's
great.
I
hit
source
hit.
Sorry
you're,
not
looking
at
my
screen,
so
I
hit
source
yeah
and
then
you
can
see
okay
well,
this
one,
I
guess,
maybe
is
not
but
scroll
down
a
little
bit,
keep
scrolling
until
the
end
of
this
doc
string.
A
All
right
now
they
are
using
it
here,
too
yeah
they're
using
the
typing
annotations
on
init.
You
see
they
have
typing
annotations,
so
we
can
just
scrap
that
we
can.
We
can
use.
That's
basically
that's
ideal,
but
usually
people
aren't
doing
that.
So
so
yeah,
that's
that's
great.
So
we
can
use
the
typing
information.
Then
let's
see
yeah
cool
all
right,
I
think
that'll
be
good.
Then
let's
see
yeah.
I
think
we
can
just.
A
We
can
just
grab
the
type
of
information,
because
that's
what
we're
interested
in
here
and
that's-
let's
see,
there's.
A
Stuff
yeah:
where
is
that
I
would
do
a
crap
for
it
or,
let's
see
okay
or
make
make
an
empire
configuration.
A
Yeah
make
config
numpy
yeah
there
you
go,
this
is
all
where
is
it
expect
yeah
inspect
signature
parameters?
Let's
see,
is
that
it?
Let's
see.
A
Yeah
exactly
right,
but
what
I'm
saying
is
the
parameter
structure
will
have
the
parameters,
so
parameters
is
each.
Is
the
there's
a
better
place
where
we're
doing
this,
but
parameters
is
each
of
the.
You
know
that
each
argument
in
the
function
right
and
so
the
parameter.
A
If
you
do
parameters
dot
items
it
ends
up
with
yeah.
Oh
there
there
we
go
down
there,
parameters.items
right,
so
it's
the
name
and
then
the
parameter
object
right
and
it's
it's
list,
it's
a
class
that
you
can
see
in
the
python
documentation.
But
if
you
do
parameter
dot
annotation
it
gives
you
whatever
the
type
is
so
yeah.
That's
probably
what
you
want
to
do
here,
so
you
can
basically
just
take
the
lower
half
of
this
right,
ensure
all
the
required
parameters
are
present
in
docstring.
A
So
basically
you
you
want
to
work
from
this
for
loop
here
forget
about
the
body
of
it,
but
really
just
you
know
the
parameter,
parameter
name
and
then
the
perimeter.
You
know
the
the
typing
information
is
there
for
you,
the
one
thing
you're
not
going
to
have.
Is
that
the
help?
But
you
know
that's
fine.
It
doesn't
really
matter
if
we're
just
using
this,
for
you
know
converting
type
stuff,
but
you
also
like
you.
A
Don't
really
need
to
do
this,
because
this
is
like
what
we
need
to
do
if
we're
gonna,
you
know
make
something:
that's
like
an
entry
point
out
of
this
right.
We
need
to
make
a
config
structure.
You
really
just
care
about.
You
know
validating.
The
types
are
what
they
are
supposed
to
be
right.
So
when
you
yeah
sweet.
A
A
A
Okay,
okay,
so.
A
A
A
A
A
Oh
arg,
all
right
so
yeah
this
becomes
async,
and
then
I
mean
the
problem
with
this
okay.
So
this
is
not
ideal.
Okay,
where's
parse
unknown
used
is,
I
guess,
the
question
here,
because
we
probably
just
need
to
clean
things
up
because,
okay,
so
we
really
shouldn't,
I
mean
we
lose,
we
lose
all.
We
lose
all
how
about
actually,
okay,
how
about
this
config
loader
equals
none
all
right.
So
if
you
don't
pass
the
config
loader,
how
about
we
change
it
so
that
if
you
don't
pass
a
config
loader?
A
Okay,
so
all
right!
Sorry,
let
me
explain:
okay,
if
we
instantiate
a
config
loader
within
this
function,
we
lose
all
hope
of
any
sort
of
thing.
If
somebody
makes
a
config
loader
for
some
point
in
time
that
you
know
say,
take
some
information,
a
file
and
actually,
like
you,
know,
okay,
so
there's
this
thing
called
vault,
it's
hashicorp
vault!
I
don't
know
if
you've
seen
this,
but
it's
basically
like
a
secret
storage
thing
and
so
say
somebody
made
a
config
loader.
A
That
said,
okay,
I
see
this
file
and
the
file.
Let
me
read
the
contents
of
the
file
and
the
contents
of
the
file
might
like
you
know
have,
or
you
know,
what's
a
better
idea.
Okay,
let's
see
all
right,
so
we
have
this
thing
called
the
actually.
This
could
be
interesting.
This
thing
called
the
trusted
platform
module
and
it's
this
hardware
security
chip,
and
so
basically
this
thing
does
all
your
crypto
for
you,
and
so
that
way
you
know
it
doesn't
get
done.
A
You
know
you,
you
put
it
on
a
different
chip.
You
can't
do
side
channels
and
stuff
on
it.
Well,
okay,
you
can
but
it's
harder,
and
so
essentially,
if
somebody
had
like
you
can
have
these
things
that
are
like
a
context
file
in
the
context
file
where
we
refer
to
some
object
that
might
be
encrypted
within
the
tpm.
So
I
have
this
file
on
disk.
A
Someone
has
signed
into
the
computer,
so
the
file
on
disk
it's
unlocked,
and
now
I
have
this
config
loader
that
you
know
when
when
we
start
the
config
loader
it
does
an
initial
handshake
with
the
tpm
right
and
the
tpm
is
very
slow.
So
whenever
you
do
that
initial
handshake,
it
takes
a
bunch
of
time,
and
so,
when
we
first
do
this
async
with
config
loader
and
like
we
have
one
of
these
files,
that
is,
is
for
the
tpm.
That's
when
it
first
loads.
A
So
basically
based
on
the
extension
right,
we
load
the
appropriate
config
loader
and
we
do
the
initial.
You
know
async
width
on
that
config
loader
right
to
make
an
initial
connection
right,
and
so
it
might
it's
really
slow
and
then-
and
so,
if
we,
if
we
were
to
do
that,
if
we
were
to
do
that
and
then
and
then
we
you
know,
then
we
actually
call
the
load
file
method
and
it
loads.
A
The
contents
right-
and
it
may
do
this
conversion
where
it
goes
and
it
talks
to
the
tpm
and
it
comes
back
and
it
gets
you
the
actual
contents
of
the
file
decrypted
through
through
through
that
that
chip
right
and
that's
all
very
slow
process.
But
the
the
point
here
is
that
initial
hand
shake
is
also
slow.
And
so,
if
we
do
this
within
this
function,
we're
going
to
lose
we're
going
to
we're
going
to
incur
that
every
single
time
right
we're
going
to
incur
that
startup
slowest
snow,
slowness
every
single
time.
A
A
Right
here
and
then
we'd
say:
config
loaders
equals
that
right
and
that
way
you
know
we
could
keep.
We
could
one
could
choose
to
keep
this.
This
config
loader's
object
open
over
the
lifetime
of
many
calls
to
parse
unknown.
So
that's
probably
the
way
that
this
should
work
and
then
in
here
we
just
do
and
let
me
just
make
sure
so.
This
config
loaders
api.
A
A
This
config
loader
api
is
not
ideal
yeah,
it's
kind
of
all
right,
so.
A
A
So
if
we
see
an
argument
right
so,
if
r
starts
with
the
the
dash
l,
if
r
dot
starts
with
you
know
at
then
we
do
this
config
loading
right.
A
Yeah
exactly
right
well
and
that's
what
I'm
saying
is
that
we
have
to
do
we're
going
to
have
to
this.
It's
going
to
be
a
bit
of
a
pain
in
the
ass
right,
because
we
have
changes
to
async
right,
but
you
really,
I
mean
you're.
Basically
I
mean
this
makes
it
a
bit
of
less
of
a
pain
of
ass,
because
you
really
only
have
to
right.
You
can
basically
just
say
none
here
and
then,
if
you
don't
pass
it
because
there's
lots
of
places
where
we're
using
this.
A
In
tests
and
things,
and
so
basically
you're
just
going
to
have
to
go
change
those
to
be
a
weight,
but
that
should
be
much
less
of
a
problem
than
than
having
to
make
them
also
take
a
config
loader
because
they
won't
most
of
those
don't
need
it
right
and.
A
Yeah
yeah
yeah,
so
you'll
have
to
do.
Do
it
main
in
the
main
place
right,
but
that
should
be
pretty
trivial
and
then
this
one,
let's
see
it's
merge,
it's
basically
yeah
load
the
thing
right
and
then
we
merge
it
into.
A
I
think
just
parsed
right,
I'm
not
sure
where
there
should
be
a
merge
function
right.
I
think
I
think
it's
pretty
much
this
right.
I
think
this
is
pretty
much
what
you're
dealing
with
here
now
you
might,
let's
see
yeah,
I
guess
yeah
that
and
that
would
let
you
do
things
where
you
combine
different
files
like
you're,
saying
right.
If
you
have,
if
you
have
different
layer
configs,
maybe
you
have
different
models
with
different
layer,
configs
or
something
yeah.
I
think
you
would.
A
A
A
A
All
right,
okay,
so
and
then
I've
updated
this
guy.
So
this
is
now
this
is
sort
of
closer
to.
I
think
what
you're
gonna
need
here,
sweet,
okay!
So
all
right!
So
just
do
you
guys
want
to
take
a
break
now
before
we
continue
or
do
you
guys
want
to
keep
going.
A
All
right,
that's
fine,
yeah,
all
right!
Well,
I'm
glad
we
started
with
you,
then
all
right.
So,
let's
see
layer
support
example.
Let
me
just
put
this
well
happy
birthday
to
you
brother,
then.
So,
let's
see
python
and
opencv
example
updated.
Okay,
we're
going
to
review
that
that
one,
let's
let
me
say,
let's
just
review
that
one
offline,
because
that
that
can
take
a
while
and
then
custom
models
is
essentially
layout
support.
A
Of
course,
have
a
good
one
thanks
textual
bye,
all
right,
so
all
right!
Well,
I'm
glad
we
picked
suction
to
go
first
so,
and
I
mean
that
still
was
not
short,
so
all
right,
all
right,
okay,
so
again,
what's
the
issue
that
we're
facing
with
the
distributed
orchestrator
at
the
moment
here.
A
A
A
A
A
A
A
A
A
A
A
A
I
mean
it
should
be
start.
I
think
I
think
the
answer
here
is
really
that
if
more
nodes
come
online,
it
should
start
using
them
right,
no
matter
right
now,
no
matter
when
they
come
online
right,
because
we
have
that
circular
queue
right.
So
it
should
just
be
a
matter
of
saying
you
know
and
right
and
isn't
that
it's
on
the
orchestrator
side,
anyways
right
so
yeah
I
shouldn't
I
mean
I
I
guess
I'm
not.
I
guess
I
just
don't
see
why
that
didn't
just
work
right,
because.
A
Oh,
it
stops
listening.
Oh
I
see
oh
yeah
just
keep
it
open,
yeah
yeah
yeah.
Just
I
guess
yeah!
That's
that's
sort
of
your
answer.
There
is
just
do
create
task
on
it
and
then,
when
the
orchestrator
closes
down,
keep
a
hold
of
that
task.
Object.
Do
async,
io,
create
task
and
then
keep
a
hold
of
that
task.
Object
somewhere,
so
that
when
you
do
in
a
exit
on
the
orchestrator,
then
you
cancel
the
task.
A
A
A
Okay:
okay
for
the
input
network.
A
Yeah
I
mean
well
you're
gonna
get
inputs
from
the
the
workers
when
they.
Let
me
let
me
take
a
look
at
the
code,
real
quick
here.
Okay,
so
also
what
happened
to
the
full
request,
the
pull
request
is
all
sorts
of
funky.
Did
you
merge
master
or
something.
A
Yeah
yeah,
that's
okay!
I
think
I
think
what
happened
here
is
that.
A
Yeah,
I
know
I
need
to
fix
the
I
need
to
fix
the
ci.
A
A
Oh,
oh,
where
should
you
add
that
okay,
let's
see
oh
great,
let's
see
where
did
we
put?
Did
I
put
that
in
somewhere?
I
want
to
see
if
I
put
that
in
somewhere.
A
Yeah
he
got
it
right.
He's
he's
right,
but
I
thought
I'd
put
that
in
somewhere,
I'm
just
trying
I'm
just
wanting
to
check
if
this
is
in
the
documentation
or
not.
I
swear
I
put
it
in
here,
but
I'm
kind
of
feeling
like
I
didn't
god
I
need
to.
We
need
to
still
rework
this.
A
Oh,
that,
oh
yeah,
no
yeah,
I
don't
know
I
would
back
out
that
last
merge
of
master.
I
don't
know
yeah,
I
don't
know
I
mean.
I
don't
really
know
what
to
tell
you
here.
Unfortunately,
I
think
what
I
would
say
is
the
problem
is
okay.
The
problem
is
you're
targeting
the
nats
branch
here
right
so,
but
we
also
haven't
done
anything
on
the
nats
branch.
So
I
think
if
we
do,
why
don't
we
do
this?
A
I
think
if
we
do
master,
then
it
should
show
only
the
diff
that
we
want,
because
we
haven't
merged
anything
into
them
in
a
stance
yeah
there
we
go.
I
think
yeah.
I
think
yash
actually
showed
this
to
me
once
okay.
So
now
we
can
take
this
and
you
can
do
okay,
yeah,
okay,
so
take
this
and
do
okay.
The
problem
is,
it
still
has
those
merge
master
all
right,
so
I
think
what
we
can
do
is.
A
A
A
A
I
think
this
might
be
all
you
need
here.
Let's
see,
yeah
try
just
this
dot
patch
thing.
A
Okay,
but
I
don't
know
it
might
give
you
it
might
end
up
giving
you
these
well,
it
said
one
out
of
12.
so
yeah.
I
think
it
might
have
gotten
rid
of
yeah,
so
I
think
it
throws
away
those
merge
masters
anyways.
So
here's
what
we
should
do
is
I'll.
Take
you
probably
want
stuff
from
master.
So
why
don't
I
just
take
master
and
and
do.
A
A
A
A
Yeah,
okay:
let's
see
where's
gnats,
let's
check
out
the
nats
branch
and
make
sure
that
it's
up
to
date
and
then
we'll
just,
I
think
what
you
want
to
do.
Is
you
just
want
to
pull
down
that
patch
and
then
and
then
wipe
out
your
thing
and
then
make
that
branch
just
that
okay
wait
no
29
days
ago,
so
it
didn't
actually
take
the
update,
so
it
might
work.
If
we
just
do
this
actually.
A
It
sets
the
upstream,
so
you
don't
have
to
say
origin
every
time
all
right.
Actually
this
should
work.
A
I
just
I
guess
it
didn't
push
it.
So
this
should
probably
because
now
it
should
have
all
those
changes
and
just
be
like
that's
nothing.
Yeah.
Okay!
There
we
go
okay.
Now
that
fixed
it
all
right,
okay,
so
we
just
needed
to
update
math,
then,
okay,
sweet
okay.
What
were
we
talking
about?
Okay,
yeah,
so
just
continue
to
listen
for
new
nodes
while
running
to
add
to
circular
queue
all
right,
sweet.
Was
there
anything
else
on
this
one.
A
Okay,
oh
okay,
so
I
mean
right
now:
does
it
it
does
okay,
so
right
now,
let's
see
oh
yeah,
that's
why
we
opened.
It
was
because
we
were
checking
it.
A
All
right,
that's
that's
just
funny,
because
that's
just
I
don't
know
where
this
came
from,
but
this
was
I
wrote.
This
was
the
initial
name
that
I
had
for
this
whole
thing,
so
it
must
have
shown
it
must
have
been
somewhere
unless
you
came
up
with
this.
But
my
guess
is
this:
this
was
somewhere
that
I
had
put
it
long
long
long
ago.
A
See,
let's
see
set
instance,
details.
A
A
A
A
A
Yeah
yeah
right
and
then
that's
what
we're
doing
here
is
we're
subscribing
to
register
worker
node
is
a.
I
would
assume
a
constant
up
here.
Yeah,
okay,.
A
A
All
right
and
yeah:
that's
when
you're
gonna
get
the
new
ones
and
you're
gonna,
okay
yeah.
So
I
would
say
I
would
say
that
that
would
that
would
be
a
good
place
for
comment.
Right
is
to
say
you
know
yeah,
so
we
could
say
something
you
know
like
all
right.
You
know
wait
when,
when
orca,
when,
when
something
like.
A
A
Right
waiting
for
all
connection,
we
found
all
available
ops
that
wait.
Okay
and
then
all
available
ops
is
okay,
yeah,
an
event
and
register
worker.
A
A
A
A
It
shouldn't
break
anything
right.
Let's
hope,
let's
see,
oh
no
goes
through
operations.
Data
flow
and
assign
an
instance
to
a
worker
node,
making
sure
that
each
worker
node
gets
at
least
one
instance.
Okay,.
A
Great
yeah
right
and
yeah
yeah
right,
it
should
happen,
I
mean
it,
it
will
happen.
Let's
see,
this
is
node
token
managing
instance.
So
the
goal
here
is
to
create
a
structure
that
says:
okay.
This
operation
instance
ends
up
with
these
nodes
right.
These
node
ids
right,
okay
and
I-
and
I
think
that
that
yeah,
so
you
have,
you
basically
have
this
dictionary
of
all
the
instances,
and
then
you
have
each
instance.
I
mean
you
can
probably
build
this
thing.
You
know
initially
right
and
then
each
instance
is
just
mapped.
A
A
A
Okay,
all
right
and
then
so,
okay,
there's
one
more
thing
that
I
think
that
we
should
do
here
is
essentially
to
really
test
that
this
is
working.
We
should
take
we
very
okay,
so
right
now,
this
is
all
you
know.
A
Theoretically,
yeah
we're
all
we're
all
good
here
right,
but
the
the
sort
of
a
true
test
here
would
be
to
say
to
start
up
a
new
process
for
each
one
of
these,
and
so
you'd
start
you'd
start
up
a
new
process
for
each
worker
right
and
then
you
would
do
something
that
would
result
in
them
all
being
like
in
them
all
being
issued
in
operation
at
the
same
time
right
and
then
you
would
lock
until
they
all
you
know
they
all
do
that
right.
A
So
you
would
use
like
the
threading
module
or
not
really
the
threading
module,
but
you'd
probably
use
like
multi-processing
or,
let's
see,
processing.
A
So
essentially
do
some
do
some.
Okay,
so
start
use,
use
the
multi-processing
module
to
actually
start
the
workers
within
their
own
process
right
so
they're.
Now,
basically,
you
know
the
fork
system
call
right
would
create
a
new,
creates
a
new
process
right
like
a
yeah,
so
make
sure
that
it's
in
its
own
process
and
now
that
it's
in
its
own
process
you
spin
up.
All
I
mean,
then
this
might
be
a
test.
It
might
be
a
test
you
want
to
do
now.
A
A
A
Yeah
that
I
mean
that's,
that's
that's
yeah,
that
that
would
I
mean
that's
something
that
would
be
good
to
do
that
one
too,
but
I
so
what
I'm
saying
here,
though,
is
really
that
that
we're
this
is
a
test
to
make
sure
that
everything
is
actually
running
in
parallel
right,
so,
basically,
and
and
it's
as
simple
as
you
have
an
operation
that
has
you
have
an
operation
that
has
let's
see,
how
do
we
do
this?
A
What
do
they
need?
They
need
like
a
semaphore
or
something.
A
Okay,
the
point
is
basically
okay,
so
take
you
have
three
operations
right:
it's
like
the
lock
demo
right
or
well.
No,
there
you
have
three,
you
have
three
operations
right.
The
goal
here
is
to
have
three
operations
run
right.
You,
you
basically
put
three
operations,
they
all
take.
You
know
a
string
as
an
input
right,
you
put
one
input
into
the
network
or
you
put,
let's
see
yeah
you
put
three.
A
You
put
three
inputs
input
into
the
network
right,
so
they
each
run
right
and
they
each
you
want
to
check
that
they're
all
running
at
the
same
time
right
so
that
they
all
got
executed
on
on
three
different
nodes
at
the
same
time.
Right
so
then,
basically
they
get
their
thing
and
they
then
they
wait
until
they
see
that
the
other
two
have
also
gotten
executed
right
and
then
they
stop
executing
once
they
know
that
all
three
of
them
are
executing
have
executed
at
the
same
time
right.
A
So,
basically,
you
end
up
with
a
situation
where,
if
they
don't
execute
all
at
the
same
time,
this
test
is
never
going
to
complete
right
and
so
then
that
that
way
that
way,
you
know
that
it
ensures
that
you
have
a
test
that
makes
sure
that
everything
is
running
at
the
same
time
right,
because
your
test
is
going
to
be
never
completing
unless
they
all
run
in
the
same
time
right.
So
it
just
it
tests
that
the
scheduling
is
working
right
and
and
actually
scheduling
things
in
parallel
and.
A
They
can
yeah,
I
mean
yeah
as
an
os
level
thing
like.
Yes,
they
can
open
files
at
the
same
time.
How
how
that's
gonna
work
is
is,
is
gonna
be
different
though,
like
that
may
not
be
it
may
not.
Actually
you
know
do
what
you
you,
you
think
it's
gonna
do.
A
A
A
A
And
then
you
basically
do
like
a
well
true
on
empty.
Like
you
know,
you
do
a
wow
while
not
empty
spin
right,
so
you
do
a
q
get
and
then
you
do
a
well,
not
empty.
You
spin
right
and
then
the
operation
completes
so
now.
The
thing
is,
you
have
to
make
it
you're
going
to
have
to
do.
You're.
A
So
there's
going
to
be
some
things
to
think
about
here,
but
it'll
be
it'll,
be
definitely
interesting
and
you're
going
to
learn
so
yeah
right,
like
everything,
everything
is
yeah.
It's
it's!
It's
it's
yeah!
It's
it's!
It's
fun
stuff!
It's
not!
It's!
Bang
your
head
against
the
wall
stuff,
but
it's
fun
stuff!
So
yeah!
Okay,
I
think
that's
your!
Your
path
there
do
you
feel
good
about
the
rest
of
what
what
you
should
be
doing.
A
A
All
right,
I
would
so
I
would
stay
away
from
I
would
stay
away
from.
I
would
stay
away
from
doing
the
the
final
demo
for,
like
you,
know,
full
a
full
thing
for
a
while
here
right
make
sure
you
can
yeah.
A
Okay,
yeah,
yeah
yeah
sounds
yeah,
okay,
so
and
then
other
things
here
would
be
like
yeah,
okay,
so
yeah
focus
on
focus
on
getting
make
sure
that
they're
all
all
going
and
then
you're
trying
to
now
you're
thinking
when
you're
talking
about
input,
node
you're
like
okay.
How
am
I
going
to
pass
these?
You
know
the
outputs
of
these
things
together
right
or
to
each
other
right,
so
the
nuts
okay.
So
it
starts
up,
and
it
says
you
know
these.
A
These
are
the
various
operations
that
I
have
and
now
basically
you're,
going
to
publish
right.
Your
your
your
plan
was
to
publish
to
a
instance
within
a
worker,
node
you're,
going
to
publish
to
the
queue
of
that
instance
within
the
worker,
node
right
to
give
it
stuff
all
right.
Okay.
So
in
that
case,
what
you're
probably
wanting
to
do?
Is
you
probably
want
to
have
this?
Let's.
A
A
I
mean
yeah.
This
is
well.
This
is
what
we're
saying
is.
This
is
why
this
is
a
proof
of
concept
right.
This
is
not.
I
mean
this.
The
the
goal
with
this
is
to
get
something
where
we're
doing
we're
doing
something
where
you
could
run
it
on
multiple
machines.
It's
not
truly
it's
distributed,
as
in
it's
running
on
multiple
machines.
A
It's
not
distributed,
as
in
you
know,
there's
no
central
central,
centralized
control
right
so,
but
a
bit
of
a
bit
of
a
bit
of
an
overloaded
term
there,
but
but
yes
that
I
mean
that
so
that's
that
would
be
a
different
problem
space
and-
and
I
think
it's
one
that
we
want
to
want
to
do
eventually
yeah
yeah,
but
it's
not
something
that
we're
gonna
try
to
tackle
right
now.
A
So
so
I
think,
what's
it
gonna
say:
okay,
so
basically
the
input
network
when
you
run
an
operation
right,
you
end
up
with.
Let's
see
you're
going
to
want
to
have.
A
So
yeah,
you
haven't
even
gotten
to
the
point
where
you
instantiate,
like
an
orchestrator
or
something
right
so
because
you're
going
to
need
to
instantiate
a
you're
instantiating
nodes,
but
you're
not
instantiating
like
an
orchestrated
node,
but
you're,
not
instantiating
like
a
dfml
orchestrator
right.
So
you
need
to
you
need
to
create
the
orchestrator
right
and
and
the
orchestrator
when
okay,
so
the
orchestrator.
Essentially
your
orchestrator
is
your
orchestrator,
your
primary
node
right.
A
Yeah,
exactly
your
input
network
context,
yeah
your
input
network
context
is
a
nat's
input
network
context
right
and
when
you
see
a
new
input
you
decide
well,
let's
see,
I
think
it's
actually
more
of
the
yeah,
the
the
yeah,
the
input
network
context
is
you
have
the
orchestrator
side
and
then
you
have
the
worker
side
right
and
the
orchestrated.
A
The
orchestrator
side
is
subscribed
to
whatever
cue
that
the
workers
are
publishing
to
right
and
they
can
all
publish
to
the
same
queue.
I
think
right
because
they're
just
getting
yeah
right,
it's
just
you
know.
What's
the
definition,
what's
whatever
right
and
well,
actually,
let's
see
it
should
have
well,
it's
going
to
have
the
parents
too
right,
and
so
this
is
where
you
get
into
right.
A
So
this
is
where
you're
going
to
get
into
these
you're
going
to
get
into
the
fact
that
the
input
has
a
parent
right
and
when
it
goes
through
the
main,
orchestrator
loop,
it's
gonna
say:
okay.
Well,
where
are
the
parents
for
this
this?
This
object
right?
Where
did
this
thing
come
from
right
because
that's
gonna.
A
The
parent,
so
the
input
has
a
parent
right,
which
is
the
input
that
generated
it
right,
and
so
you
you're
gonna
need
you
need
some
sort
of
tracking
system
here
right.
You
need
something!
That's
that
allows
you
to
say
you.
You
need
something,
that's
going
to
say,
let's
see
because
these,
so
these
the
inputs
all
have
unique,
ids
right
that
that
was
part
of
part
of
the
thing
that
we
did.
A
We
made
the
inputs
all
have
unique,
ids
right,
and
so
you
may
not
have
like
you're
going
to
want
to
you're
going
to
want
to
have
something
that
sits
like
some.
It
could
even
just
be
a
giant
dictionary
right,
but
it
basically
says
you're
going
to
start
seeing
inputs
with
ids
and
when
they
come
in
from
another
node
right
when
you're
getting
an
input
from
another
node
we're
going
to
have
some
kind
of
serialized
representation
of
it
right,
which
is
basically
them
diff,
df
types
put,
and
I
think
we
still
need
to
import.
A
A
Okay,
so,
okay,
this
is
the
other
problem.
Okay,
this
this
is
going
to
be
a
thing
you
run
into
okay,
so
get
parents
actually
gets
every
single
parent
ever
right.
So
and
that's
that's-
that's
questionable.
There
is
a
issue
that
that
is
out
there.
That
says,
are
we
sure
we
want
to
do
this?
Because
if
you
don't
have
all
the
parents
in
memory,
then
what
does
that
mean?
A
It
means
you
have
to
go
like
find
out
where
the
hell
are
they,
but
because
you
have
parents,
and
then
you
have
the
parents
of
your
parents
right
so
every
yeah!
So
can
you
hear
me
hello,
blue,
okay?
Okay,
so
you
have
the
parents,
and
then
you
have
the
parents
of
your
parents,
and
so
the
problem
is
right.
Now
we've
got
self-doubt
parents.
A
Okay
or
well,
origin
is
like
seed
right
and
parents
is
the
inputs
that
generated
this
input
right.
So
if
there
was,
if
there
was
one
up
so,
if
there's
you
know,
there's
the
there's
yeah
the
origin,
so
the
origin
is:
where
did
this
input
come
from
right?
So
that's
the
thing
we
might
make
like
client
or
something
right.
So
if
we
had
then
and
that
that's
what
lets
us
say,
okay,
these
inputs
are,
you
know
they
might.
A
Let
us
say
that
these
inputs
are
trusted
and
these
inputs
are
untrusted
right,
so
by
default,
they're
sort
of
we
make
them
seed
because
you
know
usually
we're
providing
them
right,
but
essentially
with
with
parents
right-
and
we
now
are
in
this
situation,
where
okay,
so
parents
are
supposed
to
be
the
list
of
immediate
parents
right
as
input
objects
right
well
in
the
case
when
we
export,
we
probably
want
to
do.
You
know.
A
We
probably
want
to
say:
okay,
our
parents
are
just
you
know
the
ids
of
our
parents
right
when
we're
exporting,
because
then
one
should
be
able
to
say
okay,
I
have
okay.
So
this
the
situation
that
you're
in
here
is
right.
You
you
have,
the
orchestrator
is
going
to
have
something
where
it
knows
all
of
the
right.
It
needs
to
know
all
of
these,
these
these
inputs
right
and
it
needs
to
know
them
because
it
needs
to
do
gather
inputs
and
stuff
and
gather
inputs
is
going
to
look
through.
A
All
of
the
you
know,
it's
going
to
need
to
do
conversions
on
these
definitions
and
it's
going
to
need
it
for
the
redundancy
checker,
because
the
redundancy
checker
does
redundancy
checking
on
specific
paths
of
inputs
right.
So
it's
you
know.
One
one
input
created
by
a
certain
set
of
other
inputs
is
different
right.
Then
another
input
created
via
another
path
right.
A
A
We
may
we
me-
and
now
this
is
yeah
whatever
the
nats
orchestrator
input
network
is
so
the
input
network
on
the
side
of
the
orchestrator
rather
than
the
site
of
the
worker.
Whatever
that
one
is,
we
need
we're,
probably
gonna.
We
need
that
to
have
some
kind
of,
like
you
know,
giant
dictionary
in
it
that
maps
uids
to
inputs
so
that
when
you
get
an
import
because
you're
gonna
get
these
inputs
coming
in
over
the
network
right,
so
you're
going
to
get
these
inputs
coming
in
through
this.
A
I
believe
it's
uid
right
or
no.
What
was
it?
Yeah,
uid
yeah
you're,
going
to
need
the
uid,
and
so
what
you're
going
to
do
is
you're
going
to
have
this
giant
dictionary
that
maps
you
know
uids
to
the
input,
objects
right
and
then-
and
you
know
this,
this
giant
thing
it
could
be
like
a
you.
You
know
this
could
in
this
this
could
be
swapped
out
for
a
database
somewhere
or
something
right,
but
for
now
we'll
just
use
a
dictionary
right.
A
So,
but
the
point
is
basically
when
you
get
a
new
input,
object
right
and
it's
been
serialized
over
the
network.
All
you
have
is
the
uids
of
its
parents
right.
So
when
you
need
to
rebuild
that
on
the
side
of
the
orchestrator,
that's
actually
going
to
be.
You
know
doing
the
thing
where
it
needs
the
parents,
for
you
know
the
locking
and
the
and
the
redundancy.
A
Then
you
have
to
do
when
you
see
parents
here,
you
need
to
go,
reverse
look
up
right
and
you
need
to
rebuild
that.
That
object.
That's
the
point
here!
So
basically,
that's
I
mean
that's
gonna,
be
your
main
thing
with
that
input
network
there
right
and
then
you're
gonna
need
to
do.
A
A
It's
retrieve
things
from
the
channel
when
they're,
published
and
and
you've
rebuilt
them
right
all
right,
so
we
probably
have
to
move
on
now,
because
I'm
realizing
that
we're
getting
close
to
11
and
we
need
to
talk
about
human
truth
stuff,
all
right.
So
humachu,
I'm
sorry,
I'm
sorry!
We
should
we
we've.
It's
been
a
so
what
okay
great
well,
we
should
see
okay,
so
we
need
to
repro.
A
A
A
A
A
A
A
A
A
Okay,
yeah
the
input
set
context
so-
and
this
is
the
one
I
remember
or
get
dog-
and
you
gave
me
feedback
that
this
was
not
not
clear
on
this
one.
So
basically
the
thing
is
we
need
to
create
this
object
here.
We
need
to
create
an
instance
of
base
input
set
context
and
essentially,
let's
see-
and
you
can
look
at
sort
of
string-
input,
side
context,
but
it's
going
to
look
something
like
this
here,
let's
see
so
your
record
con
and
it's
going
to
be
here.
A
Well,
okay,
it's
not
going
to
be
here
long
run,
but
for
now
we
can
put
it
here
I
mean
for
long.
In
the
long
run,
we
should
move
it
into
df,
the
the
dfml
slash
df
directory.
A
Okay,
okay,
so.
A
A
A
A
A
Let
me
just
put
the
comment
on
here
all
right,
so
essentially
what
you
do
is
you
create
it's
one
of
these
objects
right.
That's
this
base
input
context,
object
and
I'm
sorry.
I
should
explain
this
better,
but
if
you
do
this
now
and
let's
see
record
input,
record
input
set
context
and
where's
our
other
one.
Is
it
string
input
set
context,
yeah
string
input
set
context?
A
Oh
yeah,
it
says
string
input
set
context,
okay,
yeah,
so
basically
what
we're
doing
here
is-
and
this
might
be
a
good.
No,
that's
not
a
good
example
of
that,
but
essentially
right.
So
essentially,
what
happens
here
is
when
you
did
when
you
did
self
record
context
right
for
some
reason,
we
ended
up
with
like
a
string
that
had
all
the
same
stuff
in
it,
and
I'm
wondering
I
don't.
I
guess
I
don't
know
why
that
is.
A
A
So
when
we
we
can
get
the
record
object
back
by
saying,
let's
see
so
so
this
ctx
right,
let's
see
and
where's
record
record,
oh
okay,
yeah
and
when
you
yield
record
here,
okay,
so
this
is
something
called
it
says:
record
does
not
exist,
yeah,
okay,
so
you're
gonna
want
now.
What
you
can
do
is
basically
ctx
oops.
You
can
do
ctx
dot
record,
because
what
we're
gonna
do
here
is
we
create
this.
A
A
Sorry,
I
should
have
gotten
back
to
this.
Let's
see,
let's
see
so,
okay
yeah.
So
what
you
want
is
this
record
input
set
context
right,
because
then
you
pass
it
as
a
record
right
when
it
wants
to
know
what
it
is
is
a
string,
it's
the
record
key
right
and
when
you,
then,
when
you
finish
right,
when
you
have
the
results
that
are
associated
with
this
context,
you
also
have
access
to
the
record
within
the
context.
Object
does
that
that
makes
sense
sort
of
right.
It's
right,
yeah
exactly
so.
A
This
will
work
right.
It
should
this
should
work
right
and
the
idea
here
is
really.
You
know
the
the
idea
here
is
like
okay,
the
context
is
what
you
know:
what
what
is
this
data
in
in
running
as
right
like
what?
What
is
this
data
associated
with?
Is
that
context?
Writing
it's
a
record
record
input,
yeah
right,
so
the
input
set
right
is
this.
A
Is
this
list
that
you're
giving
it
right
it's
this
this
this
list
is
the
set
of
inputs
that
are
that
are
supposed
to
be
running
under
this
rec,
like
the
context
of
this
record
and
and
and
and
so
then
yeah
when
it
when
they
complete
right,
whatever
the
results
are
they're
associated
with
that
record
right.
That
was
that
that
came
from
that
input
set.
It's
not,
I
guess
the
verbiage
there.
A
It's
not
like
the
wording
of
that
is
not
perfect,
but
I
think
this
should
fix
your
problem
here
does
did
it?
Does
it
kind
of
make
sense,
sir
okay,
cool
all
right
great,
I
have
to
run
now.
Is
there
anything
else,
real,
quick,
that
anybody
wants
to
talk
about.
A
A
Okay,
that
sounds
great
yeah.
I'd
like
to
go
over
this
too.
I
just
wanted
to
make
sure
that
we
synced
up
since
we've
been
so
long
all
right,
sweet.
Well,
thanks
guys
issue
with
record
input
set.
A
A
Sc,
recording,
okay,
awesome,
hey
thanks,
guys,
sorry
how
much
you
will
well
next
time,
we'll
we'll
figure
out
whose
is
shorter.
First,
all
right
have
a
good
one.