►
From YouTube: Weekly Sync: 2019-10-08
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Hey:
hey
John
hi
am
I
audible;
yes,
how's
it
going
it's
good.
It's
good,
I'm,
struggling
with
a
Docker.
Yet
oh.
B
A
A
Okay,
so
after
the
like,
the
docker
run,
command
gets
executed
and
it's
getting
stuck
there.
It
is
not
I.
B
A
Given
a
print
statement
after
the
docker
execution,
that
is
not
getting
executed,
but
then
this
happened
first
and
it
like,
after
you
told
me
after
you've,
made
the
changes
and
now
I
start
executing
again.
It
ran
the
test.
It
took
like
one
hour,
but
it
ran
the
test
and
it
set
the
setup
test
failed
and
now
I
try
to
include
the
image
like
Cloudera,
slash,
quick
start,
and
it's
not
working
now.
B
So
one
thing
I
realized
I
screwed
up
was
this
patch
had
not
been
imported,
so
that's
like
the
bash
command
was
there,
but
then
once
you
exit
bash,
then
it
was
like
the
patch
command
is
not
imported,
but
other
than
that,
let's
see
I
mean
it's
still
wait.
Alright,
so
it
takes
a
while.
Does
it
do
all
this
stuff
like?
Does
it
output
these
logs.
A
Oh
and
knocks
didn't
come
like
it
came,
I
just
wanna
show
like
so.
A
Oh
okay,
oh
the
other
thing
ran
okay.
It
took
like
some
2650
seconds,
I,
don't
know
for
how
long
the.
B
A
That
is
yeah
so
that
thing
ran
and
it's
throwing
in
like
the
same
exception.
Cloudera
slash,
quick
start
is
not
found.
Okay,
wow,
let's
see
test
test,
Source
Okay,
so.
A
I
found
this
link
when
I
was
Googling.
The
error
I
found
one
of
the
I'll
just
share
that
with
you.
Okay,
I've
sent
send
the
link
in
Guitar,
so
here
this
Docker
run
command
the
basically
the
running
function
that
we
call
in
Python,
so
that
will
first
pull
the
container
and
then
it
will
execute
the
command.
And
here
he
has
said
that
if
we
do
like
that,
it
won't
work
like
we
should
directly
do
Docker
run
Cloud
error,
quick
start,
we
shouldn't
click,
pull
it
and
then
try
to
run
it.
B
Okay
so
wait,
so
the
problem
was
that
he
did
pull
and
then
run
or
yeah
I
mean
okay.
So
here's
what
I
would
say
what
happens
when
you
do
like?
Oh,
what
happened.
A
B
Yeah,
okay,
so
it
wasn't
able
to
successfully
pull
that
image.
That's
it's
going.
A
B
A
B
A
B
B
It's
fine,
it
should
be.
That
should
be
fine.
What
if
you?
What,
if
happens,
if
you
do,
let's
see
like.
A
D
is
it
DF,
Dash
H,
oh
geez,
it's
kind
of
a
mess,
isn't
it?
Oh
yours
won't
be
as
much
of
a
mess.
I,
don't
think
yeah.
What
happens
if
you
do
DF
Dash
H,
so
like
DF,
Dash,
h,
okay,
I'm,
sharing
that
with
you.
B
Worries.
Okay,
so,
basically
like.
B
Okay,
yeah
weird
things
are
probably
happening.
So
do
you
have
you
set
up
Docker,
though
right
yeah.
A
B
And
then
okay,
okay,
okay,
okay,
did
you
have
to
do
the
docker
machine
stuff.
B
Okay,
so
what
happens
when
you
do
like?
Can
you
just
share
your
screen
with
me
or
yeah.
A
B
Okay,
so
yeah,
so
we
need
to
pull
that
image.
Still,
that's
gonna
be
the
problem.
So
did
what
happened
when
you
tried
doing
the
poll,
did
it
just
take
forever
and
then
work
or.
B
A
B
Yeah
I
mean
so
when
you
do
create
and
it
hasn't
pulled
the
image
it
will
pull
it
down
so
yeah,
it's
gonna
be
let's.
A
B
A
B
But
yeah
try
doing
the
pull
and
then
make
sure
it
shows
up
in
Docker
images
and
then
then
you'll
be
able
to
do
the
start,
but
yeah
it's
not
going
to
work.
It's
not
gonna.
It's
not
gonna
work.
Obviously
if
it
can't
pull
down
the
image,
but
it's
looking
promising
I
just
because
I
I've
I've
gotten
it
to
to
run
here,
so
it
definitely
works.
So
that's
good.
B
See
then,
what
else
do
I
have
to
say
so?
Yeah
pull
the
image
yeah.
A
A
Okay
and
then,
and
or
like
in
the
docker,
run
command
I'll
try
to
see
if
there
is
a
timeout
flag
that
we
can
parameter
that
we
can
pass
so
I
think
that
should
make
it
easier
because,
usually
in
the
command
line,
I
give
like
a
hyphen
hyphen
timeout
equal
to
some
like
thousand
or
ten
thousand
seconds,
so
that,
like
it
doesn't
like
do
it
before.
B
B
So
cool,
okay,
yeah,
so
so
we'll
that'll,
that'll
that'll
be
great.
Okay
and
then
the
other
thing
was
I
couldn't
see.
I
guess
this
was
my
next
thing
as
I
was
going
through.
It.
A
B
So
it
started
that
Docker
container,
oh
and
then
it
had
been
dying
because
I
screwed
up
stuff,
okay,
so
I
still
hadn't
gotten
it.
Let's
see
test
okay,
so
it
should
actually
be
running
this
time.
Yeah.
So
I
can,
let's
just
see
what
happens
here
as
we
do
it.
A
B
B
B
So
that's
yeah!
That's!
Definitely
because
it's
getting
stuck
on
trying
to
download
the
image
because
when
it
says
start
it's
saying
like
Okay,
the
docker
demon
goes
wait.
I
don't
have
that
image.
I
need
to
go,
pull
it
first,
and
so
that's
yeah.
That's
a
problem.
B
So
once
I
mean
once
that
gets
once
sorry
Once
you
pull
the
image
and
have
it
downloaded.
Then
it
should
start
it
up
very
quickly.
B
B
Just
not
we're
just
not
gonna.
Do
this!
Okay
well,
I'll
run
this
and
then
we'll
come
back
to
it
soon
and
then
we'll
talk
about
some
other
stuff
because
it
takes
so
long
to
get
spun
up.
A
Let's
see:
okay,
let's
wait
for
it
to
get
spun
up
here
and
then
I'll
grab
the
output.
B
So
is
there
anything
else
you
want
to
talk
about,
or
let's
see,
I
needed
to
talk
to
you
about
one
thing
on
that
too
still
I
realized
that
there's
something
a
little
bit
wacky
with
the.
B
Okay,
but
then
what
we
wanted
to
do
was
okay,
so
Source
equals
async
exit
stack
there
so
enter.
So
we
entered
the
context
of
the
source.
We
set
the
open
and
close
methods.
So,
okay,
here's
what
it
was
yeah.
We
set
the
open
and
close
methods
and
then
we
enter
the
context
which
is
going
to
trigger
the
open
method
which
is
going
to
read
the
file
and
then
load.
It
call
load,
FD
and
then
call
dump
FD,
okay,
so
yeah.
Here's
what
it
was.
B
Okay,
so
I
think
I
had
I
had
showed
you
how
to
do
this
before
so.
I
must
I
must
have
gotten
it
wrong,
but
this
is.
This
is
the
reason
why
things
are
need
to
change
and
here's.
Why
so
this,
when
we
do
this,
get
method
that
rebinds
it
to
another
instance,
and
so
we
had
I
had
told
you
to
bind
it
to
the
source
itself.
But
then
you
know
if
we
bind
to
that
Source
right,
so
basically
self.config.source
becomes
self
when
we
do
this
get
method.
B
So,
instead
of
doing
that
or
well
we're
going
to
do
that
because
we
want
it
bound
to
the
to
the
source,
but
we
also
need
access
to
the
to
this.
Hdms
Source
object
right,
which
is
what
is
now
self
right.
So
in
this
context
here
within
a
enter
self,
is
hdfs
Source
right
and
then,
but
then,
as
soon
as
we
get
into
new
open
and
new
close
since
we
called
git
on
them,
self
becomes
what
is
within
the
inter
method.
Self.Config.Source.
B
Okay,
so
and
then
the
reason
why
this
needed
to
change
was
because,
since
we
have
like
two
things
where
we're
needing
to
talk
about
self
right,
so
in
this
instance
right
within
self.config
or
within
new
open
and
new
close,
we
want
to
think
about
self,
as
the
self
is
now
the
source
right,
the
sub
source
that
we're
using
to
read
the
file.
B
So
we're
just
gonna
say:
like
you
know,
self.client
equals
client
equals
insecure
client,
and
that
way
we
get
this
client
variable
and
if
we
Define
new,
open
and
new
close
within
the
function
or
within
the
a
enter
function,
we
now
have
access
to
this
client
variable,
because
it's
within
that
scope,
so
I
believe
this
is
what
we
want
to
do
here,
but
I
wasn't
sure,
because,
obviously
we
haven't
done
any,
we
haven't.
We
haven't
gotten
a
Hadoop.
B
Up
and
running
yet
so
I
also
don't
know,
let's
see
test
test
source,
so
I
didn't
want
to
say
before
I
was
sure
but
I
think
that
needs
to
happen
and
then
the
user
is
it
root
or
that's.
The
other
thing
I
didn't
know
is
how.
A
Yeah,
because,
by
default
like
we
I
logged
in
as
like
a
root
user,.
B
B
A
Gone
in
there,
I'm
not
sure
like
when
I,
when
I
did
the
command
line
thing,
it
was
a
root,
I
guess
but
I
think
that's
because
oh
I
need
to
check
I'm,
not
sure
like
what.
What
is
the
default?
Username,
okay,.
A
Check
that
in
one
slick,
I
figure
out
that
I'll
change
it
here
as
well:
okay,
cool
cool!
So
let's
write
that
down
to
figure
out
what
user
is
within
container.
B
Okay
and
then
here's
the
other
thing,
this
thing
clearly
just
like
stopped
running
for
some
reason
and
so
I'm,
oh
God.
This
is
this
is
what
I'm
confused
about.
Now,
it's
like
okay,
we
started
the
Cloudera
thing,
and
now
it's
not
running
so
I'm
wondering
what
the
hell
happened.
B
So,
okay.
So
it's
saying
I
T,
that's
probably
what's
going
on
yeah
okay,
so
this
is
okay!
Okay,
so
it
I
believe
what's
going
on,
is
it's
saying
I.T
because
then
it's
going
to
yeah
drop
you
to
a
bash
cell,
and
so,
if
we
don't
somehow
we're
gonna
need
to
like
keep
that
thing
open.
A
B
B
A
Okay,
do.
B
Does
it
have
him,
okay,
okay,
so
here's
what
it's
doing
this
is
this
file?
Okay,
so
then,
at
the
end
it
starts
all
of
these
things.
It
starts
all
of
these
services
and
then
it
just
executes
bash.
B
B
B
For
oh
TTY
yeah,
that's
what
I
wanted
to
make
sure
we
found
out
so
okay,
we
want
TTY
equals
true
oops.
B
Now,
where
are
we
okay?
So
we
want
TTY
equals
true,
and
we
also
want,
like
it's
gonna,
be
like
interactive
or
something
the
trick
here
will
be
like.
Does
this
make
it
so
that
so
the
the
trick
here
is?
If
we
do
this,
is
it's
still
going
to
stay
alive
because
you
know
we're
detaching
and
saying
we're
in
interactive
mode
at
the
same
time,
so
that
is
kind
of
you
know
not
those
are
kind
of
contradictory
I'm,
not
sure.
B
A
B
Okay
and
I
think
that
probably
killed
it
yeah.
Okay,
so
see.
There's
no
thing
that
says
interactive
here
so
interactive:
it
may
work.
It
may
not
work
right,
but
because
so
we
found
the
dash
T
flag,
but
we
didn't
find
the
dash
I
flag.
So
so
you
know
it
might
work
with
TTY
equals
true.
It
might
not.
So
now.
The
next
step
here
will
be.
B
Okay,
so
then
added
TTY
equals
true
need
to
check.
That
container
is
still
running
when.
B
So
yeah
then,
once
you
do
that
and
then
so
made
changes
to
source
to
get
hdfs
so
to
have
new,
open,
slash,
close
P
within
the
context
of
a
enter
and
then
so
like
I
guess
just
make
sure
this
works.
But
that's
you
know
what
you're
going
to
be
finding
out
as
soon
as
you
remove
the
the
call
to
OS
dot
system,
so
yeah.
A
A
A
No,
this
is
it
I'll
try
out
like
whatever
we
discussed
and
I'll.
Let
you
know
if
there
is
any
block.
Okay
cool,
let's
see,
hopefully,.
B
I
have
no
idea:
yeah
yeah
definitely
try
pulling
that
container
image
first
and
then
we'll
see
what
happens
from.
A
There
yeah
so
okay
cool,
so
I'll,
just
say:
okay,
Port
patch
and
change
context
of
new,
so
I
should
close.
B
Okay,
so
I
pushed
that
stuff
all
right,
so
wow
I
got
too
many
windows
all
right.
Arvin.
Are
you
still
here?
Yes,
you
are
great.
B
You
want
to
talk
about.
Do
you
want
to
talk
about
back,
backtrack,
stuff
or
all
right?
Man
yeah,
just
like
yeah.
A
A
A
So
the
thing
is
I
I
see
like
repeated
values
here,
I
need
to
correct
somewhere,
and
you
wanted,
like
the
key
to
be
the
pack,
the
key
to
be
the
operation
that
outputs
the
input
and
the
value
to
be
in
in
like
the
operation,
dot,
something
right.
I.
B
Here
yeah,
so
I
had
been
messing
around
with
you
know
the
let's
see
PDX
Johnny.
A
B
Okay
so
I'll
take
a
little
time
to
explain
like
what
I
was
thinking
here.
28
branches,
geez.
B
A
B
B
A
Yeah
output
set
that
outputs
that
particular
definition,
okay,
the
operation
and
then
or
the
operation
that
outputs
it.
B
B
So
if
we
were
to
take
the
get
one
and
say
you
know
and
use
that
instead
of
this
one
that's
built
into
should
I,
because
we
copied
it
over
now
we
basically
we
delete
one
of
them
and
use
use
the
other
one
right.
B
So
with
this,
it
has
to
match
the
definition
right.
But
with
this
with
this
syntax,
we
can
say
use
your
input
value
as
this
output
value,
so
package.contents
right
and
the
output
value
of
directory
should
be
your
input
for
the
value
of
directory,
and
so
even
though
the
definition
doesn't
match
it,
it
basically
says
it
it.
We
could
say
that,
like
you,
should
use
this
this.
This
operations
output
should
map
to
this
operation's
input,
whereas
this
one
we
only
get.
B
We
can
only
give
information
about
where,
where
output
definitions
or
where
definitions
that
are
the
outputs
of
operations
are
coming
from
right,
sorry,
that
was
a
little
convoluted,
but
you
see
what
I'm
saying
like
we
can
specify.
B
A
What
I
did
was
I
just
followed
like
the
to-do
stuff
that
you
mentioned
before
yeah,
when
you
told
me
like
that
you
you
wanted
this.
This
feature
to
be
implicitly
defined
in
the
data
class.
Before
that
you
suggest
you
gave
me
like
a
list
of
to-do's
right.
I
just
followed
those
things.
Okay,
maybe
maybe.
A
A
B
I'm
not
I'm,
not
giving
you,
let's
see,
okay,
so
yeah,
okay,
so
you
did
what
I
was
talking
about
with
the
to
Do's
okay.
So
let
me
just
read
this
real
quick
here.
So
I
can
understand,
and
this
is
outputting
that
thing.
A
B
Grab
we
go
through
all
the
operations,
we
grab
the
definition
name
and
we
create
this
output,
dick
that
says:
okay,
definition,
name,
maps
to
the
operation;
great
okay,
okay,
definition,
name,
maps
to
the
operation.
B
Okay,
so
I
think
here's
where
there's
there's
one
discrepancy
on
this
okay.
So
if
you
end
up
with
something
so
here,
if
you
end
up
with
something
that
has
only
what
this
is
going
to
overwrite
it
right,
so
if
I
have
two
up
so
these
are
this:
we're
going
through
all
these
output
values,
and
so
you
say
for
output
in
app
outputs
and
you're,
taking
the
output
name
and
you're
setting
it
to
the
operation
right.
So
if
you
have
multiple
things
that
that
produce
that
you've
overwritten
them
here.
A
B
B
Should
you
should
check
so
I'll
check
if
key
is
present,
if
not
present
set
otherwise.
B
B
B
Yeah
no
worries
yeah.
Nowhere
no
worries
because
you're
just
gonna
end
up
with
this
list,
I,
that's
okay,
oh
oh!
This
should
probably
be
a
okay.
So
now
you
said
if
op
input.name
in
flow
dict
plus
equals
templ
okay.
This
is
why
it's
ending
up
with
with
it
multiple
times
Okay.
So,
oh
yeah,
okay,
this
is
it
you're.
You
were
close.
B
This
isn't
exactly
what
I
meant,
but
I
didn't
explain
it
well
enough,
then,
so,
basically,
the
way
that
we
can
take
this
and
make
it
look
like
this
right
is
so
you
grabbed
all
of
the
you
grabbed
all
of
the
output
definitions
that
are
created
by
those
operations
right.
So
basically
you
grabbed
things
like
response,
Json
directory
directory
version
and
URL
right
like
those
are,
those
are
the
things
you
grab
the
definitions
for
them.
B
So
what
we
want
to
do
is
say:
let's
see
what
did
I
I
feel
like
I.
Let's
see
so
we
want
to
do.
Is
we
want
to
say
we
want
to
go
through
all
the
operations
right.
Look
at
all.
The
outputs
then
create
this
dictionary
of
of
definitions
that
map
to
operations
right
so
that'll
be
good,
and
now,
when
you
go
through
all
the
inputs,
you
want
to
look
at
the
yeah.
B
You
want
to
say,
okay,
this
maps
to
this
operation
good,
but
now
you
want
to
say
What,
specifically
within
that
operation
it
came
from,
so
you
have
the
definition
right.
So
you
know
that
this
this
operate
this
list
here
would
be
your
list
of
operation
names.
Let
me
download
this.
Let
me
clone
this,
so
I
can
make
some
comments
on
it.
B
It's
okay,
no
one
will
see
it.
It's
only
for
our
own
knowledge.
Let's
see
dependency
back
check.
It's
not
like
everybody's
gonna,
be
browsing
YouTube.
Looking
for
all
the
things
that
we.
A
B
Yeah,
because
this
is
the
type
of
thing
that
everybody
loves
to
watch,
let's
see
so
get
check
out.
Okay,
I
already
checked
it
out
all
right,
yeah
well,
God
help
anybody
who
thinks
about
like
everybody
will
know
how
how
nuts
I
am
if
they
watch
these
videos.
B
A
Have
the
addict
output
dict.
A
Exists
otherwise
set.
B
A
A
B
Yeah
that'll
be
the
key
exactly
so
then
we
want
to
it
will
be
in
output
dict.
So
we
want
to.
B
B
A
B
B
So
the
internal
name
right
is
like
the
function
argument
right
and
so
the
function
argument
is
package
right.
The
argument
to
that
operation
when
we
Define
it
as
a
function,
we
called
package
okay,
so
that
would
be
internal
name
because
that's
the
key
to
the
value
mapping
that
we
see
well
I
mean
you
know,
you
know
where
we
see
it
right.
Do
you
know
or
should
I
specify.
A
B
Specify
it
yeah
read,
should
I
not
pipei.
A
B
B
A
B
B
B
Okay
and
then
this
one
internal
name
response
Json
definition,
package.json.
B
Whatever
we'll
probably
change
that
stuff,
eventually
but
okay,
so
this
is
this-
is.
B
Yeah,
no
paste
okay,
so
this
is
what
we're
looking
at
here
like
when
we're
going
through
these
things,
so
we
get
internal
name.
Actually,
let
me
make
this
exactly
what.
A
B
So
so
now
we
want
to
set
flow,
dict
operation,
internal
name
so
operation
name,
internal
name,
so
the
input
package,
so
the
operation
name,
is
Pi
Pi
package
Json
the
internal
name.
Oh,
this
is
a
bad
example,
because
package
is
coming
from
flow
or
is
is
not
is
not
is
is
coming
from
the
seed,
but
that's
okay.
B
So
we
grab
the
operation.
Let's
see
the
we
want
to
grab.
B
So
this
is
the
definition.
So
when
I
say
this
is
definition
dot
name,
so
we
want
to
grab
definition
name,
but
here's
the
trick.
So
so,
if
definition
name
in
output,
dict
I
want
to
say.
B
A
Operations
grab.
B
Operation
name
internal
name,
we'll
just
say
this
is
an
empty
dick,
now
We
Set
or
this
is
an
empty
little
list
yeah,
because
this
is
a
list
here,
so
we
set
it
to
be
the
operation
name,
dot
the
internal
name
within
that
operation,
which
is.
B
We
look
through
the
outputs
and
we
check
anyone's
matching
the
definition.
So
we
look
through
the
outputs
and
add
any
one
that
matches.
B
Matches
matches
the
definition
and
set
the
ER
and
add
it
to
the
list.
In
the
format
of
you
know,
operation
name.
B
B
B
Let's
see
this
will
probably
just
be
done
now.
Let's
see
else,
we
just
say
seed.
B
I
did
not
do
a
good
job
of
explaining
it
in
the
comment.
If
then
I
ended
up
writing
a
code.
So,
let's
see
I
tried
my
explanation.
Skills
will
get
better
eventually.
B
Producing
operations,
dot
values
because
we
appended
yeah.
B
Like
that,
does
this
sort
of
make
sense
here,
where
basically
we
go
through
all
these,
so
we
we
look
at.
We
look
at
what
operations
produce
this
definition
and
then
we
go
through
all
their
outputs
and
we
say
if
your
definition
is
the
same
as
the
definition
that
I'm
looking
for
as
an
input,
then
I
want
to
add
you
to
this
list
of
of
of
things
for
this
for
this
operation.
That
has
this
internal
name
for
the
input
append
the
producing
operations
name.
B
Like
in
this
format,
we're
doing
dot,
dot,
dot,
plus
the
internal
name
of
the
output,
so
that
we're
going
to
end
up
with
this
list,
we're
going
to
see
if
we
end
up
with
this
list,
how
do
I
run
this
thing?
How
are
you
running
this.
A
Then
run
underscore
Bandit;
no,
no,
no,
you
need
to
specify
to
more
inputs,
run,
underscore
band
no
way
and
then
it's
good
Bandit
and
package.
B
A
Okay,
oh
gotta,
just
search
for
that.
Damn
thing
all
right:
okay,
so
personal
spot.
Okay,
so
I
need
to
replace
it.
Slow,
decked.
B
B
A
Oh
so
you're
initializing,
the
key
with
the
sample
value.
Okay,
yeah.
B
Now
we
just
want
to
set
default
operation
name
all
right,
so
this
is
basically
going
through
and
saying.
Okay,
if
the
operation
does
not
exist
in
the
flow
deck
make
the
operation
name
equal
to
the
empty
set
or
the
empty,
and
then
here
we
say:
okay,
the
operation
right.
It
exists
as
an
empty
set
or
as
an
empty
dict
set
this
key
to
a
empty
list
here
or
well,
yeah,
that's
fine,
and
then
this
one
we're
going
and
say
an
internal
name.
B
A
Is
right,
actually,
oh,
wait
a
second.
Can
you
go
down
and
see
if
it
is
actually
returning
the
floor
director.
B
B
Okay,
that's
correct
so
package
URL
package.url,
so
the
thing
is
I
had
started
mapping
them
to
like
instances
and
I
think
we
talked
a
little
bit
about
instances,
but
that
that
should
it
will
that
will
fix
itself,
we'll
figure
that
out
so
now
we
have
responsive
Json
maps
to
response
Json
from
package.json,
and
then
we
want
to
check
that
the
other
guy
also
got
that
yeah.
So
package
version
gets
response.
Json
map
from
response
Json,
the
contents,
the
cleanup
gets
mapped
from
the
directory.
So
it's
matching
things
correctly
now.
B
B
B
B
Okay,
so
here's
what
we
need
to
do
now.
We
need
to
look
in
dffml
service.
A
B
A
B
Oh
here
run
the
Run
stuff.
So
look
in
I'll
make
a
note
here.
B
B
This
path
info,
so
basically,
instead
of
path,
info
being
start
and
end
of
path,
info
being
start
and
end,
make
it
a
list
of
operations
or.
B
A
B
Okay,
we'll
leave
it
like
this.
For
now,
I
mean
things
that
could
be
passed
to
the
dffml,
slash
service,
slash,
Dev,
Dot,
py,
run
or
well
in
this
format,.
B
A
Okay,
so
look
at
that
four
more.
B
Load
an
operation
then,
once
you
have
the
code
to
load
an
operation,
append
that
operation
to
a
list
and
pass
it
to
depth.
Hacktrack.
B
Okay,
so
this
is
going
to
make
this
like
actually
a
command
line
utility.
So
basically
you
take
you
go
into
the
service
Dev
stuff.
B
B
Yeah
I'll
just
do
this
in,
like
so
within
the
next
two
weeks.
I
got
that
b-sides
thing
coming
up
on
the
26th.
B
So
I
guess
that's
that's
like
kind
of
next
two
weeks
here
and
basically
what
I'm
gonna
do
yeah,
so
we
I
mean
once
once,
that's
together,
like
there's
gonna,
be
a
lot
more
operation
stuff,
we're
still
ironing
out
the
sudarsana
and
Yash
had
ironed
out
all
the
Kinks
in
figuring
out
what
was
wrong
with
all
the
model
and
Source
stuff,
and
so
now
now
we
we,
you
know
they
worked
on
that
for
the
whole
summer
and
we
found
out
all
the
weird
little
things
that
needed
to
happen
since
you're
just
getting
started
on
the
operations.
B
There's
lots
of
little
weird
Kinks
still
and
after
this
and
the
DFAS
branch
that
I
have
going
that'll
all
be
like
ironed
out
and
we'll
be
able
to
to
to
do
things
more
quickly
because
so
basically,
what's
going
on
now.
Is
this
the
the?
What
I'm
writing
here
in
the
comments
is
basically,
we
want
to
be
able
to
take
like
if
I
write,
some
python
code
and
it's
just
a
bunch
of
operations.
B
If
I
just
Supply
the
path
to
those
like
in
the
python,
syntax
and
say,
like
you
know
my
file
colon
my
function,
then,
if
I
Supply
a
bunch
of
those
on
the
command
line,
it
will
then
print
out
the
data
flow
that
that
those
operations
create
right
and
it'll
print,
that
out
I've
got
it
exporting
to
a
yaml
format,
and
so
what
we
can
now
do
is
we
can
take
these
data
file
or
data
flows
store
them
in
yaml.
And
then
then
you
can
change
what
what
the
yaml
is
doing
right.
B
So
you
could
just
edit
the
yaml
file
and
then
run
the
yaml
file.
Basically,
so
the
yaml
file
is
the
data
flow,
and
so
you
just
provide
the
yaml
file,
which
lists
out
all
the
operations
that
you
want
to
use
and
then,
like
you
know,
I
could,
in
the
yaml
file,
say
that
I
want
to
use
the
git
cleanup
operation
or
the
first
example
that
I'm
going
to
do
is
actually
have
it
be.
So
when
we
clone
that
Source
right
or
when
we
download
that
source
we
run
banded
on
it.
B
B
We
don't
use
that
here
and
should
I,
but
we
could,
if
we
had
this
data
flow
format,
where
we
can
specify
that
the
inputs
and
the
outputs
linked
to
each
other,
because
even
if
the
definitions
don't
match
so
basically
the
the
demo
here
would
be
like.
Okay,
you
take
the
data
flow.
B
Because
people
are
really
used
to
editing
yaml
files
like
they're
they're,
pretty
convenient
and
then
also
you
know
when
we
move
this
to
another
language.
Eventually,
the
yaml
file
is
just
like
you
know.
Yaml
is
just
a
Json
simplified
thing
right.
So
that's
why
I
was
doing
yaml
unless,
like
there
might
be
better
ways
to
do
it.
B
B
Don't
know
well,
there's
I
mean
no,
it's
not
easy
to
parse
yaml
files,
there's
like
one
library
that
everyone
uses
so
yeah,
but
yeah.
It's
pretty
it's
pretty
common
format
that
I've
seen
a
lot.
That
seems
like
a
lot
of
people
are
doing
it
like
the
other.
The
other
thing
here
is
so
with
these
yaml
files.
What
we'll
be
able
to
do
is
you
can
write
your
operations
right
and
you
could
write
them.
A
Why
not
Jason
Json
is
like
easy
right.
Well,.
B
Yeah,
so
Json
is
easy
right,
but
json's
not
easy
to
hand
edit
the
file.
That's
the
thing:
okay,
we
can,
but
the
other.
The
other
thing
of
this
is
that
it
could
be
Json.
It
could
be
yaml,
I
mean
Json
and
yaml
are
pretty
much
the
exact
same
thing.
Only
yaml
is
Json
without
the
brackets
so
and
the
quotes
it's
just.
If
you
look
at
a
yaml
file
in
a
Json
file,
it's
it's
just
it's
Json
without
the
brackets
and
quotes,
and
so
it
makes
it
just
easier.
B
So
that's
the
plans.
That's
the
plans
right
now
and
this
DFAS
stuff.
It's
it's
coming
along
it'll,
be
it
I,
think
it'll
be
done
pretty
soon.
Along
with
this,
I
was
working
on
the
the
as
an
update,
I'm
working
on
this
adding
models
to
the
HTTP
API.
B
So
there's
the
HTTP
API
is
just
like
the
command
line
interface.
Only
you
post
Json
to
it,
and
then
it
does
all
the
things
that
you
could
do
from
the
command
line
or
from
the
library
usage
and
so
Yash
and
sudarsana
have
have
started.
Thinking
about
writing
a
web
UI
for
this
stuff,
and
the
first
thing
that
that
gash
wanted
to
go
tackle
was
the
models.
B
The
sources
are
already
up
there,
it's
just
not
so
like
we
just
you
know.
Yash
is
really
excited
about
doing
models,
so
one
he's
gonna
need.
He
needs
sources
right
to
to
pass
to
the
models
to
say:
hey
model,
here's
your
source
of
data,
so
I'm
almost
done
implementing
them
the
models
so
that
you
can
say
like
okay,
instantiate
a
model
pass
it
this
source
of
data,
that's
like
from
the
mySQL
database,
it's
sudarsana
implemented,
and
so
then
you
could
have
this
web
UI.
B
Where
you
could
say
like
okay,
you
know:
here's,
here's,
here's,
my
data
sources,
connect
them
all
upload
my
CSV
file,
and
now
here
I'm
configuring,
my
model
and
running
it
and
then
what
we're
gonna
do.
The
DFAS
stuff
is
basically
like
it's
one
branch
where
I've
like
messed
around
with
a
lot
of
stuff.
But
what's
going
to
happen
is
when
that
lands?
B
It's
going
to
enable
you
to
run
the
data
flows
from
the
HTTP
API,
so
we
can
take,
should
I
and
we
can
export
the
data
flow
as
a
yaml
file,
send
it
to
the
HTTP,
API
and
say
register
this
data
flow.
And
then,
when
you
post
a
package
name
or
like
you
know,
do
a
git
package.
Name
like
you
could
do
you
could
register
it
as
the
URL
path
of
like
slash
should
I.
You
know
where
the
next
slash
would
be
the
package
name.
B
And
so,
if
you
go
to
this
endpoint,
it
runs
the
whole
data
flow
for
should
I
and
on
whatever
package
name
that
you
put
like
you
know,
slash
should
I
slash
sum
package.
It
takes
that
sum
package
and
it
runs
the
whole
data
flow.
So
that's
that's
what
I'm
I'm,
also
working
on
that?
Okay,
so
we'll
be
able
to
we'll
be
able
to
export
these
things
to
yaml
files
and
then
send
them
to
like
different.
That's
the
bill
thing
that
we
came
up
with
that
one
day
which
I'm
now
calling
a
multi-com.
B
So
now
we'll
have
this
this
yaml
file
that
we
can
go
and
register
with
this
communication.
Channel
and
then
you
know
the
different
communication
channels,
like
the
HTTP
API
or
like
an
IRC
interface,
would
say:
okay,
I
know
that
I'm
running
this
data
flow
for
this
you
know
initiating
thing
which
would
be
like
that
URL
path,
and
now
we
can
run
the
same
code
over
different
interfaces
just
by
defining
it
in
that
yaml
file
and
then
The
Next
Step
Beyond.
B
It's
coming.
It's
really
close
here
now,
though,
because
I
reworked
a
lot
of
the
the
DFAS,
the
defas
stuff
and
then
the
HTTP
API
are
all
pretty
close
now
so
and
then
with
this
stuff
that
we
just
did
here
and
you've
been
doing
on
the
backtrack,
that'll
really
easily
export
the
data
flows.
B
Just
you
know,
people
will
write
the
operations,
they'll
just
say:
okay,
here's
all
my
operations
on
the
command
line,
give
me
the
data
flow
as
a
yaml
file,
and
then
they
can
take
that
yaml
file
and
say
register
it
with
the
HTTP
API
and
all
of
a
sudden,
you
know
they're
running
their
stuff
from
an
HTTP
server.
A
B
Right
and
that's
that's
what
I
mean
so
after
that's,
that's
like
the
stuff,
I'm
hoping
to
get
done
by
the
25th
and
then
after
that,
it's
basically
just
like
I
want
to
write
a
bunch
of
demo
apps,
and
you
know
some
that
include.
You
know
we
want
to
work
on
like
that
web
UI,
and
then
we
want
to
work
on
like
a
bunch
of
demo
apps
to
show
how
all
this
stuff
works.
B
So
yeah.
That's
the
plan.
A
Like
I
will
work
on
the
Hadoop
stuff,
but
then
it's
like
I've
been
working
on
this.
For
so
long,
so
I
think
I
can
lick.
You
know
switch
to
the
web
UI
yeah.
A
A
B
Probably
bored
to
working
on
the
Hadoop
stuff
right
now,
yeah
so
and
then
and
the
sources
all
the
sources
documentation
I
mean
if
you
wanted
to
just
start
playing
around
with
that
right
now,
like
the
HTTP
API
has
all
the
documentation
and
python
test
cases
and
some
JavaScript
code
to
interact
with
the
source
stuff.
A
B
Yeah-
and
you
know
where
the
documentation
link
is
right:
okay,
cool
and
then
I
I,
actually
I
have
some
code
that
a
an
intern
wrote
to
do
like
a
little
like
annotation
API
with
the
source
stuff
and
so
I
could
like.
I
could
send
you
that
and
you
could
see
how
she
was
interacting
with
the
JavaScript
API,
but
obviously
you'd
be
doing
everything
in
a
in
react
right:
yeah,
no,
not
Lauren.
B
What's
her
name,
Catherine,
oh
yeah,
Lauren
I
haven't
I
emailed
Lauren
I,
don't
know,
I
should
never
email
me
back.
She
kind
of
dropped
off
the
map.
I
wanted
to
see
like
if
I
could
Pawn
off
my
fuzzing
work
on
her,
but
that
wasn't
working
so.
B
Right
well,
great
yeah
I
would
love
if
you
wanted
to
start
like
messing
with
the
react
and
the
sources
that
would
be
super
great,
because
Yash
is
going
to
need
the
sources
before
he
can.
You
know,
do
any
of
the
model
stuff,
because
you
have
to
pass
a
Model
A
source,
so
he's
gonna
need
yeah.
Basically
like
the
way
that's
gonna
work
is
you'll,
see
the
API
and
you'll
see
how
like
I
mean
I'm
recording
right
now,
sir
or
I'm
displaying
right
now
so
we'll
I'll
just
show
you
real,
quick.
B
So
HTTP
API,
so
basically
you
configure
that,
like
you
list,
you
can
say
list
sources
and
it
returns
you
this
giant
thing
which
is
the
output
of
the
config
method
as
a
Json,
and
so
basically
you
could
parse
this
and
create
like
a
form.
You
know
like
just
an
input
form
that
like
uses
these
data
types
to
say,
like
you
know,
maybe
this
is
like
a
radio
button.
Maybe
you
know
this
is
a
string.
B
If
something
was
an
into
you
would
say
like
just
number
field,
you
know
whatever
you
want
to
do
right,
so
you
you
use,
create
you
grab,
create
react
app.
You
first
thing
you
do
is
like
say:
here's
your
options
right.
If
someone
says
like
you
know,
create
a
new
source.
B
You
list
this
API,
you
say:
okay,
what
do
you
have
to
work
with
and
then
you
know
when
they
click
on
CSV,
you
populate,
you
create
a
little
form
with
all
this
stuff
populated
here
and
then
you
say
save
and
it
hits
this
configure
API
endpoint
and
it
sends
that
form
over
and
then
now,
if
you
want
to
like
do
things
like,
you
know,
examine
all
the
repos,
you
could
create
something.
That's
like
you
know.
B
You
could
create
like
a
little
table
and-
and
you
could
just
when
you
say
view,
it
just-
goes
and
hit
this
repos
API
and
it
lists
all
the
all
the
stuff
in
that
Source
or,
and
you
can
do
like
you-
can
start
working
on
the
upload
stuff.
Like
there's
a
lot,
you
could
start
doing
with
HTTP
API
to
expose
all
the
sources
in
a
nice
little
UI
exactly.
B
Exactly
and
I
have
some
I
think
there's
also
yeah
you'll
have
you'll
have
significantly
more
fun
doing
that
than
fighting
with
when
fighting
with
the
dupa
punch,
but
continue
to
fight
with
Hadoop
whenever
that
works
so
yeah,
so,
oh,
no,
this
is
for
you.
B
So
when
you
want
to
start
building
the
web
UI
and
then,
if
yeah,
you
know,
if
Yash
does
something
or
well
like
whatever
you
guys
end
up
whatever
ends
up
happening,
there
he'll
need
the
sources
first.
B
So
if
you
want
to
just
start
running
on
that
I'm
sure
he
would
be,
he
would
be
happy,
especially
since
you
have
more
experience
doing
that
it
sounds
like
he
doesn't.
He
hasn't
actually
done
done
that
before
then.
Maybe
he
could
just
you
know,
jump
into
the
code
that
you've
written
so
yeah
cool
all
right.
Well,
thanks
guys,
good
thanks
for
showing
up
today,
it
was
good
to
talk
to
you
both.