►
From YouTube: Weekly Sync 2020-02-18
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.9gmub71xh8ts
A
A
A
A
A
Right,
yeah
and
LP
stuff,
very
cool
that
would
be
exciting
to
play
around
with
I.
Had
somebody
who
approached
me
the
other
day
and
was
wondering
how
to
do
some
like
natural
language
processing
stuff.
He
wanted
to
do
the
reverse
and
like
generate
sentences
of
a
certain
sentiment
and
I
was
like
you
know,
I'm,
not
sure,
quite
how
to
do
that.
One
yet,
but
I'm
sure
someone
will
figure
that
out.
There's
gotta
be
some
papers
that
do
something
like
that.
A
Now
you
can
do
one
way
right,
yeah,
exactly
let's
see
and
then
okay,
let's
see
what
else
did
we
get
from
last
week?
That's
make
sure
we
recap.
The
vote
will
rabbit
so
I
haven't
done.
E
E
A
E
A
A
F
A
F
F
A
A
A
A
A
Okay,
so
basically
the
way
they
think
config
loaders
work.
Is
it
basically
it's
it's
just
it's
it's
just
an
abstraction
around
something
like
you
know,
JSON
loads
or
JSON
dumps,
right
and
so
for
yam.
Well,
we
we
do
the
same
thing
with
the
yeah
mole
load
and
yeah
Mel
dump,
and
this
is
the
Yemma
one.
Obviously
so
so
what
we're
gonna
do
here
is
we're
gonna
make
one.
A
That's
like
you
know,
PNG
or
JPEG
load
and
then,
and
so
you'll
have
load
and
dump
right
and
you'll
want
to
serialize
in
whatever
format,
and
so
the
reason
why
their
load,
B
and
dump
B
is
because
you
were
we're
expecting
them
to
be
bytes
or
already
set
up
to
do,
wait
while
you're
going
to
be
doing
here,
which
is
which
is
loading
in
bytes
and
so
basically
base.
What
you'll
need
to
do
is,
is
you
can,
when
you
create
the
new
config
loader
plug-in
for
this
one?
A
F
F
A
G
A
Okay,
okay,
so
here's
the
I
and
here's
the
other
step
and
let
them
make
sure
that
we've
documented
this
all
after
we're
done
here.
But
so
let
me
find
the
right
issue,
so
we
can
make
sure
that
it's
descriptive
as
it
should
be,
because
I
think
we
might
have
just
I'm
pretty
sure
we
just
took
the
meeting
minute
notes
and
placed
them
in
the
issue.
So
especially
if
it's
been
awhile.
F
A
A
A
All
right
so
complete
the
CSV
source
modification,
additional
config,
better
some
image
format
that
we
can
use.
Okay.
So
so
let
me
just
pull
up
the
code
and
github
here
too.
So,
basically,
what
we're
gonna
do
is
we're
gonna,
take
the
EDF
FML,
so
the
regular
source
stuff
in
the
CSV
source.
We
want
to
modify
okay
and
the
CSV
sources
like
all
sorts
of
messes.
Well,
no,
but
basically
what
we
want
to
do
is
we
wanted
to
add
another
config
section
so
something
under
here.
That
said,.
A
A
A
respective
file
type
or
file
extension,
so
basically,
if
you
make
a
dot
like
if
the
column
is
you
know,
contains
a
file
name.
So
we'll
add
to
this
list
here
like
tag
call,
you
know,
is
there's
the
oh.
We
forgot
to
keep
that
capitalist,
but
I.
Guess
it's
okay,
it's
consistent,
but
we
should
still
fix
that.
So
the
basically
we
want
a
list
of
column
names
that
are
going
to
be
loaded
from
from
config
file.
A
So
when
we
say
when
we
have
a
CSV
file
that
looks
like
this,
so
a
or
let's
see
key
file
name
and
then
key
is
first
file.
Name
is
first
camel
and
then
second
and
second
dot
yeah
mom.
Basically
what
we
would
do
is
if
so
example,
parameter
our
name
of
like
load
files
or
something
so
then
on
the
command
line,
DF
of
mel
sources
or,
let's
say
list
repos
sources.
A
A
A
A
A
A
You
know
you
know
like
hello
there
and
then
second
dialing
yeah
mo
might
be
high
or
hello
world
and
hi
there,
and
then
you
might
see
something
like
okay.
This
is
the
first
listing
okay,
so
this
is
the
first
listing.
So
this
is
before
this
change,
and
now,
after
this
change
and
we'll
see
in
here,
it'll
probably
print
like
this.
A
G
A
Okay
and
then
we
list
before
we
list
after
we
make
the
change.
Basically,
we
look
in
load
files.
Load
files
tells
us
that
this
file
name
column,
is
one
where
we
want
to
look
at.
Read
read
that
rat
the
hence
of
that
column
like
a
file
like
a
file
name
and
then
based
on
the
extension
we
load,
the
appropriate,
config,
loader
and
and
read
in
the
file
and
that's
actually
been
simplified.
A
B
A
A
Exactly
so,
you're
gonna
put
that
code
into
no,
oh
okay,
good,
I'm,
so
happy
that
github
always
saves
the
body
of
the
issue.
Message
I'm,
always
accidentally
going
to
the
wrong
thing
in
the
middle
of
creating
an
issue.
Okay,
so
and
we'll
pull
it.
I
can't
begin
while
here
just
to
or
we'll
pull
it
out
of
config
JSON,
because
that's
from
standard
library
so
or
we'll
just
pull
it
out
of
here.
A
F
F
A
A
A
F
A
That's
it's
all
the
same
command
line
parameters
right
so
we'll,
basically
just
when
we,
when
we
have
we'd,
have
like
a
CSV
file
or
something
that
would
list
all
the
the
the
images
we
want
to
predict
on,
and
it
would
just
be.
You
know,
file
names
or
something,
and
then
you
just
say:
source
load
files
and
then
whatever
that
column
name
and
then
CSV
file
is
so
you
could
have
just
the
one.
Let's
see.
A
So,
for
example,
if
we
so
this
is
test
right.
So
if
we
got
rid
of
this
first
column
here-
and
we
just
said,
we
did
the
same
thing,
it
would
just
put
you
know,
numbers
as
the
indexes
into
the
files
and
and
they
would
have
the
only
feature
being
loaded
from
the
files
file
name
so
and
then
within
that
feature,
this
would
be
where's.
The
amnesty
justice
of
Ducks.
A
Okay,
let's
see
this
case
is
this:
the
tests
are
failing,
cuz
I
need
to
upload
the
new
package
that
just
got
merged.
So
here
right
when
we're
doing
things
like
this,
this
is
for
training
right
and
we'll
specify
what
are
the
sources
and
it's
combining
the
two
sources
so
that
we're
getting
all
the
training
data
and
we
labeled
the
way
we
did
what's
the
label.
A
What's
the
features,
features
name
right
and
we
said
label
an
image
right
and
so
we'll
just
do
something
like
for
the
predict
function
or
like
when
we
do
D
fo
from
L
predict
we'd
be
saying
you
know,
model
features
is
image,
so
I
guess
what
we
do
is
we
make
the
file
name
instead
of
file.
Name
we'd
have
a
B
image
right,
so
it
would
be
test
that
CSV
and
this
would
be
image
and
then
pretty
much.
This
command
line
stuff
stays
the
same
right.
A
So
now,
if
you
say,
source
load
files
and
then
image,
then
it
would
go,
read
the
file
right
with
the
image
data.
So
if
we
modified
this-
and
it
was,
you
know-
dot
PNG,
so
first
up,
hanji
and
second
dot.
Png
and
then
we
said,
source
float,
files
equals
image,
you're,
adding
this
config
loader
stuff,
it's
going,
and
it's
reading
that
PNG
file.
First,
a
PNG
loading
in
the
bytes
and
then
you'll
see
an
array
here
and
then
in
the
second
one
same
thing:
it
loads.
A
F
A
We
talked
about
that.
That
was
basically
the
directory,
config
loader,
stuff
and
I.
Think
we
got
that
working
yeah.
We
did
get
that
working
with
the
der
comp
stuff.
So
how
would
that
I
mean?
That's
basically
that
so
that
works
as
what
it
is
right
now,
I
think
if
you
say
dot,
let's
see
how
does
that
work?
If,
if.
A
H
A
A
B
A
A
A
A
A
A
H
A
G
H
A
Yeah,
okay,
so
yeah.
So
basically
we-
and
this
is
this-
is
yeah
you're
right,
okay,
so
what
happened
was?
Let
me
just
recap.
So
what
happened
was
we
were
originally
planning
on
doing
the
directory
thing
where
it
just
reads
all
the
files
and
then
we
thought
for
some
reason.
We
we
thought,
let's
just
put
all
the
file
names
in
a
CSV
file
and
and
now
we're
to
basically
just
thinking.
Let's
go
back
to
do
this
source.
A
Let's
just
do
one
of
these
first
I
think
this
is
let's
just
let's
just
do
one
of
these
first
and
let's
just
keep
going
with
what
we're
doing.
But
let's
make
a
note
that
we
need
to
do
both
because
we
did
we
ended
up
doing
we
were
started.
We
started
on
that
path
and
there
was
some
reason
why
we
didn't
do
it.
So,
let's
just
finish
this
one
and
then
because
all
I.
H
F
A
E
A
I
think
this
will
be
a
minimal
change
right
now,
where
is
like
it
should
be.
It
should
be
a
pretty
minimal
change
to
use
this
config
loader
stuff,
and
then,
let's
just
make
a
note
that
note,
let's
just
let's
just
make
a
note
here-
that
we
we
still
want
to
do
that
that
that
parsing,
the
whole
directory
tree
for
images
after
this
is
complete,
because
there
has
to
be
the
other
situations
where
people
will
want
to
put
file
names
into
the
their
CSV
file
or
whatever
to
read
so.
Oh
I
remember
what
it
was.
A
A
Similarly
to
this
amnesty
example
like
where
you've
provided
your
own
files,
what
you
would
end
up
doing
would
be
you'd
have
like
a
you
know,
a
one
dot,
int
right
and
then
we'd
parse,
that,
like
or
you'd,
have
like
a
Boult
dot
was.
What
are
we
calling
this
yeah
label
dot
int
right
and
that
would
that
would
be
what
the
feature
called
label
would
be:
the
integer
value,
which
is
the
correct,
the
correct
label
for
this
image
right,
and
so
then
you
would
end
up
with
all
of
these
files
right.
A
Here's
what
the
file
name
for
that
label
is
in
a
CSV
file
that
seemed
at
the
time
like
it
was
going
to
be
a
more
user-friendly
than
creating
all
these
directories
and
stuff.
But
we
could
also,
of
course,
just
create
a
different
source
where
you
know
there
is
no.
There
is
I
guess
you
would
do
like
you
know
the
file
name,
every
every
image
in
this
directory.
The
file
name
is
the
the
key
for
the
repo,
and
then
you
know
you
you
you
come,
then
you
assign
the
label
the
same
label
to
all
the
files.
A
I
think
the
reason
is.
Is
we
went
through
this
logic
earlier
and
and
there's
like
a
few
different
conditions
here,
whereas
if
we
list
them
all
in
a
CSV
file,
it's
it's
at
least
very
clear,
what's
happening,
but
let's,
let's
just
read:
let's
just
add
this
later.
Basically
so
after
this
is
complete,
make
a
source
which
reads
directory.
A
H
D
G
D
A
D
H
F
D
D
So
the
data
was
like
this,
but
when
we
are
using
them
with
the
chances
to
indecorous,
so
what
we
had
to
do
was
shift
all
the
images
that
are
nine
dot
PNG,
something
like
that
in
the
one
single
folder
and
label
them
as
nine.
And
so
we
have
the
pre
process,
basically
that
to
use
within
circa
and
care.
As
that.
G
A
Yeah
and
I
think
and
I
think
this
is
why
okay,
so
all
this
is
exactly
why
we
went
with
the
first
that
we
did,
because
there
was
too
many
too
many
ways.
We
could
possibly
structure
it
race
in
the
files.
So,
let's,
let's
get
it
ass
done
in
the
way
that
it
is
and
then
there's
definitely
a
better
way
to
do
it,
but
we'll
do
that
after
we
get
this
get
this
working,
because
all
we
need
to
really
do
is
get
this
prediction
flow,
working
right
now
and
then
and
then
we'll
be
we'll
be.
A
A
A
True,
that's
true,
okay,
yeah,
and
but
that
also
so
yeah.
That's
so
that
ties
into
the
pre-processing
source,
actually
and
and
obviously
what
the
goal
with
this
guy
was.
Basically
just
you,
you
define
some,
you
define
some
something
right
and
and
then
that
that
you
can
throw
it
through
a
data
flow
right.
You
take
a
source
and
it
wraps
some
other
source
and
then
and
then
you
throw
all
that
through
it
data
flow,
and
so
you
could
take
like
a
directory
and
then
and
then
use
the
dataflow
to
decide
what
to
do.
A
I
think
that
just
I
I
think
that
that
this
is
sort
of
a
use
case
where
we're
targeting
users
who
need
things
more
pre-canned
right,
then
then,
then,
are
willing
to
mess
with
the
data
flow
right,
because
I
think
that
that
that
we've
got
sort
of
to
two
audiences
right.
Now
it's
it's!
It's
people
who
want
to
do
machine
learning
out
of
the
box
really
easily
right
with
the
command-line,
and
then
we
have
people
who
and
there's
there's
less
of
these
people.
A
But
there
are
people
who
are
interested
in
like
how
do
you
use
this
dataflow
stuff
to
to
do
interesting
things
and
and
the
CLI
people
I,
don't
think
they
are
I
died,
yeah
I,
don't
think
it's
gonna,
be
it's
gonna,
be
quite
intuitive
enough,
so
I
think
we'll
want
to
actually
do.
We
will
want
to
actually
make
this
source.
A
A
A
Let's
see
okay
yeah
we're
probably
going
long
today,
so
sorry
guys
but
yeah
okay.
So
let's
do
so
argh
and
I
haven't
gotten
the
chance
to
really
look
at
this.
Yet
will
you
post
it
up
with
the
sub
flows,
but
I
did
start
to
skim
it
so
I,
don't
I,
guess
I,
don't
really
have
much.
I
can
say
here
yet.
Do
you
have
anything
that
you
wanted
to
talk
to
me
about
before
I
give
it
a
more
full
review
to
see?
What's
going
on?
Oh.
F
C
A
Worries
did
you
want
to?
Did
you
have
anything
to
so?
Basically,
what
I
was
saying
is
I
haven't
gotten
the
chance
to
do
a
full
like
review
of
this
yet,
but
it
also
looks
like
you're
you're
heavily
in
debug
mode
right,
so
did
you
have
any
things
I
can't
I
camera?
What
do
you
said
this
morning?
Let's
see
Oh
what
is
parameter
said.
Oh
gosh
yeah
so
parameter
said.
Okay.
So
let
me
let
me
just
answer
these
questions
real
quick
here.
So
what
is
parameter
set
parameter
set
is.
A
Parameter
said:
is
all
the
inputs
bound
to
their
respective
names
for
that
operation
right
so
you're,
saying
this,
the
and
and
the
reason
why
parameter
said
is
different
than
input
set
is
well
input
set
is
any
time
there's
new
inputs
into
the
network.
It's
all
it's
whatever
came
in
that
time,
right
parameter
set
is
okay.
This
operation
takes
these
different
definitions,
names
these
different
arguments
right
and
so
each
of
those
argument
names
is
one
of
the
parameters,
so
we
assign
the
you
know
we
assign
a
value
just
like
we
have
that
input
structure.
B
B
A
B
B
B
B
A
Okay,
so
okay
so
run
dispatch
is
where
we're
running
one
of
basically,
we
run
the
operation.
This
is
like
run.
Dispatch
has
been
scheduled
asynchronously,
so
it
basically
says
you
know
run
run
this
when
you
can
right
when
there's
when
there's
no
blocking
I
like
next
time
next
time,
the
CPUs
free
right.
So
then
we
we
go
and
we
and
it
for
every
operation
that
needs
to
be
run
with
a
parameter
set
like
it.
We
call
run
dispatch
right
and
so
we've
dispatched
the
operation,
then
eventually
the
event
loop
will
run
the
operation.
A
So
what
we
want
to
do
is
instead
of
forwarding
to
the
sub
flow
right
here
we
want
to
whenever
we
get
new
inputs,
we
want
to
forward
to
the
sub
we
want
to
forward
to
the
sub
flow
instead
of
like,
instead
of
whenever
we
add
new
inputs,
because
we
might
get
inputs
from
different
places
right
like
if
all
of
a
sudden
someone
adds.
This
is
not
the
only
thing
that
can
adequate
stew,
the
network
right,
so
some
of
the
inputs
or
seed
inputs
right.
B
B
A
H
B
A
Thanks,
let's
see
do
you,
let
me
just
review
the
file,
because
this
is
not
working
right.
Okay,
so
it
could
be
a
lot
cleaner,
but
I
think
come
on
okay.
So,
basically,
here
this
is
like
my
computer's
being
weird.
Sorry,
it's
not
scrolling
correctly
so
in
here
is
right
for
one
for
one
of
those
contexts
which
is
like
ICT
X
were
running,
we're
running
the
operations
within
that
in
that
little
sub
loop
right,
and
so
this
is
where
we're
waiting.
A
B
A
B
B
A
B
A
So
this
this
returns
a
task
object,
and
so
this
is
an
AC
Keio
object.
So
so
you
say:
yeah
add
it
as
a
coaching
right,
so
anything
with
async
in
front
of
it
becomes
a
KO
routine
which
is
like
you
know.
You
called
the
function,
but
the
function
doesn't
run
until
you
actually
run
that
covert
team.
You
await
that
Co
routine.
So
when
we
say
create
task,
we're
saying:
okay,
async
IO
go
schedule
this
thing.
Whenever
you
can
and
return
me
the
task
object,
which
will
tell
me
when
that
was
done
so
then.
A
B
A
B
A
Do
so
it's
task
or
dot
result
right,
so
task
dot
result.
So
we
say
when
we're
going
through
all
these
tasks,
so
we
use
this
weight
method
to
say
you
know
whatever
one
first
completed,
then
let's
deal
with
it
and
then
we
say
okay,
so
if
the
input
set,
if
it's
the,
if
the
tasks
that
just
completed
is
the
one,
a
new
input
sent
into
the
network
then
grab
the
result
and
the
result
is
basically
going
to
be
like.
Is
there
more
of
these
things?
Like
did
I
get
multiple
new
inputs,
that's
at
once.
A
A
Yes,
exactly
so,
then
you
say:
four
new
input
set
in
new
input
sets
because
it
just
dumped
all
of
the
pending
ones
to
you,
which
I'm
not
sure,
if
really
more,
is
needed
in
this
context
actually,
but
if
that's
what's
going
on
at
least
so
so
you
go
through
each
of
the
new
input
sets,
and
you
say,
okay,
give
me
the
parameter,
set
pairs
and
dispatch
the
operations
right.
So
what
we're
gonna
do
here
is
we're
gonna,
say
this
stuff,
where
you've
added.
B
A
A
A
Okay,
so
this
is
the
other
thing,
is
there's
this
redundancy
checker
right
and
the
redundancy
checker
checks,
what
things
have
been
run
and
what
things
still
need
to
be
run
right,
and
so
the
question
in
my
mind,
right
now,
is
basically,
if
we
forward
the
input,
do
we
care
about
it
within
the
context
of
the
parent
right
and
I'm.
Guessing
that
there's
there's
two
situations
here
and
we
probably
need
to
be.
B
A
A
A
Then
the
definition
star
forward,
yeah,
okay,
cool
and
then
we
probably
want
something
that
so
excuse
me.
Let's
see
so
there's
there's
two
cases
right.
There
is
I,
don't
care
about
anything
that
gets
forward
to
just
let
the
sub
flow
deal
with
it
and
then
there's
I
do
care
about
things
that
get
forwarded.
I
also
want
to
use
them
within
the
flow.
B
E
A
If
I
don't
want
to
do
anything
with
it,
I
don't
need
to
add
it
to
the
redundancy
checker
right
because
I'm
never
going
to
use
it.
If
I
do
want
to
do
something
with
it,
then
I
need
to
start
adding
it
to
the
redundancy
checker,
but
I.
Don't
any
really
need
to
add
it
to
the
redundancy
checker
if
it's
being
used
as
a
parameter,
because
we
add
the
parameter
sets
themselves
to
the
dunder
redundancy
trigger
sorry
I'm.
Making
this
too
confusing
it's
the
basically
I
would
say.
B
A
A
If
they
are,
then
just
what
you
know
do
do
what
exactly
what
you've
done
here
right
forward
them
and
if
they
aren't
then
do
I
pass
them
to
that
parameter,
set
pairs
function
or
do
I,
not
right,
so
you
would
say:
basically
you
would
have
some
other
variable
within
book
or
within
another
property.
That
says
like
drop
or
not
right
and
you're.
Like
parent
cares
about
something
like
that.
A
A
B
A
Let's
just
not
worry
about
it,
I
mean
because
cuz
well,
I
mean
what
I'll
end
up
happening
is
if
somebody
adds
another
thing,
they'll
realize
that,
oh
my
you
know
that
inputs
getting
like
that
operations
getting
run
because
I
was
forwarding
to
the
sub
flow,
but
it's
also
getting
run
yeah.
But
then
you
know
you
could
always
just
change
the
input
flow
right
that
the
data
flow
flow
parameter.
A
A
B
A
B
B
A
So
origin
is
meant
to
be
so
so,
for
example,
the
default
origin
of
any
any
parameter
is
seed
right.
So
any
any
input
object.
You
create
I,
think
if
the
default
argument
defaults
to
seed
and
that
basically
is
just
saying
right,
seed
seed
was
a
term
that
I
chose,
because
that's
a
common
thing
that
the
people,
if
you
guys
have
play
you
guys,
have
played
minecraft
right
or
like
the
random
seed
right.
A
So
if
you
you
set
a
random
seed,
then,
like
all
that
stuff
is
like
said
at
the
beginning,
and
and
you
know
it's
it's
it's
it's
it's
part
of
what
what
is
used
every
time
at
the
beginning,
right,
if
you're
generating
a
bunch
of
series
of
random
numbers,
then
if
you
choose
the
same
seed,
you're
going
to
get
all
the
same
output,
so
these
are
like
the
same.
The
same
values
that
get
added
to
the
dataflow
every
time
would
be
like
the
seed
values
right.
A
So
then,
if
we're
thinking
about
like
okay,
so
what
is
the
origin?
The
default
origin
is
just
like
you
know
the
seed,
that's
just
because
that's
just
what
we've
been
using,
but
you
know
the
origin
once
it
comes
from
another
operation,
the
origin
is:
what
was
the
the
output
from
that
operation
that
that
created
it?
It
didn't
really
make
sense.
Let's
see,
let
me
give
you
a
concrete
example
here.
A
C
A
A
A
All
right,
well,
I,
guess
it'll
tell
us
for
whatever
all
right,
so,
okay,
great
perfect,
so
every
time
so
like
we
ran
the
ad,
so
we
ran
the
ad
operation
in
the
processing
stage.
Here's
what
these
were.
The
inputs,
that
was
the
output,
is
some
right
and
the
value
is
42.
So
now
we
created
a
new
input
set
with
those
outputs
and
we're
saying.
Okay,
this
is
a
new
input,
the
values
42.
A
The
definition
is
the
result
and
the
origin
is
some,
the
some
property
of
the
add
operation
right,
the
sum
output
property
of
the
add
operation.
So
that's
so,
basically,
if
we're
like,
when
we
rewire
the
I
mean
that's,
that's
basically
what
it
is
it's:
where
did
it
come
from
right?
So
it
it
came
from
the
add
operation
and
it
came
from
the
some
property
within
the
result.
Team
output,
dict
right
does
that
make
sense.
Er.
Are
you
sort
of
looking
for
something
more.
B
A
A
G
B
A
B
A
Exactly
and
I
think
the
other
thing
is
that
what
we'll
need
is
we'll
need
a
way
to
just
kick
off
that
thing
right
away
right,
like
you
know
what
I'm
saying
like
if
you're
running
the
parent
data
flow
you're,
also
running
that
child
data
flow
right.
So
right
because
right
if
you've
started
the
parent
data
flow,
you
want
to
be
immediately
forwarding
things
to
that
sub
data
flow
almost
like.
We
want
to
run
that
operation
right
away.
B
A
A
B
A
Great
great,
that's
the
way
to
do
it,
us
I'm
glad
it
helped
I.
There's
there's
this
one
thing:
I
wanted
I
wanted
to
do
some
containing
the
one
thing.
That's
really
missing
from
this
right
now
is
the
fact
that
if
you
create
a
bunch
of
sub
processes,
you're
gonna
lock
up
whatever
machine
you're
on
and
so
there's
this
one
task,
that's
open!
That
says
the
the
issue.
Title
is
like
a
system.
E
A
The
cop
they're
running
contacts,
yeah
and
so
basically
and
then
there's
also
another
issue:
that's
open
called
system,
local
resource
management
and
what
that
really
means
is
like.
Basically,
we
need
a
way
to
do
things
so
that,
because
there's
like
when
you're
running
these
things,
if
you
just
start
calling
the
async
I/o
sub
process
create
within
any
of
these
operations,
you're
just
gonna
create
a
million
processes
right
because
it
just
like,
if
you
end
up
with
a
million
operations
that
get
run,
it's
gonna
create
a
million
processes
in
your
machine.
A
A
To
do
oh
yeah,
yeah
yeah,
well,
and
that's
the
idea
it's
like
once
you
once
you
get
it
right,
though
it's
really
easy
to
debug
right,
it's
just
like
when
you're
constructing
a
event
loop,
initially
and
you're
like
okay.
How
do
all
these
things
get
forwarded
in
like
what
are
you
know
what
it
was?
What
is
the
right
way
to
dispatch
things
and
stuff
like
that?
That's
that's
really
hard.
So,
hopefully
that's
that's.
A
lot
of
the
idea
here
is
like
simplify
that
right.
B
A
A
D
A
D
A
No
don't
design
this
John
Whiteman
wrong
job.
It's
like
I,
don't
know
how
many
times
it
has
it's,
how
I've
never
assigned
to
John
Whiteman
once
and
it
keeps
me
wanting
to
assign
to
him,
come
on
Google,
okay,
so
and
then
yes
and
yes,
I,
don't
know
your
last
name,
but
not
our
mentor.
Yes,
unless
I
mentor
yesh
has
anything
he
wants
to
talk
about
I.
H
A
Yeah
I
did
I,
did
some
spend
some
time
poking
around
there
and
they
look
like
good
stuff
I
needed
to
I
needed
to
add
another
idea
to
the
ideas.
Page.
That's
gonna
be
just
you
know,
like
basically
add
some
mad.
Some
models
like
people
have
been
doing
right
because
that's
definitely
a
valid
idea,
and
it's
it's.
You
know
it's
it's
it's
what
we
do
so,
but
yeah
I
didn't
I
didn't
have
any
like
immediate.
H
A
A
Great
yeah,
I
think
then
and
I
don't
know
if
you
saw
the
new
system,
but
basically
I
tried
to
I
tried
to
goddess,
so
the
tests
are
failing,
because
I
need
to
push
the
new
package,
because
I
tried
to
push
the
new
package
and
I
can't
push
to
a
non-existent
package.
Let's
see
a
contributing
I.
Try
to
add
these
things
to
where
you
can
basically
like
pick
out
how
much
time
you
have.
A
So,
if
you
don't
have
very
much
time,
you
can
grab
an
extra
short
issue
if
you've
got
lots
and
lots
of
time,
you
can
rebut
to
rewrite
the
whole
codebase
and
rust,
you
know,
etc.
X
that
are
a
here's.
The
system,
local
research
manager
in
cap
number
of
executing
context,
but
yeah,
so
that's
basically
I
was
just
just
trying
to
make
it
easier
for
people
to
pick
off
whatever
size
task.
They
have
that
they,
you
know,
have
time
to
do
so.
C
A
D
D
G
A
Web
UI,
yeah,
okay,
so
I'm
sorry,
I,
also
owed
you
guys
some
documentation
on
on
getting
up
and
running
with
the
web.
Ui
I
think
I
still
have
that
from
last
week.
Yes,
documentation
immediate
next
steps.
Let
me
re
copy/paste
this
so
so
memory
a
web
UI,
so
the
web
UI
we
can-
and
we
can
like
just
look
at
it.
Real,
quick
here
and
I
can
show
you
guys
exactly
what
what
what
I'm
talking
about,
but
so
this
is
obviously
the
web
UI
in
its
current
state.
A
The
only
page
that
works
is
this
settings
page
and
the
sources
page.
So
this
does
actually
work,
which
is
cool.
I
found
this
thing
that
basically
mocks
your
back-end
and
like
intercepts
all
your
HTTP
requests,
so
that
you
it
basically
all
of
this
stuff
is
actually
like
trying
to
go
hit
the
API
and
then,
if
you
run
the
HTTP
server
and
you
set
the
backend
URL
to
whatever
your
HTTP
server
is,
it
will
actually
list
all
the
files.
A
Although
the
uploading
doesn't
work
yet,
then
the
next
things
we
need
to
do
is
we
basically
just
need
to
go
through
and
figure
out.
You
know
how
do
we
implement
all
of
these
various
different
pages
here,
and
so
really,
what
that's
going
to
look
like
is
is
we
need
to
come
up
with
some
sort
of
like
generic
form?
A
Creator
right,
we'll
need
some
sort
of
react
component
that
that
takes
the
output
of
those
args
methods
and
builds
a
form
where
we
accept
the
appropriate
data
types
and
then,
when
we
save
the
form,
will
you
know
go
create
the
the
specific
instance
of
whatever
that
the
FF
ml
object
is
or
plugin
is
right
by
hitting
the
HTTP
server
API,
and
so
all
of
this
stuff
is
of
course
documented.
You
know
that
the
how
to
do
react
stuff
is
not
documented.
A
That's
what
I
need
to
document,
but
all
the
HTTP
documentation
exists
so
like
this
is
the
files
URL.
This
is
really
the
only
one
that
works
right
now
and
it
just
lists
all
the
file
names
and
what
their
sizes
are,
and
so
what
we'll
need
to
do
is
we
need
to
do
things
like
ok,
so
when
we
go
to
the
configure
page,
four
should
have
open-bolt
at
the
same
time.
A
A
It
doesn't
really
matter,
but
when
we
go
to
the
configure
page
for
sources
it'll,
you
know
want
to
have
a
drop-down
of
like
what
type
of
source
do
you
want
to
configure
right
and
then
it
will.
You
know:
it'll
it'll
return
to
this
giant
at
this
giant.
Json
object
where
it's
like
okay,
well,
you
can
have
a
CSV
right
and
then
here's
like
CSV
source
right
and
so
and
then
this
is
just
a
artifact
of
the
way
that
the
the
config
stuff
works.
But
then
it
says
you
know
CSV
source,
CSV
and
then
it'll.
A
A
A
G
E
A
A
lot
oh,
but
yeah
so
and
and
I'm,
probably
I'm
so
I-
think
I'm,
probably
going
to
do
some
heavy
work
on
this
within
the
next
week
or
two
here.
My
birthday
is
coming
up
on
on
Friday
here,
so
I'm
gonna
have
some
stuff
to
do
there
and
and
then
I
I've
got,
I'm
god
I.
Think
I
told
you
guys
I'm
getting
married
and
into
March.
So
I
have
a
lot
of
wedding,
stuff,
I'm
trying
to
get
done,
but.
B
D
A
There's
a
lot
to
get
done,
but
but
I'm
gonna
try
them
like
damned.
If
I
won't
try
to
get
this
web
UI
to
a
point
where
I
can
demo
it
because
I
think
I
told
you
guys,
some
people
wanted
to
interview
me
on
two
different
podcasts
and
I'll
be
talking
about
dff
amount,
and
so
I
was
hoping
that
I
could
have.
At
least
you
know
we
could
we
could
I'm
I
feel
like
there's
a
disconnect
when
I
tell
people
about
this
and
I.
A
You
guys
probably
have
felt
the
same
thing
where
you're
like
oh,
you
know
like
it,
helps
you
make
machine
learning
models
and
do
machine
learning
and
people
go
like
okay,
I,
don't
really
understand
what
that
means
right,
so
I'm
hoping
that
once
we
get
this
web
UI,
we
can
sort
of
like
create
a
quick
little.
Video,
like
you
know,
put
that
as
a
gif
on
the
front
page,
and
things
like
that
and
and
people
will
be
like.
Oh
now,
I
understand
like
what
I
can
do
with
this,
because
it's
you
know
it's
kind
of
people.
A
There
seems
to
be
some
some
disconnect
going
on.
Maybe
I'm
not
good
at
explaining
it.
Maybe
you
guys
have
more
luck
than
me,
but
I'm,
hoping
that
the
web
UI
will
be
good
and
so
I'm
hoping
to
have
it
before
those
two
interviews,
which
are
two
weeks
from
now
and
three
weeks
from
now,
because
you
know,
then,
if
people
google,
it
then
they'll
be
easier,
easier,
easier,
onboarding
form
right
who
knows
if
anybody
will
listen
but
right?
Well,
we
got
to
try
so
and
then
I
also
told
you
guys.
A
A
I
I
A
I
A
Yeah
yeah
that'll
make
you
nervous
for
sure
yeah,
okay,
hey
looking
good.
This
looks
great.
It
looks
like
you're
definitely
on
the
right
track
here.
This
all
looks
you
know
on
first
glance,
it
looks
right
to
me:
let's
see
okay,
so
I
think.
I
A
A
A
I
A
Yeah
we
grab
the
tool
and
then
we
just
run
the
tool
on
whatever
package.
So
actually
here
we
go.
This
might
be
good
the
command
actually,
that
the
CLI
usage
command
yeah
that
try
running
that.
Actually
in
that
just
copy
paste
that,
because
you
did
a
good
job
of
changing
the
formatting
to
the
correct
thing
there
so.
A
A
I
A
A
I
A
Depends
on
whether
the
tool
decides
to
output
errors,
to
standard
output
or
standard
error.
The
other
thing
is
that
when
you're
doing
Len
issues
here,
I
think
we
want
to
do
Len.
Let
me
let
me
just
I
think
it
needs
to
be
Len
issues,
issue
or
issues
and,
let's
see,
did
I
do
I
think
it
needs
to
be
that
which
is
in
the
chat.
But
let
me
just
scroll
back
up
to
that.
Little
ass
Keaney.
My
thing
that
I
sent
a
while
ago.
A
So
you're
gonna,
when
you
JSON
loads,
right
you're,
getting
this
object
right
and
the
this
object
has
this
issues
key
and
it
has
the
linters
that
it
ran
I
think
at
the
very
end
right
and
that's
that
list.
So
what
we
want
to
do
is
we
want
to
take
the
length
of
this
key
here
right,
yeah,
cuz,
then
every
index
is
one
of
the
issues.
A
I
A
A
Okay,
cool,
oh
that's,
really
say
that'll
be
our
first
thing
that
will
lead
us
into
doing
multiple
languages
and
actually
I
was
talking
to
some
people
here,
air
at
my
work
and
and
we're
gonna
try
to
try
to
I'm.
This
is
gonna.
It's
gonna
go
a
lot.
This
is
gonna,
be
a
lot
of
data
flow
stuff
going
on
here
that
we're
gonna
have
to
figure
out,
but
basically
well,
there's
not
going
to
be
a
lot
of
data
flow
stuff
that
we
have
to
figure
out.
But
basically
all
we
need
to
do
now
is
I.
A
A
I
E
A
A
B
A
A
A
I
A
A
So
basically
that,
then
we
we
in
download
files
and
we'll
know
that
we're
working
with
a
white
write
file
if
the
hashes
is
correct,
so
we
want
to
do.
Is
we
want
to
write
our
test
cases
to
use
this
cache
download
decorator,
which
is
anything
with
the
app
as
a
decorator
and
so
you're
just
going
to
call
that?
A
Basically,
you
call
this
function,
you
say
at
cache
download
and
then
you
pass
the
URL
to
what
you
want
to
download
you
pass
where
you
want
to
download
it
to
which
is
going
to
be
the
same
same
format
as
this
we're
gonna
just
say
like
so
path
lab
path.
So
file
is
the
path
to
the
file
that
we're
currently
running.
So
wherever
test
source
test,
ID
X's
on
disk,
that's
going
to
be
file
and
so
dot
parent
would
be
the
directory
that
it
bets
file
is
in
so
test
source.
A
So
you
know,
if
that's
under
your
home
folder,
it's
going
to
give
you
the
whole
path
to
that.
It's
going
to
be
this
right
and
then,
with
this
path,
libs
object,
so
you
can
say
slash
and
then
that'll
combine
it
with
the
correct
directory
combining
slashes,
whether
on
the
windows
or
Linux,
because
on
Windows,
obviously
they
do
two
backslashes
and
then
we
on
Linux
and
OS
X
Mac.
We
we
do
one
forward,
slash
right,
so
this
basically
says
okay,
so
download.
A
Take
this
file
right-
and
this
is
the
other
confusing
part
about
this-
is
that
where
I
defined
these
up
here
and
then
I
use
them
down
here
as
the
arguments
at,
will
you
see
a
star?
It's
expanding
the
the
array
into
those
arguments,
so
basically
this
becomes
the
first
argument.
This
becomes
can
argument
this
line,
and
this
becomes
the
third
argument.
A
A
A
Okay,
that
thing
might
need
to
be
changed
a
little
bit,
but
basically,
what
we'll
do
is
we'll
put
this
URL
in
here
right
so
we'd
say
this
is
the
first
argument
right
and
then
it'll
download
that
this
file
here
and
then
you'll
tell
it
where
to
download
it
to
right.
So
you
just
say
the
same
thing.
It
would
say
like
CI,
RI
resource
manager
or
something,
and
then
you
put
the
hash
of
this
file.
A
So
when
the
first
time
you
put
it
in,
if
you
just
put
any
whatever
value
for
you
put
for
the
third
one,
it's
gonna
yell
at
you,
because
it's
not
gonna
be
right
and
it's
gonna
say
I
expected
this,
but
it
should
be
this
so
I'll
just
copy
paste
the
error
message
of
what
it
should
be
and
now
use
that
value.
Basically
and
then
then,
the
tricky
part
here
is
now
that
this
is
just
set
up
for
downloading
files.
So
what
we're
gonna
need
to
do
is
we're
gonna
need
to
do
dr4
from
oh,
it's.
A
A
I
think
I'm
this's
might
be
a
little
bit
tricky,
so
I
might
I
might
make
this
function,
but
basically,
what
we're
gonna
need
to
do
is
we're
gonna
we're
gonna
have
the
same
cache
download,
but
we're
gonna.
Have
it
extract
the
contents
of
this
directory
right
so
and
then
the
question
the
question
there
is
like:
okay
is
all
that
is
all
the
contents
correct
right
so
that
well,
we
might
want
to
just
like
hash
everything,
well,
hash,
all
the
file
names
and
everything,
and
just
like
check
whether
it's
the
correct
extracted
contents.
A
A
A
Let's,
why
don't
I
just
write
this
function?
Real,
quick
to
do
this
stuff,
because
I
have
a
pretty
good
idea
of
how
this
should
work
and
then
you're
gonna
call
it
in
a
similar
way
and
I'll
make
a
test
case
that
calls
it
too
and
then
so
for
now,
don't
worry
about
it
right,
like
just
keep
going.
The
way
you
are,
you
could
even
start
on
the
other
operations.
A
This
thing
extracted
and
verified
that
the
extracted
contents
are
what
they
should
be,
so
that's
going
to
have
to
do
a
lot
more
hashing
and
verification
and
stuff
like
that,
and
so
I've
got
I've
got
a
lot
of
experience
with
that.
So
I
can
probably
write
that
pretty
quickly
and
then
and
then
you
you
can
more
quickly
go
with
what
you're
doing
right
so
well,
because
we
want.
G
A
We
want
to,
we
want
to
keep
things
speedy.
We
don't
want
to.
We
don't
want
to
do
things
for
no
reason
so
so
yeah
so
I
will
get
that
to
you.
Let
me
make
a
an
AR
for
myself
here,
let's
see
so
John
to
create
a
cached
download
extract
function
with
example
for
yash
okay.
So
let
me
just
assign
this
to
myself
here:
real
quick
oops.
A
Okay,
great
okay,
so
yeah,
then
just
let
us
know
how
that's
go.
Basically,
yeah.
Let
us
know
what
the
login
looks
like,
so
we
can
verify
that
that
thing
did
run
correctly
and
then
post
the
pull,
requests
in
and
all
kind
of
fine
tune.
Things
will
help
you
fine
tune
things
and
you'll.
Probably
then
you'll
probably
very
quickly,
move
on
to
the
next
operation,
because
my
guess
is
you've.
You've
got
the
feeling
for
how
this
works
right
would.
G
A
E
A
I
A
Happen
to
run
into
I
knew
that
that
I
had
a
suspicion
that
that
project
would
not
pass
the
linter
thing.
So
then
I
went
and
found
that
one,
the
original
one
that
I
suspected
did
not
right
so
and
that's
the
same
thing
I
think
I
might
have
put
some
examples
on
the
other
issues,
but
those
those
quite
likely
may
not
have
issues
right
so
we'll
have
to
figure
that
out,
but
yeah
cool
anything
else.
You
wanted
to
ask
me
better.
We
want
to
talk
about
on
the
call
here.