►
From YouTube: 12. Dashboarding
Description
June 12, 2019 Jupyter Community Workshop talk by Lindsey Heagy, University of California, Berkeley
A
All
right
so
I
wanted
to
give
a
quick
overview
of
ipi,
widgets
and
voila,
which
was
a
data
supporting
solution
for
Jupiter.
So
a
few
of
us
myself
and
if
you
notice
here
we're
at
the
dashboarding
workshop
last
week
in
Paris,
so
there's
sort
of
three
main
dashboarding
solutions
right
now
in
the
jupiter
ecosystem.
A
There
is,
which
is
closely
connected
with
the
plot
lead
development
other
panel,
which
is
connected
quite
closely
with
bouquet
and
that
ecosystem
of
tools
and
then
there's
wallah,
which
integrates
really
nicely
with
the
the
Jupiter
ecosystem
and
I
would
say,
is
probably
the
most
general
of
the
three
at
the
moment.
So,
but
before
we
get
there,
I
want
to
just
give
a
quick
overview
of
IPI
widgets
in
case
you're,
not
familiar.
If
you
are,
and
hopefully
I'll
show
you
an
interesting
example
of
a
science
use
case
of
high
priorities.
A
But
now
perhaps
we
want
to
actually
just
have
a
look
and
see
what
happens
if
you
change
the
frequency,
so
here
I'm
using
the
interact
function
and
we're
just
gonna,
provide
it
a
function
and
then
a
value,
and
so
in
this
case
the
value
that
I'm
providing
for
F,
which
is
the
frequency,
is
a
is
an
int
and
so
I
get
out
an
inch
slider,
so
interact
basically
looks
and
says
this
thing's
an
integer.
Let's,
let's
give
you
integer
values.
If
I
instead
made
this
a
float,
then
we
get
out
a
floats
layer.
A
So
it's
doing
that
type
inference
for
you,
which
is
quite
nice.
So
this
is
a
simple
little
example.
Maybe
we
want
to
do
something
a
little
more
and
explore
perhaps
the
connection
with
the
sine
curve
to
the
unit
circle,
and
so
this
starts
getting
into
if
you're,
explaining
complex
numbers
and
things
like
that,
what's
going
on
so
I
wrote
another
little
function
where
we
just
gonna
plot
now
the
unit
circle
with
the
sine
wave
and
so
now
we've
got
two
sliders
because
I've
provided
it
two
different
inputs.
A
We
can
change
the
frequency
and
then
we
can
actually
look
and
go
and
see.
Basically,
if
we're
mapping
a
Kurt,
a
point
on
the
curve
on
the
sine
curve
where
it
actually
falls
on
a
circle.
So
you
can
see
like
pretty
quickly.
You
can
start
actually
building
up
some
reasonably
complex
physical
visualizations,
so
that
was
using
the
interact
with
just
the
type
inference
and
it's
figuring
out
bounds
that
are
somewhat
reasonable
for
these
values,
but
maybe
I
want
to
do
something
a
little
more
fine-grained
and
actually
provide
a
different
range.
A
So
here
you
can
see
the
the
frequency
balance
that
I
have
are.
Basically,
you
know
two
on
either
side,
so
maybe
I
wanted
to
actually
give
you
something
a
bit
broader,
go
up
to
ten
ten
Hertz.
So
here
you
can
actually
then
go
in
and
provide
whatever
specific
widgets
you
want
from
the
widgets
library
I.
Have
that
build
up.
So
in
this
case
now
my
frequency
range
goes
up
to
ten.
So
for
this
specific
example,
we
have
those
constraints.
A
A
I
have
here
setting
up
an
array
for
a
survey
design
a
mesh
for
my
simulation,
build
a
synthetic
model
all
of
these
sorts
of
things,
and
so,
at
the
end
of
the
day,
what
I
have
is
some
sort
of
app
that
I
built
so
I
know
what
and
we
can
go
in
and
start
simulating
simulating
data.
But,
as
you
see,
there's
a
whole
bunch
of
code
here.
A
That
is
a
bit
perhaps
intimidating
if
I
actually
want
to
just
pass
this
off
to
a
student
to
have
them
learn
about
geophysics
from
that,
so
instead
it
might
be
nice
to
basically
have
just
a
single
view
that
that's
showing
this.
So
this
is
where
voila
comes
into
play.
So
what
I'm
gonna
do
here
is
this
notebook
is
in
this
repository
here.
So
if
I
just
launched
with
a
voila
server,
then
it's
going
to
pop
up
a
much
simpler
view
on
this.
A
A
And
so
now
we
actually
have
this
app,
just
as
a
nice
view
running
in
my
web
browser,
and
so
what
I
can
do,
let's
play
around
with
this,
so
we've
got
a
model
here
where
we've
got
basically
a
half
space.
So
let's
make
it
a
bit
more
interesting.
So,
let's
add
out
a
couple
layers:
we're
gonna
insert
a
conductive
layer
and
you
can
see
that's
gonna
update
the
data,
so
it's
kind
of
interesting
or
day
to
change.
A
A
So
if
we
look
at
the
currents,
we're
gonna
isolate
a
single
electrode
pair,
and
so
you
can
see,
one
electrode
is
injecting
current,
the
other
ones,
picking
it
up
and
when
they're
really
close
together
was
sort
of
sampling
near
the
surface.
So
this
apparent
resistivity
value
that
we
see
is
actually
pretty
close
to
the
apparent
resistivity
or
to
the
cheese's.
A
Didn't
leave
that
first
layer
and
as
we
spread
them
for
their
part,
then
we
get
currents
deeper,
and
so
you
start
to
see
this
more
conductive
layer
beneath
that,
and
so
what's
actually
going
on
under
the
hood.
There's
a
few
interesting
things
like
with
this
specific
example:
when
I
change
the
model
I'm
actually
rerunning
a
PDE
simulation,
so
you
can
hook
up
wits
to
LiveCode,
and
so
what
law
is
doing
is
it
provides
you
a
kernel
that
holds
the
state
and
is
actually
running
that
computation
as
a
user?
A
All
I
have
is
the
ability
to
interact
with
the
kernel
through
this
interface,
and
so
this
can
be
nice
if
you
actually
want
to
deploy
an
app
where
you
don't
want
users
executing
arbitrary
code,
because
the
notebook
is
great
at
having
users
execute
arbitrary
code.
That's
what
it's
designed
to
do,
but
you
don't
necessarily
want
that
in
all
cases,
and
so,
while
separates
those
concerns,
and
the
philosopher
basically
only
lets
the
user
provide
inputs
through
this
air
face.
A
So
you
can
take
a
look,
there's
some
useful
links
in
there
and
some
other
demos,
and
things
like
that
that
you
can
connect
to
and
I
think
there'll
be
one
coming
out,
hopefully
in
the
next
week
or
so
that's
about
the
workshop
and
some
of
the
products
that
came
out
of
that,
then
the
other
thing
I
wanted
to
show
is
the
Dwolla
gallery.
So
this
is
will
be
live
at
this
URL
soonish,
and
so
this
is
a
handful
of
different
examples
that
have
been
put
together
from
from
last
week
and
assembled
online.
A
A
A
A
A
A
A
It's
not
a
bad
mental
model,
so
it
basically
I
mean
to
get
this
view.
It
did
strip
out
it
used
env
convert
to
strip
out
the
code.
You
can
keep
the
code
in.
So
that's
one
piece,
that's
how
you
get
the
view,
but
the
kernel
itself
is
also
different.
There,
like
the
server.
Sorry,
the
voila
server
is
different.
Is
it's
not
gonna?
Let
the
user
send
arbitrary
code
to
it
unless
you
explicitly
put
in
a
box
that
says
enter
code
here.
D
D
D
A
Can
you
can
do
that
through
a
template?
So
if
there's
like
a
handful
that
you
want
Falls
laughing
because
that
was
Martin's
response
last
week
is
everything
everything
you
want
to
do
with
well,
apparently
can
be
solved
through
a
template,
but
what
you
could
do
is
basically
tank
metadata
on,
like
cell
metadata
basically
say,
I
want
to
show
these
handful
and
then
use
a
template
to
show
your
specific.