►
From YouTube: Weekly Sync 2020-04-07
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.h118xhnj19xu
A
A
B
A
B
A
B
D
A
So
yeah
you
just
make
a
third
operation
and
have
it
be
the
you
know
have
it
do
literally
fell
on
whatever
you
put,
it
is
so,
let's
see
yes,
let's
say
thank
another
operation.
Probably
this
is
probably
a
good
one
for
IO
as
well
or
you
know.
Oh,
it's
not
really
I
Oh,
like
maybe
put
it
in
like
where
we
got
here.
A
A
A
A
A
A
A
A
A
A
For
the
sake
of
the
fact
that
this
is
an
example,
I
think
that
we
should
drop
this
down
is
a
simple
linear
regression,
because
then
you
only
have
one
input
and
that
way
it's
because
they're
else
we
have
to
do
the
input
thing
multiple
times
and
that's
gonna
get
start
to
get
more
confusing,
and
since
it's
especially
demo,
that
won't
really
be
a
good.
It
won't,
though,
will
be
a
little
bit
too
complicated,
and
we
have
a
lot
of
little
bit
too
complicated
things
right
now.
B
A
E
A
A
A
B
E
B
A
E
A
E
A
E
A
A
The
doc
has
works
now,
but
it
didn't
so.
I
was
like
putting
in
URLs
and
I.
Had
it
get
multi
spec,
but
then
I
had
yet
single
I
think
I
had
dot,
Auto
get
single
and
so
I'm
pretty
sure
it
was
just
and
I
was
like
it
doesn't
work
and
then
I
got
old
word
that
I
broke
get
single,
but
now
I'm,
realizing
I,
just
put
it
in
that
wrong,
spec,
and
so
once
I
fix
it.
It's
probably
right
so.
E
E
E
A
A
And
check
that
everything
expected
was
out
when
data
flow
and
okay
so
yeah,
basically
and.
C
E
E
E
A
A
E
E
A
A
A
A
A
F
A
A
A
A
Right,
yeah,
perfect,
perfect,
all
right!
Oh
here's!
One
thing:
now
we
do
want
to
tap
this.
So
if
we
or
what's
gonna
happen
here,
I
guess
if
they
update
how
about
another
thing,
it's
going
to
break
that's
pretty
good
because
we
want
it
to
be
updated
too.
So
usually
we
want
to
pin
this
to
the
last
commit
because
then
it's
always
downloading
this
version,
but.
A
D
A
A
A
Well,
this
would
be
a
quick
one
to
knock
out
that
lacking
documentation.
You
know
how
to
add
a
documentation
form,
and
actually
you
know
how
to
do
it
with
the
test.
So
I
would
be
good.
This
is
actually
not
an
actress
office.
Oh
yeah,
that's
dr.
small
yeah,
that's
extra
small!
That's
not
it's!
Not
that
short,
but
this
is,
would
be
a
good
one.
That
would
be
great
thanks.
Let's
see
it's
very
important
that
we
have
that.
A
A
A
F
F
A
Same
as
honest
is
so,
this
is
related,
so
I
would
stay
away
from
Spencer
flow.
Oh
right
now,
because
this
is
kind
of
what's
going
on
here
is
this
guy
was
saying
that
that
he
tried
to
use
it,
but
you
can
figure
out
how
to
use
it
and
then
I
can't
figure
out.
Is
it
so?
How
much
is
going
to
tell
us
around
easy
because
we're
doing
something
wrong
so
once
he
figures
that
out
there
and
it's
it.
A
A
A
A
A
E
A
E
A
E
A
E
A
A
A
A
A
A
A
A
A
A
A
web
hook
URL
and
basically
what
that
means.
It's
like
every
time
the
web
hook
is.
It's
like
a
web
hook
is
basically
just
like
a
some
kind
of
blob
of
data
that
gets
sent
to
some
service
when
something
happens,
and
so
for
good
hub.
You
can
say
hey
when
I
push
to
my
repo,
or
you
know
certain
things
happen
to
my
repo
like
this
is
like
issue
comment,
create
delete,
branches
and
pull
requests
and
push
events
get
sent
to
this
web
hook.
Let's
just
look
at
it.
A
So
you'll
say:
oh,
you
want
it
right,
do
you
want
it
as
JSON
or
do
you
want
it
formatted?
And
then
you
say
what
kind
of
events
you
want
right.
So
we
can
send
you
all
sorts
of
things
or
we
can
just
send
you
everything,
and
so
what
we're
doing
here
is
we're
basically
waiting
for
push
events.
We
want
to
wait
for
push
events,
and
we
want
to
have
this
web
hook.
A
Receiver
understand
how
to
receive
push
events
and
then
how
to
look
at
the
git
repo
and
say:
okay,
do
I,
have
the
same
branch
checked
out
that
got
pushed
all
right?
If
I
did
then
I
want
to
pull
that
down
and
rebuilt
that
docker
to
container
automatically
I
want
to
read
that
that
image,
so
web
hook
service
listens
for
push
events
from
github.
A
E
A
A
A
A
C
F
A
A
So
now
what
we
need
is
like
we
need.
We
need
to
we're,
probably
gonna
make
plugins
for
this
right,
because
at
this
point
you
know
we
love
plugins.
Plugins
are
great,
so
we're
gonna
have
options
for
things
like
the
first
one.
We're
gonna
do
is
like
a
regular
docker
right.
So
you
just
look
at
all
the
containers
on
the
machine.
Okay
and
this
web.
That
service
knows
which
ones
are
out
this
or
you.
You
look
for
the
image
type,
so
let
me
just
say,
create
plugins,
which
know
how
to
redeploy
for
different.
A
A
Then
because
people
have
all
sorts
of
ways
of
complaint
nation
of
docker,
just
like
plain
old,
are
running
on
something.
Oh
it's
just
going
to
be.
This
is
going
to
be
enough
of
the
way
that
we
can
that
we
will
have
made
the
use
case
of
I
make
some
operations.
So
basically
we're
gonna
have
this
so
we're
gonna
create
plugins
for
deploy
in
different
deployment
situations
for
docker.
We
just
look
at
running
containers
if
any
of
them
are.
A
All
right
so
now,
the
result
of
this
is
going
to
be
sort
of
like
an
extended
tutorial
to
creating
some
operations.
Where
you
say,
okay,
we've
made
some
operations.
Now
you
push
them
up
here.
Github
now
add
this
webhook.
You
know
now
on
your
server
that
you
want
to
run
these
operations.
You
start
this
service
right
this
webhook
service,
and
then
you
configure.
A
We
show
how
to
configure
github
to
point
at
the
webhook
service
and
now
every
time
they
update
their
operations
of
their
dataflow,
they
get
redeployed
on
their
server
right
away,
and
so
this
way
we're
making
it
very
easy
to,
like
you
know,
take
the
stuff
that
may
be
running
locally
on
their
computer
and
now
all
of
a
sudden
whenever
they
push
it
to
github,
it's
active
at
some
new
URL
right,
and
so
this
this
is
like
this
will.
This
will
result
in
like
really
quick
development
of
new
stuff.
A
You
know
like
because
imagine
imagine
you
you
have
some
app
that
you're
working
on
it
I
mean
there's
lots
of
ways
to
do
these
things
right,
but
this
is.
This
is
sort
of
the
way
that
we're
trying
to
do
it,
and
so
you
know,
if
you
are
using
like
Google,
compute
and
stuff
or
like
AWS
lambda,
you
would
go
into
Amazon
and
configure
all
that,
but
we're
being
an
open
source
alternative
to
those
things
right.
So
you
know
you're,
like
I,
want
to
use
my
model.
A
E
E
A
E
E
A
A
A
C
A
C
C
A
Yeah,
that
sounds
good,
so
basically
I
would
say
a
high
level
like-
and
you
may
have
seen
this
already,
but
so
the
if
you
look
at
CLI,
the
Arg
class
is
meant
to
sort
of
be
the
same
type
of
thing
as
an
Arg
parsed
argument.
So
it's
whatever
arguments,
you'd
pads
to
art
purse,
add
argument
end
up
in
this
art
class,
which
is
really
like
a
dict
or
something
I.
Think
if
I
remember
correctly,
and
so
so
then
for
the
for
the
CLI
commands
themselves.
A
Whenever
they
have
that
arguing
me
to
find
argument
to
find
at
the
class
level,
that's
like
Arg
underscore
or
something
equals
Arg,
and
then
it
has
the
name
like
the
name
of
the
argument
with
the.
If
it's
supposed
to
be
a
you
know
the
on
the
path,
and
so
that's
what
the
argument
name
gets
added
as
and
then
it
acts
as
it
self
dot.
A
Whatever
that
argument
name
is
in
the
within
the
within,
like
this
run
method
of
that
class,
at
that
CLI
class
itself,
and
then
the
thing
is
that
so
we
took
that
and
we
extended
it
into
like.
We
tried
to
convert
that
config
stuff,
because
there
was
all
the
arcs
and
config
and
they
were
basically
using
this
stuff,
and
then
we
made
it
so
we
could
have
those
config
classes
there
and
when
we
did
that
it
instead
of
like
you,
know,
argh
underscore
whatever
equals
arc.
A
Now
it's
like
okay,
the
config
property
name
like
the
name
within
the
within
that,
can
that
config
class
:
the
data
type
equals
the
field
and
the
field
is
really
just
except
I,
believe
we're
passing
or
well.
No
we're
extrapolating
the
typing
information
from
the
data
type,
that's
associated
with
it
and
then
I
believe
we
built
the
args
and
then
extract
it
from
that
extra
config
thing,
which
holds
all
the
command-line
arguments
not
perished
by
the
top
level.
Cli
parsing,
which
are
those
ones
that
are
are
at
underscore.
So
anything
that's
not
an
arc
underscore.
A
Basically
that
ends
up
in
that
CLI
commands
self
dot.
Extra
config
and
then
self
dot
extra
config,
all
of
the
big
structures
like
all
or
all
of
the
plugins
when
they're
initialized
they
their
class
methods,
dot
with
config,
is
called
and
that,
as
you
can
see
in
base
in
the
FF
ml
/
base,
we
did
when
we
did
the
auto
args
and
config
stuff
that
we
thought
it
like.
We,
we
made
it
so
that
the
dot
config
method
there
without
with
config
calls
dot
config,
and
then
we
made
it
so
that
it.
A
It
basically
reads
that
you
know
all
caps,
config
config
class
and
it
reads
all
the
properties
in
that
class
and
grabs
the
data
types
and
makes
those
Arg.
You
know
the
same
Arg
Arg,
word
Argos
or
over
this
or
that
Arg
with
a
capital
A
those
classes.
It
makes
those
and
then
does
the
does
grabs
the
argument
data
out
of
that
extra
config
using
that
trench,
Traverse
config
get
methods.
A
A
A
D
B
B
A
A
D
F
A
A
A
A
Yeah
so
I'm
yeah,
so
all
actually
just
like
we're
talking
about
a
little
bit
earlier.
You
were
I'm
gonna
at
this.
It's
a
little
output
operation
and
so
I'm
gonna.
Add
this
quick
little
example
for
how
this
works
now.
Add
another
example
for
how
this
this
gets
single
one
works,
and
hopefully,
that
sort
of
gives
you
a
little
scaffold
for
like
how
do
you
setup
an
example
for
this,
but
as
far
as
the
yeah
like
doing
a
complete.
A
A
A
A
A
A
A
E
But
that
one's
through
the
more
complex
I
shouldn't
serve
that.
A
Let's
see
yeah,
you
can
just
sort
of
copy
like
the
format.
Okay,
where
was
not
happy
any
of
these
I
swear.
A
F
F
A
A
Damn
it
go
really
like
to
have.
Okay,
let's
see,
I
think
this
is
a
good
one
here,
so
this
one
inputs
yes,
so
this
is
probably
a
good
good
example
of
like
well,
you
could
do
with
the
mapping
and
the.
A
A
C
A
F
A
One
operation
at
a
time:
that's
not
really
something
that
we
do,
but
but
so
it
doesn't
really
nice.
So
if
we
passed
out,
if
we
just
sent
a
photo,
it'll
just
create
a
data
flow
with
those
operations,
and
so
that's
probably
what
you
want
to
do
in
this
case
is
you
know,
and
you
want
to
do
whatever
operation
your
path
and
then
you
usually
want
you
probably
don't
want
this.
Get
single
operation,
I
mean
I,
guess!
Well,
let's
see
no.
A
I'm,
so
sorry,
yeah
I'll,
do
it
later?
Okay,
so
you
basically
say
you
know
the
up
beautiful
model,
the
operations
you
care
about,
and
then
that
is
the
data
flow
and
then
in
the
inputs.
So
there's
a
couple
ways
you
can
do
things,
but
the
most
basic
way
is
you
just
put
this:
you
make
this
array
of
input
objects.
A
What's
the
data
type
of
the
simpler
like?
What's
the
definition
and
the
definition
and
this
one
is
the
this
data
to
print
right,
and
so
you
can
do
something
like
you
can
do
the
stage.
So
the
definition
is
the
definition
of
print
or
you
do.
You
know
change
this
to
make
it
a
little
more
explicit
here.
A
A
So
you
could,
you
can
do
it
either
way,
but
this
way
you
sort
of
get
a
little
more,
it's
a
little
more
explicit
here
for
the
example
so
that
we
want
the
definition,
which
is
the
data
employed
right.
So
if
we
look
at
data
its
data
to
print
and
that
way,
we
don't
if
we
change
this,
it
doesn't
matter
because
we
might
change
this
at
some
point
and
therefore
you
know
we're
doing
it
by
this.
This
guy
and
I.
Just
you
change.
A
Input
right
here,
they'd,
a
name
like
that
we're
talking
about
so
the
value
blank
is
going
to
the
definition
that
will
be
this
data
input.
So
you
know
I
was
here,
and
so
let's
see
so
that's
basically
the
way
this
works.
Is
you
basically
just
make
this
array
where
you
say:
here's
an
input,
object
and
here's.
A
E
A
A
The
output
ends
up
getting
called
an
input
again
because
it's
gonna
gate
uses
an
input
to
something
else,
so
that
input
was
generated
with
the
parents
being
the
two
arguments
that
were
passed
to
the
operation
right
and
so
that's
why
we're
parents,
so
we
don't
need
to
it
Spidey's!
That's
such
a
none
cheeri
for
us
for
at
two.
A
A
A
Oh
and
the
last
thing
here
and
then
you
do
the
run
and
whatever
you
print
and
results
is
going
to
be
so
this
is
the
other
thing,
is
you're,
usually
you're
gonna
want
to
use
this
get
single,
and
this
this
is
in
this
example.
There
isn't
why
we
didn't
need
get
single
is
because
we
haven't
actually
be
printing
stuff,
so
we
can
just
just
define
basically
the
way
that
the
doc
strings
work
is.
It
just
looks
at
what
to
get
printed
and
it
compares
you
know
when
you
hit
this
line.
A
When
you
run
this
line,
what
are
the
things
that
that
print
it
as
a
result?
Right
so
with
this
particular
example,
the
point
is
that
it's
gonna
print
something.
So
this
ends
up
working
here.
We
don't
need
get
single
really,
usually
we
need
get
single
because,
for
example,
with
this
one,
you
push
you
at
you
say:
I
want
this
operation
and
then
it
doesn't
actually
take
any
inputs.
So
you
didn't
have
to.
We
didn't
have
to
add
any.
A
We
had
to
pass
any
inputs
in
that
array
there,
but
we
do
usually
append
this
seed
and
we
don't
have
to
do
it
that
way.
You
can
just
add
this
input
to
the
to
this
array,
but
you
need
this
input,
that
is,
of
the
spec
input
for
the
get
single
operation
and
the
get
in
this
one.
This
is
one
of
those
where
it's
like
I'm.
That's
that
pull
request
asylum,
actual
documentation
for
get
single,
but
what
it
does
is
it
basically
just
says:
okay,
the
the
definition
that
it
takes.
A
Is
this
spec
and
the
spec
has
the
value
should
be
an
array
of
the
names
of
the
definitions
that
you
want
to
get
one
of
those
of
right.
So
if
I
have
a
dataflow
generates
a
bunch
of
data
and
all
like
and
and
a
bunch
of
those
input,
data
is
have
definitions
which
match
this
input.
The
get
single
operation
will
return,
one
of
them,
one
of
those
inputs
and
the
get
multi
operation
returns.
Anything
matching
that
definition,
any
data
matching
that
definition
right.
A
A
We
we
want
to
run,
get
single
as
the
operation
which
produces
the
outputs
and
the
outputs
of
what
gets
stored
in
the
results
here,
and
so
we
want
to
say:
okay,
the
output
should
be
basically
we're
telling
it
doesn't
want
the
output
up
the
data
flow
to
be
the
result
of
running
this,
get
single
output
operation,
and
we
want
to
get
something
out
that
operation
to
be
returning
to
us.
One
input
one
piece
of
data
in
the
network
that
had
a
definition
matching
the
definition
of
this
accept
user
input
output,
which
is
this.
A
Yeah
user
input
right,
so
this
definition
of
user
input
is
input
data
in
the
output
dictionary
of
this
operation,
so
the
name
the
dot
name
here
is
user
input
right
because
it
comes
from
here
because
it
gets
it
there
right,
and
so
that's
how?
Basically
we
you
know,
we
use
a.
We
use
the
operations
for
everything
right.
We
use
them
to
decide
what
gets
run
in
the
network
and
we
use
them
to
decide
how
stuff
gets
out
of
the
network.
A
A
So
you
get
from
synthesizing
the
two
of
these
examples
together
to
create
the
examples
for
like
the
maps
and
one
and
because
you'll
you'll
end
up
with
okay
I
have
to
I
I
need
my
get
simple,
spec
right,
because
I
need
to
get
the
output
of
those
those
new
maps
that
get
created
the
new
dictionaries.
And
then
you
need
to
pass
your
inputs
to
the
inputs
that
are
actually
going
to
go
to
that
operation
as
well
like,
for
example,.
A
With
the
mapping
operation,
there's
a
key
in
value
and
let's
see
yeah,
so
if
you're
gonna
create
a
new
dictionary,
basically,
which
is
also
called
a
mapping
in
some
languages,
then
you're
gonna
pass
the
key
and
you're
gonna
pass
the
value.
So
those
are
just
two
of
your
inputs
and
then
you
want
to
have
get
single
grab
this
mapping
output
here
and
then
you'll
just
check
that
it
was.
A
A
A
A
And
okay,
that
sounds
good
and
then
the
other
thing
is
that
basically
yeah,
you
can
always
ping
me
on
get
a
rape
or
ping.
Anyone
and-
and
so
the
last
thing
is
with
it.
So
mapping
will
be
sort
of
the
one
that
you
want
to
start
with
to
get
your
feel
for
it
start
here,
start
here
mapping
and
then
then
do
DB.
A
And
so
with
the
database
to
database
stuff,
then
you'll
want
to
look
at
the
test
case
for
it
as
well.
It's
gonna
help
you
figure
out
how
to
do
the
config,
but
yeah
cool.
All
right
is
there
anything
else
from
anybody,
if
not
we'll
call
it
call
it
a
day.
Thank
you
all
right,
yeah!
Thank
you.
This
will
be
great.
However,
steadily
all
of
a
sudden
we've
we've
been
steadily
adding
to
this
operation.
A
Examples
I
think
that's
gonna
help
people
get
the
data
flows
a
lot
more
lets,
get
the
one-off
examples
on
the
operations
and
build
some
of
these
more
data
flow
demos.
It's
it's.
The
data
flows
are
a
novel
concept.
I
mean
there's
a
lot,
there's
some
a
lot
of
other
projects
out
there.
These
days
that
are
trying
to
do
something
similar
that
there's
many
people
trying
to
figure
out
like
people
call
them
workflows,
people
call
them
data
flows,
but
this
is
like
every
night.
Lots
of
people
are
trying
to
do
stuff
like
this.
A
So
it's
like
a
that's
a
weird
concept
that
we're
all
trying
to
they're,
just
trying
to
figure
out
a
good
way
to
do.
Yeah.
All
right,
cool
I
will
see
you
guys
next
week
then
and
stay
healthy
everybody
and
good
luck
with
school
stuff.
I
hear
people
are
getting
pretty
hammered
pretty
hard
with
what
university
is
trying
to
throw
them
about
the
online
work.