►
From YouTube: Weekly Sync 2020-06-19
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.hmuqg6k5xmp4
A
C
C
A
Hey
all
right,
good
news,
only
one,
only
one
problem,
let's
see
one
problem
can
take
a
while,
but
we
never
know
right,
okay,
so
who's.
Next,
let's
see,
we've
got
a
sock
shop.
E
F
D
E
G
G
B
A
A
A
H
A
What
we
should
do
is
we
should
really
when
we're
doing
this
window
stuff,
we
should
figure
out
how
to
get
the
main
test
suite
running
on
windows
in
the
CI,
because
that
would
be.
That
would
be,
though,
the
real
way
to
make
sure
that
this
works
I
have
no
idea
what
everything
works
on
OS,
X,
but
I
kind
of
just
assume
it
does.
Does
anybody
have
a
Mac
and
do
this
on
a
Mac.
A
Longer,
oh,
wait
a
minute
yeah
my
dad
has
a
Mac
and
he's
been
messing
with
it.
So,
yes,
it
does.
Work
works,
fine,
yeah,
okay,
that's
good!
Let's
see
so,
let's
see
oh
yes,
windows,
stuff
and
then
John
needs
to
do
the
goddamn
HTTP
tests
make
it
should
be
test
work
on
Windows
and
let
me
just
open
an
issue
for
that.
A
H
A
H
A
May
have
just
forgotten:
oh
this
line.
Oh
yeah,
no
I
think
I
just
forgot
to
merge
this
sorry
yeah.
This
looks
good
I.
Don't
know
why
I
didn't
merge
this
oh
yeah
yesterday,
I
had
like
20
tabs,
open
and
I
was
like
I,
don't
know.
What's
going
on
and
I
closed
them
all
and
so
sorry
that's
what
happened?
Okay,
so.
B
D
A
A
A
G
A
B
D
A
Alright,
let's
see
which
one
of
these
is
gonna
be
quick
to
knockout.
Okay,
so
should
we
be
using
import
lab?
How
about?
I
think,
let's
just
decide,
know
if
it's
messing
with
your
ide
and
it's
not
actually
speeding
things
up,
because
the
main
bottleneck
was
like
it
then
dancers
sort
of
know.
Does
that
sound
good
everyone?
Should
we
just
change
that
stuff
back?
A
A
Right
well,
poor,
shame
at
least
he
thought
until
use
import
lip.
So
that's
always
good.
Let's
see
alright!
Okay,
let's
make
a
new
issue.
A
A
A
A
A
B
A
A
A
G
All
right,
yes
yeah,
so
the
thing
here
is
there
are
multiple
ways
in
which
that
input
can
be
given
so
the,
but
at
the
end
of
the
day,
everything
should
be
in
the
form
of
string,
just
like
so
I,
just
like
in
the
example
that
have
shown
there
yeah.
So
the
problem
with
that
is,
there's
no
standard
script
that
people
use
to
convert.
So
everyone
like
they
have
their
own
custom
script
and
they
will
convert
it
to
format
and
they
will
push
so
I
have
given
two
options.
G
G
A
G
G
We
can
be
couple
this
whole
thing
and
give
it
like
that,
like
the
way
you
told,
but
then
we'll
have
a
couple,
what
they
gave
as
a
string
and
break
them
into
features,
and
then
we
can
do
that,
but
that
can
get
complex,
because
there
are
a
lot
of
things
that
are
intrinsic,
and
here
they
are
not
explicit.
Most
of
the
things
are
implicit.
Just
you
ask
me
now
or
what
is
1924
air
yeah.
D
G
A
G
A
D
G
All
these
no.
A
G
A
G
Like
before
the
test,
I
have
used
that
only,
but
that
is
basically
no
one
can
see
actually
yeah.
A
G
A
My
gosh
yeah,
oh
yes,
there,
it
is
sighs,
like
everyone
just
always
says
we're,
always
like
every.
If
they
get
help
goods
now
it
has
any
down
time.
You
get
this
thing
free
and
we're
all
like.
If
it
has
any
down
time,
we
all
lose
our
minds
like
at
least
I
do
and
everyone
on
Twitter.
Let's
see,
let's
see
it
still
working
on
the
question
answer
me
model.
A
Alright,
I
think
that's
pretty
much
it
on
this
one,
alright,
okay!
So
let's
just
make
sure
that
we
have
another
issue:
open,
okay,
so
one
thing
that
I'm
thinking
here,
though,
is
that
basically
you're
saying
convert
to
VW
is
true
like
if
that's
true,
then
we're
gonna
do
this
so
I
think
probably,
but
so
basically,
if
I
have
a
regular
record
and
I
just
use
the
woeful
rabbit
model
and
I
haven't
specified,
convert
to
VW.
True,
it's
just
not
gonna
work
right.
G
A
Let's
make
okay,
that's,
basically
that
was
training.
What
I
was
trying
to
get
out
here,
because
so
I
guess
I
haven't
put
this
up
yet
but
like
when
it
one
of
the
things
that's
gonna
be
really
good
here
about
what
we've
done
is.
Is
you
know,
I
can
assure
you
guys
this
thing,
I'll
shake
this
thing.
Let's
see
so
I
did
I
show
you
guys
the
thing
where
we
loot
just
loop
through
every
model,
with
model
dot,
load
right
and
then
try
training
to
see
which
one
gets
the
best
accuracy,
basically
yeah
right.
A
So
that's!
The
idea
is
like
we
want
most
of
if
we
can
give
up
everything
to
be
pretty
much
the
same.
So
if
I
like
pass
features
and
predict
and
I
just
sort
of
try
accept
like
I'm,
pretty
much
gonna
get
hit
every
regression
model
right
and
I'll,
just
like
you
know,
dump
the
failures
on
the
classification
ones
in
the
clustering
ones,
right
like
I,
just
don't
care
and
what
I'm
gonna
end
up
with
is
just
a
list
of
you
know:
I'll
end
up
with
every
single
model,
and
you
know
what
the
accuracy
was.
A
A
What
we
can
do
is
when
people
put
in
their
data,
we
can
just
sort
of
give
them
like
I,
when
we
should
probably
make
like
a
command
for
this
too,
but
sort
of
just
like
I
run
me
all
the
models
command
right
or,
like
you
know,
a
little
UI
that
says
I'm
just
gonna
run
every
single
model
and
tell
you
which
one's
the
most
accurate
right
and
so
like.
Well,
it
won't
do
any
you
know
tweaking
of
the
settings.
You
could
tweak
the
settings.
A
A
A
A
F
A
A
What
oh,
no,
no
yeah,
we!
Basically,
we
need
to
write
that
I
mean
I
have
code
for
it.
I
just
need
to
make
an
example
out
of
it.
It
would
be
very
easy
to
do
where
is
like
a
good
where's,
a
good
black.
Where
would
be
a
good
place
for
it
like
tutorials,
like
maybe
model,
maybe
we
should
just
change
this
to
model
tutorials,
simple
model
or
writing
writing
a
simple
model
packaging,
your
model,
and
then
you
know
finding
the
best
model
for
your
data
or
something
does
that
sound
good.
H
A
H
H
A
I
mean
they're
all
exactly
so
auto
ask
a
line
is
going
to
do
that
for
psych
it,
but
we
want
to
you
know
we
want
to.
We
want
to
do
that
for
all
the
models
right,
including
tensorflow,
everything
that
we
have
right.
So
when
we
have
Auto
SK
learn,
you
know,
we'll,
probably
just
you
know
in
the
loop
of
models
that
we're
using
we'll,
probably
just
only
use
Auto
SK
line.
A
I
did
this
other
thing
too
yeah?
So
basically,
this
is.
This
is
what
we
basically
just
go
through
and
and
I
need
to
add
this
error,
while
I
put
an
issue
up
for
that.
So
but
basically
we
just
go
through
and
we
say,
like
you
know,
what's
the
list
of
models
we
want
to
try
and
then
you
know
you
just
do.
A
You
do
okay,
god
I
was
in
the
middle
of
with
this,
and
then
you
just
do
modelled
load
right
and
then
you
try
it
all,
and
then
what
I
was
going
to
also
do
is
try
to
do
every
permutation
of
features.
So
you
could
try
all
the
different
features
which
I
thought
would
be
cool
right,
because
if
some
features
are
actually
messing
with
your
model,
then
you're
gonna
try
you're
gonna
train
the
model
on
every
permutation
of
features
that
you
have
and
sort
of.
Basically,
you
know
the
end.
A
The
end
of
this
is
basically
you're
just
going
to
end
up
with
the
best
model
right
and
so,
oh
and
then
I
also
is
messing
with
this
thing.
That's
sort
of
just
like
I
saw
this
because
you
know
all
the
models
have
like
different
ways
of
defining
accuracy.
So
I
made
this
thing,
I've
just
I,
don't
know
what
do
you
guys
think
about
this?
This
might
be
something
that
we
should
do
a
different
way,
but
I
thought
this
is
one
way
we
can
do
it.
A
You
know
basically
just
like
this
MA
II
model,
so
that
mean
what
does
it
called
mean?
Where
the
hell
did
go
mean
absolute
error,
so,
basically
just
like
to
make
it
so
that
you're,
comparing
apples
to
apples
on
these
models
right,
just
basically
wrap
change
the
you
basically
wrap
a
model
and
you
make
the
accuracy
output
for
the,
for
the
wrapper
just
run
predict
on
the
the
model
that
you're
wrapping
and
then
just
do
this
mean
absolute
error.
A
Calculation,
I,
don't
know
this
might
be
something
better
like
I
guess
this
about
this
I
mean
this
is
a
simple
approach
that
works
well
for
the
for
the
it
might
just
be
something
that
we
want
like
I,
don't
know,
I,
don't
know,
there's
like
lots
of
ways.
We
could
do
this
like
this
could
just
be
a
function
that
wraps
accuracy
you
know,
or
it
could
be.
You
know
the
model
wrapping
the
whole
model.
It
probably
doesn't
mix
in
any
ways.
Any
thoughts.
A
A
new
model
that
tries
all
the
models-
that's
a
good
idea.
That
is
a
great
idea
yeah,
so
let's
actually
yeah.
So
we
can
make
this
concept
okay.
So
let's,
let's
make
this
concept
of
like
a
wrapper
model
right
and
then
we
can
have
you
know
we
can
do
things
like
you
know,
okay,
so
this
wrapper
or
a
wall
I
got
so
we
can
have
to
kind
of
like
I,
don't
know.
Have
you
guys
seen
the
gets
pricing,
the
async
context,
manager
list
so
using
context
manager
list
yeah?
A
This
is
just
enters
every
single
context
in
the
list,
so
we
could
do
like
this.
You
know
we
could
use
this
guy
and
then
we
enter
the
context
of
all
the
models
and
just
so
that
you
can
write
wrappers
easily
around.
You
know
something
that
deals
with
a
bunch
of
models
like
we're
doing
where
we
do
this
and
then
we
could
yeah
I
could
yeah
anyways
yeah
I
like
that
idea.
Let's
just
make
one
model
that
runs
all
the
other
models
that
we
can.
We
can
abstract
it
later.
A
A
Will
run
accuracy
or,
let's
see,
run
we'll,
try,
training
each
model
and
was
gone
suit
on
shoe,
so
this
model
will
try
training
each
model
and
then
use
the
best
most
accurate
one
for
prediction.
This
is
kind
of
also
know
what
I'm
thinking
about
this
ma
e
stuff
is
that
when
I
was
looking
at
I
think
the
camera.
What
I
was
looking
at
I
was
looking
at
some
other
library,
and
they
had
this
concept
of,
like
you
know.
A
Well,
I
thinks
I
could
in
other
places
they
have
this
concept
of
like
okay,
tell
me
how
you
want
me
to
the
assessee
accuracy
right
and
the
initial
idea
with
the
ethanol
was
sort
of
just
like
you
know,
do
something
reasonable
and
you
don't
have
one
be
the
I'm
perfectly
accurate,
but
that
obviously
is
not
very
helpful
when
we're
trying
to
compare
novel,
accuracies
and
everybody's
got
a
different
way
of
defining
what
their
accuracy
is.
So
we
need.
A
D
A
A
G
A
A
A
Yeah,
okay,
great
perfect:
this
is
what
I'm
talking
about
yeah.
Okay,
so
but
I
mean
wait
a
minute!
Oh,
it's
just
gonna
actually
create
the
directory
PWD
okay,
so
this
is
not
really
okay.
So
I
was
like
how.
Why
is
this
working?
Well,
it's
working
because
it's
a
little
really
just
creating
the
string.
A
G
A
A
D
G
Also
I
was
thinking
we
shouldn't
standardize
the
way
we
pass
the
directories,
because
now
we
don't
have
default
directory.
So
in
all
the
examples
we
have
to
think
anything
everywhere
so
either
in
either
you
can
do
any
current
working
directory.
We
make
a
folder
of
the
name
of
the
portal
that
we
are
using
or
something
like
that.
G
G
D
A
Mean
maybe
the
stuff,
that's
like
all
stuff
that
we
all
need
to
do:
yeah,
yeah,
ok,
so
so
we
need
ok.
What
else
is
like
everybody's
stuff?
Ok,
I
think
this
is
OK,
so
we
need
a
standard
like
ok.
So
what
you're
saying
is
like
we
should
come
up
with
something
that's
like
because
some
of
some
of
the
examples
say:
temperature
sometimes
model
there.
Some
are
saying
you
know
blah
blah
like
just
standardize
what
we
pat
like.
You
know.
Everyone
says
Model
T
or
something
or
what
are
you
saying.
G
A
The
other
thing
is
that
we
should
probably
I
mean
so
this
here.
It's
like
the
current
working
directory
is
implied
right,
so
this
is
sufficient
here
right,
because
if
you
just
give
a
path
like
this,
this
implies.
You
know
that
you
know
it
implies
that
you're,
starting
with
PWD.
So
let's
change
those.
A
A
Because
I
know
we
do
that
for
the
I
know
for
the
now
we
do
not.
We
should
play
just
do
that.
Oh
now
that
we
have
a
relative
CH,
sir.
Well,
it's
a
good
one
to
know
about
just
buried
in
here.
Why
is
this
in
the
tests
acing
test
case
file?
This
should
be
in
a
oh
s,
file
all
right.
Okay,
then
yeah
we
should
probably
just
you
know.
We
should
probably
just
let's
just
do
it
here
like
because
if
we
just
do
so.
A
A
A
A
B
A
B
A
A
Does
this
satisfy
the
standard
way
thing
like
if
we
just
say
I
mean
if
everybody
just
says
like
I
mean
I
feel
like
yeah
we're?
So
what
do
you?
What
do
you
like
do?
Do
we
have
more
desire,
for
you
know,
quote
unquote
standard
here
like
cuz
I
feel
like
this
might
not
really
address
that
like
what?
What
do
you?
What
do
you
propose
I.
G
G
A
That's
a
good
idea:
that's
a
great
idea,
alright,
so
yeah,
let's
do
okay!
So
when
we
are
writing
okay,
so
where
would
be
a
good
place,
for
this
would
be
a
good
place
for
this
in
the
documentation,
because
we
need
to
document
that
this
is
the
way
to
do
it.
So
when
we,
when
people
are,
maybe
we
need
a
little
section
in
the
model
tutorials
on
contributing
your
model
or
something
would
that
be
a
good
place
for
that
under
the
contributing
documentation?
A
I
mean
we've
got
a
lot
of
stuff
into
the
contributing
documentation
right
now,
it's
kind
of
like
there's
a
lot
of
information,
but
the
you
know
Sphinx
must
have
updated
and
maybe
I'm
just
now
noticing
this
yeah
we've
got
a
lot
of
stuff
under
the
contributing
documentation.
I,
don't
know
if
it's
all
super
the
best
place
for
it
to
be.
A
Yeah,
what
do
you
guys
think
should
we
have
a
little
section
on
because
we
have
they?
We
have
now
we're
going
to
have
simple.
You
know,
writing
the
simple
model
packaging
the
model,
and
then
we
can
have
a
section
on
contributing
the
model,
and
then
it
can
talk
about
like
how
we
write
test
cases
and
stuff,
or
is
there
a
better
place
for
this?
Should
it
go
under
controlling
documentation.
A
A
B
B
B
A
A
Have
a
setup
which
sisters
into
a
tempter
all
right,
and
then
you
know
as
a
side
note
to
this
I
really
at
some
point.
We
should
really
go
through
all
of
the
model
test
cases
and
basically
make
integration
CLI
to
test
case
like
the
where
the
are
we
okay
there
we
go
he's
like
okay,
so
async
test
case
is
great
right,
it's
very
basic,
but
ideally
we
would
end
up
with.
We
would
have
you
know
some
of
these.
You
know
contact
stacks
because
those
are
handy
and
even
more
ideally,
you
know.
Basically
we
would.
A
This
would
be
like
you
know
the
base
test
case
that
every
test
case
is
from
because
then
we
don't
have
to
do
a
bunch
of
you
know
extra
work
here
and
there,
because
this
is
like
I
mean
by
the
time
you've
got
this
thing's
got
like
a
lot
of
like
I
mean
it
doesn't
go
to
a
lot,
but
I
mean
you
know
the
having
the
required
plugins
is
is
handy
and
then
having
the
contact.
Stacks
is
handy
and
being
in
your
own.
A
A
A
A
A
A
A
That's
probably
what
it
was.
You
know,
okay,
so
one
thing
here,
that's
just
I
think
we
can
probably
just
do
this
right
now,
so
the
test
it's
it
is
passing.
So,
let's
just
split
this
up
into
two
things.
So
it's
like
this
that
should
work
right.
Let's
see
that
way,
it's
sort
of
more
clear
that
we've
got
two
things
going
on
there.
A
Yes,
since
we
did
that
oh
I
guess
these
guys
are
kind
of
like
we
should
probably
form
that
does
the
same
to
what's
the
format
does
the
same.
If
we've
got
more
than
so
I
mean
you
guys
know
what
I'm,
why
I'm
doing
this
right?
It's
because
if
we've
got
sort
of
like
more
than
we
do
this
with
a
couple
other
things
right,
oh
I
missed
the
backslash.
A
F
A
A
A
Okay,
looking
good
sweets,
this
is
exciting,
fun,
stuff,
fun,
stuff
and
then
so
yeah
you're
adding
this.
And
then
you
have
another
PR
where
you're
gonna
go
or
way.
Note
you
already
updated
in
here
yeah
I.
Just
looked
at
that
great
wow.
This
is
exciting.
Now
I
can
actually
have
the
PNG
is
named
PNG,
fun
stuff.
So.
A
E
D
A
A
A
Oh
yeah,
do
we
have?
Is
this
a
rebase?
Oh
yeah,
you
actually
waited
to
do
today.
Yeah
I
screwed
up
now
my
bad
I'm
used
to
you
guys
are
doing
such
a
good
job
with
the
with
the
commit
messages
now
I
was
through.
I
was
used
to
just
sort
of
like
a
bunch
of
commit
message
and
then
I
threw
more
of
these
on,
and
then
there
was
a
squash,
but
now
that
you've
you've
done
it
so
nicely
now
I
just
destroyed
your
nice
I.
Have
you
know.
E
D
A
D
A
A
A
A
B
A
E
A
A
A
A
You
guys
know
what
I'm
looking
for
right.
Do
you
guys
understand
what
I'm
doing,
because
this
is
sort
of
a
good
thing
to
know?
Okay,
so
let
me
just
explain
just
a
case
but,
like
you
know,
file
types
will
usually
have
magic
bytes
that
they
start
with
and
so
for
P
and
G's.
It
looks
like
this
is
probably
our
sequence,
so
we
are
looking
for
maybe
even
wait.
A
A
It'll
say
like
you
know,
this
is
a
PNG
image
file
and
then
it
you
know
actually
like
goes
and
looks
at
it
because
it
understands
TNG's,
but
usually
the
way
that
you
determine
what
a
file
is
without
looking
at
an
extension,
is
you
look
for
these
magic
header,
bytes,
and
so,
if
you've
got
like
an
Els
file.
A
So
basically
the
thing
with
the
PNG
files
is,
they
obviously
have
some
header
so
like
PNG
file,
format
and
there's
this
person
who
makes
this
wonderful
images
of
them.
Like
you
know,
if
one
time
I
think
I've
told
you
guys
this
before
one
time
I
was,
it
was
Google
and
I
was
like
trying
to
figure
out
this
image
because
there's
just
wonderful
this
somebody
somebody
makes
these
and
oh
this
person.
A
A
A
Helpful
for
understanding
file
formats-
okay,
this
is
like
you'll,
probably
end
up
referencing
this.
At
some
point,
it's
really
good.
So
let
me
just
put
some
notes
here
so
dependency:
no,
not
an
option
for
building
pngs.
Sorry,
let's
see
well.
A
D
A
A
Okay,
so
yeah,
basically
and
we'll
just
go
over
like
what's
going
on
here,
just
for
the
for
the
fact
that
you'll
run
into
this
in
the
future.
So,
basically
simply
if
you
look
at
all
these
images
that
we
will
spine
similar
things
right,
usually
if
you've
got
some
kind
of
file
format,
it'll
start
with.
You
know
what
how
do
I?
A
How
do
I
what's
the
magic
number
like
magic
bits
or
signatures,
what
they're
calling
it
here
and
then
you
know
it'll
have
some
information
about
like
what's
the
size
of
this
file
and
how
do
you
decode
it
and
that's
what
we're
seeing
here.
So
you
know
like
how
many
bytes
to
read
and
stuff-
and
you
know
like
with
the
ITX,
for
example,
with
the
ID
x
source,
when
we
wrote
that
it's
actually
a
really
good
example.
A
E
A
Yeah
so
yeah,
so
this
is
actually
a
pretty
good
example
of
how
you
might
deal
with
a
new
binary
format
that
you
don't
understand
right.
You
would
sort
of
hope
that
this
person
has
made
a
beautiful
graphic.
You
would
go
look
it
up
and
then
you
would
start
well
using
the
struct
module,
and
so
it's
a
basically
the
struct
module.
A
Struct
module
lets
you
pack
and
unpack
binary
data
in
whatever
format
you'd
like,
and
so
it's
very
helpful
for
you
know
dealing
with
these
binary
data
formats.
So
if
we
were
gonna
do
this,
we
might
you
know
we'd
go
find
our
reference
and
if
you
can't
find
the
reference,
that's
like
a
nice
and
beautiful
and
colorful
like
this.
A
Probably
what
you're
gonna
end
up
with
is
an
RFC
document
and
an
RFC
or
you'll
end
up
playing
in
the
Papa
New
Guinea
rugby
league
in
RFC
document
tells
you
exactly
the
so
most
most
things
on
the
internet
like
most
things
that
we
deal
with,
have
an
RFC
like
either
like
people.
Things
will
either
have.
You
know
like
if
there's
multiple
implementations
of
something
like
chances
are.
A
Someone
has
taken
the
time
to
write
up
like
a
spec
and
an
RFC
is
also
pretty
much
like
a
spec,
and
so
when
you're
dealing
with
something
that
follows
a
spec
first
I
mean
the
first
thing
you
wanted
to
go.
Do
is
find
the
spec
because
well,
this
is
gonna,
be
helpful.
It's
still
gonna
we're
gonna
be
going.
You
know
what
the
hell
in
a
few
minutes
here
right,
but
we're
not
going
to
do
this
whole
thing.
A
I
just
want
to
kind
of
overview
of
what
to
do
when
you,
when
you
have
to
deal
with
this,
and
so
you're
gonna
want
to
go,
find
the
spec
and
you're
gonna
want
to
you.
Don't
want
to
like
you're,
not
gonna,
be
able
to
read
the
whole
spec,
because
these
things
are
really
like.
Look
at
how
long
this
thing
is
it's
insane
and
we
wonder
why
there's
security
vulnerabilities
when
you
parse
images
and
videos
right,
not
it's,
because
this
is
a
mess
right
and
so,
and
they're
gonna
have
like
lots
of
like
especially
okay.
A
Okay,
so
you
guys
know
DHCP.
Basically,
this
is
how
your
router
assigns
you
a
dynamic
IP
address
on
the
you're,
no
local
network,
or
sometimes
it's
used
on
wider
networks
and
they're
gonna.
Have
this
sort
of
language
where
they
say
must
must
not,
should
should
not
and
there's
another
RFC
that
defines
these
things,
there's
an
RFC
for
all
these
words
here,
basically
anything
anything.
A
That's
like
people
follow
this
thing
when
they
program
its
use,
there's
usually
an
RFC
for
it,
and
so
someone's
I
feel
like
this
one
used
to
be
pretty
good,
yeah,
yeah,
okay,
so
they're
nice,
they're
gonna
have
a
little
thing
like
this
sort
of
like
we're
referencing
over
here
with
our
what
the
hell
is
going
on
in
this.
You
know
binary
data
and
then
they're
gonna
start
telling
you
things
like
you
know
what
what
bytes
and
this
one
isn't
actually
an
octet.
So
that's
like
what
it's
like.
A
A
Let's
see
yeah
and
where's
a
good
example
here,
so
it's
gonna
tell
you
what's
going
on
lots
of
them?
Have
these
especially
Network
protocols,
it's
gonna
be
like
okay.
This
is
the
message
and
how
you're
going
to
decode
this
message
right
and
so
for
the
PNG.
What
we're
gonna
look
at
is
like
there's
gonna,
be
a
bunch
of
blocks
like
this
right,
and
so
it's
probably
gonna
tell
us
things
like.
Ok,
when
you
hit
this
block,
here's
how
you
decode
it
this
has
got
a
whole
back-and-forth
where
there's
good
examples
in
here
somewhere:
ok,
yeah!
A
Ok,
yes!
So
this
one,
for
example,
this
is
like
okay,
here's
the
discover
message
right
and
here's
the
cases
which
you
would
see
this
and
here's
how
you're
going
to
decode
that
packet
from
above
right
and
what
what
kind
of
things
are
going
to
be
in
that
packet
and
if
there's
going
to
be
more
data
appended
to
the
end
of
that
packet.
What
is
it
going
to
look
like,
and
so
this
PNG
one
is
probably
like,
really
nasty.
A
Are
they
yeah
yeah?
This
is
not
going
to
be
straightforward.
Is
it
yeah?
So,
basically,
oh,
maybe
it
is
sample
CRC
code,
ok,
yeah!
Sometimes
they
give
you
sample
code
and
stuff
yeah
all
right.
Well,
we
could
just
sort
of
encode
a
PNG
file,
but
it's
looking
like.
Oh
you
know
what
why
don't
we
just
do
that
actually
wait
a
minute.
That's
that's!
A
Here's
another
thing
that
is
like
a
nice
way
to
get
started
on
this
as
you
use
something
to
create
what
you
want
and
then
you
look
at
it
and
you
look
at
the
examples
and
you
start
to
see
how
does
it
change
so
image
open?
Okay?
Where
is
this
the
business
pill
we're
using
yeah
we're
using
pill?
Okay,.
A
A
But
if
this
is
like
something
where
it's
like,
you
know,
gonna
be
encoded
in
some
way
and
there's
like
no
pattern,
then
then
we're
just
kind
of
like
screwed
right,
because
we
wait
like
we're
not
gonna
like
we're,
not
gonna.
We
don't
have
time
to
go.
Add
a
bunch
of
code
to
like
Zee
Lib,
compress
a
bunch
of
zero
pixels
in
the
format
like
two
to
basically
write
this
function
right.
We
don't
have
time
for
that.
So.
A
You
know
we
can
do,
though
we
can
just
add
this
to
the
test
dependencies.
Do
we
want
to
deal
with
that?
Maybe.
A
A
A
A
A
Yeah,
of
course,
all
right,
so
let's
do
and
then
that's
that's
sort
of
like
this
is
a
disclaimer
for
everyone.
Now,
like
we're,
opening
the
door
on.
You
know
dependencies
in
the
tests
because
for
some
reason,
I
hadn't
just
like
that
was
a
pretty
obvious
thing
that
didn't
cross
my
mind
so
because
we
just
don't
want
them
in
the
main
library
right.
D
A
D
A
D
F
A
A
A
E
A
Yeah
not
exactly,
let's
see
no
no
that'll
work,
that'll
work,
yeah
that
should
work.
A
C
D
A
C
A
C
A
A
C
C
A
Should
not
gonna
fake
wait
a
minute?
Wait
a
minute:
okay,
cotton
fit
class!
Okay!
This
should
be
an
actual
class.
Wait.
F
C
A
D
D
C
C
D
A
A
The
intent
behind
what
I
was
saying
here
was
that
if
you
say
DB
here,
it's
gonna
instantiate
the
object
and
then
give
you
basically,
it's
gonna
put
a
reference
into
configs,
so
the
changes
so
that
should
have
been
localized
to
two
data
flow
or
weight,
not
data
flow,
but
yeah.
It's
a
data
flow
I.
Think,
let's
see,
maybe
it's
an
initialization,
but
let's
see
it
config,
let's
see
so
yeah,
so
configs
in
sup,
okay,
I
know
what
I
know.
Why
does
this
happening?
Okay?
It's
because
this
is
a
mess.
A
Let's
see
all
right,
so
we
should
really
be
loading.
These
things
when
we
load.
This
is
why
this
every
so
we
should
be
loading
as
so.
This
is
this
is
like
this
is
like
this
is
this
is
this
is
not
something
that
you
did?
This
is
probably
something
I
did,
so
we
don't
do
anything
to
config,
so
we
load
the
data
flow
right
now
right.
A
A
An
op-amp
ting
can
fit
yeah
because
we're
this
is
all
backwards,
as
his
ass
backwards
is
why,
let's
see
yeah
we're
like
we're
like
parsing,
these
were
okay
yeah,
we're
like
not
parsing
out
those
config
objects
when
the
data
flow
is
created,
right,
we're
parsing
them
out
when
we're
in
stanza
is
instantiating.
The
operation
right
and
that's
gonna-
lead
us
to
hell
here,
because
this
is
like
that's.
We
need
to,
especially
for
the
shared
configs.
C
A
A
A
So
what
I'm
sitting
yeah?
What
I'm
saying
is
that
is
that
the
current
way,
what
we're
doing
things
is
broken
right.
It
don't
like
it
works.
Well,
it
works
fine
right.
So
right
now
everything
works.
Fine,
because
only
an
operation
like
the
operation
cares
what
its
config
is
and
it'll
just
instantiate
it
when
it
gets
it
right,
but,
okay,
how
could
we
wish
to
maybe
simplify
this
so
right?
A
We
won't
find
out
about
errors
and
configs
until
we
could
initialize
a
data
flow
when
you
create
a
data
flow,
it's
not
going
to
do
anything
with
this
configs
unless
they're
like,
if
they're
in
dictionary
format
right
rather
than
actually
instantiate
it
objects
like
we
have
with
that
Python
file.
That
was
in
the
gist.
That
was
the
example
right.
In
that
case,
you
know
it's
got
an
instantiated
object
right
and
so
that's
stuff,
and
up
with
that,
what
that
code
and
OP
is
doing
is:
let's
bring
that
up
same
diff
well,
base
base
base.
A
Okay,
so
here's
the
stuff
from
share,
compare
yeah
I
said
this
this
this
well,
this
shouldn't
even
be
here.
This
should
be
an
implementation
based
class.
So
that's
like
first
problem
right
right
now.
What
happens
is
when
you?
It
basically
is
like
okay,
if
the
config
class,
if
I,
have
a
config
class
and
my
config
is
a
dictionary
rather
than
like
an
object,
then
I'm
gonna
convert
it
right,
but
the
thing
is
the
thing.
A
Is
that
so
that's
like,
so
that
that
means
that
all
of
these
things
that
like
when
you
imagine,
we
have
like
a
gamma
file
right.
So
we
have
a
you
know:
phone
all.
Our
configure
in
the
yellow
file
well
write
this.
What
this
code
is
doing
is
basically
it's
we're
lazy,
we're
lazy
loading,
all
of
those
configs
we're
loading
them
when
the
operation
is
initial,
it's
initialized,
rather
than
when
the
data
flow,
is
initialized
right
and
so
there's
like
two
approaches
that
we
could
take
here
right.
A
We
could
go
through
and
we
could
initial
that
we
could
go
through
and
we
could
look.
We
the
right
way
to
so
there's
two
ways
that
we
could
do.
This
right,
we
can
continue
lazy
loading
or
we
can
make
it
so
that
when
you
instantiate
a
data
flow,
you
end
up
with
instantiate.
It
can
fix
right.
So
if
I
have
like
a
plugin
for
one
of
them
well,
then
it's
going
to
resolve
the
plug-in
a
time
of
you
know
doing
from
from
dict
on
the
data
flow.
A
So
the
downside
to
that
is
basically
we
have
to
like
go
traverse
through
every
single
dictionary
in
config
and
shared
configs
and,
like
you
know,
work
our
way
back
up
like
we
have
to
like
traverse
all
the
way
down
into
every
single
dictionary
and
then
work
our
way
back
up
and
then
like
instantiate.
You
know
plugins,
as
we
see
plug-in
structures
right
or
what
is
that
called
is
config
dict
I
think
we
have
a
function
for
yeah.
A
So
basically
we
have
to
traverse
all
the
way
down
every
single
dictionary
and
then
look
at
something
and
see
if
it
is
a
config
dictionary
if
it
is
instantiate,
the
object
go
on
level
up
right.
So
we
have
to
do
that
sort
of
recursive
thing
which
might
be
the
right
way
to
do
this,
because
then
we
end
up
like
actually
resolving.
You
know
we'd
actually
end
up
knowing
whether
a
config
is
bad.
A
A
Then
you
know
that
you
just
need
to
make
it
a
reference
right.
So
you
have
this
dictionary
with
you
know.
Some
operation
instance
name
equals
a
string
rather
than
a
instantiated
config
object.
Well,
okay.
That
means
that
that
string
is
whatever
that
is
in
the
dictionary
and
shared
configs,
so
that
now
we
actually
have
our
system.
A
A
D
C
A
Yes,
that's
good
yeah
cuz!
This
is
gonna
be.
This
is
gonna,
be
important
when
you
do
the
distributed.
Orchestrator,
stuff,
I'm,
assuming
I'm,
not
sure
yet,
but
I
assume
that
having
a
shared
config
thing
will
be
something
that
that
well
I,
don't
know,
if
probably
won't,
be
important
for
the
distributed
Orchestrator
per
se,
but
it's
definitely
important.
C
A
D
C
A
A
A
We
may
not
be
using
this
anymore.
The
reason
this
exists
is
because
for
this
exists,
because
at
some
point
I
have
a
branch
where
I'm
working
on
this,
but
at
some
point
we
will
have
when
the
op
decorator
decorates
a
function
that
is
not
asynchronous
it
will.
It
will
by
default,
call
it
within
loop
running
executor.
That's
gonna
be
the
default
that
we
set
up
at
some
point
right,
because
unless
you
pass
some,
you
know
parameter
to
the
OP
decorator.
A
But
that's
why
it
exists
is
so
basically,
if
you
have
an
argument,
I
believe
yeah
I
believe
what
this
does
is.
It
goes
through
and
it
says
if
you
have
an
argument
where
the
annotation
is
what
you
said.
Your
config
class
was
then
that
that
we're
gonna
pass
that
to
you
as
your
you
know,
we're
gonna,
we're
gonna,
give
you.
A
C
A
A
Basically
they
are
these
dictionaries
right
where
we're
providing
a
lambda
and
the
lambda
is
going
to
return
whatever
the
hell
you
want
to
incur
the
contact
stuff.
So
then
that
way,
it's
it's
a
it's
a
very
short
hand.
It's
obviously
like
it
makes
it
yeah
it's
shorthand
for
the
double
context:
entry
right
and
you
don't
have
to
make
a
double
context-
entry
you
could
just
do
enter
or
you
could
just
do
context
ensure,
but
it
lets
you
set
up,
especially
like
what
the
pipe
I
operations
and
safety
it's
like.
A
A
Make
non
async
functions
wrapped
with
op
run
in
with
loop
run
and
execute,
or
when
that
happens,
it's
likely
that
self
won't
be
serializable
into
the
thread.
Processed
and
figs
are
guaranteed
to
be
serializable
wow,
that's
a
hell
of
a
word
right
there
serial
as
well.
It's
not
even
a
word.
Who
cares
it's
the
word
now?
Let's
see,
figs
are
guaranteed
to
be
serializable.
Therefore,
this
lets
us
define
operations
that
have
figs
and
need
to
access
them
when
running
within
another
thread,
and
then
I
will
have
that
circuit
and
there's
another
cool
thing.
A
All
right
so
do
we
have
other
things
to
talk
about
this
on
this
one
or
you're,
probably
gonna
have
to
reference
the
recording
because
I
don't
like
writing
all
of
that
down.
It's
gonna
be
a
pain
but
I
feel,
like
we
kind
of
summed
it
up
concisely,
so
pacing
issues
with
sure
config.
Well,
let's
just
let's
just
it
is
kind
of.
We
can't
be
counting
some
so
say
so
solution.
A
Stan
she
ate
fix,
then
go
or
then
when
okay,
so
either
would
be
better
if
we
went
through
at
time,
it'd
be
better.
If
we
did
this
when
we
instantiate
the
dataflow,
because,
like
else
otherwise,
every
time
you
write
a
new
Orchestrator,
it's
gonna
have
to
go
like
know
about
shared
config,
which
is
okay,
and
it's
okay
for
now
well,
we'll
cross
that
bridge.
When
we
get
there
and
in
memory
when
instantiating.
A
D
A
A
E
A
A
E
E
A
A
A
A
Okay,
cool
yeah,
sweet,
we
were
Jackson,
we
talked
about
this
at
the
beginning
and
we
talked
about
how
we
want
to
put
together
a
tutorial
to
say:
I
wanted
to
put
together
a
tutorial
to
show
people
how
to
like,
go
through
all
the
models
and
then
find
out
which
one
is
the
best.
But
we
were
talking
about
how
psych
it
has
some
weird
things
about
their
models,
and
so
basically,
once
we
get
the
Auto
SK
learn
that'll
cover
like
all
of
Psych
it
so
that'll
be
good.
I
A
D
A
A
A
B
A
A
A
D
A
A
This
many
spaces
perfect,
all
right,
okay.
So
then
what
is
the
next
like?
What's,
let's
just
run
through
the
rest
of
this
guy
elves,
that
we
can
be
sure
that
this
is
working
now,
so,
oh
and
I
should
probably
generate
the
or
not
the
language
stuff.
Let
me
just
regenerate
this
real
quick,
oh
wait!
A
minute!
You
don't
have
that
there,
so
we
move
this
lines
of
code
language
by
comments.
Okay,
it's
this
one
now,
okay
and
they
should
I
date.
A
flow
is
just
this
should
I
data
flow,
which
that
needs
updating
at
least.
I
A
A
D
A
A
A
A
A
A
I
A
A
F
A
D
A
A
I
D
A
A
A
So
mapping
create
created
directory
lines
of
code
by
language,
okay,
so
I'm
seeing
another
thing
here,
which
is
that
maybe,
oh
my
god,
this
tutorial
probably
hasn't
worked
since
before
the
input
validation
was
that
it
goddammit,
because
we
should
be
converting
this
thing
into
you
know
this
thing
should
be
getting
converted.
So
if
we
do
like
you
know,.
A
A
A
A
A
A
A
Basically,
when
we
do,
you
know
that
stuff,
how
you
did
that
the
sub
spec
and
everything
so
with
the
spec.
We
we
we.
Basically,
we
use
that
to
create
a
new
input.
Object
like
the
input
object
and
the
input
has
the
value
and
well
what
else
does
it
have?
It
has
the
value
that
has
the
name
and
the
value
and
the
definition,
but
it's
creating
wonder
if
this
is
because
we're
creating
a
parameter
rather
than
oh,
it's
because
we're
creating
a
parameter
rather
than
input,
so
basically
that
spec
stuff.
What
it
does
is
it
says?
A
Okay,
you
are,
you
know,
creating
a
new
you
created
some
value
of
this
type.
Well,
is
that
if
that
type
is
a
dictionary,
and
it
has
a
spec,
then
it
better
conform
to
that
spec
right.
That
was
what
the
whole
sub
spec
stuff
didn't
with
the
spec.
It's
just
like
one
level
right,
so
the
thing
is
when
we
create
when
we
do
redirection,
we
create
parameters
and
parameters
are
ended,
up,
get
being
what
get
passed
unless
we
thought
we
did
the
inputs
at
some
point
here.
A
But
a
parameter
is
not
the
same
as
the
input
ray.
It's
a
different
object,
and
so
it's
got
different
constructor,
and
so
we
lose.
The
validation
that
we
did.
I
believe
is
what
happened
in
is
what's
happening
so
so,
where
the
hell
does
that
go
I
mean
that
what's
like,
what's
run
run
an
operation
okay
and
it
creates
it,
takes
an
input
set
context
and
it
runs
the
operation.
So
run
dispatch
is
going
to
take
a
parameter
set
and
it's
gonna
pass.
A
A
A
A
Value
Oh
origin
is
the
input
okay,
so
it
has
the
value
set
yeah,
it's
just
losing
all
any
and
all
input
validation
here,
which
is
just
sad.
So
we
should
probably
make
a
parameter
a
subclass
of
an
input
because
what
it's
got
in
origin?
It's
got
a
definition.
It's
got
a
key
and
okay.
The
only
thing
it
needs
is
a
key,
so
we'll
just
go
ahead
and
make
it
a
subclass
here
and
then
we'll
end
up
with
that.
Wonderful,
wonderful
input,
validation.
D
A
A
That
would
be
very
bad,
although
it
would
be
kind
of
good,
because
it's
if
you
have
so
basically,
if
you
have
actually,
we
should
file
a
CBE.
That
would
be
funny.
Oh
wait,
a
minute.
How
much
paperwork
will
not
cost
me?
If
you
guys
know
what
CVS
are
so
a
CV
I
think
we're
probably
gone
over
this,
but
a
CV
is
basically
like.
A
Don't
worry
about
it:
yeah,
hey
yeah!
You
guys
always
always
feel
free
to
drop
I
hope
you
guys
know
that
I'm
working
work.
Obviously
we
go
long.
So
if
we're
done
with
your
stuff
feel
free
to
drop
whenever
see,
ya
have
a
good
one,
all
right.
Okay
and
now
we
should
end
up
with
the
input
validation
that
we
wanted.
The
info
validation
we
deserve.
A
Key-Value,
origin
definition:
okay,
there
we
go
so
now
we
should
be
presented
with
a
nice.
Spec
validation
error.
Yes,
perfect!
This
is
what
we
wanted.
So
now
we
convert
this
thing.
This
mapping
right
gets
converted
into
this
git
repository
checked
out
and
it
says:
hey
you,
you
didn't
give
me
a
URL
or
a
commit.
So
now
I
mean
the
nice
part
of
that
is
that
we
can
just
assign
default
values.
A
A
And
so
it's
good
I
don't
know,
okay,
so
I
don't
want
to
take
any
more
of
your
time.
So
I'll
work
on
this.
Now
after
we
do
the
meeting,
and
now
we
can
conclude
the
meeting
and
then
we
will
and
I'll
post
this
up
there.
So
I
think
that
you're
I
think
at
this
point
like
this
is
the
last
part
of
the
tutorial
that
you
need
it.
Changes
on
right.