►
From YouTube: Jupyter Community Call - September 2019
Description
Recording from Jupyter Community Call in September 2019.
The notes from this call can be found here:
https://jupyter.readthedocs.io/en/latest/community/community-call-notes/2019-september.html
Read more about these calls on Discourse:
https://discourse.jupyter.org/t/jupyter-community-calls/668
A
Alright,
hello,
everybody
welcome
to
our
September
Jupiter
community
call
thanks
for
everyone
who
came
and
yeah
so
we'll
just
go
ahead
and
get
started
here.
I
think
we
have
a
few
things
on
the
agenda.
So
just
a
reminder:
we
do
these.
Every
month,
the
last
Tuesday
of
the
month,
9
a.m.
Pacific
and
yeah
anyone
can
join.
A
Anybody
can
present
whatever
they
like
something
somewhat
related
to
the
Jupiter
ecosystem
in
space.
It's
just
an
opportunity
to
pitch
fun.
Things
you've
been
doing
think
about
it
like
a
like
a
virtual
Jupiter
con,
and
so
we
just
been
doing
these
10
minute
flash
talks
where
you
just
share
something
that
you've
been
working
on
through
some
sort
of
interactive
demo
and
then
any
short
reports
you
might
have.
So
let's
go
ahead
and
get
into
the
main
agenda
on
our
short
reports
and
celebration.
B
Yeah
sure
I
thought
that
this
was
awesome
just
a
short
little
post
and
it
kind
of
goes
a
lot
along
with
what
you
were
just
talking
about,
Zach
being
able
to
run
that
second
notebook
server.
So
it
looks
like
and
I
think
Nick
can
even
speak
to
this
a
little
bit
more
because
he
definitely
influenced
it.
But
this
is
Matt
Rockland
talking
about
how
to
spin
up
notebook
apps
using
desk,
which
I
thought
was
a
kind
of
cool
idea.
B
A
C
Felon
Philip
by
the
name
of
crest
crest
Chris
Kowski
on
on
github,
has
been
pushing
that
forward
with
a
integration
of
language
server
protocol
into
Jupiter
lab
and
we've
been
reaching
out
to
some
other
people
in
the
community
and
doing
some
work
there.
It's
it's
going
pretty
well,
so
I
think
there's
there's
definitely
some
future
there.
You
know.
A
A
B
Cool
cool
cool,
all
right,
let
me
just
check
and
see
if
we
may
binder
happy
well
anyway,
there
might
be
a
binder
for
my
talk
at
some
point,
but
let's
see
so,
if
we
go
to
the
heck
md,
I've
got
two
links
for
you.
All.
One
of
them
is
a
post
to
gist
that
I'll
be
giving
this
presentation
from
and
then
import
and
be
has
a
link
itself.
B
So
let
me
tell
you
a
little
bit
more
about
import
and
be
so,
let's
restart
this
kernel,
so
I
can
run
it
for
you
and
I'm,
not
a
liar
as
we
move
along.
So
why
import
and
be
so
first
of
all
import
and
be
isn't
wasn't
designed
as
a
tool
so
much
as
it
was
designed
to
make
better
notebooks
so
import
and
be
teaches
reproducible
habits.
If
your
notebook
can
be
imported
as
a
module,
then
it
likely
will
restart
all
so
by
reusing
notebooks.
B
You
start
to
put
an
extra
verification
layer
on
your
notebooks
and
as
a
result
of
using
import
and
be
instead
of
making
really
long
increasingly
complex,
nonlinear
notebooks.
What
we're
able
to
do
is
we're
able
to
split
them
up
into
different
places
and
reuse
them
at
different
levels.
It
also
talks
about
how
notebooks
can
be
used
as
applications
and
then
what
we
can
start
to
see
is
that
this
concept
of
restart
run
all
really
starts
to
see
notebooks
as
units
of
testing,
so
import
MB
is
a
Python
package.
You
can
get
it
on
pip.
B
So,
let's
see
it's
a
tip,
install
import
and
be
I
hope
it
works.
Please
send
any
issues
my
way,
and
this
we've
been
using
this.
It's
probably
one
of
the
core
pieces
of
the
deathbeds
organization
for
a
long
time.
We
use
it
in
practice
and
we
also
use
it
in
application
for
testing
and
data
science
work.
So
let
me
tell
you
the
story
of
import
and
B.
So
what
we're
going
to
do
here
is
we're
gonna,
we're
gonna
write
a
little
notebook.
Basically
we're
just
gonna
make
a
notebook
with
a
code
cell.
B
It's
got
foo
in
it
and
when
we,
if
we
try
and
do
import
demo,
we've
called
the
notebook
demo,
I
pi
mb,
nothing
happens,
we
get
a
module
error,
and
so,
when
I'm
writing
notebook,
sometimes
I
want
to
leave
errors
in
the
notebook.
This
is
a
way
to
do
it
by
just
sort
of
inlining
PI
tests.
So
now
it
says:
hey
I
can't
import
demo.
So
what
if
I
go
and
import
it
now
with
import
and
B?
B
So
now
we
have
this
context
manager
that
has
replaced
our
system
require
our
system
hooks
and
we
can
import
notebooks
and
they
work
as
Python
files.
If
I
go
to
demo
boo,
the
value
is
10
and
that's
kind
of
the
simplest
proof
that
we
have
here
for
this
problem.
So
now,
let's
say:
I
go
up
and
I
change
my
file
and
I
try
to
import
it
again.
B
Nothing,
nothing
happens
same
thing
down
here,
that's
important!
Yet
again,
nothing
happens.
So
the
question
somebody
might
raise
now
is
our
notebooks
reloadable,
so
I'm,
just
gonna,
so
in
import
and
be
reload,
is
just
the
standard.
Python
reload
operator,
I
just
put
it
on
the
module.
So
it's
a
little
bit
more
reusable
and
if
I
run
this
basically
what's
happening,
is
I'm.
Definitely
raising
a
module,
not
found
error,
otherwise
I
would
have
gotten
in
some
trouble
just
to
prove
it
to
you
all,
I,
that's
how
that
works.
B
So
now,
what
are
we
gonna?
Do
we're
gonna
change
our
notebook
and
then
we're
gonna
use
import
and
be
reload
inside
of
the
context
manager.
So
every
time
I
run
this.
We
still
get
our
printouts
here,
so
the
import,
MB
infrastructure
does
indeed
work
with
reload,
so
we
can
use
import
and
be
in
packages.
So
JSON
schema
is
a
notebook
in
a
package
somewhere
and
I
can
use
relative
imports,
and
as
long
as
in
my
init
that
PI
I
call
import
MB,
it
makes
it
possible
to
transparently
use
notebooks
as
Python
modules
inside
your
code.
B
Sometimes,
what
we'll
do
is
we'll
make
notebooks
that
have
a
load
extension
feature
to
them,
so
maybe
we're
making
ipython
extensions
so
inside
of
a
function
inside
of
our
context,
manager,
we'll
relatively
import
some
things
and
then
we'll
call
their
load
extension
functions,
so
I
mean
import
and
be
really
has
your
notebook
working
as
any
other
Python
module.
The
only
thing
that's
different
is
how
we
develop
it
right
when
we're
working
in
a
Python
application.
We
usually
have
named
the
thing,
but
notebooks
our
name
is
always
main
to
start
with.
B
So
what
we
find
often
times
is
when
we're
working
with
notebooks.
We
have
this,
if
name
equals
main
condition
to
say:
hey
I
only
want
to
do
this
if
I'm
running
in
the
notebook
or
I
can
only
do
this
if
I'm
running
in
a
module
and
there's
a
little
post
in
here.
That
kind
of
goes
on
to
describe
some
of
the
reasons
about
why
name
equals
main
is
important,
so
some
of
you
may
be
asking
what
does
import
and
B
do
so
inside
of
the
sistex?
B
We've
got
some
loader
details
and
this
is
the
information
that
Python
uses
hey
for
a
pie
file.
This
is
that
this
is
this:
the
loader
that
I
use.
If
I
call
this
same
expression
inside
of
a
context
manager.
We
can
see
that
my
loader
details
have
changed
and
now
import
and
be
notebook
loader
is
there
with
some
extra
options
to
it,
and
that
is
responsible
for
I,
PI
and
B
files.
So
some
things
about
notebooks
oftentimes.
B
We
don't
name
notebooks
properly,
like,
for
example,
this
notebook
here
is
titled
as
if
it
were
a
blog
post
right.
So
we
can't
import
that
in
Python,
but
with
import
and
B.
We
can
we've
put
some
fuzzy
finding
attributes
on
here
where
one
underscore
is
a
star
two
underscores
as
a
star
star,
so
I
can
go
and
import
and
be
s.
Oh
great
cool
story,
Tony!
Oh,
this
is
what
happens
when
you
live
hack
on
your
notebook
that
you
want
to
import.
So
let's
not
worry
about
that
right
now.
B
Something
bust
is
cool,
so
we'll
get
back
to
where
we
were
burning.
That's
distracting,
let's
see
if
it
works
now
does
not
work
at
the
moment.
Maybe
because
this
is
I,
don't
know
why
it's
not
working.
It
generally.
Does
let's
ignore
this
part.
For
the
meantime,
maybe
it
works
on
binder.
So
if
that's
not
working,
this
might
not
work,
but
there
is
an
import
and
B
extension
which,
when
we
go
to
an
import
statement,
replaces
the
completer
so
that
we
can
now
go
and
find
fuzzy
names
of
things
that
we
want
to
import.
B
B
It
is
Oh
which
one
okay
I'll
fix,
that
in
just
a
second,
so
the
other
thing
that
we
can
do
is
we
can
use
the
import
notebook
context
manager
to
create
loaders
for
other
files.
In
this
example,
we're
loading
some
sort
of
hybrid
languages
here
and
let
me
see
if
Nick
did
not
race
so
which
one's
not
raising
import
demo.
Okay.
So
if
we
go
to
that's
the
reload
demo,
my
test
raises
import
demo
if
Nate.
So
this
is
a.
B
This
is
a
great
example
of
where
one
thing
is
true
in
the
application,
and
another
thing
is
false
in
the
module
so
now,
hopefully,
nick
has
debug
to
my
problem
in
real
time.
For
me,
which
is
great,
patience
is
key
here:
oh
no
I
deleted
all
those
cells
now
they're
back
okay.
So
now,
if
we
go
here
and
put
an
underscore,
Fuzzy's
imports
whoo
all
right,
so
our
print
statements
and
stuff
show
up.
You
know
if
we
were
to
reload
that
we
get
everything
again.
B
Every
Python
module
has
a
loader
to
it,
and
this
obscure
name
here
is
pointing
back
to
an
IP
MB
file
and
we
can
see
it
hanging
off
of
the
Syst
modules.
Another
thing
yes,
so
now
that
we
have
our
fuzzy
importing,
we
don't
have
to
use
our
context
manager
when
there
is
a,
but
when
the
extensions
loaded.
So
we
can
just
import
notebooks
as
if
they
were
modules
and
then
another
cool
trick
of
import
and
be
is
the
ability
to
we
go
and
discover
Python,
literals,
so
strings
and
integers
and
tuples.
B
B
You
want
me
to
make
an
error.
Do
you
okay,
great?
So
let
me
go
here
and
we'll
make
this
notebook
and
we'll
call
it
okra
yep,
all
right,
Knicks
in
the
room,
so
I'm
reacting
to
him
as
if
this
little
conversational,
but
it
is
indeed
not
which
one
are
we
on
here-
we're
on
this
one,
okay,
all
right!
So
now,
let's
make
a
bad
notebook
that
goes
so
this
does
something
funky
and
then
we
assert
false.
We
clearly
know
that.
B
B
So
one
of
the
problems
that
I
early
had
early
on
importing
notebooks
was
up
fixing
errors
and
it's
very
important
to
be
able
to
retain
the
line
numbers
as
we
import
these
things
and
I
really
appreciate
this
digression,
because
I
can
also
share
with
you
all
the
fact
that
oh
I
did
Oh
bad,
doesn't
import.
Does
it
what
a
bummer?
B
Okay,
so
now
we
go
over
here,
actually
maybe
we
duck
into
dual
screen
mode,
because
this
is
where
import
and
B
really
starts
to
shine,
and
now
we
go
and
do
true
and
then,
if
we
go
up
where
to
import
import,
bad
bad
now
works
and
our
dock
string
actually
becomes
the
first
markdown
cell.
So
yeah
that's
a
little
bit
about
debugging
import
and
be
notebooks
I.
A
B
Don't
know
how
what
you
would
do
with
them,
so
they
turn
into
strings
because
so
import
that
MB
convert
opinion
turns
them
into
comment
by
turning
them
into
strings
the
fur.
If
the
first
cell
is
a
markdown
cell,
then
the
first
thing
in
the
Python
module
is
a
string.
So
that
means
that
automatically
the
markdown
becomes
a
doc
string,
whereas
if
it
were
a
comment,
quite
the
Python
compiler
would
not
recognized.
B
B
See
like
you
guys,
I
have
not
followed
the
trail
of
JavaScript
I
hate,
JavaScript
I,
miss
CoffeeScript,
so
all
of
the
things
I
do
are
by
hacking,
the
ipython
shell,
so
basically
I'm
writing
something
into
the
ipython
completer.
That's
like
looking
at
what
files
are
available
with
a
specific
extension.
Oh.
B
C
And
contributions
welcome
if
you
find
things
that
don't
work
like
the
CLI
right
now,
that's
a
it's
a
really
cool
demo
when
it
works,
but
it's
not
up
today.
We're
always
looking
at
more
interesting
ways
to
use
things
and
a
longer
con
would
be.
Can
I
import
a
notebook
because
of
all
the
extra
metadata,
that's
in
another
kernel
and
get
another
kernel
type
and
can
I
get
back
a
pointer
to
an
our
kernel,
a
pointer
to
another
kernel,
and
then
what
are
the
types
look
like
between
it?
C
C
C
Don't
you
break
today?
Don't
you
break
today?
Okay,
it's
probably
not
gonna
drink
today,
yeah,
okay.
So
what
robot
lab
is
is
a
single
click
installer
for
Windows,
Linux
and
Mac.
That
gives
you
Jupiter
notebook,
jupiter
lab
nodejs
python,
selenium
firefox
gecko
driver
just
like
a
ton
of
stuff
so
that
you
can
try
out
acceptance.
C
Oh,
it's
looking
great,
and
so
what
I
got
in
here
is
this
new
folder
defaults
to
the
home
directory
because
a
lot
of
people,
if
they're
just
trying
to
try
this
stuff
for
the
first
time
they
don't
think
a
lot
about
their
paths.
But
they'll
know
what
that
looks
like
someone
make
a
new
folder
and
working
and
I
start
a
new
thing
here:
I
don't
want
PowerShell
coz
breaks
the
world.
C
So
we're
gonna
go
in
here.
It's
going
to
load
up
some
stuff,
everything's
a
little
slow
on
Windows,
the
first
time.
I,
don't
know
what
my
token
is,
so,
let's,
let's
find
out
what
my
token
is
view
page
source.
Oh
that's,
see
now
I'm
getting
stuck
on
different
things.
I'll
have
to
go
all
to
find
my
token
here
from
the
command.
C
It's
done
crazy.
Demos
like
this
knows
how
gross
this
is
all
right.
Oh,
come
on,
you
are
coming
with
me,
yep,
okay,
so
here's
my
token
and
just
loaded
up
this
thing
called
selenium
library.
This
is
the
the
robot
syntax.
This
is
all
syntax,
highlighting
that
we
built
for
especially
for
this
purpose-
and
you
know,
we've
got
some
some
fun
things
we
can
do
so
we're
going
to
load
this
in
and
robot
language
lets.
You
define
things
in
this
sort
of
hybrid
Python,
e,
English
kind
of
thing.
C
The
idea
is
to
get
to
human
readable
things
that
you
can
reuse
later,
but
you're
kind
of
free
to
do
every
blowing
away.
These
are
some
I
PI
widgets,
which
we
kind
of
get
for
free
because
of
being
built
on
top
I
played
colonel
I'm,
not
gonna
press
those
right
now,
but
they
do
exciting
things,
and
so
we're
gonna
try
this
first
task
here.
So
I'm
gonna,
open
up
Jupiter
lab
on
this
machine-
and
this
is
gonna
complain-
is
my
firewall
and
opening
a
browser
is
pretty
slow.
Anybody,
that's
done.
C
C
C
What
does
that
mean
so
we're
about
framework?
This
is
the
thing
that
I
always
am
able
to
win
people's
hearts
and
minds
with
this
is
the
chest
report
that
you
get
out
of
it,
and
so
you
get
this
beautiful
tree
of
everything
that
you
tried
to
do.
It's
like
a
you
know
like
a
profile
run,
and
you
can
see
all
your
intermediate
values
inside
of
here,
so
it
did
a
bunch
of
fun
things
like
that.
You
do
not
want
to
know
how
we
get
that
into
the
browser
for
lab
people.
C
It's
probably
a
security
hole
anyhow
moving
on,
so
we
just
opened
one
of
those.
Let's
take
a
look
thing
over
here
and
this
is
we're
gonna,
try
and
use
that
browser
that's
open
over
there.
You
saw
some
stuff
flicker,
maybe,
but
we
just
made
an
annotated
screenshot
of
where
different
things
are
on
the
browser,
and
so
that's
kind
of
hilarious.
We're
gonna
keep
going.
The
screenshots
also
show
up
inside
the
log,
which
is
fun
we're
gonna
here,
and
you
know
we're
gonna
try
and
do
this
thing
and
open
up
the
lab
examples.
C
C
It
opened
the
wrong
one
because
the
selector
is
kind
of
kind
of
janky
there,
but
I'll
get
to
that
in
a
little
bit
here
and
you
know
so
we're
collecting
up
broken
tests
and
winning
tests
and
stuff
like
that,
this
one's
totally
busted,
because
this
is
where
you
know,
folder
icon,
like
that,
doesn't
work
so
that'd
be
something
like
I
know:
data
icon
equals
the
file
manager
or
something
like
that.
I,
don't
remember,
I'd
have
to
go.
Look
at
it,
wait
a
second.
What,
if.
C
What,
if
I
just
click
down
here,
it's
a
tab
bar
tab,
mod,
what
styled
components?
I
hate
you
so
yeah,
it's
something
like
this
that
wouldn't
be
stable
between
builds,
but
there
we
are
Sonne
how
things
would
go
along
there.
We
do
crazy
stuff
and
all
kinds
of
things
like
that.
Alright,
that's
interesting
that
you
know
this.
All
this
stuff
works
locally,
it's
kind
of
fun
to
kill
this
guy
off
when
I
kill
this
off.
C
Now
it
does
something
to
the
kernel
and
it
does
some
other
things
I'm
going
to
close
this
off
too,
and
we
got
a
bunch
of
other
cool
features
in
here.
You
know
we
can
go
grab
things
from.
Oh,
that's,
just
that's
just
background
running
code.
You
know
you
can
actually
run.
Oh,
this
is
for
people
that
don't
even
know
Jupiter.
So
we
didn't.
We
didn't
worry
too
much
here.
We
go
so
this
one,
because
we've
got
the
you
know
the
xkcd
thing
this
uses
no.
This
is
this
is
not
the
robot
one.
C
You
know
what
I'm
actually
not
going
to
do
any
of
these
other
ones,
except
for
maybe
this
one.
This
is
always
kind
of
a
Hail
Mary.
So
this
is
a
Windows.
Only
setting
you
use
the
thing
called
white,
which
is
a
semi
defunct,
dotnet
running
application,
but
we're
gonna,
try
it
so
we're
gonna,
try
and
launch
notepad
looks
like
it
launched
it
kind
of
takes
a
sec,
but
I
think
it's
working.
So,
let's
see
if
this
works
yeah
yeah
Dutton.
It
always
does
that
to
me
so
yeah,
there's
probably
something
listed
in
here.
C
C
It's
such
a
good
one
attached
to
notebook
yes
put
stuff
in
there.
Oh
wait!
It
doesn't
actually
run
anything.
Yeah
I
think
it's
hanging.
Okay,
so
anyhow,
that's
a
better
demo
when
it
actually
works,
and
so
it's
got
all
the
other
stuff
under
the
hood.
You
can
make
Python
notebooks
all
that
kind
of
stuff.
We
got
some
other
freaky
examples
if
I
drop
back
into
here
and
instead
of
doing
tutorials
I
do
examples.
C
C
C
C
This
is
an
example
of
using
the
using
Python
right
in
line
this
Tony
stuff
would
be
at
home
with
this,
because
this
is
actually
hacking
things
into
a
namespace
called
vision.
Library
robot
can
now
use
that
namespace.
It
would
have
exploded
if
we
hadn't
used
that
before
and
now
we're
gonna
try
and
command
is
gonna.
Break
too.
C
C
C
Robot
kernel
is
the
thing
that
we're
just
looking
at
and
it
does
use
robot
to
test
itself
and
I've
also
made
a
Jupiter
library
that
supports
testing
Jupiter,
lab
classic
notebook
classic
and
interact.
It's
broken
right
now
because
of
the
SVG
Dom
changes,
but
yeah
yeah.
You
can
absolutely
test
extensions
with
this,
and
we've
got
that
live
on
a
couple
of
the
deathbeds
projects.
C
It's
beautiful
because
you
can
run
multiple
reports
out
at
the
end.
So
if
we
were
to
dig
into
robots
from
Jupiter
and
actually
it's
pain,
they
have
to
go,
get
it
basically
you
it
runs
it
on
multiple
operating
systems,
multiple
browsers
and
then
you
can
bring
all
those
test
reports
back
together
and
see
all
in
one
place.
You
can
do
tags
and.
D
C
Kinds
of
fun
stuff
like
that,
but
I
just
don't
have
that
available
right
now.
So
the
the
clutch
thing
on
this
is
the
ability
to
build
offline
deliverable.
You
know
sneakernet
capable
packages,
and
so
it's
you
know
this
whole
pipeline
is
not
custom
to
robot
lab.
You
could
do
this
for
anything
that
you
can
package
inside
acontece,
so
pretty
much
anything.
So
if
we
wanted
to
have
a
Jupiter
lab
standard
distribution
that
had
all
the
Jovian
widgets
in
it
and
Jupe
lab,
and
all
that
nonsense
we
could
we
could
do
that.
C
We
could
host
that
you'd
be
taking
on
things
that
normally
we
defer
to
people
like
kondeh
to
do
support
of
how
you
actually
get
your
Python
and
your
node.
But
by
the
same
token,
anybody
that
supported
a
workshop
knows
you
go
in
there
and
all
of
a
sudden
you're
overloading
the
entire
network
with
gigabytes
and
gigabytes
of
requests
if
you're
doing
anything
non
non
trivial.
So
it's
got
a
lot
of
advantages
in
that
Booker
yeah.
C
A
H
H
Excel
was
fine
when
they
had
one
excel
file
and
it
was
still
fine
when
there
were
seven
Excel
files
and
then
there
were
25,
and
then
there
were
43
and
now
there's
over
a
hundred
and
people
back
Lloyd
doing
any
would
require
them
to
go
open
the
other
99
files,
so
we
reimplemented
the
model
in
Python.
There
is
a
user
interface
originally
constructed
in
Jupiter
lab
this.
The
version
that
I'm
showing
here
is
running
in
voila,
and
so
it's
we
made
the
notebook
run.
H
H
H
The
model
has
a:
u
a
graphic
of
how
the
data
flows
through
the
model.
This
is
an
if
SVG,
we
generate
it
dynamically,
based
on
what
solution
you've
loaded,
so
the
it
starts
with
an
SVG
file
that
has
every
module
that
this
model
can
possibly
use,
and
then
it
prunes
out
the
ones
that
are
not
used
in
this
particular
solution
by
just
removing
them
from
the
XML
of
the
SVG
file.
H
This
is
another
area
that
was
somewhat
more
difficult
when
we
got
it
working
in
notebook,
because
the
IDs
we
use
this
same
SVG
in
multiple
places
than
the
IDS
would
conflict
and
they
would
fight,
and
so
we
had
it
rewrite
the
SVG
to
make
the
IDS
unique
on
each
of
these
tabs
there.
It
is
again-
and
this
time
it's
highlighting
you
are
here.
This
is
what
we
are
looking
at.
H
Things
well,
let
me
let
me
show
it.
Let
me
ask
the
question
the
when
we
first
started
working
on
this.
We
started
getting
feedback
from
the
audience
of
users.
The
audience
is
mostly
going
to
be
researchers,
that's
PhD
students,
grad
students
and
postdocs
in
various
fields,
geology,
oceanography
and
so
on
and
somewhere
less
than
half
were
familiar
with
notebook
and
those
that
were
familiar
with
notebook
had
a
and
comfortable
using
it
had
a
better
than
average
chance
of
knowing
about
get
and
knowing
about
Python.
H
But
then
that
means
that
over
half
were
not
really
comfortable
using
notebook.
So
when
we
were
in
Jupiter
lab
and
you
had
to
click
the
Run
button
over
half
of
the
potential
users
didn't
like
that
very
much
so
that
prompted
the
get
it
working
and
voila
so
that
it
will
just
render
and
we're
trying
to
make
it
possible
to
work
with
the
model
without
having
to
see
the
code
without
having
run
boxes.
H
H
It
initially
started
on
a
implementation
as
a
Jupiter
lab
extension,
but
that
doesn't
help
us
with
the
voila
interface
here
and
so
I'm,
considering
having
it
doing
it
in
the
back.
End
have
buttons
here
that
will
tell
it
to
create
a
git,
commit
and
then
upload
it
and
have
the
Python
code
do
those
operations.
Is
that
crazy?
H
H
H
G
H
G
H
Possibly
yes
and
I,
could
we
can
look
at
that,
but
like
when
we
were
going
down
the
path
of
a
Jupiter
lab
extension
that
was
going
to
look
very
different?
If
we've
made
this
set
of
decisions,
if
we
want
it
to
be
voila,
we
want
it
to
render.
Are
there
alternatives
that
can
work
in
voila
or
do
we
really
need
to
handle
this
in
the
back
end
and
the
front
end
just
displays
buttons.
C
E
Is
meant
to
not
write
to
the
disk
like
they
go
to
some
trouble
to
keep
you
from
using
a
voila
application
as
an
attack
vector?
But
if
you
built
a
server
component,
a
Jupiter
server
component
that
you
ship
with
a
lab
extension
and
there's
basically
like
a
jupiter
lab
extension
on
the
front
end
with
a
toolbar
that
invokes
these
new
rest
endpoints
that
you
added
to
the
tornado
application
serving
lab.
Then
that
can
do
the
talking
to
the
server
and
writing
to
disk
and
all
that.
E
But
the
voila
portion
of
the
serves
the
application
never
actually
writes
to
disk,
like
if
you
think
of
voilá,
as
basically
read-only
except
it
has
server
access
to
get
calculations
done.
But
it's
not.
It's
meant
to
be
safe
to
deploy
to
the
public,
and
you
can
think
of
the
lab
extension
as
the
edit
mode,
which
has
right
to
disk
and
all
that
other
stuff.
How.
C
C
Ok,
so
there's
certainly
some
ongoing
work
to
make
that
happen,
but
I
think
we're.
You
know
I
think
that's
a
desirable
end
goal
to
get
to
so
that
you
can
so
that
you
can
get
reusable
things
that
you
write
for
your
heavy
duty,
authoring
environment,
but
that
you
also
can
use
in
these
kinds
of
environments.
But,
ok,
you
would
still
not
have.
You
would
not
rely
on
anything
on
the
env
server,
except
for
the
widget
bus.
Basically
right.
C
C
Prevents
all
it
gates
is
arbitrary
code
execution
with
kernel,
dot,
execute
I,
say:
if
you
write
an
evil
widget,
then
you
can
have
an
evil.
Voila
application.
There's
a
protect
you
from
so
not
to
do
with
that
I.
Just
wouldn't
do
it
with
local
get
right
like
if
you
can
get
it
out
of
the
stateless.
It's
running
inside
a
hub
right,
just
have
asynchronous
posts
to
to
a
local
get
thing,
and
then
you
could
moderate
or
something
like
that.
But
for
the
kind
of
thing
that
you
do
get
is
perfect.
You
can
not
guess
multiple.
C
H
The
moving
a
collection
of
Excel
files
to
Python
had
some
kind
of
unexpected
interactions
with
the
folks
that
we're
familiar
with
the
excel
files.
In
particular,
there
are
no
tests
for
excel
because,
of
course,
there
are
no
tests
for
excel
and
the
even
the
metadata
the
knowledge
of
what
do
the
different
models
do
depends
on
human
memory
and
so
having
the
implementation.
H
H
The
Jupiter
lab
notebook
looked
almost
exactly
like
that.
The
things
that
ended
up
getting
redone
were
to
make
it
a
tabs
all
in
one
frame
so
that
if
it
went
and
rendered
it
on
its
own,
it
would.
It
would
just
feel
and
not
not-
output
lower
on
the
page
that
people
didn't
always
notice
and
then
fix
things
that
that
just
worked
differently
in
notebook
I
mentioned
the
two
that
were
the
most
difficult
SVG
was,
and
it's
meeting
unique
IDs
for
the
nodes
was
was
by
far
the
most
difficult
to
resolve.
A
C
So
there's
been
some
requests
for
more
robust
forms
inside
of
Jupiter
lab
without
as
much
work.
So
what
I've
done
here
and
it's
on
a
branch
but
there's
no
PR
yet
as
I've
replaced
the
form
that
you
used
to
get
to
do
it.
This
way,
it's
two
ways
to
rename
things
replace
the
form
that
you
used
to
get
that
had
the
logic
of
how
to
validate
the
file
name
on
a
rename
notebook
and
the
label,
and
you
know
I
had
stuff
kind
of
all
over
the
place.
C
It
now
puts
all
of
that
into
one
lazy
loaded
that
apparently
might
not
build
sweet.
Good
demo
works
locally.
You
know
it
doesn't
work
on.
It
doesn't
work
on
binder,
it
doesn't
work
but
repurposing
the
spinner.
It's
trying
to
load
this
this
slowly.
In
the
background,
let's
see
if
I
can
might
just
be
a
time
thing
still
working
on
getting
the
promises
right,
yeah
there
we
go
so
yeah
the
promises
room
right.
This
is
a
JSON
schema
form.
So
if
I
go
in
here
and
change
it
to
be
nothing
says,
it's
a
required
property.
C
You
know,
I
can
put
something
in
there.
That
has
a
slash
in
it
doesn't
match
that
pattern
can't
do
that
either
and
you
can
make
ridiculously
arbitrary,
complex
forms
out
of
this.
It
supports
you,
know,
adding
multiple
items
and
stuff
like
that.
So
Ilana.
This
is
a
quick
shot
at
it.
The
more
full
one
is
one
that
we've
we've
talked
about
before,
which
is
in
addition
to
having
the
the.
C
Oh,
did
we
get
rid
of
the
tableview?
Let's
got
another
table,
you
so
used
to
have
a
table
view
in
here,
and
what
we
would
also
like
is
a
form
view.
So,
if
I
went
into
something
semi
complicated
instead
of
reading
through
JSON
comments,
be
able
to
create
a
schema
that
allowed
you
to
modify
these
just
with
one
form
without
having
to
write
a
bunch
of
phosphor
code,
we're
about
to
react
code
or
anything
like
that
yeah.
So
that's
that's
a
fun
little
thing.
I
C
A
Cool
all
right,
I'm
gonna
go
ahead
and
stop
the
recording,
but
everyone
feel
free
to
hang
out
on
this
car
as
long
as
you
like,
and
you
can
chat
across
the
channel
for
fun.
It's
good
to
see
everybody
thanks
for
coming
again,
we'll
do
this
next
month,
I'll
put
out
the
video,
hopefully
in
the
next
couple
of
days
and
yeah,
we'll
see
you
all
next
month,
thanks
for
coming.