►
From YouTube: Weekly Sync 2020-02-25
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.5ag1jgawqo6r
A
A
B
A
Worries
yeah
so,
but
this
looks
I
mean
it
looks
good.
Let
me
just
add
that,
because
I
did
forget
to
say
that
we
need
a
test,
did
I
say
that
no,
we
did
I
just
said
about
the
documentation,
so
let's
also
add
a
test
for
CSV
source
to
make
sure
that
the
loading
which
was
added
there
works
and
then
I
didn't
see.
Let's
see,
oh
there's,
there's
some
sort
of
oh
I
bet
it's
because
we
merged
that
way.
A
B
A
B
A
B
B
A
D
A
A
Yeah,
yeah,
ok
and
if
there's
all
the
stuff
with
the
yeah-
and
this
is
hopefully
I'll-
get
to
that
I'm
trying
to
get
to
that
config
stuff,
but
I've
been
really
swamped
and
then
not
feeling
good
lately,
so
I'm
I'm
hoping
to
get
to
that
soon,
but
because
unifying
that
config
will
help
at
that.
One
issue
that
we've
been
talking
about,
like
you,
defy
that
config
stuff
well,
is
this:
it
will
help
us
be
able
to
do
this
easier,
I.
A
Think,
since
we
have
to
do
this
sort
of
what
was
it,
it
was
yeah
this
dick
ister,
pre-process
I
can
fake
I
feel
like
I
did
something
like
that
recently,
though,
I'm
not
sure
what
it
was,
yeah
I'm,
not
sure
what
it
was,
but
I
think
it
might
be.
We
might
be
closer
slightly,
but
yeah,
ok,
cool,
that's
good
stuff,
and
then
did
you
understand
what
I
was
saying
about
the
there
was
that
clear
about
the
tests,
not
even
the
tests
for
the
amnesty
to
toriel
itself,
no.
A
Yeah,
basically
all
it
was
was
actually
I.
Think
I
might
have
referenced
it
in
the
that's.
So
did
I
reference
it.
Oh
no,
no
I
talked
about
that.
Okay,
so
let's
just
go.
Look
at
it
real
quick,
but
basically
what
that
was
talking
about
is.
If
you
go
look
at
examples
and
if
we
look
at
let's
see
I'll
pull
up
Doc's
first,
so
Doc's.
A
Quickstart
model,
so
this
I
figured
out
how
to
sort
of
make
it
easier
to
test
the
model
stuff,
sorry
easier
to
test
the
documentation,
because
you
know
we
end
up
with
all
these
code
block
console
things
and,
like
you
know,
how
do
you
test
that
effectively
because
you'd
have
to
like
parse
these
restructure
text
files
and
pull
out
all
the
console
code
blocks
and
run
them?
Well,
instead,
I
figured
okay.
Let's
just
do
this.
Literal
include
block
on
a
Sh
file.
A
C
A
A
Right
because
I
know,
we've
had
it's
hard
to
keep
the
documentation
in
sync
with
the
rest
of
the
stuff,
because
you
know
it
doesn't
fail.
The
test
don't
fail,
whereas
this
will
help
us
know
when
we've
when
we've
changed,
something
that
also
needs
to
change
in
the
documentation.
Does
that
make
sense.
A
Okay,
so
that's
and
then
let's
so
that's
that
looks
good
nice
yeah
nice
job
on
that
looks
like
we're
off
to
good
good
start
there,
and
then,
let's
see
so,
who
else
do
we
have
on
here?
We
got
Himanshu
so
yeah
and
again
so
Himanshu.
How
are
you
let's
see
I
know
we
still
haven't
figured
out
the
I've
been
trying
to
figure
out
what
the
hell's
going
on
with
that
boost,
where
it's
acting
up
or
was
the
boost
library
right?
It's
still
not
working.
F
A
A
A
Yeah
yeah
that
if
we
could
figure
out
I
mean
you
know,
that's
it's
obviously
that's
an
option,
especially
since
we
took
out
that
virtual
environment
stuff
there
was
that
there
was
some
reason
we
had
that
camera
or
what
it
was,
but
I
think
the
uninstall
takes
care
of
it
or
whatever.
So
the
let's
see
yeah.
If
we
can
figure
out
how
to
do
Conda
in
the
I
mean,
this
will
probably
help
us
going
forward
right,
because
this
is
not
gonna
be
the
first
time
we
do.
A
This,
there's
going
to
be
other
libraries
that
have
compiled
time
dependencies
tensorflow
is
just
really
nice
because
they
compile
everything
for
everyone.
So
you
don't
have
to
deal
with
this,
but
yeah.
If
we
can
figure
out
how
to
use
Conda,
there
might
be
good.
What
else
have
you
been
working
on
lately.
C
F
F
E
F
F
A
C
F
F
F
Let
us
see
this
one
okay,
so
these
are
the
models,
all
the
models
that
they
have.
We
said
they
all
of
them
are
pre-built.
We
can
have
so
in
the
models.
We
can
take
the
models
and
we
can
load
them
from
the
pukin
waves.
They
already
have
the
pyramids.
We
don't
need
to
worry
about
loading
and
doing
the
stuff
that
you
were.
F
F
F
A
E
F
A
A
A
It
follows
this
same
pattern
right
with
the
double
entry
stuff
which
is
not
like
this.
So
a
lot
of
a
lot
of
data
from
all
has
to
do
with
models
right
and
with
most
of
the
models
like
there's
no
network
resources.
So
they
don't
really
need
to
follow
this
pattern.
So
I
was
thinking
about
making
a
a
simplified
version
of
the
model
class
that
would
basically
be
used
basically
a
more
a
more
abstract
version
that
would
make
it
make
it
simpler
for
people
add
models
because
I
think
we're
finding.
A
A
To
figure
out
what
a
simplified
model
model
base
class
should
be
to
make
adding
new
models
easier,
/
faster,
because
that's
I
mean
we're
at
the
point
now
where
we
have
a
few
models.
We
know
we
know
where
we
know
what
what
kind
of
things
they
all
have
to
do.
You
know
what
kind
of
abstract
methods
they
might
need,
or
things
like
that
because
is
right.
A
Now
we
just
have
two
three
and
we
could
probably
be
doing
more
more
plumbing
work
at
the
at
the
base
class
level
to
make
it
even
easier
to
implement
things
so
yeah,
that's
that's
sort
of
like
something
that
needs
to
be
done
so
I
all.
Let
me
make
an
issue
for
this
and,
let's
see,
and
then
the
other
thing
is
once
we
have-
that
we'll
probably
update
the
tutorial
so.
A
A
A
Config,
ok
and
then-
and
then
here
we
might
do
so
in
is
this-
is
just
like
Canada
Billy.
What
I
was
thinking
and
then
you
guys
can
give
me
your
thoughts.
You
know
we'll
do
Indian.
It
will,
basically
so
within
the
a
enter
and
the
a
exit
methods
was
where
we
were
trying
to
do
the
loading
and
saving
of
things,
but
that
wasn't
really
ending
up
happening.
A
We
kind
of
we've
started
to
put
things
sort
of
all
over
the
place,
so
I
think
we
knew
we
need
to
consolidate
this
type
of
stuff.
So
we
might,
this
might
even
be
like
we
might
even
need,
like
a
load
like
that's
an
abstract
massive
abstract
base,
method
and
I'm,
really
really
on
top
of
my
game
today
and
just
abstract.
A
A
And
then
predict,
and
so
any
any
thoughts
on
like
you
know
how
to
make
this
real
real
clean
would
be
much
much
appreciated.
Just
you
know
if
you
have
any,
if
you
have
any
ideas,
basically
from
implementing
models
yourself,
that
you're
thinking
hey
this
type
of
you
know,
this
is
something
that
that
I
saw
when
I
was
implementing
this
a
lot.
How
could
we
add
this
to
the
base
class
or
you
know
what
abstract
method
could
we
add
so
that
it
it
always
this
in
a
consistent
place?
C
F
No,
they
are
keeping
on
increasing
the
number
of
ultimately
some
online
life.
We
have
to
read
so
many
things.
Can
we
do
anything
for
their
videos?
That
is
very
repetitive,
so
they
complaining
that
read
so
many
arguments
and
then
for
accuracy.
We
have
to
read
again:
all
those
are
can
have
violent
conflict
and
yeah.
A
That's
a
very
good
point,
so
yeah.
That
was
another
thing
that
that
I
was
thinking
at
one
point
and
I
know.
We
kind
of
we'd
had
some
discussion
on
this
at
at
one
point
to
of
whether
the
you
know
whether
we
should
be
able
to
swap
out
a
config
file
for
the
command-line
options
and
I
think
that
it
would
be
I
think
it
would
be
a
good
thing
to
do
and
at
this
point,
I
think
the
config
parsing
is
is
mature
enough,
that
it
should
be
a
relatively
small
change
but
yeah.
E
G
A
We're
definitely
keeping
both,
let's
definitely
keep
both
I
think
and
that
may
have
been
where,
where
this
discussion
died.
Last
time
is
because
I
think
I
think
I
might
have
brought
this
up
or
somebody
else
did
it
and
then
somebody
said
a
similar
thing
where,
like
I
think
was
the
other
yeah
she's,
not
on
the
call
right
now,
I
think
he
said
you
know,
a
lot
of
people
are
using
it
via
the
command
line
right.
G
A
We
have
the
command
line
right,
and
that
was
mainly
because,
if
we're,
if
we're,
that
was
mainly
because
like
if
you
need
to
use
this
call-out
from
some
other
language
to
use
this
right
like
if
you
have
like
a
C
program
where
you
know
a
PHP
program
or
anything
right
and
but
you
can,
you
can
call
out
via
the
console
and
run
shell
commands,
then
you
you'd
be
able
to
do
any
machine
learning
that
you
need
it
to
be
a
dff
ml
and
so
yeah.
So
we're
definitely
want
to
keep
all
the
command
line
flags.
A
A
E
C
C
C
A
A
A
A
C
A
Okay,
so
that's
related
this
this
okay,
so
basically,
what
we've
got
here
is
is
right.
Now
the
configuration
stuff
can
be
serialized
into
a
dict
object
and
the
dict
object
can
be
output,
as
you
know,
JSON
or
Y
amel,
and
this
is
what
it
ends
up,
looking
like,
which
is,
of
course,
what
we're
doing
over
here.
A
If
you
want
to
curl
command
and
you
you
have
like
some
of
your
post
data
in
a
file
you
might
say
like
at
and
then
the
file
name
and
it'll
pick
up
the
data
in
that
file
name
and
use
it
there.
So
I
was
thinking.
Maybe
we
could
just
borrow
that
syntax
and
say
you
know
like,
but
maybe
this
is
like
modeled
on
a
mole
or
something
what
what
did
it
just
do
there,
but
I'll
tell
you
animal
okay,
he
didn't
when
he
does
this,
he
did
when
it
does
that
it
always
chased
it.
A
It's
like
this
is
in
a
pre-formatted
block,
I'm,
not
trying
to
reference
somebody's
name.
She
was
let's
try
this
again.
Okay,
there
we
go
all
right
so
yeah.
If
you
did
at
model
yeah
mo
it
would
take
all
of
this
stuff
within
this
file,
which
would
be
modeled
MO,
and
it
would
basically
use
these
as
command
line
arguments
right.
So
then
you
could
also
put
something
like
you
know.
Oh
it's
gonna.
Do
it
to
me
again
sources,
oh,
oh
great!
A
It
didn't
and
then
you
would
have
you
know
that,
let's
see
I
guess
we
need
to
figure
out
how
to
do
sources
too.
So
something
like
so
it's
just
that,
oh
and
then
you
could
say
sources,
okay,
here's
how
I
would
do
that.
This
is
not
great
difficult,
CSV
and
then,
let's
see,
where
is
maybe
we
want
to
do
it
more
like
I
think,
let's
see
sources
yeah,
here's
how
we
should
do
that,
let's
see
or
no
sources
yeah
now.
A
A
I
you
could,
you
could
keep
it
all
in
a
single
file,
but
basically
I
was
just
thinking.
You
know
right
every
time
you
specify
at
you
load
the
arguments
from
that
file.
The
reason
why
you
might
want
to
do
multiple
files
is
because,
if
you
have
you
know
the
same
sources
that
you're
using
over
and
over
again
with
different
models,
then
you
wouldn't
want
to
hand
edit
the
file
right.
F
H
A
B
C
A
H
F
A
F
A
All
right,
good
stuff
and
then
yeah,
so
this
is
ridiculous.
I,
don't
know
what
the
hell's
going
on.
This
is
completely
insane.
We
install
boosts
like
this
is
the
worst
part
of
this.
Is
that
you
can
see
it
install
boost
up
here
and,
and
then
it
does
it
just
like
it
doesn't
exist.
Lib
boost
like
how
many
lib
boost
you
need
to
install
before
it
exists.
F
A
A
This
github
workflow
is
testing
doggy
mo
because
I
think
there's
some
calls
to
pip
in
there
that
will
need
to
be
calls
to
calendar
or
whatever
and
we'll
need
to
figure
out
how
to
install
kondeh
within
that
environment,
and
so
I
think
that
I'll
have
to
go
into
the
install
dependency
section
like
we
were
doing
with
the
boost
stuff,
but
yeah,
so
that'll
be
good
good
for
the
future.
A
F
A
Nice
job
Michelle
figures.
Ok,
let's
see
alright.
So
let's
see
I
think
this
is
Steve.
D
is
not
on
the
call.
So,
let's
let's
skip
that
and
then
Sudarsan
is
not
on
the
call.
So
I'll
skip
that
for
now,
let's
see
rich
from
scratch.
Ok
I'm,
not
sure
what
this
guy's
name
is
but
he's
not
on
the
call
so
we'll
skip
to
us
from
now,
and
then
this
is
what
rabbit
this
is
contributing.
Ok,
this
guy
I
need
to
he's
been
jumping
on
the
on
the
Gator.
We
need
to
get
back
to
him.
A
A
Branch,
oh
I
know
what
was
going
on.
Ok,
so
I
got
stuck
because
I
know
I
think
we
have
some
people
that
are
on
Mac
and
basically
the
thing
is
so.
The
thing
is:
if
you
need
to
download
go
lang,
and
so
you
need
to
download,
we
need
go
link,
CI,
lint
right
and
we
need
and
I
realize
that
go
Ling.
Ci
lint
requires
a
recent
version
of
go
because
I
have
like
go
1.10
on
my
computer
apparently,
and
it
got
mad
about
that
and
it
was
saying
that
you
know
it's
not
compatible
with
that.
A
So
I
realize
ok,
we
need
to
download
a
recent
version
of
go
and
so
for
the
purposes
of
testing
here
we
basically
need
this
cash
cash
download
and
extract
situation.
We
need
that
to
download
the
recent
version
of
go,
the
recent
version
of
go
like
CI
lint,
and
then
we
need
to
download
the
repository
that
we're
going
to
scan
right.
So
we
have
three
things
that
we
need
to
download
and
then
I
was
like
okay.
Well,
alright,
we've
got
some
people
on
on
on
OS,
X
and
I.
A
At
some
point
there
was
somebody
on
Windows:
I
saw
their
stack
traces
for
Windows,
and
so
I
was
like
okay,
well,
they're
gonna
be
confused.
If
we
don't
download
to
go
basically,
we
need
to
download
the
go
binary
for
Windows.
So
if
you're
on
Linux,
we
need
to
download
the
Linux
binary
if
you're
on
OSX,
we
need
to
download
the
OSX
binary.
If
we're
on
Windows,
we
need
to
download
the
windows
binary
or
else
when
we
try
to
run
the
go
commander.
Oleg
CI
lint
tries
to
run
the
go
command.
It's.
I
A
A
A
It
has
this
unpack
archive
function
and
this
unpack
archive
function.
It
will
take
like
you
know.
If
you
pass
in
a
path
that
it's
a
dot,
zip
file
or
tar.gz,
it
will
extract
it
well.
The
problem
is
that
it
won't
it's
not
extracting
it's
not
for
the
Mac
OS
tar
file
on
Linux.
Well,
okay,
so-
and
this
is
like-
maybe
this
is
like
something
that
you
don't
need
to
work
on,
but
okay,
basically
I
extract.
A
The
this
is
this
is
this
is
in
this
is
in
a
temporary
directory
I
downloaded
that
that
tar
file
right,
we
download
it
with
the
Cashtown
letter
function.
We
extract
it
with
the
regular
tar
utility
on
linux,
like
that
tar
command
line
utility
and
in
that
directory
we
ended
up
with
this
go
we
end
up
with
the
go
binary,
which
is
like
exactly
what
we
would
expect
and
it's
a
Mac
OS
executable.
Well,
when
we
extract
it
with
SH
util
unpack
archive.
A
It
ends
up
not
even
existing
like
if
there's
nothing
in
that
directory
and
I
guess,
I
should
probably
should
probably
just
give
up
on
this
it'll,
probably
just
work
on
Mac
OS,
but
I
was
like
all
hung
up
on
the
fact
that
when
you
extract
the
archive
the
go
binary
isn't
there,
but
it
doesn't
even
matter
when
we're
on
Linux
I
guess.
But
I
was
just
worried
that
you
know
I,
don't
have
a
Mac
OS
system
to
test
on
and
like
what,
if
it
just
won't,
show
up
there
either.
A
This
is
kind
of
like
a
moot
point
right
like
right
at
this
I'm,
not
sure
who
this
person
is
but
I
know
they
existed
at
some
point.
So
I'll
probably
just
skip
that
and
and
and
push
up
that
that
what
I
have
right
now,
but
just
for
Linux
and
if
anybody
yells
at
us
saying
like
I,
couldn't
run
this
test
on
Windows
or
Mac
OS
than
like.
Oh
okay,
like
well
we'll
deal
with
that.
Then
right
when
we
get
there.
A
J
J
A
A
This
is
when
we
build
this
tool,
we're
gonna
be
able
to
go,
and
we
can
do
massive
scans
of
everything
and
we
can
say,
like
okay,
like
we
did
a
massive
scan
of
github
and
like
here's
all
the
projects
that
you
know
have
vulnerabilities
in
them,
whether
they're
in
JavaScript,
whether
they're
and
go
right.
Well,
we'll
have
this
tool
that
that
that
lets
us
point
it
at
anything
arbitrary,
and
then
we
can
do
this
like
run
this
massive
scan
and
and
Wow,
you
know.
A
Right
and
what
you're
finding
obviously
is,
of
course
like
when
you're
yeah
right
like
okay,
we
got
a,
we
got
to
find
the
first
test
cases
right,
so
we
have
to
do
some
sort
of
little
manual
scanning
at
first,
so
yeah,
it's
it's
tricky.
It's
tricky!
Okay,
great
great!
Well,
I'm
glad
so
are
you?
Are
you
kind
of
stuck
on
anything
at
this
point
or
you
were
able
to
identify
one
and
you
still
working
on
getting
the
whole
getting
the
operation
set
up
or
I.
A
J
A
Was
gonna
do
that?
So
that's
and
that's
what
that's?
What
yeah
I
got
I
just
got
all
I
got
kind
of
down
a
rabbit
hole
there
that
I
probably
didn't
need
to
go
down
so
I'm
just
gonna
make
it
work
for
Linux.
So,
let's
see
John
good
at
all,
we'll
just
make
make
work
for
Linux.
A
A
J
A
Yeah,
oh,
this
looked
cool
yeah,
okay
yeah,
so
this
is
something
this
is
something
yes.
So
this
is
and
that's
why
I
added
this
note
to
actually.
A
D
A
Right
so
these
guys
they
do
things
on
git,
repos,
right
and
so
they'll
do
something
like
so
this
one
grabs
the
default
branch
of
a
git
repo
right.
So
as
an
input
it
takes
the
git
repository
and
it
outputs
the
branch
and
it'll
you
know
runs
from
git
commands
and
and
they'll
figure
out
some
things
about
anything,
that's
a
git
repo
right.
So
the
idea
here
would
be
I
will
probably
add
this
guy.
Oh
no!
This
is
huge.
A
Okay,
so
we'll
fry
add
this
to
something
that
we
would
use
within
this
git
repo
features
writer.
Well,
this
is
this:
is
it
used
to
be
called
operations?
You
should
be
called
features
and
the
this
hasn't
gotten
renamed
yet
so
we'd
probably
want
to
make
an
an
operation
that
runs.
This
get
Bowl
finder
right
on
the
git
repo
right
and
so
then
we'll
have
long-term,
where
we're
gonna
end
up
with
is
when
you
run,
should
I
on
something
it'll
say:
okay,
what's
the
language
and
what's
the
version
control
system?
A
If
the
version
control
system
is
get,
then
I
can
run
all
of
these
get
operations
on
it
and
then
as
well.
As
you
know,
I'll
run
whatever
the
static
analysis
tools
for
that
particular
language
are
right,
so
we're
trying
to
create
something
that
basically,
you
pointed
at
anything
it
uses
all
that
all
the
information
available,
I'm
gonna
come
up
with
everything
security
related
about
this
about
this
repo,
so
yeah,
that's
that's
that'll,
probably
go
in
here
and
let
me
make
it.
A
A
A
You
could,
or
you
could
put
it
in
another
file
within
like
what
you.
What
you
might
want
to
do
is
I
guess
here.
Let
me
let
me
edit
this.
You
wouldn't
want
to
put
it
in
that
file.
You
would
want
to
add
another
file,
yeah,
that's
probably
an
operation
that
gets
that
is
run
by
or
like
that
lives
in
a
new
file
in
this
directory
right.
So
you
would
create
it
under
there
and
just
like
you've
been
going
into
you
know,
example
should
I
and
running
your
test.
A
E
E
C
C
A
Will
be
working
on
adding
get
bold
finer
with
in
the
future,
get
directory,
okay,
cool,
great
awesome
and
then
I'll
try
to
get
that
to
you
today
for
real
this
time.
I'll
stuff,
stop
worried
about
section
windows,
all
right,
great
yeah!
Thank
you
all
right,
so
I
think
everybody,
every
III
believe
are
gonna
and
I
probably
have
some
some.
Some
rather
deeply
data
flow
things
to
talk
about
here.
G
D
K
A
A
G
A
G
G
A
G
A
G
A
G
A
A
A
A
C
A
Okay,
so
sorry,
let's
see
so
this
goes
through
and
it
basically
says:
okay
like
here's
this.
These
are.
These
are,
where
all
that
you
know
where
you
can
say
like
in
Pinter,
like
I,
think
you've
seen
that
before
and
then
you've
seen
the
context
enter
the
config
class
and
then
the
keyword
arguments
end
up
just
being
the
things
that
you
pass
to
the
operation
class
to
instantiate
the
operation
like
the
inputs
and
outputs,
some
extents
and
stuff,
and
so
in
turn
context
or
a
while
show.
Let
me
just
show
you
this
so
first,
so
alright.
A
Yet
the
the
the
operations
really
follow
the
same
pattern
right,
because
everything
has
to
follow
that
same
double
context,
entry
pattern,
and
so
the
proper
really
just
hides.
That
fact
behind
you
know
it
just
it
hides
that
by
making
it
easier
to
use
just
like
we
have
to
create
that
simplified
model
interface.
I
A
Because
we
can
do
whatever
we
want
so
and
then
the
other
figment
it
does
is
it
works
whether
you
have
a
so
you
can
wrap,
you
can
wrap
a
function
or
you
can
wrap
a
operation
implementation
context
itself
and
then
have
it,
create
the
implementation
right,
because
the
amount
of
times
were
you
really
like,
there's
basically
like
I
just
I,
did
a
lot
of
work
to
try
to
make
this
very
easy
to
you.
This
is
very
wacky
in
this
part
of
this
in
the
proper.
G
A
A
A
C
A
We're
doing
self
thought,
as
we
do
self
dot,
Oct
X
dot
parent,
because
what
that
ends
up
doing
is
this
is
the
orchestrator
right,
and
this
is
the
orchestrated
context.
So
Oct
X
is
the
orchestrator
context.
So
when
you
call
the
base
Orchestrator,
it
creates
you
a
new
base,
Orchestrator
context
right
so
now,
you've
got
like
a
whole
nether.
You've
got
you've,
got
a
whole
nother
Orchestrator
to
run
operations
and
right
there
to
run
your
data
flows
in.
But
what
we
really
want
to
do
is
we
want
to
do?
A
G
A
A
A
G
A
H
A
A
C
A
Always
use
context
management,
your
errors
always
get
cleaned
up
and
if
you
always
use
a
sink
I/o,
your
network
errors
always
get
handled
properly,
not
using
a
sink.
I
owe
the
just
I've
yet
to
see
a
project.
Do
good
job
handling
network
errors
properly,
because
I
mean
that's
the
point
of
the
event
loop.
It's
like
you
have
to
handle
all
the
network
errors
properly,
but
yeah.
So
basically
it
just
it
just
helps
us
make
sure
things.
Things
are
clean,
but
basically
yeah.
A
C
A
You
may
even
want
to
do
it
as
like.
You
may
even
want
to
do.
Let's
see,
there
was
something
that
I
was
thinking
of.
Okay,
so
there's
a
few
cases
here,
right,
there's
basically
there's
the
case
where
so
we
start
the
sub
flow
right
and
we
have
so.
We
start
the
sub
flow
and
we
have
inputs
that
haven't
yet
like
inputs
in
the
seed
of
the
parent
flow
that
need
to
get
forwarded
to
the
sub
flow
right.
A
A
A
C
A
We
had
the
some
flows
running,
but
now
the
subfloor
has
a
new
contexts
running
within
it
right.
So
there's
like
you
know,
maybe
you
know
there's
multiple
contexts
running
in
it
and
now
we
need
to
decide
like
do
we
forward
the
inputs
to
every
new
context,
or
do
we
just
forward
them
to
like
the
initial
context,
but
it's
also
like
I.
I
A
I
A
A
long-running
thing
then
who's
to
say
that
that
list
of,
like
I,
need
to
keep
forwarding
this.
Some
things
like
doesn't
just
grow
indefinitely,
yeah,
in
which
case
I
kind
of
think
that
maybe
this
is
right.
This
is
just
like
this
is,
and
this
is
why
I
like
wanted
to
spend
a
lot
of
time
on
this,
to
try
to
figure
out
what
happens
here,
because
I
think
we're
we're.
We
we
risk
a
situation
where,
where
we.
G
C
A
A
G
A
B
A
F
G
G
A
We
only
add
it
once
so.
Basically,
in
this
situation,
what
we
do
would
be.
We
create
something
that's
sort
of
like
local
to
the
orchestrator.
That's
like
dataflow
seed,
but
it's
like
you
know,
Orchestrator
dot,
well,
I
guess
this
is
received
from
parent
blog.
This
is
already
Orchestrator
local
right
or
where
is
this?
Let's
see
is
this
in
the
network
context
or
memory
input
network
context,
okay,
yeah,
so
I?
Guess
it
stays
in
here
right
wherever,
wherever
that
seed
input
function
is
let's
go
find
that
sorry.
A
Yeah,
okay,
so
the
nice
thing
about
putting
it
here,
I
think,
is
because
what
happens
here
is
is
we're
adding
this
set
of
things
to
every
context
right
as
soon
as
that
context
gets
run
and
so
for
what
we
do
is
is
you
when
you
register
the
sub
flow?
You
take
everything
that
needs
to
be
forwarded
at
that
point
in
time,
and
you
put
it
in
some
structure
that
that
will
end
up
like
here
right,
so
something
equivalent
to
self
to
config
data
flow
seed.
A
Something
like
you
know,
you
could
put
self
dot
receive
from
parent
flow
right,
but
this
is
now
within
because
self
here,
I
think,
is
the
orchestrator
right,
yeah,
so
remember,
Orchestra,
so
you'd
move
its
received
from
parent
flow
to
the
orchestrator
and
and
then,
when
you
register
the
sub
flow,
you
say:
okay,
everything
that's
pending
gets
added
to,
you
know,
receive
from
parrot
flow,
and
then
you
modify
a
sedum
plus
to
add
you
know
anything.
That's
in
received
from
parent
flow.
A
Also
to
this
input
set
right,
so
you'd,
basically
I
think
you
would
just
have
to
modify
these
two
things
here
right
to
basically
say:
okay,
like
you
know,
if
it's
an
input
set,
then
you
then
you
add,
you
know
you
add
another
for
loop
here
and
you
add
another
of
this
monstrosity
here.
That
really
could
have
just
been
a
for
loop,
a
comb
all
generator
happy
I
thought.
G
G
A
C
A
A
C
B
A
A
A
G
G
H
A
If
we
put
it
in
the
seed,
we're
saying
we
want
you
to
forward
this,
we
or
we
want
every
context
that
gets
started
to
have
this
input
right
well
and,
and
so
what
was
the?
What
was
the
context
that
we
were
doing
this
in?
Let's
that's
like
step
back
and
figure
out
why
we
were
doing
this
in
the
first
place.
I
think
I'm,
just
realized
I
just
realized
here
that,
like
we
may
be
going
down
a
rabbit,
hole
right,
we're
trying
to
figure
out
like
what
what's
the
truth.
C
A
A
G
A
Let's
see
that's
yeah
I
mean
let
me
open
the
both
real
quick.
Maybe
let's
look
at
the
media
minutes
to,
because
I
have
a
feeling
that
we
might
be.
We
might
solve
our
own
question
here.
If
we
just
look
at
why
we
were
doing
this
right
because
there's
there's
there's
several
cases
here
and
we
only
care
about
a
few
of
them.
E
A
E
I
E
C
A
D
G
H
A
G
A
A
A
A
C
A
C
C
A
A
A
A
C
A
G
A
Yeah
there's
another
one
get
multi,
that's
in
a
branch
that
needs
to
be
merged,
I
used
it
in
another
branch,
some
that
works
okay.
So
for
a
test
case,
you
need
two
operations.
Basically
one
one
that
gets
earlier.
Let's
see
the
context
has
to
be
running,
runs
until
there's
no
more
input
so
I'm.
Just
thinking
of
how
do
we
test
this.
E
G
G
G
G
A
E
E
A
Overview
of
memory
works
all
right.
I'll
try
to
do
this
today,
yeah
all
right,
so
I'll
try
to
finish
the
cache
down
and
stuff
and
do
this
over
yoga
February
today
and
that
way
I'll
try
to
give
you
like
a
diagram.
Oh
all,
right.
Let's
see
what
make
it
so
inputs
get
forwarded
to
active,
so
flows
are
active
context.
A
A
A
That
that
that's
gonna
be
yeah.
That
would
be
good
is
that
that
one
is
also
for
the
same
so
async
iterator
and
the
operations
about
inputs
are
kind
of
like
they're,
both
they're,
both
sort
of
like
they're,
both
sort
of
like
similar.
Oh
this,
to
do.
Let's
see
oh
yeah
I
need
you
I
need
to
provide
you
with
an
example
for
that
too.
So,
let
me
say:
John
it's
two
example:
yeah
I,
just
this
one
examples
kind
of
long,
so
I
hadn't
been
able
to
do.
K
A
Okay,
yeah,
so
I'll
find
you
provide
you
the
example
code
on
this
one.
But
basically
the
idea
is
like
same
same
sort
of
thing.
It's
like
you
know
the
operation
without
input,
so
the
operation
without
input
starts.
You
know,
maybe
it's
just
waiting
for
one
thing
in
which
case
when
it
returns
it.
You
know,
then
it's
done
right,
but
maybe
it's
an
async
iterator
and
every
time
it
yields
not
like
a
context
manager
right
where
it
just
yields
once,
but
in
an
async
iterator.
It
yields
multiple
times
every
time
it
yields.
A
Gets
added
to
the
network
so
in
this
case
right
with
this
example
with
the
chat
bot,
you
know
every
time
you
know
new
gets
added
to
the
gooder
channel,
then
the
input
gets
added
to
the
network
right.
A
G
A
C
A
H
A
C
A
G
A
G
A
G
A
This
will
be
sweet,
that'll,
be
great
yeah
that
yet-
and
that's
that's
exactly
that's
sort
of
like
an
ideal.
You
know
this
is.
This
is
like
why
we've
got
the
dataflow
stuff
in
this
project
is
because
I've
heard
a
lot
of
stuff
and
I've
gotten
to
a
few
things
that
people
always
seem
to
say
it's
really
hard.
You
know
making
machine
lots
of
people
are
making
machine
learning
models
right.
The
problem
is
like
okay
figuring
out
how
to
integrate
them
and
then
like
keeping
them
integrated.
It's
difficult
right
because.
C
A
Like
you
know,
you've
got
so
much
code.
Everything
always
changes
all
the
time,
and
so
ideally,
the
data
flow
stuff
makes
it
easy
to
say.
Okay,
you
know,
we've
got
some
chat
function.
You
know
you
just
write
the
function
for
the
chat
bot.
You
write,
you
know,
you've
got
the
function.
That
does
the
train
model.
You
know
we.
We
eventually
will
have
that
web
UI.
You
can
just
link
come
together.
Right,
I,
just
simplify
this,
so
this
will
be
good.
This
will
be
great,
so
NLP
model
and
get
her
chat.