►
From YouTube: Weekly Sync 2021-09-21
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.rfwjm5y1v98q
A
A
A
A
Let's
see,
I
don't
know
if
this
is
really
going
to
help
this
discussion,
but
yeah.
So
I
was
working
to
add
these
event
types.
So
essentially,
we
would
see-
because
you
know
right
now-
we
only
get
the
results
of
the
data
flow
when
it's
complete
and
it
would
be
nice
to
be
able
to
say
okay,
we
want
to
get
progress
updates,
basically
right.
So,
like
hey
an
input
moved
from
one
operation
to
the
next
right
because
for
purposes
of,
for
example,
visualizing
the
data
flow
or
tracking.
A
What's
going
on
you,
you
would
want
to
know
you
know,
what's
going
on
inside
the
data
flow,
not
just
whether
it's
done
or
not
right,
so
I
was
working
on
adding
event
types
and
sort
of.
As,
as
part
of
that
work
I
was
exploring.
I
was
playing
with
you
know
how
we
might
implement
a
you
know,
a
more
pythonic
api
around
the
data
flows,
and
I
think
the
thing
that
I
consistently
keep
running
into
is
the
the
flow
definition
right
and
the
way
that
we're
linking
together
yeah,
for
example,
here
right.
A
A
A
Carnivore
takes
an
integer
value
and
then
it
returns
a
string
of
dead
or
beef,
and
then
this
beefed
feed.
This
is
just
a
very
basic
data
flow,
so
the
beef
to
feed
says
basically
just
just
as
a
replacement,
so
that
if
you
have
42,
you
end
up
with
beef.
If
you
have
beef,
you
end
up
with
feed
and
then
the
last
one
basically
just
says
you
know
did
is:
is:
is
the
string
feed
or
is
feed
in
the
string
right?
So
this
is
true,
and
this
is
false.
A
A
A
A
A
A
A
So
essentially,
this
is
a.
This
is
how
we
can
use
that
for
running
a
sub
process
and
basically
making
it
so
that
we
can
add
we
can,
we
can
add,
we
can
create
a
task
for
the
read
line
function
on
both
the
standard
out
and
standard
error
of
a
of
a
sub
process,
and
that
way,
so
we
say
basically,
you
know
we
create
the
task
we
grab
the
read.
We
call
the
read
line,
we
create
the
co-routine
for
the
read
line.
A
We
create
a
task
out
of
the
co
routine,
which
is
sort
of
as
soon
as
you
do
create
class
create
task.
It'll
start
running
it
in
the
background.
If
there's
a
running
loop,
or
at
least
it'll,
submit
it
to
be
run,
and
then
you
assign
it
to
work,
and
we
basically
say
okay,
so
output
would
be
standard
out
or
standard
area.readline,
so
this
one
is
weight,
and
this
one
is.
This
is
a
task
for
when
the
process
completes
we'll
get
the
result
is
or
what
is
it?
A
If
you're
familiar
with
running
sub
processes
is
okay,
I
would
like
to
watch
the
output
of
the
process,
but
I
also
need
to
you
know
know
if
the
process
errored
out
right,
and
so
this
solves
that
this
sort
of
solves
that
problem-
and
this
is
sort
of
my
this
is
one
of
my
favorite
uses
of
async.
I
o
is
for
this,
because
this
is
just
like
frequently
a
problem,
and
so
essentially
yeah.
You
end
up
with
this
this
this
loop,
basically,
where
you're
like
okay,
well.
Well,
you
know,
while
I'm
well.
A
Out
of
the
loop
then
cancel
any
work
that
remains
so
so
what
I'm
thinking
is
I
mean
this
is
a
very.
This
is
essentially
what
we
do
with
the
data
flow
right.
Is
we
basically
say
you
know?
Well,
I
have
operations
to
run,
you
know,
run
them,
and
then
in
the
body
we
decide
what
more
operations
need
to
be
run
right
and
the
logic,
the
logic
that
we
decide
which
operations
need
to
be
run
by
is
really
you
know
the
flow
right.
That
is
our
the
flow
modifications
that
we're
doing.
A
B
A
So
I'm
I'm
thinking
you
know,
there's
some
kind
of
hybrid
here
where
we
could
sort
of
define
a
a
way
where
you
know
we,
we
sort
of
offer
up
a
pattern.
You
know
like
we
offer
a
pattern
and
then
this
can
and
a
few
helper
functions
right
that
help
people
write.
You
know,
maybe
it's
not
a
full
data
flow,
but
it
is
this
loop
right
and
if
they're
operating
in
this
loop,
then
they
can
easily
transition
from
the
loop-based
approach
to
a
full
data
flow
based
approach.
Right.
B
A
A
I
know
it's
not
something
that
people
are
always
used
to,
but
I
think
it
becomes
very
important
as
soon
as
you
start
doing,
network
operations
right
and
if
you
ever,
the
problem
is,
if
you
ever
break
the
async
thing
now,
you're
now
you're
sort
of
now,
you
can't
do
this,
for
example,
right
as
soon
as
you,
you
write
a
non-async
function
and
you
need
to
call
a
sub
process
and
watch
its
output,
and
this
is
like
basically
it
for
me.
It
basically
always
ends
up
being
this.
A
Well,
you
know:
there's
this
command
line
tool
that
fits
really
well
into
this
portion
of
this,
or
else
I'd
have
to
rewrite
it
and
there's
no
good
substitution
in
python
right
and
so
then
you
need
to
end
up
calling
the
sub
process
right
and-
and
so
so
you
need
there's
some
aspect
of
it
where
it's
it's
it's
good
and
maybe
we
can
offer
well.
We
could
also
offer
this
for
non-async
things
and
we
could
sort
of
just
treat
it
like
a
work.
Cue
right.
A
If
that
helps
ease
people
in,
and
we
could
say,
hey
here's
your
regular
for
loop,
now,
here's
your
async
for
loop!
Now,
here's
your
full
data
flow
right
and
we
can
sort
of
step
them
through
the
reasons
why
this
is
this
is
why
you
might
do
it
this
way.
This
is
why
you
might
do
it
the
async
way,
and
this
is
why
you
might
do
it.
The
full
data
flow
way
right
and
here's
the
benefit
that
you
get
out
of
your.
You
know,
each
step
that
you
take
along
that
path.
A
A
Docs
demos
yeah,
because
I
you
know
we
have
the
we
have.
I
think
this
this
is
the
main
part
that
needs
to
be
flushed
like
we
have
a
lot
of
good
good
stuff
and,
and
you
guys
have
all
flushed
out
most
of
it
right
and
the
data
flows
is
something
that's
not
really
flushed
out.
Yet
right
and
let's
see,
let's
see
tutorials
yeah,
because
the
data
flows
is
really
just
like.
A
You
know,
using
locks,
yeah,
there's
a
few
things
that
we've
done,
but
it
doesn't
explain
why
you
know
it's
sort
of
just
like
do
it
this
way
and
and
then
it's
like
well,
the
question
is:
why
the
hell
would
I
do
it
this
way.
You
know
why?
Wouldn't
I
just
write
my
normal
stuff
right,
and
so
I'm
thinking.
I
think
that
if
we
have
yeah,
I
think
I
think
thanks
for
batting
this
around
with
me,
I
think
yeah.
If
we
explain
you
know
how,
how
do
we
come?
How?
A
How
did
we
arrive
at
this
at
this
conclusion?
That
data
flows
are
the
way
to
go
by
walking
people
through
their
different
options
and
and
showing
them?
You
know
this
is
what
you
get
and
then
once
you
get
full
data
flow,
then
we
need
to
start
thinking
about
you
know.
So
this
gives
things
like
visibility.
A
And
then
soon,
with
the
event
types
we'll
have,
the
you
know
we'll
be
able
to
I've
got
a
guy
in
my
work.
We're
gonna
work
on
I'm
gonna
do
some
of
this
event
type
stuff
and
he's
doing
another
little
project
and
we're
going
to
get
together
and
and
we're
going
to
demo
how
you
can
see
you
know
the
inputs
flowing
through
the
network
run
time
drive
and
soon
runtime,
visibility.
A
B
A
Yeah
potential,
but
no
no
execution
right
now,
so,
okay,
so
you're
going
to
take
a
look
at
you
know
these
these
existing
things
that
you've
been
working
on
the
tuner
thing.
The
tuner
thing
definitely
we'll
want
to
do
before
before
we
hit.
You
know
beta,
because
we'll
want
to
make
sure
that
that's
one
of
those
stable
apis.
I
think
I
think
that.
A
B
B
B
B
A
A
Okay,
cool
and
then
I've
got
as
far
as
also
data
flows
go,
so
I'm
hoping
I'm
doing
some
stuff,
I'm
doing
some
stuff.
With
my
with
with
intel
and
we're
trying
to
implement
this,
I
don't
know
if
you've
I've
sort
of
been
quietly
pushing
some.
Where
were
they
basically
this
that
the
I've
changed?
The
the
this
there's
this
software
portal
demo?
I
took
the
software
portal
demo
and
I
slightly
refined
it
to
this
inner
source
portal.
A
We're
trying
to
do
this
inner
source
stuff
in
my
work,
which
is
basically
like
applying
open
source
to
internal
development
and
sort
of
like
saying
everybody
within
the
company
should
be
able
to
see
these
things,
and
then
you
know
how
does
that
work
right,
and
so
we
need
to
collect
metrics
on
projects
and
then
we're
going
to
be
looking
at.
You
know
maybe
doing
some
similarity
analysis
across
different
projects.
A
So
we
were
I
I
pitched
that
hey
you
know.
Maybe
we
can
use
dffml
for
this,
so
we're
gonna
we're
trying
to
use
dffml
and-
and
so
hopefully
this
will.
This
will
in
depth
being
this.
This
is
going
to
be
a
lot
of
data
flow
work
going
on
here,
so
I'm
hoping
that
we
can
use
this
to.
You
know
as
a
this
will
probably
help
help
me
flush
out
and
I'll
need
to
write
more
documentation
around
the
data
flow
stuff
and
we'll
need
to
think
about.
A
You
know
more
about
how
data
flows
work
as
we
go
through
this,
and
I'm
also
going
to
do
a
thing
I
need
to
do
by
friday.
Actually
I
need
to
do
that
tonight.
Actually
I'll
probably
need
to
do
that
today,
but
we
need
to
write
a.
I
need
to
write
a
tutorial
on
how
we
do
similar
to
this
continuous
deployment
of
data
flows,
but
how
we're
going
to
do
the
whole
scraping
service
with
kubernetes
and
and
thinking
about
how
do
you
run?
A
How
do
you
like
kick
off
a
data
flow
for
each
thing
to
gather
some
data
in
a
container
and
stuff
and
and
the
full
deployment?
So
this
is
going
to
be
kind
of
interesting
to
see
how
this
goes
and
and
then
hopefully
we
can
also
sort
of
prototype.
How
does
the
model
workflow
like?
How
do
we
do
this
with
models
too?
A
So
it
should
be
interesting
to
see
see.
Hopefully,
hopefully
you
can
get
this
to
like
a
full
deployment,
because
I
had
that
we
had
that
one
tool
that
was
using
it
at
first
using
dfmo
first
and
then
now
that
tool
got
eold,
so
I'm
hoping
we
can
get
it
used
in
this
new
inner
source
portal
that
they're
making
and
we'll
get
some.
You
know
more
feedback
from
users
and
stuff
and
and
more
implementation
experience
here.
A
A
A
A
A
Yeah
yeah,
I
forgot
to
go
sync
with
him:
I've
gotten,
I'm
sorry!
I
haven't
been
very
active
the
past
couple
weeks.
I've
been
under
a
lot
of
pressure
to
there's
been
a
lot
of
stuff
going
on
within
my
group,
and
so
I've
gotten
all
over
the
place,
and
now
I'm
sort
of
starting
to
regain
a
little
bit
of
sanity
here.
A
A
This
is
to
get
feedback,
so
yeah
I'll
get
some
feedback
from
them.
They
might
tell
me
I
I
have
no
idea,
because
their
stuff
is
very
you
know
the
one
api
api
until
they're,
it's
more
low
level
kind
of
stuff.
You
know
it's
not
really
user
facing
we're
very
user
facing
right,
and
so
you
know
what
I
told
them
is
this.
This
is
the
point
of
dffml
is
right.
A
We
can
make
things
more
high
level
because
me,
as
somebody
who
wants
to
go,
write
a
you
know
to
to
imp
to
use
a
machine
learning
model.
I
don't
really
necessarily
want
to
go
program
in
data
parallel
c,
plus
plus
right.
You
know,
I
just
want
to
say
you
know,
train
me
a
model
and
use
it,
so
I
was
trying
to
show
them
hey.
You
know,
we've
got
these
models
and
we
can
swap
out
different
ones,
and
so
I
think
your
use
cases
were
perfect
for
for
what
we
had
talked
about
at
the
time
now.
A
You
know
various
intel
maintained
machine
learning
stuff
where
they
would
just
implement
the
dfm
model
themselves.
You
know
and
maintain
that
model
themselves
right
because
then
they'd
see,
oh,
I
don't
have
to
go
implement.
You
know
xy.
You
know
my
users
immediately
get
to
to
do
this
right
and
I
don't
have
to
to
yeah
right
there's
a
lot
of
stuff
they
get
for
free
if
they
just
implement
the
model
class
right,
so
cool
cool.
Thank
you
for
reminding
me.
That
was
a
big
that
was
very
important
reminder
there,
great
all
right!