►
From YouTube: Weekly Sync: 2020-01-28
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
B
Yeah
yeah
it's
going
nice
John,
so
am
I
audible.
Yes,
you
are
Audible.
Yeah
John
I
saw
that,
like
you
tagged
another
PR.
A
A
A
B
It
locally,
actually
that
might
help,
let's
see
so.
B
Or
tell
my
other
computer,
all
right
I'll
have
to
figure
out
how
to
do
that
later.
Oh
yeah
and
I.
A
B
B
B
A
Can
start
get
started
for
today?
Let
me
just
run
through
the
things
that
I
we
have
going
so
far,
so
we
got
that
message
from
that.
One
person
saying
that
we
have
bad
doc
strings
or
non-existent
doc
strings.
So
that's
an
issue
and
I
have
created
two
issues
to
track
that.
A
One
of
them
is
that
everything
needs
doc
strings
basically
and
basically
I
did
that.
The
first
thing
I
did
that
for
was
the
SQL
stuff
that
Ogden
added,
so
I
went
through
and
I
added
the
doc
strings
for
it
and
basically
it'll
end
up.
Looking
like
this
and
I'll
show
you
here's
the
pre-format
or
here's
the
version
in.
Let's
see
here's
what
it
looks
like
in
the
source
code.
A
It's
basically
you
say
what
the
parameters
are.
You
give
the
data
types
and
some
description
of
them,
and
then
you
say
what
the
return
values
are
so
pretty
simple
stuff.
The
other
thing
that
we'll
need
to
do
is
like
the
example
code
to
I.
Don't
know
if.
B
I
had
that
on
here.
Yet
oh,
no,
that's
AO
helpers!
Oh
I!
Guess
util's!
Not
on
here!
Okay!
Well,
that's
a
bummer!
A
I'll
just
push
it
I'll
just
push
it,
but
so
some
of
them
have
the
doc
test
examples.
So
this
is
the
other
issue,
so
the
first
one
is
basically
we
need
to
go
through
and
document
it
in
this
format
right
here,
and
this
is
sort
of
like,
as
you
find
things
if
you're
looking
for
something
that
would
be
great
to
do.
A
If
you
want
to
just
go
through
a
few
of
the
functions
that
you
know
or
methods
that
you
know
and
add
doc
strings
for
them.
It's
not
the
most
exciting
thing
in
the
world,
but
it
gets
a
little
more
exciting
when
you
write
the
test
for
them
and
do
the
doc
test
stuff,
because
then
we
can
add,
like
I'll.
B
Show
you
this
is
always
fun.
B
Somewhat
subjective,
but
so
let's
see,
let's
see,
till
okay
and
I
believe
I
added
them
to
data
update
doc,
string
samples,
okay,
so.
A
A
So
yeah,
when
they
show
things
like
this,
with
the
little
arrows
that
it's
it
means
like.
You
know
if
you
were
doing
this
in
the
python
interpreter
and
then
the
next
line
without
the
arrows
is
what
the
output
should
be.
So
you
can
run
the
doc
test
module
and
it
will
basically
go
through
all
of
the
documentation
strings
for
a
given
file
and
check
that
they.
A
It
will
check
that
they
are.
You
know
when
you
run
the
thing
on
the
line
with
the
three
arrows
it
outputs.
What
was
on
the
line
below,
and
so
what
I
did
was
I
just
went
through
and
I
I
updated
them
for
this
data
file,
because
she
was
confused
about
what
this
stuff
was
doing
so
because
it
was
the
dock
strings
were
not
correct.
A
So,
basically,
now,
if
you
go
and
you
run
the
doc
test
command
on
this
file
and
I
can
show
you
guys
how
that
works.
Real,
quick
here.
B
B
A
Okay,
yeah,
okay,
so
you
have
to
do
it
with
Dash
v.
So
basically
it
goes
through
and
it
tries
to
run.
Let.
B
Me
find
one
that
was
the
one
that
we
were
looking
at
here:
okay,
yeah,
controverse,
config
git,
and
that
was
okay
side
by
side;
sorry,
okay
or
that's.
Contrary
config
set
all.
A
Right
so
it
goes
through
and
it
tries
to
run
this
line
here,
and
so
it
runs
whatever's
here
and
then
you
have
to
put
little
dot
dot
dots
just
like
that.
Whatever
would
happen
in
the
in
The
Interpreter.
If
it
shows
dot
dot
dots,
you
need
to
put
dot
dot,
dots
there
to
continue
the
statement,
and
then
it
compares
the
output,
so
it
says
trying
expecting
and
it's
got
what
it
was
expecting
exactly
so
it
this
string
here,
matched
and
so
all
is
well
in
the
doc
test
paths
passes.
A
So
what
we'll
try
to
do
is
we
need
to
try
to
go
through
and
and
obviously
this
one
I
didn't
document
the
arguments.
So
it's
it's
not
it's!
Nothing
is
nothing
is
as
it
should
be
right
now,
but
that's
the
point
of
these
issues
so
we'll
go
through
and
if
you
have
extra
time
we're
looking
for
random
things
to
do.
This
will
be
great
because
then
people
will
see
on
the
the
documentation
website.
It'll
be
really
obvious,
as
people
are
going
through,
they
won't
have
to
read
the
source
code.
A
They
can,
just
you
know,
know
what
stuff
to
call,
because
we
all
have
had
to
read
all
the
source
code,
so
yeah,
okay.
So
that's
basically
the
deal
with
this
and
it
comes
out
nicely
formatted
like
this
and
if
you
add
the
example,
the
example
will
also
come
out
nicely
formatted.
So
people
can
just
copy
paste
from
the
documentation
website
here
the
examples
and
that
will
be
super
helpful
for
them
and
yeah.
A
So
that
is
the
first
bullet
point
that
I
wanted
to
talk
about,
and
then
the
pre-trained
model,
stuff,
himanshu
and
I
are
banging
our
heads
against.
Why
tensorflow
is
installing
in
one.
A
The
funny
thing
is
that
it's
installing
when
we
go
through
and
we
look
at
okay
so
and
I'm
pretty
sure
it
has
to
do
with
this
virtual
advice
stuff
actually
at
this
point,
but
I
can't
prove
it
yet
so
we've
changed,
himachu
went
through
and
moved
all
the
tensorflow
one
stuff
to
tensorflow
2
and
found
this
wonderful
log
level
thing
to
make
it
so
that
we
don't
have
to
view
all
those
stupid
logs
that
don't
get
through
the
logging
infrastructure.
That
python
has
and
then
we
pump
the
version
here.
But.
B
A
A
A
Right
so
when
we
set
up
the
when
we
run
one
of
the
plugins,
the
first
thing
we
do
is
I,
create
a
virtual
environment,
activate
the
virtual
environment
and
install
pip
install
the
upgraded
version
of
pip.
So,
like
this
shouldn't
be
a
problem
at
all,
it
should
be
just
fine
now,
that's
where
I'm
getting
confused
here,
because
we
activate
the
virtual
environment,
we
install
pip,
and
then
we
run
the
tests
and
then-
and
so
this.
So
this
is
where
it's
failing
in
here.
It's
like.
Okay,
it's
in
the
virtual
environment.
A
A
It
runs
the
test,
then
it
tries
and
run
all
these,
like
other
things,
that
we
have
that
aren't
necessarily
tests,
as
well
as
like
the
longer
tests
that
that
require
some
of
the
the
integration
tests
that
require
other
plugins
and
the
examples,
and
it
does
some
of
that.
It
deactivates
the
virtual
environment
and
then
to
install
the
docs
we
kind
of
clear
we
deactivate
the
virtual
environment.
A
So
we're
like
we're
back
in
a
clear
area,
install
the
plugins
again
and
run
the
scripts
or
and
run
the
run,
the
doc
scripts
and
run
the
coverage
report
for
everything,
as
well
as
the
integration
tests
which
again
I
don't
know.
If
you
saw
I
just
found
an
issue
that
basically
this
line
here,
checks
if
any
of
the
integration
tests
are
being
skipped
and
then
Bales.
If
they
did
get
skipped.
B
A
It
checks
if
they're
skipped
it
doesn't
check
if
they
errored,
so
we
also
need
to
add
a
line
and
I'm
pretty
sure
it's
just
if
I'm
pretty
sure
it's
just
error
equals
star,
but
you
know
we
need
to
check
that
and
so
somewhere
in
here
like
when
we're
running
any
of
these
tests.
Here,
for
example,.
A
A
A
A
A
And
in
this
in
this,
when
we're
running
the
main
test-
and
we
install
all
of
the
when
we're
running
the
main
test-
and
we
install
everything-
let's
see
this
is
right
after
the
test-
config
loader
stuff.
So
that's
here
where
we're
creating
the
last.
A
We
create
the
config
loader
here
and
then
we
run
that
and
then
we
run
this
and
when
we
run
service
Dev
install
this
is
still
in
the
virtual
environment,
so
they
that
makes
less
sense
because
that
doesn't
make
any
sense
at
all
then
so
I
guess
this
is
still
an
open
issue.
I
was
hoping
we
might
figure
it
out
right
now,
but
it
doesn't
that's
complete
nonsense.
A
Okay,
here
this
might
be
it,
we
activate
the
virtual
environment
we
install
pip
and
Twine.
We
run
the
install
on
the
root,
which
is
the
main
package.
Then
we
run
the
tests.
So,
okay,
okay,
I,
better
know,
what's
going
on
here
all
right,
so
we
don't
actually
install
the
package
because
you
don't
need
to
install
packages
to
test
them
and
you
shouldn't
you
shouldn't
need
to.
A
But
my
guess
what
happens
when
you
install
when
you
run
the
test,
is
you'll
see
like
downloading
to
the
dot
eggs
directory
where
it
downloads
the
dependencies
locally
to
the
whatever
your
path?
Is
that
you're
running
the
test
from
wherever
setup.py
is
it'll?
Create
this
directory
called
dot
eggs
and
it'll
install
the
packages
in
there
and
then
use
those
packages
for
the
tests
now?
A
This
is
where
like
setup
tools
and
disk,
utils
and
pip
are
all
sort
of
like
Loosely,
combined,
but
also
the
same
thing,
but
also
not
my
guess,
is
whatever's
in
charge
of
installing
dependencies
to
the
dot
eggs
directory
for
tests
does
not
know
how
to
install
the
correct
like
it.
It's
using
the
old
version
of
pip
or
something
the
version
of
pip
that
didn't
get
upgraded.
So
if
we
add
the
install
will
probably
be
okay.
B
A
This
will
probably
work
because
that's
the
difference
here
that
I'm
seeing
right
now
is
we're
installing
the
package
first
using
the
regular
pip
command.
This
one
is
not
installing
the
package,
it's
just
running
the
tests
and
installing
the
packages
with
whatever
whatever
runs
the
test,
has
a
different
thing
way
of
installing
the
packages
than
pip
would,
if
we
did
it
for
real.
So
let's
try
that
and
see
what
happens
so
install
you.
B
Test,
okay
and
I:
wonder
if
we
we
should
probably
just
uninstall
just
to
be
safe
because
down
here
we're
going
to
do
things
that
that
will
be
weird.
So,
okay.
B
A
Okay,
so
and
then
so
the
SQL
up
stuff,
I
still
haven't
gotten
to
the
export
stuff.
Sorry
I
was
working
on.
I
was
working
on
the
web.
Ui
I
wanted
to
get
that
started
I'm
trying
to
get
that
to
a
place
pretty
soon
here,
I'd
like
to
get
it
to
a
place.
A
There's
one
thing
that
I
need
to
fix
that
I'll
talk
about
at
the
end,
but
I
want
to
get
that
to
the
place
where
we
can
start
accepting
contributions
on
that,
because
that's
going
to
be
cool
and
so
but
I'm
going
to
get
to
the
SQL
op
stuff.
I
have
some
stuff
at
work
that
I'm
being
hounded
for
other
projects
that
are
higher
priority
to
other
people
that
are
being
that
I'm
being
hounded
for
to
do
so.
A
I
need
to
get
those
done
and
that's
where
I've
sort
of
haven't
been
able
to
work
as
much
so
sorry
about
that.
But
I'll
get
the
export
stuff
soon.
A
So
the
repo
feature
specific
predictions
again,
we
got
he
contributed
that
we
got
that
merged.
That
was
great.
So
now,
basically,
what
we'll
see
is.
A
Oh
yeah,
oh
yeah,
that
might
that
might
screw
things
up:
yeah,
okay!
So
when
we,
when
we
merge
that
stuff,
once
we
figure
out
the
TF
one
to
two
thing,
then
once
you
yeah,
because
the
way
that
the
predict
method,
the
repo.predict
predicted
method,
changed.
A
B
A
See
I'm
sorry
I
must
must
have
not
seen.
Let's
see
minor
changes,
okay
and
then
you
fixed
it
great,
okay,
yeah
perfect.
Let's
just
merge
this
right
now
then.
B
A
B
Confidence-
okay,
that's
not
accessing
that!
The
full
okay.
A
Cool
all
right,
yeah,
let's,
let's,
let's
take
these
things
off
and
add
it
to
the
changelog
and
then
when
you're
done,
remove
the
WIP
tag
and
that
way
all
it'll
it'll
signal
to
me
that
I
need
to
come
check
at
it
again
or
just
ping
me
in
the
issue.
A
That,
probably
because
it
looked
it
looked
done
when
I
last
looked
at
it,
except
for
those
things,
so
I,
probably
just
thought
we'd
done
it.
Okay,
so
this
is,
will
be
done
soon.
A
Idx3,
stuff,
I,
think
suction
has
been
busy.
I
haven't
heard
from
him.
I
mean
we
heard
from
him
last
week
and
he
said
he
was
super
busy.
I
know
people
are
going
into
midterms
and
stuff
right
now,
so
that's
probably
what's
going
on,
but
yeah.
That's
that's
same
as
last
week
I
pushed
up
the
source.
A
Actually
it
is
published
because
I
had
to
do
some
stuff
I
had
to
put
in
some
keys
and
I
was
going
to
lose
access
to
the
settings
page
because
they
only
give
us
temporary
access,
so
the
source
is
actually
up
there.
You
can
install
it,
but
it's
not
merged
into
master.
So
we
just
need
to
get
the
few
things
that
we
wanted
for
the
documentation
there
and
then
it'll
be
good.
A
The
input
validation
that
August
doing
so
that's
very
similar
to
the
spec
stuff
that
starson
is
doing,
and
so
that
is
basically
it's.
It's
almost
it's
very
similar
type
of
thing.
The
idea
here
was
basically
that,
when
these
inputs
come
in
the
network,
we
want
to
validate
the
data
types
so
and
the
tests
do
a
good
job
of
illustrating.
A
What's
going
on
with
that,
so
basically,
what
we'll
have
here
is,
if
you
say
that
shape
name
is
you
know
if
you
say
that
shape
name
is
a
string
and
you
want
to
do
some
validation
on
that.
You
might
say:
okay,
like
any
anything
that
becomes
a
shape.
Name
needs
to
be
a
uppercase.
It
needs
to
be
all
uppercase
right,
and
so
then
the
validation
function
will
return
the
same
thing
but
uppercase
and,
for
example,
Pi.
A
A
I
was
getting
some
Security
review
from
one
of
my
buddies
on
the
security
team
the
other
day,
and
he
was
saying:
oh,
have
you
have
you
done
all
the
input
validation
I
was
like
well,
the
beautiful
thing
about
this
is
we
can
trace
all
the
inputs,
and
so
we
can
very
easily
do
input
validation,
and
this
is
going
to
be
very
exciting
from
like
a
security
perspective
of
of
you
know,
you
can
build
it
when
someone
comes
to
you
and
says:
have
you
validated
all
your
inputs,
which
is
basically
like
what
everyone
around
my
work
hates
to
hear?
A
It's,
because
that's
what
we
asked
them
on
the
security
I'm
on
the
security
team,
and
we
ask
people
constantly.
Have
you
validated
all
your
inputs
and
the
answer
is
like
no
I
mean?
How
would
you
know
if
I,
how
would
I
know
if
I
validated
all
my
inputs?
Well,
if
you're
doing
stuff
with
this
data
flow
programming
style
of
things
like
we
can,
we
can
know
if
we
validated
all
our
inputs
because
nothing
can
get
to
any
of
our
code
until
it's
been
validated
now.
So
it's
it's
very
exciting.
A
It
will
relieve
lots
of
headaches
for
anybody
who
wants
to
do
this
and
so
and
then
the
spec
stuff
is
in
the
same
vein.
Obviously,
but
we've
talked
about
that
before
so
and
that's
that's.
It's
like
the
layer
before
the
input,
validation
or
well.
It's
also
part
of
the
input.
Validation
is
we're
doing
anything,
that's
a
dictionary
that
should
have
certain
Keys
we're
using
those
specs
to
convert
the
dictionary
into
its
name.
A
Tuple
value-
or
you
know
whatever
the
spec
is
some
kind
of
class
that
actually
takes
those
parameters,
and
that
way
you
can
know
you
know
you,
don't
sometimes
you
access
right.
So
if
we
tried
to
access
repo
directory
and
that
key
didn't
exist,
we
would
throw
an
error
in
this
function.
Now
it's
going
to
happen
is
as
soon
as
you
try
to
input
something
into
the
network
that
should
be
of
that
data
type.
A
It's
going
to
validate
that
it
has
a
directory
parameter,
so
it
won't
even
let
it
get
in
there
unless
it's
correctly
formatted.
So
we
will
know
that
things
will
work
as
they
come
in
and
then,
of
course,
this
validation.
The
way
that
that
got
added
is
it's
going
to
get
added
right
after
this
spec
conversion.
So
then
you
could
validate
the
different
fields
in
the
spec
if
you
wanted
to
so
this
is
very,
very
exciting
stuff,
I'm
thrilled
about
it.
A
A
B
I'm
not
sure
like
what
is
it
exactly
do.
A
Oh,
oh,
this
was
the
docs.
This
is
a
relatively
new
one.
I
think
what
happened?
What
happens
here
is
we
ensure
that
the
documentation
is
being
updated,
so
the
docs
folder.
So
you
have
to
run
the
documentation
generation,
script,
yeah.
Okay,
so
if
you
just
run
actually
I
think
everything's
already
installed.
So
if
you
just
run
dot,
slash
scripts,
Slash
docs.sh
and
then
commit
the
changes
and
push
those
up,
that
should
be
good.
A
B
Again,
it's
a
problem
with
the
pap
again.
Oh
still,
it's
saying
you
must
give
at
least
one
requirement
to
an
install
something
to
do
with
the
dot
that
you
put
I.
Think
oh.
B
A
That
would
be
great,
though,
because
we've
got
a
lot
of
these
unused
methods
that
are
hanging
around
from
the
very
in
the
very
initial
implementation.
Didn't
do
data
flow
stuff
it
had
this
very
it
was.
It
was
not
a
great
way
of
generating
feature
data.
You
had
to
deal
with
all
this
locking
and
stuff.
That
was
not
fun,
and
that's
that's
why
the
data
flow
stuff
is
nice
is
because
you
don't
have
to
deal
with
locking.
B
Let's
see
what
else
do
we
got
here?
Oh.
A
Justin
is
working
on
this
Auto
arcs
and
config
he's
basically
there's
a
few
more
files
where
we
we
haven't
finished,
going
through
and
and
removing
the
origin,
config
method
and
replacing
them
with
the
config
decorator.
So
he's
still
in
progress
on
that.
Let's.
B
See
what
else
do
we
got?
Let
me
just
make
sure
we've
gone
through
all
the
pull
requests:
I'm
improving
the
quick
start
at
some
point
here.
A
And
then
I
need
to
do
the
export
here.
B
Which
I
started
doing
that
this
morning?
Hopefully
I'll
get
to
it
today.
All
right,
cool
I
think
we're
pretty.
A
Much
gone
through
all
the
pull
requests.
Is
there
anything
else
that
or
what?
What
else
do
you
guys
want
to
talk
about
here
before
I
sort
of
give
you
a
little
I?
Can
I
can
do
the
demo
of
the
web
UI
or
why
don't
we
talk
about
everything
you
guys
have
to
talk
about
first,
because
there's
not
that
much
to
talk
about
with
the
web
UI.
A
Everybody
got
you
know
if
you
want
something
to
work
on.
Do
you
have
something
to
work
on,
or
are
you
blocked
on
anything
that
we
don't
know
about
that
you're
blocked
on.
A
Okay,
let's
see
so
you've.
B
B
Skills
here,
so
what
else
did
we
have?
That
was
going
with
the
models.
B
A
So
apparently,
apparently
this
is
like
so
who
was
telling
me
this
thing
has
been
around
for
a
long
time.
It
was
made
by
Yahoo
back
in
2007,
and
and
apparently
this
had
been
like
the
gold.
This
continues
to
be
like
the
gold
standard
for
machine
learning.
It's
just
like
tensorflow
gets
a
lot
of
hype,
and
so
apparently
this
is
like
what
people
really
love
to
use
in
production.
A
It's
very
battle
tested
and
really
awesome,
so
this
would
be
really
cool,
and
so
the
thing
about
this
is
what
we'll
end
up
doing
here
is
we'll
I
think
it's
a
command
line
interface
or
they
have
okay,
they
have
python.
Okay,.
B
Let's
see,
okay,
let's
see,
let's
see
where
is
I,
don't
see
any
python
code
here.
B
A
A
So
the
interesting
thing,
so
the
thing
about
dff
ml
is
we're
running.
Everything
in
these
async
functions
right,
and
this
is
great
for
doing
I
O.
It's
not
great.
If
you
have
a
machine
learning
model,
that's
blocking
the
main
thread
now
the
thing
about
most
of
the
machine
learning
Frameworks.
A
Is
they
don't
understand
async
right,
so
the
the
reason
why
async
is
nice
is
because
we
can
stream
data
in
and
properly
handle,
network
errors
and
network
issues
and
and
just
like
networking
networking
is
done
correctly
with
async
and
await,
and
so
when
you're,
when
you're
building
these
large,
like
when
you're
doing
the
data
flow
networks
and
stuff
and
you've
got
all
this
data
flying
around
and
some
of
it's
coming
in
from
external
sources.
A
A
So
if
you're,
okay
with
things
breaking
every
once
in
a
while
and
getting
time
out
errors,
then
it's
fine,
but
if
you're
not,
then
you
want
to
use
async
and
weight
so
we're
using
async
in
a
way.
For
that
reason,
now
the
problem
is
obviously
it
blocks.
You
can't
anything.
A
Cpu
bound
will
block
the
event
Lube
now
anything
and
and
machine
learning,
algorithms
and
the
usage
of
you
know
whether
you're
going
out
to
the
GPU
or
not
all
that
stuff
is
is
hogging
the
CPU
as
it
you
know,
shoves
things
in
and
out
of
memory
of
the
GPU
or
whatever
right.
A
So
the
nice
thing
about
Whipple
rabbit
is
that
we
can
launch
it
as
a
sub
process,
and
then
we
can
feed
the
data
in
through
its
standard
input
and
that
way
it
will
run
in
a
separate.
It
will
run
in
a
separate
process
which
is
even
better
than
a
separate
thread,
because
python
has
that
thing
called
the
Glo.
So
python
has
this
thing
called
the
global
interpreter:
Lock
And.
A
A
You
have
to
jump
through
a
bunch
of
Hoops,
and
so,
if
we
start
a
sub
process-
and
we
just
feed
the
data
in
async,
we
can
asynchronously
feed
the
data
into
the
sub
process,
which
is
you
know
we
like
that,
because
we're
asynchronously
reading
the
data
from
various
sources,
so
it
would
be
very
cool
if
we
could
figure
out
how
to
do
this
using
their
command
line.
Client
so
basically
call
out
using
the
sub
process,
the
various
subprocess
that
it
commands
an
async
IO.
So,
let's
see
in.
A
Operation,
okay,
so
these
guys
are
examples
of
that
in
the
should
I
example
program
that
we
create.
We
do
this
async
IO
create
sub
process
exec
and
actually
in
the
get
features
too,
but
we
basically
just
we-
it
creates
a
sub
process,
and
then
we
use.
A
We
say
that
we
want
to
use
pipes,
Unix
pipes,
to
communicate
with
it,
and
so
then
we
can
read
and
write
data
from
those
pipes,
and
so
what
we'll
end
up
doing
here
is
basically
doing
that
async,
4,
repo
and
repos
and
then
STD
in
dot
right
and
then
you
know,
whatever
the
format
is
that
the
repo
data
should
be
in
to
that
sub
process.
And
this
way
we
can
we,
we
sidestepped
a
global
interpreter
lock
by
writing.
A
We
make
it,
we
make
it,
we
take
a
CPU
bound
problem
and
we
make
it
into
an
IBO.
I
o
bound
problem
again,
and
so
this
will
be
very
cool,
because
you
could
run
multiple
machine
learning
models
without
blocking
the
main
thread
and
without
having
to
do
funky
tricks
with
memory
and
things
like
that
to
get
the
data
into
the
model
in
another
thread.
A
While
reading
from
the
main
thread
and
things
like
that,
eventually
we'll
figure
that
stuff
out-
but
it's
going
to
be
it's-
it's
gonna-
be
kind
of
heavyweight
stuff
to
figure
out.
So
this
would
be
cool
to
see
to
get
this
experience
of
or
like
to
allow
users
to
have
this
experience
where
they
can
very
easily
like
they
could
be
running
multiple
models
within
one
data
flow
right
and
everything
is
still
working,
because
the
main
thread
is
not
blocked.
A
Cool
yeah
so
definitely
yeah
play
around
and
see
how
it
goes
and,
and
then
let
us
know
but
yeah
it
looks
like
you
know:
they've
got
some
sort
of
input
format,
so
we'd
basically
just
be
doing.
You
know
repo
dot
features
and
then
taking
the
features
and
converting
to
them
to
whatever
this
input
format
is.
B
And
they
have
this
contextual,
banded
reinforcement,
learning
right,
you
can
see.
So
this
has
a
quite.
It
has
a
better
python
interface
yeah.
Most
of
them
are
otherwise
they
are
like
CLI
based.
A
A
Yeah,
yeah
and
and
obviously
yeah
the
python
interface
will
be
great
too,
because
eventually,
we'll
figure
out
we'll
we'll
have
a
good
way
to
do
the
splitting
splitting
the
models
into
another
thread,
but
for
now
we'll
probably
just
want
to
do
like
it
would
be
great
if,
if
you
wanted
to
start
adding
a
new
model
from
a
new
framework
to
do
this
to
do
this
with
the
python
stuff.
And
then
you
know
the
the
point
of
that
conversation
was
really
just.
A
If
you
wanted
to
try
using
the
sub
process
stuff
too,
we
could
see
how
it
works
when
it
gets
when
it
goes
async,
because
it
would
be
interesting
to
see
see
what
happens
from
the
data
flow
perspective,
where
we've
got
like
a
bunch
of
these
models,
making
predictions
at
the
same
time
or
something
it'll
just
be
it'll,
be
fun
to
watch
right.
A
bunch
of
things
happening
at
the
same
time,
it'll
be
fun
to
watch
it'll
be
fun
to
watch
his
one
way.
A
To
put
it
it'll,
be
very
cool
and
useful
as
another
way
right,
because
if
you
have
say
like
a
bunch
of
frames,
so
so
the
other
reason
why
this
stuff
is
all
I
think
is
because
you
know
reality
is
asynchronous
right.
So
if
I
have
a
bunch
of
frames
coming
in
from
some
camera
somewhere,
I
would
like
to
or
like
from
a
bunch
of
cameras,
I'd
like
to
dispatch
all
of
them
to
some
inference
model
right
and
then
it
all.
A
The
camera
sources
come
into
the
data
flow
and
then
one
of
the
operations
is
run
the
inference,
and
then
you
know
store
that
in
SQL
database
or
something
right,
and
so,
if
we've
got
one
one
of
these
as
a
prototype
that
could
do
actually
run
this
stuff.
In
parallel,
we
could
see
all
of
those
inferences,
Just
Happening
very
fast,
and
it
would
be
it
would
be
awesome
right.
A
I
want
to
do
I.
Think
one
of
the
fun
things
that
would
be
it
would
be
fun
to
do
is
to
take
the
stuff
that
we've
been
doing
like
with
well
we'll
have
the
web
UI
right,
but
that'll
be
kind
of
just
like
focused
on
you
know,
actually
interacting
with
dfml,
just
like
the
command
line,
but
basically
it'll,
basically
just
be
a
web
UI
version
of
the
command
line.
A
Stuff
right,
where
we're
like
train,
predict
accuracy,
data
sources
and
then
set
up
data
flows,
but
it
would
be
cool
to
do
and
I
think
we
talked
about
this
before,
but
like
a
little
demo
app
where
we
basically
have
a
data
for
we,
we
take
some
input
data
like
and
we
train
a
model,
and
then
we
have
like
a
demo
app
and
I
was
thinking.
You
know
the
the
handwritten
digit
data
set
might
be
a
good
one
for
this,
where
we
could
go
and
we
could
just.
A
We
could
have
like
a
little
a
web
page
that
captures
the
video
and
every
time
you
know,
every
frame
it
converts
it
to
an
image.
So
you
can
like
hold
your
phone
over
a
piece
of
paper
with
some
digits
drawn
on
it
and
every
time
the
frame
changes
it
converts
or
it
takes
the
frame
as
an
image
sends
it
to
the
data
flow
on
the
server.
That's
running
the
prediction
for
the
NIS
data
set
and
sends
you
back
what
is
the
text
representation
of
that
digit
right?
A
So
that
would
be
a
very,
very
easy
little
demo,
app
that
we
could
do,
and
we
can
think
of
more
things
like
that
right,
but
it'll
be
it'll,
be
fun
to
put
those
sorts
of
things
together.
I
mean
we
already
got
all
the
pieces
here.
We
just
need
to
go.
Do
that
type
of
thing?
You
know
the
final
final
demo
app
sort
of
things,
but
yeah
cool,
so
yeah.
If
you
want
to
do
that,
that
would
be
that
would
be
sweet.
A
Okay,
cool
and
then
so
again
did
you
want
to
do
that?
I
mean
I,
know
I,
I
sort
of
just
threw
that
at
you,
because
you
know
I
think
I
think
that
that
would
be
an
interesting
one
for
you
to
do
you're
going
to
learn
you're
going
to
learn
some
cool
stuff
doing
this,
but
we
can.
A
Yeah,
so
this
is
going
to
be
basically
so
the
web
UI
or
the
the
so
the
web
UI
is
going
to
be
like
it's.
It's
a
react
app.
They
will
stand
up
basically
on
the
documentation
website
or
you
could
stand
it
up
yourself
somewhere,
but
you're,
basically
just
and-
and
this
is
now
is
a
good
time
for
me
to
show
this
I
guess.
A
A
So
then
what
you
would
do
is
you
would
do
the
dfml
service
Dev
HTTP,
and
you
would
do
this
Command
right
here
server
and
then
you
wouldn't
do
insecure,
but
you
know
you
would
you
would
start
it
correctly,
which
would
be
this
command?
So
you
would,
you
know,
run
that
on
some
server
or
what
you
could
even
do
is
what
this
is
going
to
be
really
fun
is,
is
so
with
Git
pod,
you
could
you
can
start
HTTP
services
or
just
any
service,
and
it
will
forward
the
port.
A
So
if
somebody
doesn't
even
have
access
to
a
machine
like
they
can
just
go
on,
get
pod
run
this
command
and
then
paste
the
URL
that
gitpod
gives
them
into
this
into
the
web
UI
here
and
they
won't
even
have
to
have
anything
set
up
locally
and
they'll.
A
Just
you
know,
be
able
to
start
using
all
of
the
stuff
that
we've
been
working
on
I,
think
that
would
be
very
cool
and
so
actually
I
think
I
already
have
that
linked,
yes,
good,
so
yeah,
then
you
just
put
in
the
URL
and
you'd
hit,
save
obviously
I
haven't
finished
doing
that
yet,
but
this
is
the
main
thing
that
needs
to
happen.
First,
like
I
was
talking
about.
This
is
what
needs
to
happen
first
before
we
can
really
start
accepting
contributions,
because
I
need
to
figure
out
how
to
propagate
this
URL.
A
Once
it's
changed
through
all
the
different
pages
so
that
they
can
make
so
that
they
make
requests
to
the
correct
back
end
when
you
change
the
backend
URL
or
set
it
from
demo
mode
to
an
actual
URL,
but
yeah
so
they'll
go
through
in
here,
and
you
know,
then
this
is
the.
This
is
the
upload
interface.
So
the
way
it's
structured
right
now-
and
this
is
where
we
need
some
feedback,
but
you've
got
your
sources.
A
You've
got
your
models,
you've
got
your
operations
and
your
data
flows
so
obviously
step
one
is
you
know
you
upload
your
data
and
then
here's
like
the
list.
For
some
reason
the
icons
aren't
working,
but
this
shows
you
the
folders
and
the
data
or
the
files
and
the
folders
and
the
none
of
the
other
Pages
work
right
now.
But
so
you
upload
your
data.
You'd
configure
your
sources,
so
you'd
say:
Okay,
I
want
a
CSV,
Source
or
I
want
a
my
SQL
source,
and
then
you,
you
know
all
the
this
is.
A
This
is
why
all
this
config
stuff
is
very
important
because
it
serializes
it
all.
It
allows
us
to
serialize
that
all
so
that
we
can
then
present
it
in
different
formats
like
the
web
UI.
So
we
can
basically
Auto
create
forms
that
will
populate
the
different
fields
of
those
config
structures,
and
so
then
you'll
be
able
to
configure
the
source
and
you'll
be
able
to.
You
know,
look
through
all
the
data
and
the
various
sources
that
you
have
configured,
then
you
go
to
the
model
page
and
you
configure
your
model.
A
You
know
you
say:
okay,
these
are
the
features
that
I
want
and
here's
the
data
source
or
here's
the
you
know,
here's
there's
here's
the
various
parameters
that
I
want
number
of
epics
and
number
of
steps,
and
things
like
that,
like
we've,
been
doing
on
the
command
line,
you
want
to
train
the
model,
then
you're
going
to
say:
okay,
here's
the
model
that
I
want
to
use
that
I've
configured
and
here's
the
sources
that
I
want
to
use
that
I've
configured
all
the
same
stuff
will
just
you
know,
we'll
have
an
icui
for
it
and
then,
of
course,
the
operations
and
the
data
flows.
A
This
is
going
to
be
a
little
more
complicated
to
make
uis
for,
but
there
was
this
pretty
cool.
Let's
see
this
Library,
which
I
think
is
going
to
be
really
nice
for
making
the
the
the
data
flow
stuff.
So
this
this
looks
awesome
and
it
looks
kind
of
like
there's
some
similar
products
out
there
that
somebody
demoed
this
of
or
like
created
this
as
an
example
of,
but
they
don't
do
they
they
do
sort
of
like
things
that
are
not
what
we're
doing.
A
But
ours
is
very
generic
right,
so
we
can
we'll
end
up
doing
whatever
at
some
point,
but
so
yeah.
The
idea
would
be.
These
would
be
the
operations
right
and
then
you
click
on
it.
They've
already
got
most
of
the
code
right,
so
this
is
great.
We
can
pretty
much
just
go
and
start
using
their
thing,
but
yeah.
So
this
is
this
will
be
helpful.
We
can
probably
hopefully
embed
this
somewhere
right
within
the
data
flow
creation,
but
yeah.
A
So
that's
what
the
web
UI
is
shaping
up
to
look
like
and
as
soon
as
I
figure
out
how
to
do
that.
Setting
the
the
back
end,
we'll
be
ready
to
go
for
everybody
to
just
jump
on
different
parts
of
this
and
start
start
working
on
it.
If
you,
if
you
want
to
do
JavaScript,
if
that's,
if
that's
your
thing
or
other
people,
I'm
sure
that
that
that
don't
know
how
to
do
python
but
want
to
be
involved
in
the
JavaScript
side
of
things
they
might
jump
on
this.
A
But
I
think
this
is
going
to
be
really
cool
because
you
know
this
makes
it
so
that
people
who
don't
we
could
even
have
something
where
it's
like.
Hey.
You
know,
stand
this
up
on
your
Google
Google
compute
gives
free
server
list
I.
Think
you
get
a
million
free
serverless
calls
just
just
per
year,
so
we
could
set
something
up
so
like
it
would
work.
A
A
I
think
that
We've
made
a
lot
of
good
progress
here
in
the
past
few
months
too,
and
so
so
getting
getting
getting
people
a
little
bit
more
of
a
flashy
flashy
marketing
type
things
will
will
help
I've
been
talking
to
some
people,
and
they
said
you
know.
If,
if
I
can
come
up
with
some
marketing
materials,
they
can
start
helping
helping
like
get
the
word
out
more
so
I
might
be
trying
to
come
up
with
some
marketing
materials
and
things,
but
you
know
that
usually
involves
sort
of
screenshots
right.
A
So
that's
why
I'm
trying
to
get
the
UI
going?
So
hopefully
we
get
some
more
traffic,
more
stars,
more
people
using
this,
obviously
because
it's
helpful
so
but
yeah.
That's
where
that's,
where
things
are
at
with
me
and
yeah
any
questions
on
any
of
that
or
any
questions
for
me
or
anything
else.
B
A
B
Yeah
John,
so
the
I
ran
the
scripts
Slash
docs.sh.
But
then
again
it's
it's
saying
like
it
needs
to
local
changes
to
the
following
files
would
be
overwritten
by
checkout
and
it's
listing
the
files
that
got
changed.
B
Did
you
push
up
those
changes?
Yeah
I
did,
let's
see.
B
A
A
B
The
by
the
gift
pod
file,
but
Dev.
A
Mean
try
running
the
service
Dev
install
command,
see.
The
thing
is
the
reason
why
I
told
you
not
to
run.
That
is
because,
when
gitpod
starts
up
it's
supposed
to
do
this
command
here
the
service
Dev
install,
which
should
have
gotten
everything
right.
It's
it
did
we
shouldn't
what's
What's
Happening
Here
is
when
you
generated
the
docs,
some
of
the
plugins
were
not
and
were
not
discovered,
which
means
they
were
not
installed.
A
So
somehow,
somehow
the
installation
got
wiped
out
for
some
of
the
plugins,
which
is
odd,
but
you
know
it
just
happens.
Sometimes
it's
yeah,
especially
if
you
do
like
get
clean
or
things
like
it'll
just
get
messed
up
so
yeah
I
would
try
that
service,
Dev
install
command
and
then
re-run
the
doc
script
make
sure
the
only
one
that
changed
is
that
operations
and,
if
not,
then
I
can
pull
it
down
and
go
from
there,
but
I
think.
B
Oh,
this
is
not
the
right
one.
Let's
see
were
there.
Anything
else
here.
I
think
is
the
you
are
the
URL
isn't
used
anywhere?
Is
it
yeah,
so
I
think
that's
fine,
then
I
think
it
should
be.
A
A
A
B
A
A
Yes,
yes,
I
understand,
I,
understand
yeah,
that's
been
me.
I've
I've
been
pulled
on
to
other
things
at
the
moment
and
so
I'm
like
trying
to
do
this
in
my
free
time
as
much
as
I
can
or
well.
I've
always
been
trying
to
do
this
in
my
free
time,
but
you
know
I,
unfortunately,
haven't
had
as
much
time
at
work,
but
I'm
hoping
I
can
get
some
more
solid
back
in
here.
A
B
A
B
That's
the
one
we
were
just
doing.
Let's
see,
let's
see,
let's
see.
B
A
One's
done,
I'll
think
about
it,
because
there's
a
lot
here
and
I'm
I'm
trying
to
figure
out
which
ones
are.
Oh,
this
might
be
good.
Actually
this
one
we
remember
when
we
did
all
the
late.
We
added
the
labels
to
the
sources.
Yeah
I,
remember:
gash,
said
you
know:
label
has
machine
learning,
meetings
meanings
we
should
we
should
change
it
to
tag.
B
A
B
B
Can
you
explain
a
bit
on
I
like
what
you
do?
Oh.
A
I'm,
sorry,
that's
right:
I
had
a
feeling.
I
was
getting
sidetracked
there.
Okay
I
knew
there
was
I
was
like
I
went.
I
came
to
explain
this
for
some
reason:
okay,
so
the
deal
with
that
one
is
that
the
so.
This
is
the
okay,
so
I
don't
know.
I'm
just
gonna
give
you
guys
a
brief
overview
of
how
of
how
website
stuff
works.
A
Just
in
case
you
are
familiar
so
the
way
that
most
web
uiser
there's
there's
a
couple
ways
to
write
websites
right.
You
can
write
like
if
you're
familiar
with
PHP
or
Django,
or
things
like
that.
Those
are
Frameworks
where
the
UI
and
the
back
end
are
very
tightly
coupled
together
and
then
there's
and
and
that
was
sort
of
like
historically
up
until
a
few
years
ago.
The
way
that
most
people
were
writing
well,
probably
up
about
like
until
seven
years
ago,
is
like
when
it
really
started
to
switch
over.
A
End
is
very
tightly
coupled
with
the
front
end
code
and
the
front
end
would
be
everything
that
you
see
and
runs
in
JavaScript
on
your
browser
and
the
back
end
is
whatever's
running
on
the
server
and
recently
there's
been
this
shift
to
where
what
we
want
to
do
is
we
want
to
create
these
like
static
websites
that
you
could
deploy
anywhere
and
then
have
the
and
have
the
backend
code
be
entirely
decoupled,
and
what
that
allows
you
to
do?
Is
you
define
some
sort
of
like
you
know
you,
you
pick
some
definition.
A
You
stick
to
it
for
the
back
end
right,
some
sort
of
scheme
that
the
front
end
is
going
to
communicate
with
the
back
end
over,
and
this
is
where
things
like
rest
and-
and
you
like
rest
in
the
open,
API
definitions
came
from.
Was
people
try
to
standardize
what
what
are
these
you
know?
How
should
we
write
it
back
end
and
how
do
we
make
it
clear
like
what
does
the
back
end
do
so
that
it
can
be
exposed
to
to
the
front
end,
and
you
can
swap
out
the
front
encode?
A
I
could
easily
do
that
as
long
as
I
implement
the
same
interface
on
the
back
end,
you're
not
tied
to
any
one
particular
framework
like
you
previously
had
been
with
these
tightly
coupled
back-end
front
end
designs,
so
that's
that's
the
way
that
that
our
HTTP
service
works
and
our
web
UI
works
is
we
have
the
web.
Ui
is
a
react.
Application
and
reacts
is
a
very
popular
JavaScript
framework
by
Facebook,
and
so
basically,
what
we're
doing
is
this
is
just
you
know.
A
This
is
just
a
dumb
website
like
it
doesn't
know
how
to
do
anything
it
it
can't.
You
know.
Eventually,
we
could
actually
use
tensorflow.js
and
stuff
and
do
some
stuff
in
the
browser
here,
but
right
now
it
doesn't
do
anything
really
right
like
it.
Just
all
it
knows
how
to
do
is
be
the
display
for
whatever
the
HTTP
service
does
right
and
the
HTTP
service
is
the
thing
that
actually
interacts
with
all
the
code.
A
You
know,
that's
that's
that
Imports
dffml
and
the
dfml
plugins
and
actually
runs
them
just
like
the
command
line,
application
does
or
the
command
line
interface
does.
And
so
what
we
need
to
do
here
is
we're
we're
exposing
we're
just
exposing
all
of
the
routes
that
we
put
in
the
HTTP
API,
which
is
basically
all
of
all
of
these
URL
paths
end
up
with
like
their
own
page
and
so
right
now.
The
authentication
model
for
and
the
security
for,
the
HTTP
API
is
pretty
it's
very
basic.
A
Stuff
basic
is
in
it's,
it's
not
very
usable
by
a
wide
audience
like
it's,
it's
it's
kind
of
complicated
how
it
actually
works,
but
but
it's
basic
in
it's,
it's
not
something
that
you
would
ever
see
anywhere,
and
so
the
thing
is
that
https
is
commonly
so
https
used
to
mean
SSL
and
now
we've
moved
off
SSL
to
TLS
and
that's
just
sort
of
like
the
underlying
encryption
transport
layer
protocol
that
we
use
TLS
stands
for.
Ssl
stands
for
socket.
What
was
it
like?
A
A
Right
here
is,
is
what
you're
seeing,
and
so
you
have
the
certificate
of
the
website
and
the
certificate
is
signed
by
some
Authority
like
digicert,
and
so
people
pay
these
as
authorities
or
you
can
use
let's
encrypt
to
issue
them
a
certificate
for
their
website
and
then
the
certificate
authorities
pay
people
like
Microsoft
or
Chrome
Google
to
add
their
root
certificate,
which
is
the
certificate
that
signs
the
other
certificates.
A
So,
basically,
you
generate
your
certificate
for
GitHub
and
you
say:
hey
certificate
Authority
like
could
you
please
sign
this
to
say:
I'm
really,
GitHub
and
they're,
like
okay,
you're,
really
GitHub
like
I'll,
give
you
that
certificate,
but
we
don't
want
to
deploy
every
single
website
certificate
to
every
single
computer.
A
So
what
we
do
is
we
trust
only
the
the
root
certificates,
the
which
are
things
like
verisign
and
digikey,
and
let's
encrypt-
and
we
so
we
add
their
certificates
to
everybody's
computers
and
that
way,
if
someone's
certificate
is
signed
by
one
of
the
main
certificates
that
exists
out
there,
that
is
installed
on
our
computer,
then
we
trust
their
certificate.
So
we
basically
like
we
trust
them
by
proxy,
because
someone
else
trusts
them.
We
trust
whoever
trusts
them,
and
so
that's
currently
the
way
the
web
UI
works.
A
Is
we
create
one
of
these
certificates
and
we
just
use
that
one
that
we
it's
called
self-signing.
So
we
sign
our
own
certificate
because
we're-
and-
and
if
you
wanted
to
then
have
this
actually
show
up
as
like
a
green
check
mark
or
a
green,
you
know
lock
in
the
browser
you'd
have
to
install
that
certificate
to
your
computer,
but
without
without
the
green
or
without
installing
it.
You
have
to
basically
manually
specify
kind
of
like.
A
What's
what
we're
doing
here
is
we're
manually
specifying
this
is
the
the
ca
that
I
trust
the
certificate
Authority,
which
is
those
people
like
verisign
and
those
people
who
sign
other
people's
certificates
right.
So
we
generated
that
one
and
so
we're
going
to
specify
manually,
because
we
don't
want
to
add
it
it's
too
complicated
to
add
it
to
the
system,
trust
store.
A
And
then
the
other
thing
that
we
can
do
with
these
CA
certificates
is
that
we
can.
We
can
do
what's
called
Mutual
or
TLS
client,
auth
or
like
Mutual,
or
it's
not
really
Mutual,
but
client
auth
basically
means
that.
So
the
way
that
it
works
is
that
you,
the
client,
verifies
the
identity,
the
identity
of
the
server.
By
checking.
A
If
it's,
you
know,
if
it
has
one
of
those
root,
Cas
that
that
it
trusts
in
its
in
its
store
locally
right,
and
so
here's
that's
where
why
we
specified
this
one,
because
we're
saying
this
is
your
local
store
that
you
should
look
at
for
trust
and
it's
we
just
give
the
one
that
we
we
generated
right
and
self-signed,
and
now
what
you
can
also
do
is
you
can
say,
hey
server
when
a
client
can
let
connects
I
want
you
to
make
sure
that
the
client
also
provides
you
with
a
certificate,
and
so
the
server
can
verify
the
client
certificate,
and
so
that's
that's.
A
What
we
do
here
is
we're.
We've
we've
done
this
very
naive
method
of
of
authentication.
Just
by
saying,
okay,
everybody
who
wants
to
connect
to
the
server
when
it's
in
Secure
mode
has
to
have
one
of
these
client
certificates,
so
the
client
verifies
the
server
check,
and
now
the
server
has
to
verify
the
client,
because
or
else
you
know,
anybody
can
connect
to
anything,
and
this
is
about
to
run
a
bunch
of
arbitrary.
You
know
data
flows
or
machine
learning,
commands
or
pull
from
various
data
sources,
and
you
don't
want
that
stuff
to
be.
A
You
know
run
by
anybody
on
the
internet.
You.
You
really
need
to
be
authenticated
for
that
right
if
you're
going
to
stand
this
up
on
some
public
server,
and
so
this
is
all
well
and
good
right.
A
But
the
thing
is:
that's
not
very
usable,
because
now
everybody
who
connects
to
my
server
needs
one
of
these
client
keys,
so
I
have
to
generate
if
I
have
any
friends
who
want
to
go.
Look
at
my
models
or,
like
you
know,
run
a
quick
thing
on
my
server
that
I
have
stood
up.
I
need
to
go,
generate
them
a
key
and
give
them
that
key
right.
A
These
client.pam
and
client.key
I
need
to
go,
give
them
those
things
and
then
they
have
to
install
them,
or
they
also
have
to
install
the
root
C8
of
their
server
so
that
their
machine
trusts
it
and
yada
yada.
It's
a
huge
pain
right,
so
it
works
okay
for
development
or,
if
you're
doing
one-off
stuff.
But
you
know
where
we're
going
where
we're
trying
to
make
this
stuff
super
usable.
It's
not
it's
not
going
to
be
great
right.
We
need
Super
usable,
so
we're
going
for
here
is
basically
I.
B
Real
quick
here,
the
deepsource.io,
so
let's
see.
A
What
we're
going
to
try
to
do
here
with
this
openid
connect
stuff?
Is
you
guys
have
probably
seen
where
you
do
like
you
go
to
start
analysis
right?
So
this
is
just
some
random
oauth
blow.
These
people
are
like
hi,
you
know
we.
We
see
that
our
well
I
guess
I'm,
already
sort
of
locked
in
here
God.
Damn
it
all
right.
A
Let
me
try
ER
well,
I
won't
be
logged
in
GitHub,
but
basically
this
is
the
kind
of
thing
where
it's
like
sign
in
with
Google
or
connect
with
GitHub
right
and
then
it'll.
Redirect
you
to
GitHub
and
it'll,
say:
hey
like
you
want
to
authorize
this
application
and
then
you
say
yada
yada
and
you
click
next
right
and
it
says:
okay
like
this.
A
This
application
can
now
see
your
email
address
right
and
we
are,
you
know
the
random
application
asking
GitHub
to
give
us
someone's
email
address
in
this
case
right
and
the
reason
why
we're
doing
this
is
because
we
don't
want
to
run
our
own
databases
of
usernames
and
passwords
right.
Everybody
who's
using
this
probably
has
a
GitHub
account
or
a
Google
account
or
a
Microsoft
account,
and
so
what
that
library
is
going
to
let
us
do
is
leverage
the
fact
that
other
people
have
accounts
other
places.
A
So
so
what
we
can
do
is
just
say:
hey
like.
Can
you
just?
Let
us
know
that
you
do
have
an
account
somewhere
so
that
we
can
differentiate
you
from
other
people
right
and
this
then,
and
that
way
what
it'll
do
is
it'll,
redirect
them
to
that
sign
in
page
or
authorization
page,
and
they
say,
hey
and
Google,
says
Hey
like
do
you
want
to
give
this
application
permission
to
view
your
email
address?
They
say
yes
and
we
then
say:
okay,
like
we
know
you
are
someone
with
an
email
address
right.
A
We
can
now
let
you
do
XYZ
right.
So
so,
if
you
maybe
stand
up
the
server-
and
you
say
only
let
email
address
blank
connect
right.
You
know
like
Ogden,
gmail.com
and
and
then,
if
they
go
through
the
authentication
flow
and
they
choose
Google
and
it
says
okay,
this
is
you
know
this.
This
is
Bill,
gmail.com,
you're,
gonna,
say:
hey,
that's
not.
You
know,
Google
didn't
Google,
Google,
didn't,
say
your
login
gmail.com,
so
I'm
not
going
to
let
you
in
right.
A
If
Google
said
you
were
Ogden
gmail.com,
then
all
right,
everything's,
fine,
you
can
use
the
web
UI
or
the
HTTP
service,
which
will
you
know,
be
the
one
that
accepts
this
token.
So
does
that
kind
of
make
sense,
yeah,
there's
a
lot
of
information.
I'm,
sorry.
A
Yeah,
basically
the
idea
is,
they
will
say
you
know
we
just
need
somebody
to
manage
accounts
for
us
right,
because
we
don't
want
to
store
usernames
and
passwords.
Other
people
store
usernames
passwords
you
get
into
that.
It's
a
mess.
Also
it's
nice
because
you
can
now
integrate
with
with
corporate
like.
If
you
have
some
sort
of
internal
corporate
service
or
right
you're
running
some
external
service,
everybody,
everybody
standing
up
their
own
username
and
password
databases
means
you
know
somebody
can
go
steal,
everybody's
username
and
password
databases
right.
A
You
want
to
keep
those
the
things
that
store,
usernames
and
passwords
do
a
good
job.
Let's
let
them
do
it
right
and
that's
the
point
of
the
oauth
2
and
open
ID
connect
and
all
that
it's
basically
delegate
delegate
the
login
style
stuff
to
you
know
things
that
are
meant
to
do.
Login.
We
don't
need
to
write
an
application
to
do
that.
A
It's
not
hard
to
do
that.
It's
not
hard
to
Hash,
passwords
and
stuff
and
accept
them.
It
just
means
that
you
know
now.
You
need
another
account
for
another
service
right
and
you
already
have
things
to
do
that.
It's
let's!
Let's
not
mess
with
it
right
so
from
the
perspective
of
like
okay,
what
do
you
do
with
this
information?
B
All
right
so
you'll
want
to
add
the
Callback
route.
A
Here
so
this
is
the
list
of
roots
which
basically
just
Maps
the
URL
to
a
method
right
and
what
you'll
do
is
you'll.
Take
you'll
you'll,
implement
you'll
figure
out
how
that
stuff
works.
You'll
start
the
HTTP
server
right
and
you'll
have
added
your
you.
You
need
to
add
a
function
that
is
similar
to
the
rest
of
these
functions
here
and
you
don't
want
to
decorate
it
with,
like
the
model
context,
fruit
and
stuff
like
that.
Obviously,
because
it's
not
a
model
context
thing,
but
you
know
something
like
something
like
the
upload.
A
A
So
basically
you
copy
the
structure
of
one
of
these
methods.
You
add
the
URL
path
that
the
method
should
be
accessible
at
to
the
to
the
list
of
of
URLs,
and
then
you
figure
out
what
you
need
to
do.
Is
you
need
to
figure
out?
How
do
we.
B
A
B
The
key
is:
how
do
we
figure
out,
where
is
that
issue
I
just
had
it
all
right,
whatever
the
key
is,
how
do
we
use
these.
A
B
We
will
accept,
let's
see
where
it
is
Aussie
callback,
GitHub,
but
I
think
this
is
what
it
is.
A
Basically,
this
is
our
base.
Url
would
be
our
server
right
and
then
this
is
the
path
that
we
register
at
our
that
method,
that
you're
going
to
write
right
and
so
once
when
we
send
the
we.
Basically,
we
take
the
user
and
we'd
redirect
them
to
some
URL
for
GitHub
right
and
then,
when
GitHub,
when
GitHub.
When
we
finish
the
the
like
confirm
when
we,
we
click
the
authorize
button
or
whatever,
on
the
GitHub
website,
we
we
have
provided
some
callback
URL
and
let
me
see
if
that
deep
Source.
B
A
App
yeah
I'm,
not
really
sure
I,
don't
have
a
good
demo
for
you
right
now,
but
I'm
sure
you'll
see
something
kind.
B
Of
a
token
or
code,
what
you
get
a
kind
of
a
token
or
some
code,
yeah.
A
Basically,
basically
it
you,
you
say
you
know,
GitHub
oauth,
authorize
and
then
you,
you
know,
like
question,
mark
callback,
URL
equals
and
then
URL
to
your
server
right
and
then
and
obviously
that
can't
be
localhost.
You're
gonna
have
to
do
some
port
forwarding
or
this
might
be
like
get
pod
or
something,
but
you
also,
you
know
you
also
don't
have
to
mess
with
this
issue.
If
you
don't
want
to,
this
is
just
something
that
would
be.
It
will
be
very
cool
so
and
then,
and
then
what
GitHub
will
do
is
it'll.
A
Take
that
URL
that
it's
supposed
to
redirect
you
back
to
or
be
there
the
one
that
it's
supposed
to
call
when
it's
done
authorizing
it's
going
to
make
the
request
to
that
URL
and
provide
that
URL
with
some
information
about
the
user.
I
believe
that's
the
flow.
If
I
remember
correctly,
and
then
you
take
that-
and
you
say:
okay,
like
the
user
was
authenticated
by
GitHub.
I
can
use
that
token
for
them.
So
GitHub
will
give
you
some
token,
and
you
say
all
right
now.
This
is
I.
I.
A
But
but
if
you
want
to
dive
into
this
you'll
figure
out
more
like
it'll,
become
sort
of
apparent
I
imagine
it
will
still
be
confusing,
but
yeah,
that's
something
that
needs
to
happen
so
that
we
can
sort
of
like
not
deploy
these
these
these
certificates,
in
the
way
that,
in
the
way
that
we're
doing
we
really
just
want
to
have
like,
let's
encrypt
somebody
grab
their
certificate
from
let's
encrypt,
which
is
a
free,
TLS
certificate
provider.
A
B
Let's
see,
let's
see
yeah
I
think
that's
I.
Think.
A
Yeah
I
think
that's
really
all
I
have
to
say
about
that
right
now,
but
of
course
like
this
is
kind
of
like
this
is
going
to
be
an
it
in
the
weeds
issue.
It
it
won't.
Be
quick
it'll,
be
a
lot
of
learning
you're
going
to
learn
a
lot
of
very
important
stuff.
If
you
want
to
do
it
stuff
that
you'll
probably
use
for
a
while,
but
but
you
know
it's
not
going
to
be
easy.
A
A
Cool
cool,
yeah,
I
kind
of
think
it
might
take
a
while,
just
but
but
yeah
if,
if
it
it
it's
basically
just
like
the
the
tricky
part
is
going
to
be
learning.
A
How
does
that
flow
work
and
how
do
I
actually
use
that
flow
to
do
something
right
and
how
do
I
integrate
it
with
the
with
the
the
HTTP
service
that
exists
right
and
then
other
other
things
other
than
that
is,
let's
see
well,
I'd
have
to
think
about
it,
and,
of
course
you
always
you
guys
know
how
to
how
to
do
the
sort
by
have
you
guys
used
this
to
find
issues.
Has
this
been
helpful?
The
like
medium
time
to
complete
and
stuff
like
that.
B
A
That's
true,
okay,
yeah,
so
it's
always
easy
to
find
things.
That's
that's
good.
All
right,
yeah,
I,
just
I
think
this
is
probably
more
helpful
for
people
who
are
just
jumping
onto
the
project,
but
I
also
haven't
really
noticed
any
of
the
people
that
I
told
us
about
stick
around
so
I,
don't
know
we'll
see,
I'm
gonna
keep
doing
it
and
if
you
guys
add
issues
I,
don't
know
if
you
have
permission
set
labels
too,
but
you
can
always
just
tell
me
and
I'll
I'll.
Add
the
label
to
it.
B
A
A
Oh
okay,
this
is
this
is
something
that
that
was
gotcha.
That
happened
in
the
in
the
contributing
documentation
a
few
months
ago,
Justin
Cott,
the
dash
e,
has
to
go,
be
the
the
argument
that
it's
directly
in
front
of
the
path
that
you
want
to
install.
A
B
Okay
sure
I'll
do
that
and
then
I'll
do
this
we'll
see
if
we
can
yeah
I'll
just
do
that
or
let's
see
if
plugin
equals
export
plug-in
equals
model.
Tensorflow
scp-I.
A
All
right,
hopefully
that
will
fix
things
here,
if
not
I,
think
I
think
that
should
be
the
problem.
So
hopefully
we
get
that
tensorflow
stuff
fixing
all
right
thanks
guys
and
just
of
course
always
on
getter.
If
there's
anything
else
and
I'll
talk
to
you
guys
next
week.