►
From YouTube: Weekly Sync 2020-08-04
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.4d3vzsyk7afc
A
A
A
A
C
D
E
G
E
A
E
G
G
G
H
A
A
A
I
A
A
A
You
need
to
use,
didn't
see
over
and
then
issues
with
should
I
so
there
was
an
issue
with
the
should
I
stuff
where
I
found
that
basically
we're
having
this
rust
package.
So
should
I
just
runs
whatever
the
applicable
static
analysis
tool
is
with
the
use
command,
and
so
the
test
case
for
rust
ended
up
actually
testing
javascript,
and
so
we
weren't
actually
picking
up.
Basically,
there
was
some
modifications
required
there,
so
I
had
tried
to
fix
that
one
as
a
part
of
tackling
the
various
things
with
the
ci
this
weekend.
A
E
E
A
A
But
it
seems
to
be
that
that
you
know
when
you
specify
a
version
range
which
is
greater
than
it
just
installs
the
greatest
version,
and
then
it
looks
later
at
all
the
other
packages
and
says:
oh,
this
one
actually
is
restricted,
but
then
it
just
goes
and
it
says
oops
I
already
installed
the
one
with
the
latest
version
and
then
it
just
fails
with
contextual
version
conflict.
I'm
that's
my
current
understanding
of
what's
happening
here
and
basically
yeah.
A
Yeah,
it's
like.
Why
are
you
installing
the
latest
version?
If
you
have
these
ones,
that
say
the
version
range,
then
you
should
be.
Hopefully
I
mean
you
should
be
resolving
it
to
install
within
this
range.
If
you
see
one
that
says
a
range
and
one
that
says
just
greater
than
x
right,
but
obviously
that's
not
happening
so
maybe
there's
a
way
we
can.
You
know,
set
this
within
an
environment
variable
or
something
so,
okay.
This
is
like
new
stuff.
A
A
A
A
A
A
Okay
and
then
issues
with,
should
I
was
that
rust
test
issue
causing
ci
to
fail.
So
basically
it
started
failing
because
it
was
detecting
more
vulnerability.
So
I
went
in
to
update
the
fact
that
it
now
has
more
vulnerabilities,
and
then
I
found
that
it's
actually
testing
the
rust
package
for
javascript
vulnerabilities
and
not
detecting
that
it
needs
to
be
scanning
for
rust
and
yeah.
So
all
right.
A
And
so
it's
still
broken,
but
I'm
hoping
to
fix
that
one.
I
want
the
ci
to
be
clean.
Obviously,
before
I
take
off,
I
probably
still
have
my
laptop,
but
all
right
so
distributed
orchestrator.
Okay,
now
I've
got
this
on
two
computers,
so
all
right,
nope
wrong.
One.
Okay,
we'll
take
care
of
that.
One
too.
A
A
D
A
B
B
A
A
I
don't
think,
there's
anything
else
at
the
moment,
other
than
the
fact
that
we
should
test
with
multiple
worker
nodes.
Just
you
know
to
make
sure
that
this
is
in
fact
running
with
multiple
workers
right.
You
should
set
up
the
tests
for
that
right.
So
I
would,
I
would
recommend,
like
three
of
them
or
something.
A
D
A
I
I
A
A
Yeah
so
make
sure
you
have
multiple
nodes
with
check
if
repository
valid
okay
and
then
maybe
you
know
ones
that
only
yeah
ones
that
have
operations
that
other
nodes
are
going
to
have
and
then
also
make
sure
that
nodes
have
operations
that
only
they
have
and
then
make
sure
that
numbers
and
the
circular
fuse
is
correct.
So
because
yeah,
that's
going
to
probably
save
you
headache
later
on.
Yes,
yeah.
A
B
A
D
H
H
B
A
A
H
A
A
A
Yeah,
let's
just
do
okay,
this
is
like
okay,
so
the
problem
with
this
is
okay.
The
reason
why
this
is
the
way
it
is
is
because
so
the
idea
was
that
you
would
have
context
and
then
the
context
might
be
some
object
that
lives
in
memory
right.
The
context
is
some
object
that
lives
in
memory,
maybe
on
a
node
or
maybe
on
you
know,
yeah,
maybe
you
know
maybe
on
on
different
machines
and
it
might
reside.
A
You
would
just
have
the
context
and
you
would
want
to
to
like
dynamic
like
you
would
want
to
pull,
and
this
is
where,
like
I
don't
know,
if
this
made
sense-
and
this
may
need
to
change,
but
the
idea
was
that
you,
the
handle,
so
there's
the
contacts
and
there's
the
handle
and
the
handle
is
what
you
would
use
to
actually
access
the
data
within
like
redis
or
something
right.
So
maybe
it's
like
a
unique
key
or
something,
and
why
was
it
async?
A
You
know
I
should
have
commented
it,
but
basically
there
was
this.
Is
this
I
was
trying
to
explain
why
this
looks
so
horrible
and
the
point
is
there
was
a
reason
and
it
probably
should
change,
because
you
know
I
don't.
I
don't
like
at
this
point.
Who
knows
what
it
was
and
we're
not
using
it
so
basically,
but
for
now,
until
we
change
it
everywhere,
we
should
probably
make
it
the
same
everywhere
in
case
we
end
up
using
it
or
changing
it.
A
I
know
that
probably
that
was
just
like
you
guys.
You
guys
know
what
I
was
saying
that
right
basically
yeah.
Okay,
this
this
is
ugly.
There
was
a
reason
for
it:
it's
not
currently
being
used,
but
until
we
change
it
everywhere,
let's
just
be
consistent,
yeah,
that's
that's
the
point,
so,
okay,
so
that
and
then
that-
and
that's
this
should
be.
Let's
see,
that's
that's
that
on
this
one.
So
I'll
just
do
this.
A
A
In
base
okay,
yeah,
no,
I
believe,
that's
it
yeah.
The
only
thing.
The
other
thing
that
we've
done
is
we
use
stir
on
the
context,
some
places-
and
that's
probably
that's
like
we
shouldn't
be
doing
that
either,
but
I
think
that's
also
places
where
we
know
that
it's
a
input
set
context
or
a
string
input
set
context.
Oh
yeah,
that's
in
root
c
that
shouldn't
be
done
either
and
as
string.
A
A
A
H
A
All
right,
all
right,
so
anything
else
on
your
own,
all
right,
okay,
waiting
on
layers,
for
example.
I
need
to
do
this
today,
especially
if
I'm
going
to
leave.
So
I
want
that's
my
these
are
my
goals.
Is
layer
support
example
and
make
sure
the
ci
is
clean
for
everyone
before
I
take
off,
I
will
still
be
available-ish,
but
you
know
not
as
much
until
next
tuesday,
so,
okay,
okay,
so
I
may
we'll
see
we'll
see
if
oh
yeah
yash
is
here.
A
H
A
Okay,
so
yeah
I'll,
just
I
mean
you
just
you
know
you
can
just
make
a
make
a
meeting,
link
and
post
it.
Let's
see
because
yeah
the
one
that's
on
the
calendar
hit.
Obviously
that's
I
don't.
I
haven't
been
able
to
figure
out
how
to
make
it
so
that
everybody
can
just
join
okay,
so
working
on
adding
custom
models
using
the
api
for
pi
torch.
So
you
wanted
to
talk
about
that
right.
E
A
E
A
E
E
E
J
A
E
A
A
What
this
length
of
the
of
the
feature
was
when
you
create
the
numeric
column,
it
wanted
to
know
what
the
length
was
there,
but
I
would
assume
that
that
stuff
has
been
maybe
updated
with
I
mean
himacha,
you
updated
it
to
cf2
stuff.
So
I
don't
know
if
that
still
matters
at
all,
and
I
guess
we're
not
using
tensorflow
here.
Are
we
so,
let's
see
sorry
which
one
when
we
did?
A
E
A
E
And
there
is,
there
is
just
one
more
thing
I
found.
I
don't
know
if
someone
got
stuck
there
too,
what
happens
is
when
we
are
reading
the
columns?
We
increase
one
time
dimension,
because
so,
if
there
is
two
dimensional
data
we
are
putting
in
every
we
write,
np
dot
array,
and
then
we
put
the
data
inside
it.
So
it
makes
it
three
dimensional
data,
so
so
that
is
something
we
need
to
keep
in
mind
while
giving
the
input.
E
G
E
Array,
yes,
so
so
we
are
converting
np
array
and
there
is
x,
calls
features,
so
that
is
already
a
two
dimensional
and
we
are
when
we
are
converting
it
again
into
an
error.
It
adds
one
more
dimension
to
it
all
right
yeah,
so
so
that
is
something
if
code
is
not
visible,
then
that
is
something
difficult
to
guess.
E
So
I
was
just
thinking
the
other
day
that
we
should
be
able
to
guess
what
will
be
the
first
dimension.
That
is
so
it
what
tensorflow
does
it
is.
It
does
not
takes
the
first
dimension,
it
takes
it
as
none
okay.
So
that
means
the
number
of
examples
that
we
can
have
so
that
may
vary.
Nobody
knows
in
file.
How
many
I
mean
you
can
count,
but
that
is
not
friendly
right
yeah
so,
but
we
need
to
specify
here
because
we
don't
do
it
automatically.
E
So
I
need
to
go
check
in
the
file
that
there
are
50
examples
that
any
I
am
putting.
So
I
need
to
specify
that
the
dimension
of
the
data
will
be
50
cross,
whatever
the
column
size
is
so
that
is
something
yeah.
So
so,
actually
I
need
to
talk
about
these
things
only
today
and
I
have
one
more
problem
with
this:
okay.
A
A
A
G
A
A
A
D
J
J
A
F
E
H
A
H
J
A
A
D
H
A
A
It
seems
to
be
slow.
I
wonder
we
probably
need
to
do
a
thing
where
I
have
a
branch
open
right
now,
where
basically,
you
can
control
the
number
of
executing
contacts,
and
I
guess
I
mean
it's
not
critical-
that
we
do
this,
but
the
idea
here
would
be
you
know
we
have.
We
have
two
approaches
we
talked
about
this
before,
but
we
have
two
approaches
here
that
we
could
take.
We
could
do
where
is
the
data
flow
source
source
df.
A
So
yeah
here
we
use
the
orchestrator
context.run
and
we
do
it
for
each
record.
So
we
have.
We
could
do
here
something
like
this,
where
we
do
like
record
context
and
then
we
say
record,
and
this
way
the
thing
is,
we
would
get
the
records
out
of
order,
but
it
shouldn't
necessarily
matter
and
we
would
end
up
with
it's
running
all
the
context
at
the
same
time.
The
other
thing
is
that,
oh
here,
this
is
why
oh
yeah-
because
these
are
all
pretty
these-
are
all
cpu
intensive
operations.
A
H
A
F
J
A
A
A
E
F
A
A
E
I
think
the
the
histogram
calculate
histogram
method
gives
some
sparse
matrix.
Okay,
because
if
it
is
sparse,
then
json
may
not
be
the
perfect
thing
to
use,
because
then
we
have
npc
format
and
then
we
have
a
sci-fi
that
handles
the
sparse.
It's
just
very
everything
will
speed
up,
and
especially
the
memory
users.
E
E
E
A
E
A
A
A
A
H
A
A
A
A
A
H
A
A
E
G
E
E
A
E
A
A
You
know,
if
you're
predicting
on
something
that's
a
stream.
You
may
not
know
what
the
count
is,
but
we
could
just
return
like
negative
one
or
something
in
that
case.
So
because
yeah,
you
need
to
know
how
many
records
exist
within
the
source,
so
you
need
the
source
to
implement
some
sort
of
count.
Method.
G
A
E
E
So
what
I
want
is
I
want
to
insert
an
operation
in
between
these
two
so
that
the
output
of
the
the
most
upward
operation
is
accumulated
using
that
particular
operation,
and
when
everything
is
exhausted,
it
will
create
a
list
of
outputs
of
the
remote
stopward
and
then
it
will
send
to
the
vectorizer
yeah
yeah.
Okay,.
A
A
So
right
now
the
orchestrator
context
that's
running
is
going
to
I
mean
we
we
complete,
we
need
to.
We
need
to
run
like
everything
has
to
be
run
differently,
because
so
the
in
this.
With
this,
what
we
talked
about
earlier
right
when
we,
I
think
that's
when
this
came
up,
we
could
also
do
it
like
this
right.
So
basically
stir
well
context.
A
A
A
Well,
there's
going
to
be
one:
let's
see,
there'll
be
one
instance
per
data
flow
yeah
there's
one
instance
per
data
flow,
so
you
could
create
an
operation
that
has
like
a
lock
and
then
a
list
and
then
every
time
it
okay.
So
it
would
look
like
it
would
look
something
like
so
yeah.
We
need
to
change
it
first
of
all,
so,
first
off
we
need
to
change
it
to
be
like
this
and
then
second
off,
we
would
say
something
like
async
def.
A
G
A
A
A
A
A
A
A
A
A
A
All
right
so
when
the
orchestrator
context
is
created
right
and
that's
basically
when
we
yeah
it's
here
so
when
we
have
this
when
we
create
a
data
flow
source
context,
so
for
so
for
the
lifetime
of
this,
this
data
flow
source
context
this
this
this
operation,
like
the
example
our
example
operation,
we'll
we'll
have
this
list
right.
So
basically,
if
we
run
if
we
run
the
records
method
here,
it's
going
to
be
the
same
thing
for
the
whole.
A
A
A
A
A
A
None
all
right
so
should
feature
namer
definition,
name
to
add
as
source
length
right,
so
the
number
of
so
basically,
if
someone
specifies
length
right,
they
should
give
the
definition
name
that
they
want
to
be
added
to
the
context
and
it
will
contain
the
length
of
the
source
right
and
so
we'd
come
in
here,
and
we
would,
let's
see
so,
there's
length
right.
So
we'd
come
in
here
and
we'd
have,
let's
see
like
first
up
words
and
length.
A
A
A
A
A
J
A
A
A
A
A
A
A
A
A
A
And
then
it
should
wake
up
everyone
else,
so
we
grab
the
lock.
We
add
our
word
to
the
lock
or
we
add
our
list
to
the
lock
or
to
the
list,
and
then
we
check
okay.
If
the
length
is
correct,
then
we
set
the
event
and
everyone
else.
So
basically
only
the
last,
the
last
one
is
going
to
hit
this,
and
everyone
else
should
be
here,
waiting
right
and
then
the
rest
of
the
operations
and
the
data
flow
will
complete
when
that
event
is
set.
A
Okay,
multiple
async,
io
tests.
I
believe
that
this
is
how
this
is
supposed
to
work.
So
I
think
that
should
be
what
you
want
here
now.
The
one
other
thing
that
we
thought
about
was
that
this
orchestrator
context
is
being
created
when
orchestrator
context
is
being
created
on
the
a
enter
method,
but
it's
really
only
relevant
and
it's
really
only
relevant
within
records,
and
the
other
problem
is
that
if
you
get
a
single
record,
that's
not
going
to
work
right.
A
F
E
A
Complete
it
did,
it
said:
170
records
were
saved
and
it
was
167
megabytes
so
and
that
was
it
yeah.
That's
that's
a
lot.
Let's
see,
no
wonder
that
didn't
work,
okay,
so
source,
I'm
just
thinking
like
this
is
an
abstract
base
method.
Here
the
record
and
obviously
it
didn't
base
sort
of
context
record
is
abstract,
but
this
must
not
instantiate
or
inherit
from
abc
yeah.
It's
not
because
yeah.
If
we
call
record
there
is
no
record
method
on
data
flow
source
context,
so
that's
kind
of
a
problem.
A
A
If
you
grabbed
a
single
record
right
you
you
need
to
process
every
record
to
do
this
right,
so
you
also
need
essentially
an
option
to
the
data
flow
pre-processing
source
to
say.
Okay,
so
you
need
you
need.
This
record
needs
to
be
implemented
this
this.
This
method
needs
to
be
implemented,
implement
this
record
earth
method.
A
We
forgot
to
implement
that.
So
I
didn't
catch
this
when
we
did
the
code
review
on
this
one,
because
this
I
should
have
seen
this,
but
I
also
would
have
thought
that
the
abstract
base
method
stuff
would
have
caught
it.
So
that's
another
problem
there,
so
we
forgot
to
implement
it
when
we
initially
added
the
data
flow
source
context
and
the
so
basically
what's
gonna
happen
is
that
you
would
have
to
either
do
you'd
have
to
have
two
options
so,
like
all
of
the
records
right
and
if.
A
A
A
Or
something
like
this
right,
so
you
need
to
be
able
to
say
like
do.
I
run
all
the
records
right
because
so,
if
you,
if
you,
if
someone
were
to
call
dot
record
and
you,
if
someone
were
to
call
dot
record,
you
would
need
you
need
to
run
the
entire.
You
need
to
run
every
single
record
through
because
you
can't
you
can't
know
what
one
records
output
is
without
running
all
of
the
records
data
flows
right
because
you
have
to
run
this
operation
that
accumulates
everything,
and
so
therefore
you
need.
A
A
E
E
A
G
E
G
A
E
G
A
Okay
and
yeah
I
mean
so
so
the
the
logic
behind
the
the
reasoning
behind
the
way
it
is
that
it
is
is
because
it's
all
it's
it's
completely
defined
as
like
event
driven.
You
know
right
like
because
essentially
every
time
a
new
definition
is
produced,
that's
an
event
right,
and
so
it
may
be
possible
to
to
introduce
a
concept
of
of
loops
more
in
a
more
user-friendly
way.
A
It
does
give
you
this,
it
does
give
you
it
it
does.
Let
you
define
this,
you
know
event-driven
approach
to
things,
and
so,
when
you're
defining
you
know,
if
you
want
a
loop,
then
you
end
up
needing
to
say
like
okay.
Well,
there's
that
definition
again
and
then
and
you'll
you
would
see
like
when
you
visualize,
when
you
make
the
diagram
you'd,
see
that
that
that
the
where
I
swear,
I
had
an
example
of
this
somewhere.
A
You
would
see
that
oh,
this
was
the
depth
tree
command,
but
that's
not
finished
yeah.
You
would
see.
You
would
basically
see
the
diagram
feeding
the
definition
back
to
itself
and
there's.
There
was
one
basically
that
that
the
there
was
an
issue.
There's
an
issue
up
there
to
create
the
dependency
tree
right
for
the
python
projects,
where
we
would
go
figure
out
the
version
numbers
and
of
each
package
and
sort
of
create
a
tree
right,
and
that
is
essentially
like
it's
it's
kind
of
a
loop,
but
it's
kind
of
like
a
recursive.
A
It's
it's
it's.
The
way
it
ended
up
working
was
that
you
have
a
data
flow
and
the
data
the
data
flow.
Has
this?
Essentially
you
put
the
data
you,
the
top
there's
a
top
level
data
flow
and
then
there's
the
subflow
and
the
subflow.
Does
the
thing
where
it
just
says:
okay,
you
know
start
with
a
package
and
find
all
the
dependencies
right
and
then
the
output
of
that
data
flow,
which
is
the
subflow,
is
a
bunch
of
packages.
And
so
then
you
just
say:
okay,
that's
that's!
A
The
subflow
is
running
as
an
operation
right,
so
the
run
data
flow
operation
runs
a
data
flow
right,
so
it
now
it
takes
a
package
and
outputs
packages
and
when
it
sees
packages,
as
you
know,
being
output,
it
immediately
reruns
this
operation
right,
so
it
just.
It
inherently
creates
this
tree
until
there's
no
more-
and
I
don't
know-
I
mean
it-
it
essentially
ends
up
being
like
a
it's,
it's
kind
of
like
a
loop,
but
it's
kind
of
not
you
know
right,
because
the
whole
thing
is
is,
is
the
idea?
A
Is
that
it's
event
driven?
So
basically
I
mean
I
just
wanted
to
give
you
some
background
on
that
right
and
if
you
can,
if
you
have,
if
you
have
a
way
that
you
can
maintain,
if
you
can
come
up
with
a
way
where
you
maintain
the
event-driven
nature
of
things,
while
making
loops
more
like
more
user-friendly
in
in
the
way
that
you
would,
you
would
declare
that
this
is
something
that
has
a
feedback
loop
right.
Then,
then,
I'm
all
for
it.
A
It's
it
may
not
be
it
may
not
be
you
know
immediately
it.
It
mean
it.
It's
probably
going
to
take
some
take
some
take
some
thinking
about
yeah,
just
just
because
it's
it's
kind
of
it's
wacky
stuff
right.
So,
let's
see
okay!
Actually
now
I
know
what's
going
on
here
all
right,
okay,
so
let
me
post
this
to
the
create
a
gift,
because
it's
kind
of
long,
okay,
so
df
source
and
and
the
other
thing
to
say
on
that.
I
know
we're
getting
really
long
here.
A
A
A
You
could
take
like
a
fight,
a
python
function
and
decorate
it
with
something
you
know
make
some
kind
of
decorator
and
then
have
the
inputs
be
the
operations
that
you
want
to
run
and
then,
when
you
call
this
function
it
would
actually
it
would
run
it
would
pass.
It
would
sort
of
okay.
So
yeah,
you
imagine,
you
have
this
function
and
you
have.
The
arguments
are
all
the
operations
you
want
to
run
now.
The
body
of
the
function
shows
you
know
you're.
A
You
would
basically
call
the
functions
right,
call
the
operations
and
take
the
outputs
and
pass
them
to
the
other
operations
right
and
so
basically
you're.
You
have
this
regular
style.
You
know
syntax
for
what's
going
on
here
right,
it's
it's
very
obvious
right
to
the
to
the
casual
observer.
Now
the
trick
becomes.
What
you
would
do
is
that
within
the
decorator
you
you
you
make
it
so
that
when
the
function's
called
it,
doesn't
it's
not
actually
calling
those
operations
it
it
creates.
A
A
E
A
A
A
E
G
A
E
A
A
A
A
A
Okay,
the
docker
container
is
open,
broken
cli
needs
to
be
upgraded
to
use
flow
and
then
the
dam
integration
demo
that
one
needs
to
be
fixed
actually
I've
had
I've
had
multiple
people
ask
me
about
that
use
case,
and
I'd
have
to
be
like
that
demo
is
actually
broken,
so
I
that's
still
my
ars
to
go
fix
that
all
right.
Well,
thank
you.
Everyone
and
anybody
got
anything
else
or
are
we
good.
A
Yes,
the
layer
support
thing
yes,
and
so
that
is
my.
Let
me
just
I
will
write
that
down
right
now.
I
have
like
20
lists
going.
Actually,
let's
say
no,
that
is
not
on
this
list.
Okay,
all
your
support,
your
support,
all
right.
Okay,
thank
you,
guys
have
a
great
I'll
talk
to
you,
maybe
on
getter,
and
you
might
see
me
online
a
little
bit,
but
probably
next
tuesday.
So
all
right,
thank
you
and
have
a
good
one.
Thank
you.
Bye.