►
From YouTube: Oz - vega-lite data science visualisations in Clojure - Christopher Small - Scicloj meeting 5
Description
Christopher Small demonstrates Oz, a Clojure project for data visualisation using the Vega and Vega-lite high level grammar for interative graphics
https://github.com/metasoarous/oz
The fifth meeting of the Scicloj community started a series of meetings about data visualization and literate programming. August 9th, 2019, 5pm UTC.
SciCloj is an open online gathering of the Clojure data science community
More details here:
https://twitter.com/scicloj/status/1157646172770721798
Text chat of the meeting:
https://tinyurl.com/y53qfk8c
Nextjournal runnable notebook with some of the live demos in the talk, transcribed by David Schmüdde:
https://nextjournal.com/schmudde/scicloj-oz
Unfortunately, a little bit of the live demo did not work (it turns out that the live-reload! functionality is only broken on 1.6.0-alpha3, but still works on 1.6.0-alpha2).
You may find more about Oz in these videos by Christopher Small:
* Oz live code reloading demo
https://www.youtube.com/watch?v=yUTxm29fjT4
* Oz - static site generation with live code reloading
https://www.youtube.com/watch?v=4f3fiWcNt7Y
Join our other meetings and online discussions -- more details here:
https://scicloj.github.io/pages/about/
A
Well,
thank
you
very
much
for
joining
us.
Welcome
to
the
psychological
community.
As
you
can
guess,
we
are
a
community
that
discusses
all
things:
data
science
and
how
we're
going
to
use
closure
to
build
tools
and
applications
that
make
data
science
more
accessible
to
everybody,
and
this
community
all
start
from
a
thread
in
closure
closure
verse.
Since
then,
there's
been
lots
of
really
great
event.
So
far,
we've
had
tech
ml
by
Kristin
Nuremberg
had
a
really
involved
discussion
about
deep
learning,
with
Kara
Maya,
discussing
all
things
around
MX
nets.
A
Python
projects
are
out
there.
So
this
week
we're
going
to
look
at
visual
visualizing
data
science,
which
is
an
important
step
to
help
explain
what
all
the
data
science
actually
means
actually
to
people
who
are
not
data
scientists
like
myself
and
so
we've
got
a
number
of
those
talks
coming
up
in
over
the
next
few
months
and
today,
Christopher
do
you
prefer
Christopher
or
Chris,
either.
A
A
A
Yeah,
it's
pretty
cool
project
as
well.
I
mean
I've,
seen
sort
of
videos
as
well.
So
it's
really
interesting
my
project
to
work
with
and
as
well
as
that's
as
well
being
the
major
contributor.
Then
chris
is
also
a
founder
of
the
unchipped
edge
scientists
of
Polly's,
which
is
an
AI
powered
survey
tool
for
open-ended
feedback
and
has
free
democracy,
which
also
sounds
quite
interesting
as
well
yeah.
And
if
you
find
in
fact
Chris
on
github
at
MIT
Soros
as.
C
B
A
A
If
anybody
else
is
feeling
brave
and
wants
to
share,
they
come
it's
nice
for
Chris
to
be
able
to
see
who's
talking
to
as
well
and
if
you're
not
talking,
please
mute
your
microphone
as
well,
especially
if
it's
a
torrential
rainstorm
outside
like
there
is
in
my
house,
oh
my
Gary,
and
with
that
I'm
gonna
hand
over
to
Christopher,
so
Chris
off
you
go.
Thank
you
very
much.
Awesome.
B
B
Some
humble
beginnings
of
having
focused
really
more
corley
on
the
on
the
usage
of
data
visualization
as
a
date
assess
the
data
science
tool,
and
so
one
of
my
goals
for
today
is
to
really
give
you
a
sense
for
all
these
different
features
and
how
they
fit
together
and
I.
Think
the
best
way
to
do
that
is
going
to
be
to
do
some
live
coding.
So
you
can
really
just
see
kind
of
in
in
the
flesh
what
what
all
these
components
are
and
how
they
fit
together.
B
B
It
was
like,
where
someone's
someone's,
making
a
little
nice
exit,
turn
off
their
microphone.
Yeah.
Okay,
that's
better
yeah!
So
please,
please
do
a
few!
If
you
have
any
questions
or
you
know
just
want
to
interject
something,
please,
please
feel
free
to
to
pipe
in
so
just
at
a
high
level
kind
of
give
you
a
sense
of
the
different
points
that
we're
going
to
be
touching
on
here.
B
Did
that
reagent
API
lets
you
kind
of
take
things
in
that
direction.
We
also
offer
the
ability
to
compiled
HTML,
so
not
only
individual
data
visualizations,
but
documents
which
might
contain
data
visualizations
and
math,
typesetting,
etc.
And
this
you
know,
as
I
mentioned
before
many
other
slides
is
based
on
you
know,
markdown
and
hiccups,
so
I
either,
which
way
whatever
your
sort
of
preferred
flavor
of
of
you
know,
create.
Creating
pages
is
for
for
for
some
context.
You
can.
You
can
be
embedding
these
data
visualizations
within
within
them.
B
Now
this
actually
includes
static
site
generation,
which
is
really
cool,
I
hope
this
one
of
things
I
hope
to
be
able
show
off
today
and
in
some
ways,
which
is
where
this
sort
of
Swiss
Army
knife
model.
So
that's
the
breakdown
right,
because
the
static
site
generation
is
a
feature
which
could
totally
live
almost
entirely
on
its
own
right
and
so
that
that
may
actually
end
up
happening
something,
but
but
for
now
it
actually
works.
Really
well
is
this
kind
of
complete
package.
B
B
Data,
which
was
the
agent
and
I
want
to
try
to
offer
something
for
folks
in
in
that
intersection
there,
and
so
for
both
the
closure
Peter
and
I
closure
kernels.
You
know
we're
kind
of
fortunate
here
that
we
have
actually
two
different
kernels
to
use
closure
in
the
in
the
Jupiter,
the
Jupiter
notebook
environment.
B
Specifically,
data
visualizations
and
kind
of
more
into
like
data
science,
workflow
toolkit
space
so
again
can
be
going
over
all
these
in
in
more
detail
here.
So
hopefully
we'll
get
a
better
sense
for
how
these
kind
of
fit
together
and
hopefully
see
that
they
do
fit
together,
but
before
I
go
into
much
further.
B
I
just
want
to
take
a
little
bit
of
time
to
cover
Vega
light
and
Vega,
because
really
the
data
visualization
well,
it's
kind
of
grown
beyond
the
initial
scope
that
that
oz
had
data
visualization
really
is
still
a
really
core
and
key
component
to
to
the
library.
So
so,
with
that
in
mind,
we
should
talk
about
the
the
engine.
That's
powering
the
these
data
visualizations,
so
Vega
light
and
Vega
are
declarative.
B
Data-Driven
data,
visualization
languages
and
when
I
say
data-driven
I
actually
mean
that
these
data
visualizations
are
JSON
data
structures
and
they
are
based
on
the
grammar
of
graphics
which,
if
you've
used
ours,
ggplot2
you're
very
familiar
with
this.
The
Gigi
and
Gigi
plot
comes
from
grammar
of
graphics.
D3
has
been
inspired
by
some
of
these
ideas.
I
think
plotly.
B
A
number
of
other
different
frameworks
have
have
learned
from
the
grammar
of
graphics,
and
it's
been,
it's
been
really
influential
in
the
space,
but
one
of
the
things
that
big
and
big
alight
bring
to
the
table
that
sort
of
novel
is
this
idea
of
a
grammar
of
interactivity.
And
it's
you
know.
This
is
one
of
the
things
that
unfortunately,
I
won't
be
able
to
even
I
mean
there's
too
many
other
things
to
cover
today.
B
I
won't
be
able
to
even
scratch
the
surface
of
the
kind
of
interactivity
that's
possible,
with
just
vague
and
big
alight,
even
without
getting
into
regent
or
anything
like
that,
but
but
hopefully,
I
have
time
to
just
see
just
a
little
bit
and
one
of
the
things
that
makes
the
interactivity
so
powerful
is
that
there's
a
functional
data
flow
model
built
into
these
Vega
big
alight
specifications.
So
within
them
you
might
be.
B
B
Tableau,
you
know
a
lot
of
a
lot
of
big
things
that
have
come
out
of
the
sort
of
data
visualization
community
have
come
from
folks
who
have
worked
in
the
IDL.
So
it's
you
know
it's
it's
a
really
great
lab,
they're
doing
really
great
work,
and
you
can
kind
of
rest
assured
that
this
kind
of
underlying
framework
here,
vague
and
pega
light
is
being
you
know,
assured
forward
by
some
really
really
thoughtful
smart
folks.
B
So,
if
you're
interested
in
getting
a
better
sense
of
Vega
light
and
really
kind
of
how
it
works,
what
you
can
do
with
it
all
the
sort
of
bells
and
whistles
I'd
really
highly
recommend
this
YouTube
video
titled
Vega
light
a
grammar
of
interactive
graphics
and
you
should
be
able
to
search
on
YouTube
for
that
and
find
it.
This
is
a
really
great
job
of
giving
you
just
you
know,
run
running
the
mill
of
everything
that
they
can
make.
B
Well
specifically,
the
Vega
light
can
do
now
if
you're
interested
in
the
kind
of
underlying
philosophical
connections
between
Vega
Vega
light
and
closure
they're.
Actually,
some
are
some
really
kind
of
interesting,
deep
threads
that
connect
the
two,
and
so,
if
you're,
just
in
that
I've
got
another
talk.
That
I
did
at
and
parody
some
a
little
while
ago.
Now,
it's
almost
a
year
ago,
I
think
and
well
no
not
quite
anyway,
whatever
some
months
ago
and
that's
titled
Vega
Vega
light
enclosure.
So
you
should
be
able
to
search
on
youtube
for
that
as
well.
B
Yeah,
so
yeah
again,
if
you're
interested
in
learning
more
about
Vega
and
big
alight,
in
particular,
I
recommend
checking
out
those
those
two
resources,
but
for
now
I
kind
of
want
to
move
on.
So
we've
got
a
lot
of
other
stuff
to
cover.
So
the
one
thing
which
I
do
want
to
drill
home,
though,
is
that
you
know
part
of
what
makes
Vega
Omega
light.
B
So
magical
to
me
is
just
the
fact
that
they
are
data
specifications
this
it
seems
it
may
seem
either
sort
of
incidental
or
maybe
almost
encumbering,
but
it
really
is
one
of
the
things
that
enables
a
ton
of
power
with
it.
You
know
I
could
not
have
built
the
tool
kit
that
I
built
and
made
it
possible
for
folks
to
focus
enclosure
community
to
use
all
this
work.
B
B
B
Declarative
data
visualizations
and
it's
extremely
powerful
and
customizable
configurable,
but
unfortunately,
due
to
that
kind
of
sheer
power,
there's
there's
a
lot
of
stuff.
That
kind
of
requires
a
lot
of
boilerplate
and
makes
it
a
little
bit
challenging
to
use
as
a
day-to-day
data
science
tool.
However,
it's
great
as
a
compiler
to
target
because
of
its
flexibility
and
again
the
fact
that
it's
just
data,
you
know
whatever
sort
of
language
or
framework
you're
in
you
can
be
building
these
specifications
dynamically.
B
This
is
one
of
the
other
things
that
makes
this
paradigm
really
powerful
right
and
and
effectively
using
Vega
as
a
compile
to
target.
So,
if
you're
familiar
with
guerrilla
repple,
it's
really
cool
a
closure
notebook
environment-
it's
data,
visualization
functionality
is
based
on
Vega.
This
was
actually
my
first
sort
of
encounter
with
Vega
was
was
through
guerrilla
repple
and
unfortunately,
at
the
time
you
know
right
when
I
kind
of
dug
into
Vega.
B
B
Bago
light
is
in
some
ways,
sort
of
an
unfortunate
name,
because
it
can
kind
of
give
the
impression
that
it's
sort
of
watered
down
or
not,
you
know
not
as
powerful,
and
that's
not
really
the
right
way
to
think
about
it.
It's
it's
actually
extremely
powerful,
but
sort
of
geared
in
different
ways
than
Vega
is,
whereas
vega's
power
is
geared
towards
really
maximizing.
The
kind
of
set
of
things
you
might
possibly
be
able
to
do.
B
So,
if
you're
doing
your
day
to
day,
David
was
a
data
visualization
work
and
you
come
up
with
a
visualization
that
you
really
like
and
want
to
build
on,
maybe
turn
into
part
of
an
application
but
need
to
kind
of
customize
beyond
what
Vega
light
is
able
to
accomplish,
you
can
compile
out
to
Vega
and
then
just
go
to
town
with
all
of
the
you
know,
bells
and
whistles
that
Vega
has
to
offer.
So
together.
This
combination
is,
is
just
really
powerful.
B
These
these
things
kind
of
play
play
on
each
other
really
nicely
so
now,
you'll
be
talking
about
this
kind
of
abstractly.
It
helps
to
just
look
at
an
example
and
really
just
see
like
what
is
it
that
we're
actually
talking
about
here.
So
this
is
a
excuse
me.
This
is
a
really
simple
Vega
light
example,
where
you
know
the
first
thing
we're
doing
here
is
specifying
their
data
and
in
this
case
we're
using
a
URL
which
is
convenient.
B
If
you
have
a
lot
of
data-
or
you
know-
want
to
refer
to
data
on
the
web
somewhere,
but
no
to
note
that
you
can
also
specify
values
here
and
just
pass
in
a
list
or
vector
or
whatever
you
want
to
call
it
of
of
data
dictionaries
or
objects,
which
is
useful
if
you're
at
the
repple-
and
you
know
actually
have
some
data
that
you
just
want
to
literally
pass
on.
The
next
thing
that
we
do
here
is
we
specified
the
mark.
B
So
I
said
that
Megan
Vega
light
are
the
sort
of
declarative
grammar
of
graphics
mappings,
and
the
idea
there
behind
the
grammar
of
graphics
is
that
we
should
be
able
to
describe
data
visualizations
as
mappings
from
properties
of
our
data
to
aesthetics
of
a
data
visualization
and
specifically
here.
What
we're
doing
is
we're
saying
that
we
want
to
take
these
data
points
and
we
want
to
mark
them,
as
should,
if
you
interviews
the
word
point
there,
we
want
to
take
these
pieces
of
data.
B
These
data
or
entities,
I,
guess,
is
more
appropriate
and
we
want
to
represent
them
as
points
in
a
data
visualization.
The
next
piece
here
is
me
encoding,
which
tells
us
how
we're
actually
doing
that
mapping
like
what
properties
of
the
data
are.
We
mapping
to
which
aesthetics
of
these
marks
that
we're
creating.
So
in
this
case
we're
going
to
be
mapping
the
field
horsepower
to
the
X
aesthetic
in
the
of
these,
these
data
points
and
we're
mapping
miles
to
gap
miles
per
gallon
to
the
Y
aesthetic
of
these
these
data
marks
and
then
well.
B
This
is
not
necessary.
It's
kind
of
helpful
to
see
that
you
know
there's
some
other
kind
of
properties
here
that
you
can
specify.
So
if
we
wanted
to
color
by
another
variable
like
origin,
and
then
we
can
specify
that
as
well
here.
So
what
we
get,
then,
is
this
nice
little
visualization-
and
this
is
just
a
static,
static
image
here,
but
we
get
this
nice
little
visualization,
which
is
exactly
what
we
expected
right.
B
It's
miles
per
gallon
versus
horsepower
and
we're
coloring
by
orange
in
here,
and
it
gives
us
a
key
and
a
legend
and
everything
so
the
equivalent
just
for
reference,
the
equivalent
Vega
that
would
have
required
to
create
this
as
sort
of
a
bare-bones
minimal
thing
would
have
been
two
or
three
times
as
long,
but
ever
been
a
bunch
of
kind
of
configurator.
It
wouldn't
have
come
with
axes.
It
wouldn't
have
come
with
the
the
legend
it
would've
been
very
bare-bones,
just
sometimes
which
you
want
when
you're
building
something
up
as
an
application.
B
B
D
B
B
E
B
Yeah
I
haven't
used
the
grid
system
as
much
so
I'm,
not
sure
exactly
how
fully
I
can
answer
the
question,
but
it's
very
similar
to
it.
In
my
mind,
it's
very
similar
and
so
depending
on
what
what
language
or
tool
kit
you're
using
to
create
your
Vega
of
regulate
specifications,
it
can
actually
be
very,
very
similar
to
to
ggplot.
So
in
particular,
while
I
tend
to
kind
of
emphasize
the
you
know
just
build
the
data
spec
by
hand
effectively
and
then
pass
that
around
sort
of
side
of
things.
B
The
Vega
light
library
itself
actually
does
have
some
functions
which,
which
lets
you
kind
of
build
on
an
ongoing
specification
kind
of,
as
you
would
see,
with
with
with
ggplot
there's
also
in
Python.
There's
the
Altair
library,
which
is
really
rather
clever,
I
mean
I'm,
not
an
object-oriented
fan,
but
it's
it's
got
some
really
cool
meta
programming
where
it
actually
ingests
the
the
json
schema
specifications
for
the
you
know
what
what
Vega
and
bagel
I
should
look
like.
B
Well,
specifically,
make
a
like,
so
it
doesn't
do
Vega,
but
ingest
those
and
actually
dynamically
builds
a
object-oriented
API
based
on
that,
and
so
the
net
result
is
something
very,
very
similar
to
ggplot.
Where
you
create
this
plot
instance,
and
you
actually
passing
a
data
frame
for
the
data,
at
least
by
default.
Through
those
other
ways
you
can
pass
the
data
in,
but
and
and
then
you
call
these
methods
on
it
kind
of
in
sequence,
to
add
this
aesthetic
or
that
aesthetic,
this
mapping,
that
layer
etc.
So
yeah,
it's
it's
it's
very
similar.
B
If
you
had
told
me
that
I'd
be
saying
this
like,
however,
many
years
ago,
I
told
you,
you
were
crazy
because
I
was
I
was
a
huge
ggplot2
fan,
I
mean
I
when
I
was
back
at
Fred,
hutch,
Cancer,
Research
Center
and
you
know
doing
dative
installations
and
day-out
I
used
eg
plot
two
all
the
time
and
in
no
other
language
had
I
really
found
something
that
I
liked
as
much
or
that
was
as
powerful.
But
you
know
pretty
quickly
after
getting
into
Vega
light.
B
I
realized
I
was
blown
away
by
just
all
the
things
that
it
could
do
that,
but
actually
ggplot
you
couldn't
so
the
interactivity
I
mean
I,
guess
shiny
kind
of
gets
into
some
of
that
stuff.
Now,
but,
but
really
it's
it
really
stands
out.
I'm
pretty
quickly
became
100%
sold
that
you
know
I'm
not
going
back.
Basically
I
found
on
my
found,
my
environment,
so
cool
yeah.
Thanks
for
that
question,
any
anyone
else.
B
Okay,
cool
well
without
further
ado,
then
please
stop
me
if
you
do
think
of
something
that
you
want
to
ask,
but
without
further
ado,
I'm
gonna
open
up
a
repple
here
or
a
terminal
whatever,
and
hopefully
that's
big
enough
for
everyone
to
see.
You
know,
let
me
know
if
it's
not,
but
I
won't
get
too
much
into
my
setup
here,
but
I
like
to
use
I'm
kind
of
old-fashioned.
B
But
it's
sort
of
the
the
longest-running
closure
build
tool
which
kind
of
lets
you
create
new
projects
and
run
projects
etc,
and
somebody
use
this
to
create
a
new
project,
we'll
just
call
it
AHS
demo
and
it's
gonna
take
a
second
to
fire
up
and
create
that.
But
once
we
have,
then
we
can
CD
in
here
and
again.
I
mentioned
that
the
only
thing
you
really
need
to
do
to
set
up
AHS
in
your
project
is
to
to
add
a
dependency
on
on
the
the
project.
B
A
B
A
B
B
We
can.
We
can
give
that
an
alias,
and
we
require
that
as
for
for
ease
of
use
here
now,
one
of
the
thing
oh
and
right,
this
is
like
I
forgot
to
change
directories
in
here.
Okay,
there
we
go
yeah.
So
when
I
ran
line,
repple
I
wasn't
in
the
same
directory,
yet
so
it
wasn't
connecting,
but
now
that
I'm
in
there
that
should
that
should
work.
B
So
just
one
thing:
real,
quick,
while
that's
loading
up
its
if
you've
used,
you
know,
Python
or
Ruby
or
I,
mean
even
know,
JavaScript
right,
you're,
probably
familiar
with
the
idea
of
a
ripple.
This
sort
of
interactive
session,
where
you
can
be
typing
in
code
and
evaluating
it
and
and
closure,
is
no
stranger
to
the
repple
and
in
fact,
closure
is
just
sort
of
a
little
bit
rabid
about
their
usage
of
the
repple
as
as
a
Productivity
tool.
B
So
now,
while
it's
totally
fine
to
just
run
all
these
examples
directly
in
the
repple
here,
I
could
come
in
here
and
require
a
score
as
Oz
and
it's
gonna
take
a
second
to
actually
load
up
the
dependencies.
But
once
that,
once
that
happens,
I
could
go
in
here
and
be
directly
typing
in
all
these
coding
examples
in
this
repple
right.
But
if
you're
someone
who's
been
coding
for
a
while,
you
probably
have
a
development
environment
that
you
really
like
to
use.
B
So
now
that
we've
required
that
namespace,
what
we
can
do
here
is
call
oz
of
view
and
we're
just
going
to
run.
This
same
example
that
we
that
we
had
before
and
yes
I'm
just
pulling
up
my
notes
here.
Okay,
so
first
we
can
specify
the
data
and
again
this
is
going
to
be
a
URL
HTTP
mega
github,
IO,
editor
cars,
editor
data,
cars,
JSON
and
the
next
thing
we're
gonna
do
again
is
specify
the
mark
time.
B
B
Tooltip
functionality,
where
you
know
as
I
hover
over
data
points,
it'll
display
a
little
tooltip
with
kind
of
the
basics
of
the
basic
information
that
we
were
visualizing
here,
and
this
can
totally
be
customized,
so
you
can.
Actually
you
have
a
lot
of
control
over
what
what
sort
of
information
you
can
explai
there,
but
pretty
cool
right
like
that
was
that
was
really
quick.
You
know
we
we
had
some
data,
we
we
specimen.
We
ran
a
specification
and
now
we've
gotten
theta
visualization,
and
we
can
iterate
on
this
very
quickly.
B
So
we
might
go
in
here,
and
you
know
want
to
do
this
as
a
line
plot.
Instead
and
now,
once
we
evaluate
that
voila
right,
we
get,
we
get
a
line
plot.
So,
and
just
one
thing
to
point
out
here
is
that
vega
light
is
just
one
things
that
makes
it
special.
Is
it's
just
really
smart
about
kind
of
doing
the
right
thing
like
knowing
what
you
meant
to
do
and
not
having
to
be
kind
of
told
to
do
it
right?
We
didn't
tell
it
to
break
up
these
lines
based
on
origin.
B
B
B
One
of
the
things
that
one
of
things
that
I
remember
yes
all
right,
then
now
the
data
points
actually
have
different
shapes,
and
so
right,
you
probably
would
only
be
doing
one
of
the
other
here
most
of
the
time,
but
sometimes
it's
actually
nice
to
use
multiple
aesthetics
to
really
kind
of
drive
home.
The
point
of
what,
where
the
differences
are
between
some
data
right,
so
yeah,
I'm,
gonna,
I'm
gonna
scale,
this
back
a
little
bit
and
cut
these
out.
B
B
Yeah
right,
so
one
of
the
things
I
might
want
to
do
here
is
display
a
line
which,
which
bins
the
data
and
we'll
see
what
that
looks
like
a
second
here
and
then
right.
So
what
we're
doing
is
we're
bidding
on
along
the
x-axis
so
that,
instead
of
displaying
all
these
data
points,
we're
we're
sort
of
averaging
over
these
bins
and
the
way
that
we
do,
that
is
specify
been
true
for
the
x
axis
and
then
aggregate
you
mean
for
the
y
axis
here
and
so
I.
B
B
So
to
do
that,
we
use
the
layer
functionality
which
lets
us
combine
multiple
mappings
effectively
as
layers,
it's
one
of
the
kind
of
core
ideas
behind
the
grammar
of
graphics,
idea
that
you
can
layer,
multiple
visualizations
on
top
of
each
other
to
kind
of
add
context
and
information,
and
so
for
this.
For
this
one
I'm
not
going
to
do
any
of
the
bidding
or
anything
I'm
going
to
be
representing
this
data
as
individual
points.
They
got
the
aggregate
here
and
now
what
I
should
see
we're
going
to
do?
B
One
more
thing
here,
which
is
I'm
gonna
map
them
the
opacity
here
to
just
a
static
value
of,
say,
zero
point:
three:
what
we
should
see
now
yeah!
So
now
what
we
get
one
more
thing
here:
I'm
gonna
do
to
make
this
a
little
bit
bigger,
easier
to
see.
I'm
gonna
do
with
say
800
Haight,
let's
say
600,
okay
and
evaluate
that
and
yeah.
B
So
now
we
have
something
much
easier
to
look
at
here
but
you'll,
see
by
by
taking
these
data
points
as
individual
pieces
of
data,
and
you
know
making
them
a
little
more
opaque
and
then
layer.
On
top
of
that,
these
sort
of
Bend
lines
we
get
a
sense
not
only
for
the
distribution
of
the
actual
data
as
data
points,
but
also
kind
of
a
summary
of
that.
B
B
A
B
B
B
You
can
fit
quite
a
bit
of
data
in
and
there's
even
a
WebGL
renderer
that
lets
you
render
quite
a
bit
of
data
which
is
really
cool,
so
yeah,
sorry,
I'm
not
giving
a
very
kind
of
direct
answer
there
I
think.
Sometimes
it
can
also
depend
on
how
much
you're,
rendering
at
once
cause
it's
actually
the
rendering
performance
that
I
think
ends
up
being
the
bottleneck
in
some
cases.
So
sorry
I'm
not
giving
you
a
super
direct
answer
there,
but
you're
definitely
you're,
definitely
fine
and
say,
like
the
tens
of
thousands
territory.
B
B
We
can
we
can
look
at
that.
Real
quick
I've
actually
got
an
example
of
that
in
in
here
somewhere
see
they
go
light.
It's
I
mean
just
answer
your
question
directly.
It's
not,
but
it's
it's
very
simple
to
add
the
selection.
Of
course
the
the
real
trick
is
like
what
do
you
do
with
the
selection?
And
actually
you
know
I've
got
some
examples
later
on
in
the
slideshow.
B
B
Yeah
great
okay,
back
over
here,
okay,
yeah
cool,
so
I'll
leave
that
out
for
now
one
thing
that
I'll
mention
real
quick
is
just
that
I,
just
like
with
most
coding.
I,
don't
actually
remember
a
lot
of
this
stuff
off
the
top
of
my
head.
I
mean
some
of
it.
I
do
that
I
use
all
the
time,
but
but
other
bits,
you
know
the
the
vago
documentation
online
is
really
great.
Usually
a
Google
search
will
will
get
you
to
something
that
you
want.
Also
the
both
Vega
and
Vega
Lite
sites
have
really
great
examples
sections.
B
So
if
you
go
there,
you
can
just
kind
of
scroll
through
and
really
quickly
visually
get
a
sense
of
all
the
different
kinds
of
visualizations
that
that
you
can,
that
you
can
create
with
these
frameworks
and
usually
find
something
in
there.
That's
close
to
what
you
need
and
then
kind
of
adapt,
as
as
you
will
and
combine
with
other
other
examples
of
cetera.
So,
but
hopefully,
we'll
have
some
time
at
the
end
here.
I
could
actually
just
do
that.
B
We
can
kind
of
scroll
through
the
examples
page
and
you
can
get
a
rough
sense
of
some
of
the
things
that
might
be
possible
so
but
yeah.
If
there's
no
other
questions,
I'll
kind
of
keep
moving
here.
So
one
of
the
things
early
on
which
I
realized
would
be
really
nice
and
actually
yeah
I
mean
that
that
kind
of
came
up
as
a
need
for
me
was
that
I
was
wanting
to
work
with
both
Vega
for
certain
visualizations.
B
I
mean
you
can't
actually
put
tables
of
data
in
here,
but
it's
not
it's
not
really
its
strong
suit,
and
so
what
I
realized
is
that
you'd
be
really
sort
of
simple
to
build
on
this
model
and
sort
of
almost
extend
it
with
the
notion
of
pickup
as
a
as
a
language
for
combining
individual
visualizations,
together
with
other
kind
of
other
kind
of
HTML
content.
So
just
as
a
simple
example
of
this,
you
know
we
might
create
a
div
here
and
then
you
know
maybe
add
a
title
and
we
should
see
it.
B
Okay,
yeah
there
we
go
right
so
in
the
context
of
this
hiccup
I
can
nest.
This
big
alight
specification
under
a
Vega
light,
key
or
I
guess
I
should
say
tag
and
and
it'll
render
that,
together
with
the
rest
of
the
the
hiccup
content,
so
just
real,
quick
because
again
I'm
trying
not
to
assume
that
people
are
coming
into
here
without
an
opponent
of
closure
experience.
So
this
hiccup
notation
is
a
really
simple
data,
notation
for
expressing
HTML
or
XML
content,
and
it's
what's
I
mean
for
me-
is
just
easier
to
write.
B
How
can
I
mean
if
nothing
else
right
but
yeah?
It's
also
kind
of
nice,
because
just
a
very
simple
data
model,
you
can
take
this
stuff,
you
can
dynamically
construct
it
and
when
you
kind
of
blur
your
eyes
a
little
bit
and
get
used
to
it,
it
actually
looks
really
similar
to
XML
or
HTML
and
yeah.
So
I
I
prefer
using
this.
B
Whenever
I
can,
for
literally
writing
HTML
but
yeah
I
mean
we
could
add
another
little
paragraph
in
here,
some
more
stuff
whatever,
and
you
know
that
pops
up
there,
so
you
know
so
I
could
be
doing
lists
or
tables,
or
you
know
styling
and
anything
that
I'd
want
to
do
with
just
to
see
a
sense
of
the
style.
It's
actually
that's
a
good
example,
so
I
wanted
to
say
style
this
in
a
particular
way.
B
I
can
add
this
dictionary
here
at
as
the
second
attribute
or
second
entry
in
this
de
Spectre,
which
might
map
say
color
to
blue,
and
you
know
now,
when
I
go
in
here,
that's
blue
or
I
can
make
it
italic
right.
You
know
right,
I
could
do
whatever
right.
You've
got
the
full
power
of
HTML
here,
just
in
this
sort
of
nice
data
format
so
yeah.
This
is
one
of
the
things
that
I
think
really
makes
us
powerful
and
which,
again
for
the
entry
point
to
it,
kind
of
evolving.
B
Beyond
its
initial
humble
beginnings,
as
a
data
was
a
data
visualization
framework
to
more
of
kind
of
a
complete
scientific
document
framework
right
if
you're
familiar
with
hiccup,
you
can
go
in
here
and
now
start
creating
documents
where
you
know
maybe
I'm
I've
got
a
code
name
space
here,
where
I'm
doing
a
bunch
of
data
processing
and
then,
at
the
very
end,
I'm
spitting
out
some
some
document,
which
summarizes
all
that
data
standards
relations
as
pros
kind
of
explaining.
What's
going
on,
etc,
right
so
really
really
really
kind
of
useful
stuff.
B
B
Cool,
thank
you.
So
if
I've
got
a
bunch
of
other
stuff
that
I'm
doing
in
preparation
for
getting
to
this
data
visualization,
you
know
and
I
change
something
up
here
having
to
go
up
and
rehire
light
all
this
stuff
and
sort
of
re-evaluate
it
can
be
kind
of
frustrating,
but
one
of
the
things
that
provides
which
gets
around
this
and
specifically
gets
around
one
of
the
cases
in
which
this
is
really
valuable
is
when
you
have
kind
of
heavy
data
processing
components
of
your
workflow.
B
So
if
you're
going
and
running
some
machine
learning
pipeline-
or
you
know
downloading
a
bunch
of
data
from
the
internet,
whatever
it
might
be
that
that's
taking
up
too
much
time,
you
don't
want
to
have
to
rerun
that
stuff.
Every
time
you
know
when
I'm,
when
I'm
moving
faster,
it's
because
I'm
just
re-evaluating
the
whole
file,
but
having
to
highlight
a
specific
trunk
of
code
and
evaluate
it
ends
up
taking
more
time.
B
B
B
B
B
So
a
lot
of
these
pieces
that
I've
been
talking
about
here,
kind
of
evolved
organically
and
naturally
one
step
after
the
next.
So
the
the
function
here
which
lets
us
do
this
is
Oz
build,
and
what
we
do
here
is
we've
specified
a
vector
of
build
specifications,
we're
gonna,
say
from
a
site
source
in
or
should
go
ahead
and
make
sure
that
directory
is
their
first
site
source,
we're
putting
some
stuff
in
there
in
just
a
second
and
we're
gonna
be
building
to
build
and
it'll.
B
Actually
it
infers
build
if
we
don't
specify
it
so
there's
a
default
for
that,
but
you
don't
specify
from
now
the
fact
that
there's
a
vector
of
these
means
that
you
can
kind
of
customize
different
directories
of
input.
Data
might
get
processed
differently,
which
can
be
kind
of
useful,
but
so
hope,
what's
going
to
run
this
here
and
now
we're
going
to
open
a
file
at
sites
or
say
hello,
MD
and.
B
B
B
B
And
yeah
there
we
go
okay,
sorry
about
the
sorry
about
the
wait
there
right.
So
there
we
go
so
now.
We've
got
this
content
up
here
and
just
to
kind
of
further
drive
home.
The
point
here,
I'm
going
to
actually
kind
of
separate
this
off
and
pull
it
off
to
the
side.
So
you
can
see
these
things
kind
of
running
together,
because
this
is
how
I
tend
to
use.
This
is
I'll.
Have
my
content
open
in
one
on
one
side
of
my
screen
and
and
then
be
visualizing?
B
So
we
don't
have
to
like
go
and
reload
there's
just
a
really
nice
set
of
features
and
I
haven't
seen
anything
like
this
out
there
in
the
closure
community.
As
far
as
static
site
generation
features
go,
so
you
know
it's
even
even
if
you're
not
doing
data
visualizations
or
data
science
work,
just
the
fact
that
you
can
use
the
static
site
generation
for
personal
websites
for
for
blogs,
whatever
in
and
of
itself
I
think
is
a
really
valuable.
It
is
a
really
valuable
thing.
I've
really
enjoyed
working
with
it,
so
yeah
I.
B
Let's
see
what
some
tried
to
be
thoughtful
here
about
what's
I
what
I
cover
I'm
I'm
tempted
here
to
give
give
this
one
more
go
on
the
live
code
reloading.
So
I
would
like
to
show
you
that
if
I
can
I'm
actually
going
to
pop
this
back
open
again
I'm
going
to
comment
this
out
and
plop
this
back
in
and.
B
I'm
gonna
try.
This
live
reload
one
more
time.
Hopefully
you
can
get
that
yeah
I,
don't
know
why
this
is
not
working.
I
haven't
had
this
problem
before
I
just
wrap,
no
idea.
What's
going
on
there
off
to
debug
that
yeah
sorry
for
that
I,
that's
unfortunate
that
I'm
not
gonna,
be
able
to
show
that
off.
But
you
know
I'll
give
just
a
brief
explanation
of
what
should
be
happening
here,
and
hopefully
you
know
later
on
it's
in
line
notes
or
whatever
we
can
kind
of
clear
up
whatever
the
issue
was.
B
B
Doing
odd
things
where,
if
I
have
some
really
expensive-
or
you
know
time,
computationally
expensive
steps
that
I'm
doing
in
some
sort
of
some,
some
workflow
I'll
sometimes
put
them
in
def
once
so
that
I'm
not
rewriting
them.
But
then
it
gets
to
be
really
problematic
when
I
do
need
to
rerun
them,
because
something
upstream
changed,
and
so
that
I'm
going
through
and
changing
def
once
to
Def.
B
And
then
it
you
just
get
into
this
kind
of
mess
of
having
to
worry
about,
staying
which
things
would
be
run
in
which
which
things
have
been
need
to
be
running,
which
don't
and
this
very
kind
of
simple
model,
just
free
running
from
the
first
change
in
the
file.
When
you
save
it
really
kind
of
just
removes
all
this
headache-
and
you
know,
I-
don't
use
this
for
normal
day-to-day
closure
coding
at
all,
I
you
could
potentially
I
guess
I
find
it's
usually
easier.
Just
to
be.
B
You
know
in
control
which
forms
I'm
loading
or
reloading,
but
for
doing
this
kind
of
data
science
workflow,
where
you're
just
kind
of
exploring
data
mucking
around
with
it
I've
found
that
it's
a
really
nice
really
nice
toolkit.
So
yeah
I'm,
again,
I'm,
sorry
that
this
isn't
that
this
isn't
working
the
way
I
had
expected,
but
but
yeah.
Hopefully
we
can.
We
can
figure
that
out,
and
you
know
let
you
know
what
the
problem
was.
There
yeah.
B
B
B
This
data
or
posting
this
data
to
a
github
gist
and
the
Vega
online
editor
has
this
cool
functionality
that
lets
you
load
a
Vega
Vega
light
specification
from
a
github
gist,
and
so
you
don't
set
up
some
credentials
to
stuff
to
use
this
functionality.
But
what's
really
cool
is
that
you
know
from
from
going
and
creating
some
visualizations
here
to
then
sharing
with
someone
who
you're
working
with
a
colleague.
B
It
just
becomes
really
easy
because
you
can
just
you
know,
run
this
function,
grab
the
URL
paste
it
in
slack
or
whatever,
and-
and
you
know
someone
you're
collaborating
with-
can
load
this
up
in
the
Vega
editor
and
actually
go
in
here
and
start
tweaking
it
and
save
it
and
I
mean
it's.
It's
really
kind
of
a
cool
cool
set
of
functionality,
but
unfortunately
it
doesn't
support
hiccup
coz
hiccups,
not
something
that
it
it
it
knows
about,
but
what
I
did
to
sort
of
facilitate?
B
This
is
I
built
a
site
called
oz
Visio,
which
makes
it
possible
to
share
these
hiccup
documents
which
might
contain
data
visualizations.
So
if
I
go
in
here
now
and
oh
actually,
just
click
open,
Lincoln
I
didn't
do
that
before
it's
gonna.
Take
a
second
to
load
up
here.
I
need
to
improve
the
performance
of
this
as
things
I
inserted
that
a
little
bit
quickly,
but
right
here
we
go
so
it
up.
I
can
now
get
this
URL
again.
B
So
my
set
of
things
here-
yes,
I,
don't
think
I'm
gonna
have
time
to
I'd
to
show
off
the
Ragin
API
or
notebook
integration
and
again
I'm.
Sorry
that
the
that
the
live
code
reloading
didn't
work.
Hopefully
I'll
figure
that
out
and
get
back
to
people
about
what
the
issue
was
there,
but
kind
of
switching
back
over
here
to
our
the
rest
of
our
there's.
The
the
content
I
have
prepared
some
of
the
things
that
are
worth
kind
of
knowing
about
in
the
Vega
and
big
alight
ecosystem.
B
Our
Voyager,
which
is
a
tableau
like
browser
tool
based
on
Vega
light
and
I'll,
be
try
to
be
really
quick
with
this.
It's
it's
a
really
cool,
really
cool
tool,
so
you
open
it
up
it
loads
up
with
some
dummy
data,
actually
the
same
cars
dataset
that
we've
been
playing
with
here
and
right
away,
without
even
doing
anything
it's
presenting
some
sort
of
univariate.
B
B
You
can
pass
around
between
processes,
etc.
Right.
So
really.
This
is
just
an
amazing
tool
which
you
know
I
highly
recommend,
if
you're,
if
you're,
using,
if
you're
using
this
whole
tool
kit
and
how
many
chance
of
working
with
folks
who
are
non-technical
and
wouldn't
want
to
be
coding
up
stuff
themselves.
This
is
just
a
really
powerful,
really
powerful
piece
to
the
the
puzzle
here.
B
So
this
is
a
cross
filter
example
where
we've
I'll
show
you
I'll
start
actually.
So
here
we
go
start
by
showing
you
how
the
and
let
me
make
the
a
little
bit
bigger
for
folks
I'll
start
by
showing
you
where,
in
the
spec,
we're
adding
this
this
select
functionality.
So
that's
in
here
one
of
the
layers
that
we
have
is
selection,
and
so
it's
a
brush
selection
of
type
interval
and
we're
brushing
the
X
the
X
aesthetic.
B
Here,
you're
able
to
start
interacting
with
this
data
and
starting
to
get
a
sense
for
how
these
different
variables
relate
to
one
another
right.
So
in
this
case
you
know
if
I'm
interested
in
you
know,
where
do
these
low
time
entries
pop
up
in
relation
to
delay
and
distance?
Well,
you
can
start
to
get
a
sense
for
that
right.
They
want
to
see
where
do
the
high
pop
up
and
I
don't
see
any
particular
correlation
there,
but
right
you
know
you'd,
imagine
based
on
some
certain
data.
B
You
might
really
be
able
to
start
digging
in
in
sort
of
novel
and
interesting
ways
to
the
data
and
really
I
mean
almost
yeah
in
it.
You
can
almost
get
the
sense
of
like
really
kind
of
digging
your
fingers
in
and
starting
to
pull
out
information
that
wouldn't
be
possible
with
the
static
visualization.
So
this
is
again
one
of
the
things
just
really
powerful
with
them
with
this
framework.
So
there's
a
bunch
of
other
examples
here.
B
Maybe
if
you
know
someone
has
questions
we
can
we
can
look
at
some
others
again
just
to
go
over
the
highlights
here
about
functionality
that
that
we've
kind
of
covered
there's
a
repple
API
for
exploration
from
the
from
the
repple
region,
API
for
turning
that
stuff
into
apps
compiling
into
HTML,
including
static
site
generation.
Publishing
and
sharing
features
notebook
integration,
then
by
code
reloading,
all
of
which,
hopefully
don't
make
this
a
Frankenstein
monster.
I
hope
that's,
not
the
conclusion
that
we
all
get
from
this
to
me.
We're
not
here
yet
to
me.
B
B
Well
simply
because
it's
kind
of
starting
to
do
so
much
that
you
can
only
point
to
it
as
like,
a
Swiss
Army
knife,
but
you
don't
really
get
a
sense
for
what
it
is
until
you
kind
of
dig
into
each
one
of
these
features
and
and
see
how
they
relate
together.
So,
incidentally,
you
should
find
this
is
actually
a
knife
that
supposedly
you
can
buy
for
ten
thousand
dollars
on
Amazon,
and
the
comments
on
this
thing
are
just
ridiculous.
B
So
if
you're
you're
looking
for
a
good
laugh,
just
try
to
find
this
winger
Swiss
Army
knife
on
Amazon,
so
it's
it's
I,
don't
know
how
that
made
it
past
the
Amazon
census,
but
anyway.
So
that's
what
I
got
for
now.
Thank
you
for
sitting
here
and
listen
to
me
and
I'm
happy
to
take
any
any
questions.
Now,
if,
if
anyone
has
some.
A
A
B
So
Vega
and
Vega
white
do
have
an
API
which
lets
you
add
data
to
an
existing
view.
Specification
I,
haven't
I,
haven't
exposed
that
yet
through
through
the
reagent
API,
it's
something
that
I've
been
waiting
a
little
bit
to
work
on,
because
I've
been
kind
of
thinking
about
the
way
that
I
want
to
do
it,
but
I
think.
B
Using
big
and
big
light
is
take
the
the
signals
which
represent
data
selections
and
then
go
and
use
them
in
the
rest
of,
say,
a
react
application
to
figure
out.
You
know
which
say
which
data
you're
going
to
put
in
a
table
of
you,
it's
a
sense
of
being
really
powerful,
because
then
you
can
have
a
data.
Visualization,
like
a
scatter
plot,
which
are
effectively
using,
is
like
a
navigating
window
into
more
detailed
view
of
the
data
as
again
say
like
a
table,
or
you
know
whatever
it
might
be
now.
B
I
will
say
that
if
you're,
if
you're,
just
using
Vega
or
Vega
like
components,
I
highly
comment',
just
using
the
kind
of
built-in
filtering-
and
you
know
interactive
features
to
say,
take
two
visualizations
and
sort
of
connect
them.
As
we
saw
with
the
interactive
example,
the
cross
filter
that
I
showed
you,
but
in
cases
where
you
need
to
take
that
data
and
use
it
in
kind
of
the
greater
context
of
a
say,
Iraq
application
or
some
other
web
application
that
ends
up
being
really
powerful.
So
yeah
that
is
on
the
roadmap.
B
B
Yeah,
the
the
live
code
reloading
all
that
kind
of
stuff
is
what's
been
most
useful
to
me,
and
so
that's
what
I've
been
spending
my
time
on.
You
know
what
time
is
kind
of
limited,
so
I
I
can't
work
on
everything
that
I
want
to
add
right
away,
but
certainly
if,
if
folks
are
interested
in
helping
with
that,
I
would
love
to
have
contributions.
B
B
B
B
Not
I
have
to
look
like
that
for
sure,
but
if
you
install
the
node
module,
you'll
get
a
system
executable
that
will
can
read
in
bigger
Vega
light
specifications
and
spit
out
a
static
compiled
image,
either
as
SVG
or
as
PNG,
or
maybe
it's
JPEG
I'm,
not
sure.
But
one
way
to
go
is
to
just
call
out
to
that
shell
process
and
effectively
what
that
would
do
is
make
it
so
that,
if
you,
if
you
have
that
installed,
then
you
would
you
would
get
this
functionality
effectively
right.
B
There
I
took
me
a
little
longer
than
I
think
most.
It
should
be
possible
to
to
do
that
and
I
actually
have
a
code
files
tucked
away
somewhere,
where
I
tried
to
get
that
working,
but
wasn't
able
to
and
I
just
need
to
go
back
and
kind
of
revisit
that.
The
third
path
which
someone
actually
wrote,
a
library
that
did
this
as
a
fork
of
Vizard,
which
actually
I
haven't
mentioned
this
yet
but
Oz,
is
a
fork
of
Vizard
which
was
written
by
Nathan
or
sorry,
not
Nathan,
not
naked,
which.
G
B
That
I'm
sorry
my
path,
him
yeah
yeah,
he
he
wrote
Vizard,
which
I've
worked
as
oz.
Someone
else
had
some
time
before
that
forked
off
is
I,
forget
what
the
the
library
was
called
down,
but
and
actually
added
this
functionality
where
he
was
sending
the
the
visualizations
to
the
front
end
to
actually
to
like,
whatever
browser
connected
to
having
them,
render
their
as
SVG
and
then
passing
the
SVG
spec
back
to
ya
back
to
the
to
the
to
the
closure
ripples.
So
that
is
another
way
to
go
here,
which
I,
don't
I,
mean
yeah.
B
So
all
three
of
these
approaches
sort
of
have
their
pitfalls
right.
It's
like,
if
you
don't
have,
if
you're
trying
to
do
this
as
a
server
on,
say,
a
server
where
you're
maybe
doing
a
data
pipeline,
you're
processing
a
bunch
of
visualizations
into
into
static
content
into
just
images
or
SVG.
That
doesn't
really
work
as
well
for
you
and
you
could
maybe
use
selenium
or
something
like
that.
But
you
know
there
might
be
there
might
be
gotchas
there
as
well
with
the
java
sort
of
direction.
B
You
know
it
makes
certain
assumptions
about
which
java
version
you
have
going
with
the
node
executable.
It
assumes
that
you
have
not
only
the
node
module
installed,
which
is
the
easy
part
actually
what's
what's
hard
with.
That
is
getting,
or
at
least
was
for
me,
but
what
I
kind
of
got
stumbled
on
with
it
when
I
tried
setting
it
up
was
that
you
have
to
have
I.
Think
it's.
Yes,
it's
the
canvas
API.
You
have
to
have
like
canvas.
B
Libraries
to
link
to
from
node
and
for
whatever
reason,
that's
been
challenging
for
me
on
my
system,
I
I,
think
on
Macs.
It
tends
to
be
a
little
easier
to
set
up.
So
none
of
these
solutions
is
exactly
perfect
and
I
think.
Ultimately,
what
I
may
do
is
kind
of
try
to
implement
all
of
them
so
that
you
know,
whichever
one
ends
up
working
for
you,
it'll
just
kind
of
defer
to
that,
but
yeah
I'm
again.
B
This
is
just
one
of
those
things
that
I
have
spent
a
bit
of
time
on,
but
it's
been,
you
know
for
all
the
reasons
that
I've
described,
it's
been
a
little
bit
of
a
challenge
and
hopefully,
hopefully
I'll
be
able
to
knock
that
out
soon.
But
again,
you
know
just
trying
to
move
move
as
fast
as
I
can,
with
the
time
that
I
have
mm-hmm.
F
B
That's
I
will
say:
that's
definitely
a
feature.
That's
really
high
priority
for
me
because
I,
you
know
in
the
past,
I've
done
a
lot
of
work
where
I've
had
to
do
that
kind
of
workflow,
where
I
have
had
to
compile
a
lot
of
static
images
for
whatever
reason,
and
so
it's
definitely
something
that
I
want
to
support
and
we'll
we'll
get.
G
D
B
Okay,
I
would
love
that
and
yeah
I
mean
I.
Think
the
easiest
of
all
these
approaches
to
implement
is
actually
just
calling
out
to
you
know
to
the
to
the
to
the
node.
Binaries
I
mean
that's
just
that's
super
straightforward,
so
I
mean
yeah.
Maybe
we
can
actually
just
knock
that
out
this
weekend,
because
that'd
be
great.
If
it's
easy
to
install
or
you
know,
if
you're
already
going
to
install
that,
then
that's
you
know,
that's
that's
an
easy
in
road
to
getting
that
functionality,
at
least
in
some
form
early
on
so
yeah.
B
So
thank
you
both
for
bringing
that
up.
I
yeah,
let's
knock
it
out,
I
think
that'd
be
great.
Yeah,
como,
Cheers,
yeah
I
also
just
wanted
to
say:
Tomas
is
alright.
Mm-Hmm
yeah
I've
looked
a
little
bit
at
clj
plot
now
and
really
cool
work.
I'm
excited
to
see
your
presentation
in
a
few
weeks
here
and
talk
more
about
how
these
things
kind
of
fit
together.
Yeah.
C
Yeah,
if
I
may
ask,
can
you
hear
me?
Okay,
yes,
yeah
yeah,
yeah,
and
so
this
is
linear
and
so
I
guess
what
Oh's
is
about
the
way
I
understand.
It
is
about
two
things:
one
is
connecting
to
the
Vega
ecosystem
and
the
other
is
a
certain
workflow
that
falls
office,
which
is
about
rendering
and
connecting
it
to
the
web-headed
experience
and,
and
so
I
wonder
about
the
other
thing
about
what
could
be
done.
C
B
B
What
I've
had
in
mind
for
that,
because
I've
certainly
had
ideas
for
other
things
that
I've
wanted
to
add
to
this
and
the
big
one
which
comes
to
mind.
It's
actually
an
issue
up
for
this
online
is
the
ability
to
add,
see
a
data
table
of
of
whatever
chunk
of
data
you're
looking
at
right,
because
then
you
can
kind
of
imagine.
This
is
the
kind
of
thing
that
I
find
myself
often
wanting
to
do.
B
It's
like
yeah
great,
it's
nice,
that
my
visualization,
but
sometimes
you
actually
just
want
a
table
of
maybe
not
even
all
the
data,
maybe
just
some
of
the
data,
but
but
that
can
be
really
valuable
for
presentation
and
documents.
For
you
know
whatever
end
I
mean
with
hiccup,
you
can
kind
of
do
some
of
that
right.
I
mean
you,
can
just
kind
of
manually
construct
the
table,
but
it'd
be
really
nice.
If
you
had
some
higher-level
components
where,
instead
of
you
know
doing
you're
doing
your.
B
B
Right
so
in
in
our
hiccup,
when
we
want
to
embed
a
vague
alight
visualization,
we
add
the
Vega
light
tag
right.
So
what
I'd
imagine
is
maybe
you'd
be
able
to
add
a
table
tag
and
then
just
kind
of
pass
in
your
data
or
refer
to
it
via
URL
kind
of
like
you
do
with
with
with
Vega
light,
and
that
then
that
would
just
kind
of
go
to
town
and
create
the
table
for
you,
and
you
wouldn't
even
have
to
think
about
it
right
and
maybe
there'll
be
some
specification
options.
B
That
would
let
you
you
know,
control
the
order
of
columns
or
whether
things
are
sortable.
You
know
all
that
kind
of
stuff
how
things
might
be
styled,
and
it's
really
easy
to
see
there
that
you
could
totally
go
overboard
and
make
things
way
too
complicated
I
want
to
try
to
build
something,
that's
just
just
enough
and
not
too
much.
But
what
that
has
sort
of
led
me
to
this
idea
of
is
that
you
know
the
more
of
these
pieces.
B
So
you
call
something
like
oz
register
tag
handler,
and
then
you
specify
you
know
Danielle's
like
crazy.
You
know
tag
renderer
and,
and
so
now,
when
you
go
in-
and
you
you
know
in
here,
if
it
sees
anyone
of
any
tag
that
sort
of
matches
something
that's
been
registered,
it's
gonna
go
through
and
call
whatever
whatever
function
you
you
have
specified
for
that
now.
B
The
challenge
in
that
is
that,
depending
on
your
context,
whether
you're
on
the
front
end
in
reagent
or
whether
you're
on
whether
your
enclosure
and
are
statically
compiling
right,
it's
like
you
almost
need
different
handlers
for
different
cases,
and
that's
one
of
the
reasons
why
I
haven't
built
this
yet
because
I
don't
want
to
build
it
the
wrong
way
and
sort
of
get
myself
in
trouble.
But
it's
I
think
it's
really
I
mean
you
know.
B
C
B
Wonderful
yeah,
yeah,
cool
yeah
and
so
again,
I
mean,
if
anyone's
anyone's
interested
in
any
of
this
and
wants
to
you
know
kind
of
chip
in
helping,
even
just
think,
through
architectural
II
how
these
things
might
fit
together
or
solve
some
of
the
conceptual
problems.
Whatever
would
love
any
help,
folks
or
folks
are
willing
and
able
to
give.
B
So
so
yeah
start
start
with
a
get
up
issue.
If
things
need
to
kind
of
work
off
into
closure,
Ian's
or
Azul
up
or
whatever
you
know,
we
can
have
conversations
elsewhere,
but
yeah
get
up.
Issues
are
good
way
to
start.
Thank
you.
Yeah
and
also
I
mean
I
when
I
think
of
something
that
I
want
to
add,
I,
usually
go
and
throw
up
an
issue,
real,
quick,
not
always
there's
some
things
that
I
haven't
added
for
whatever
reason,
but
it's
also
just
a
great
place
to
just
check
to
see.
B
If
you
know,
if
you're
thinking
of
something
like
hey
I,
wonder
if
eyes
does
or
it
wants
to
do
or
whatever
X
Y
or
Z,
then
you
know
just
go
in
and
search
through
the
issues
and
yeah.
Absolutely
if
there's
not
something
there
yet
go
ahead
and
add
it.
If
there's
something
already,
there
feel
free
to
chime
in.
D
F
B
I,
don't
just
spend
their
time
you're,
not
you're,
not
the
first
person
who
suggested
that
yeah
and
actually
I
have
I
have
submitted
and
I
think
they.
You
know
they
recently
did
a
survey
which
kind
of
gave
them
their
kind
of
roadmap
for
some
of
their
priorities
over
the
next
several
months
and
I'm,
not
sure
when
they'll
be
doing
the
next
survey.
But
one
of
the
things
I've
been
interested
in
is
just
getting
kind
of
a
vote
of
support
for
for
something
like
this
from
the
community.
B
So
if
you
see
the
closures
together,
stuff
come
up
and
you
want
to
make
it
known
that,
like
hey
data,
science,
is
something
that
that
we
should
be
focusing
more
on
as
a
closure
community.
Then
please
do
that,
because
that's
yeah
that'll
help
out
really
immensely
I.
Think
that
I
mean
you
know.
Other
others
have
talked
about
this
before
there's,
certainly
some
holes
in
the
closure
community.
B
As
far
as
you
know
how
you
use
it
for
data
science,
not
community,
so
much
as
ecosystem
I
should
say,
the
the
community
has
been
great
but-
and
you
know,
I-
think
a
lot
of
those
are
starting
to
get
filled,
which
is
really
awesome.
I
mean
not
that
long
ago
there
really
were
a
lot
of
options
for
visualization
in
closure,
and
I
mean
that
was
one
of
the
pain
points
I
first
hit
when
I
got
into
closure
was
like
it
was
great
for
doing
kind
of
like
the
core
data
munging
and
data
manipulation.
B
Side
of
you
know,
data
science
workflow,
but-
and
you
know
stuff,
like
machine
learning
and
whatever
I
mean
you
can
always
fork
off
to
another
process.
For
that,
but
like
data
visualization
from
you
is
just
something
I
do
all
the
time
and
you
know
really
wanted
to
have
as
part
of
my
closure
workflow-
and
you
know
it's
really
great-
that
now
between
us
and.
B
Hanami
and
coj
plot-
and
you
know
some
other
stuff
out
there
too.
You
know,
there's
really
a
bunch
of
cool
stuff
happening
on
that's
just
not
a
whole
that
we
have
anymore
so
yeah
right.
But
what
I
want
to
say
is
also
with
you
know,
with
the
lib
Python
stuff
that
Kristen
Berger
has
been
working
on
just
amazing
work
right
and
one
kind
of
fell
swoop.
You
know
making
making
the
wealth
of
the
Python
ecosystem
more
sort
of
accessible
to
us.
B
You
know
that
will
help
start
bringing
more
people
in
so
my
hope
is
that
you
know
we
can
kind
of
make
that
message
and
yeah
sort
of
convince
folks
with
you
know,
in
the
closures
together
panel
to
you
know,
start
funding
more
data
science
projects,
whether
it's
AWS
or
whether
it's
you
know,
Lib,
clj,
sorry,
Lib,
Python
or
or
or
whatever
it
might
be
right.
I
think
that
there's
there's
a
huge
amount
of
value
to
that
data.
B
Sciences
this
kind
of
rapidly
growing
field,
that's
considered,
really
high
value,
and
we
have
a
lot
of
I
mean
as
a
data-driven
language.
We
just
have
so
much
potential
strength
in
that
in
that
ecosystem.
So
I
know
I'm
preaching
to
the
choir
here.
So
I'll
stop
talking
about
that,
but
but
yeah
please.
You
know
please
please
express
interest
for
that.
If
there's
something
you
want
to
see.
A
H
Colleen
and
Swami
here,
hi
hi,
can't
see
you,
but
I
can
hear
you
hey
great
great
work,
fantastic
work,
taking
all
done
as
a
as
a
ggplot
heavy
user,
a
question:
it's
not
actually
up
so
much
Oz,
but
the
differences
between
we
bagel
I,
the
mega
and
ggplot.
Of
course,
Vega
brings
a
lot
of
things
that
ggplot
doesn't
do
like
the
interactivity
and
stuff
like
that.
But
is
there
anything
that
you
miss
from
ggplot
that
you
you
would
like
to
have
in
Vega.
B
That's
a
really
good
question,
I'm
really
tempted
to
say
no,
the
one
thing
that
I,
maybe
miss
a
little
bit
but
I'm
I
hesitate
to
even
say
is
that
at
the
time
I
really
liked
Gigi
plots
sort
of
style
of
you
know
being
able
to
create
a
visualization
specification
and
sort
of
add
to
it.
This
idea
of
like
creating
the
base
specification
and
then
going
and
adding
some
layers
to
that
or
you
know
going
in
and
tweaking
some
things
sort
of
step-by-step
excuse
me.
B
I
thought
was
a
really
nice,
for
you
know
it
early
incrementally
building
visualizations
up
so
initially
I
kind
of
missed
that
when
I
was
getting
into
Vega
light,
but
more
and
more
I
mean
it's
just,
and
this
is
probably
the
kind
of
thing
that
really
depends
on
you
know
on
on
the
individual.
The
coder
who
you
know
and
what
their
kind
of
preferences
and
style
of
working
is
for
me
personally
I
really
don't
mind.
Just
writing
out
this
kind
of
big
data
spec
and
usually
when
I
need
to
kind
of
break
things
down
into
pieces.
B
It's
easy
enough
for
me
to
you,
know
to
just
kind
of
do
that.
It's
like
okay,
I'm
gonna,
find
this
one
piece
of
the
speck
here
and
now
I'm
gonna
go
and
reuse.
That
here
I
mean
that
I've
found
that
I
end
up
feeling
like
I,
have
more
leverage
over
being
able
to
kind
of
dynamically
construct
these
visualizations,
if
I
just
leave
it
as
data
that
having
been
said
I'm,
you
know,
I
do
again.
B
I
mean
kind
of
my
mantra
here
continues
has
been
and
continues
to
be,
that
I
really
want
to
make
us
something
that
tries
as
much
as
possible
to
cater
to
everyone
again
without
turning
into
the
big
crazy
block.
Swiss
Army
knife,
so
I
have
thought
a
little
bit
about
what
would
an
API
look
like
that's
kind
of
similar
to
being
able
to
sort
of
layer
in
these
pieces
and
I
really
haven't.
B
This
is
actually
one
of
the
things
that
hanami
does,
which
is
kind
of
interesting
is
that
it
has
some
sort
of
higher
level
components
for
constructing
visualizations,
so
I
mean
that's
one
thing
that
you
might
want
to
kind
of
look
at
in
that
space.
It's
definitely
different
from
what
ggplot
does,
but
but
very
interesting,
so
I
thought
a
little
bit
about
that
kind
of
side
of
things
and
I
I,
just
haven't
felt
really
confident
that
I'd
be
adding
enough
value
over
over
just
the
basic
specifications.
B
Cuz
to
me
when
I
look
at
a
really
simple,
vague
alight
specification,
it's
like
God
everything,
I
kind
of
want
I,
just
want
to
see
it
as
one
sort
of
chunk
of
data.
That's
that
kind
of
how
how
I
personally
like
to
work
with
things
and
again
that's
been
a
little
bit
of
an
evolution
for
me.
I
think
I
missed
missed
that
more
at
first
then
than
I
do
now,
but
yeah
there's
nothing
else.
B
That
I
can
really
think
of
I
mean
as
far
as
functionality,
I
think
that
Vega,
not
even
just
in
the
interactivity,
but
even
in
the
way
that
things
layout
and
faceting
and
you
know,
being
able
to
take
two
plots
and
sort
of
join
them
together.
I
know
you
can
do
some
of
that
stuff
with
grid
and
I've
done
that
in
the
past,
but
I've
just
found
that
with
Vega
it
tends
to
do
the
right
thing
more
often
than
when
I'd
have
to
hack
certain
things
together
in
are
sometimes
so.
B
B
C
And
if
I
may
add
to
the
ggplot
discussion
by
Sammy,
I
guess
I
guess
one
conceptual
difference
between
T,
G+
and
Vega
is
that
ggplot
compiles
on
the
server
on
the
back
end
right
on
the
same
one
time
where
you
do
your
statistical
computation
and
that
allows
for
statistical
computation
to
be
part
of
the
computation
yeah,
and
so
you
may
add,
statistical
smoothing
of
theta
yeah
yeah,
yeah,
alright
and
that
may
be
missed.
Yeah.
Oh.
B
Maybe
so
that's
that's
a
really
great
point.
Yeah
thanks
for
bringing
that
up.
That
is
actually
one
thing
that
I
have
missed
the
some
of
the
yeah.
Some
of
the
statistical
stuff
that
it
provides
is
has
been
missing
and
vega
bites
actually
very
recently.
So
then,
now
there
is
some
stuff
that
well,
I'm
not
sure
if
it's
in
big
a
light,
yeah
I
know
if
we're
forgetting
what
the
status
of
this
is
now
I
have
to
look
it
up,
but
yeah
I
think
I
think
they
just
added.
B
B
B
You
know
that
the
one
of
the
really
nice
things
about
the
fact
that
again,
this
is
being
ushered
forward
by
the
IDL
interactive
data
lab
at
University
of
Washington,
is
that
the
I
mean
they've
got
a
whole
team
of
grad
students
and
Jeffrey
here,
who's.
Just
great
great
researcher,
all
working
on
this
and
yeah
I
mean
they.
You
know
I've
in
my
experience,
watching
them
watching
them
work
on
things
all
sometimes
I
mean
I've.
B
Had
this
experience
multiple
times
now,
at
least
like
three
or
four
times
now,
where
there's
something
that
I've
tried
to
do
and
haven't
been
able
to
do
it
and
I
go
and
I
update
the
version
of
Vega
light
or
they
go
whatever.
It
is
and
like
they've
added
it
since
then,
and
in
other
cases
at
least
again,
two
or
three
times
that
I
can
think
of,
there's
been
a
feature
that
I've
wanted
and
it
hasn't
been
in
the
latest
version
and
so
I've
gone
online.
B
You
know
submitted
an
issue
and
within
sometimes
a
few
weeks,
they'll
have
added
it
and
published
a
new
version
and
boom
there.
It
is
so
you
know
they're
it's!
It's
really
I
can't
highlight
this
enough,
like
it's
really
one
of
the
strengths
of
the
ecosystem,
that
they
do
such
great
work
and
that
they're
so
responsive
and
and
are
doing
things
as
an
academic
lab
right.
I
mean
they're
they're
thinking
carefully,
they're
writing
papers.
They're.
C
Thanks
so
maybe
we
can
discuss
interactivity
for
a
moment.
Yes,
so
so
both
Vega
and
Vega,
like
they
offer
a
certain
grammar
for
this
in
describing
interactions
and
I,
wonder
how
how
well
that
may
play
with
the
outside
world.
For
example,
if
you
have
another
component
in
your
page,
well,
yeah
react
to
anything.
Have
you
it
yeah
yeah.
B
B
B
Yeah
cool,
so
this
is
an
application.
This
actually
not
enclosure.
This.
This
is
built
with
react
using
the
thing
that's
called
reactive,
eiga
plug-in,
which
does
very
much
like
what
the
reagent
side
of
Oz
does
but
has
been
a
little
bit
more
fleshed
out
in
some
as
far
as
some
of
the
tapping
into
signals,
etc,
and
what
what
we
implemented
here,
I
can
talk
if
you're
interested
I
can
talk
a
little
bit
about
the
kind
of
domain
data
here
and
what
we're
actually
looking
at.
B
Unfortunately,
we
just
updated
the
schema
for
this,
and
so
we're
kind
of
operating
on
limited
data
until
we
until
we
rebuild
the
data
according
to
the
new
schema.
So
this
doesn't
look
quite
as
wonderful
as
I
had
hoped
to
be
able
to
show
you,
but,
but
in
short
here,
what
you're
able
to
do
is
right.
We
have
a
scatterplot
here,
which
you
know
again.
If
we,
if
we
had
all
the
data
in
here,
there
would
be
a
bunch
of
stuff
in
here,
and
you
see
some
colors
and
different
stuff.
B
But
what
we
can
do
is,
as
we
highlight
data
points,
we're
doing
exactly
what
I
kind
of
described
earlier
in
the
talk
where,
as
I
highlight
data
points
in
the
visualization,
it's
updating
what
you
see
down
at
the
table
below
right.
So
as
I
you
know,
I
can
even
I
can
even
grab
this
and
move
it
around
this.
This
window
selection
here
and
the
the
table
updates
darn
near
instantly,
and
so
this
application,
then
you
know
in
here
on
these
sort
of
detailed
points.
I,
can
kind
of
drill
in
and
find
out
more
information
about.
B
One
of
these
specific
data
points
that
we
were
looking
at
and
even
further,
you
know
now:
I
can
I
can
kind
of
click
on
one
of
these
data
points
and
see
some
more
information
about
the
history
that
led
to
this.
Then
it
was
interested
in
the
domain.
Data
I
can
explain.
What's
actually
going
on
here.
Might
help
interpret
what
you're
saying,
but
the
long
story
short
is
that,
yes,
you
can
absolutely
do
this.
All
that
we're
doing
here
is
we're
we're
adding
a
hook
to
I.
B
Think
it's
a
signal
handler,
which
is
what
it's
is,
what
they
call
it
right.
So
I
should
explain
a
little
bit
what
that,
how
that
kind
of
relates
to
things
so
again,
Vega
Vega
light
are
based
on
functional
reactive
programming
ideas
and
in
FRP
we
talked
about
and
sometimes
different
sort
of
frameworks,
etc
can
use
different
language.
But
one
of
the
kind
of
common
terms
is
a
signal
right.
As
this
idea
of
you
know,
reagent
we
tend
to
call
them
reactions
or
you
know
in
I
think
they
call
them
signals
in
Elm
and
yeah.
B
There's
some
other
terminology
floating
around
there
as
well
in
to
remember
what
they
are
in
the
react
realm,
but
I
think
they're
called
selectors
in
react,
but
the
idea
is
that
in
in
Vega
they
do
call
them
signals
and
you
can
tap
into
a
signal
and
any
time
it
changes.
You'll
get
this
handler.
You
know
that
and
that
you
can
call
and
plug
into
and
for
for
interactivity.
B
Every
little
piece
of
interactivity
try
to
add
to
the
application
is
ultimately
ending
up
manifesting
as
a
signal,
and
so
by
attaching
one
of
these
signal
handlers,
you
can
pipe
that
data
out
and
use.
However,
you
want
so
in
this
case
we're
taking
that
data
where
we're
plugging
it
into
the
react
framework
into
redux
and
and
then
you
know,
we're
doing
all
the
kind
of
standard
react
stuff
to
then
like
filter-
and
you
know,
control
of
the
views
based
on
that.
B
So
I'll
say
that
sometimes
things
can
be
a
little
bit
tricky
where,
like
as
I,
go
and
I
click
around
here
and
select
different
data
points.
Oh
that's
like
it's
kind
of
bad
example.
Here
let
me
try
it
like
that.
Okay,
so
as
I
go
and
sort
of
select
different
data
points,
you'll
see
that
it
actually
updates
the
visualization
as
well.
So
the
visualization
updates
the
table
of
what
the
table
can
also
update
the
visualization.
B
You
can
get
into
weird
sort
of
loops
that
way,
so
you
have
to
be
a
little
bit
careful,
but
you
know,
as
long
as
things
are
one
way,
it's
very
straightforward,
I
mean
even
when
it's
both
ways.
If
you're
sort
of
careful
about
how
you're
doing
things
you
can,
you
can
avoid
the
problems
but
yeah
I,
actually
kind
of
feel
like
explaining
what
this
is
because
I
think
it's
so
cool.
This
is
again
I
wish.
B
All
the
data
was
up
here
is
because,
if
it
even
cooler
to
look
at
but
each
one
of
these
data
points
represents
a
family
of
B
cells,
so
in
immunology,
B
cells,
code
for
antibodies
and
antibodies
are
sort
of
the
the
front
line
of
defense
in
the
adaptive
immune
system.
So
when
you
knock
out
a
cold,
it's
your
antibodies
that
are
that
are
that
are
really
doing
the
bulk
of
the
work
there.
B
But
when
you
get
a
new
cold,
what
you're
having
to
do
is
you're
having
to
take
old
B
cells,
the
cold
coded
for
the
last
sort
of
cold
virus
that
you've
got
and
it's
having
to
evolve
them
a
little
bit
too
to
adapt
to
this
new
cold
stream
right
and
once
you
get
from
that,
are
these
different,
related
sort
of
families
of
B
cells
and
each
one
of
these
points
in
this
visualization
actually
represents
a
whole
family
of
B
cells.
So
when
we
go
down
below
here,
we
select
a
one
of
these
specific
families.
B
What
we're
looking
at
here
is
a
phylogenetic
tree
or
evolutionary
history
of
that
particular
family,
and
so
you
can
start
to
drill
down
and
figure
out.
You
know,
based
on
this
coloring
scheme.
It
looks
like
you
know.
Where
starts
to
get
red
here.
This
is
where
you
started
to
get
a
really
effective,
B
cell,
so
you
can
go
in,
and
click
on
that
and
find
out
what
was
the
series
of
mutations
that
led
to
that
that
particular
B
cell?
B
I
was
gonna,
go
sleep
over
seeing
him
at
the
time,
and
you
know
dealing
with
some
of
the
finer
some
of
the
thorny
issues,
etc.
But
you
know
he
came
in
not
knowing
any
Vega,
actually
not
having
done
react
before
he
done.
Angular
yeah
I
think
was
angular
and
stuff,
but
he
really
quickly.
He
was
able
to
get
up
to
speed
and
within
a
period
of
like
I,
think
it
was
like
two
or
three
months.
We
were
able
to
build
out
most
of
this
functionality
and
you
know
it's
taken.
B
Obviously
you
know
how
projects
go
right,
there's
a
long
tail
where
you
know
those
last
follows
those
final
polishing
touches
tend
to
take
a
book
all
the
time
somehow,
and
there
are
other
parts
of
the
system
that
we're
working
on
right
so
but
I
mean
really
in
a
very
short
amount
of
time.
With
someone
who's
totally
new
to
the
framework,
we
were
able
to
build
some
incredible
interactive
data
functionality
and
I.
Just
can't
imagine
having
built
this
in
any
other
tool.
B
Kit
and
I
mean
I
can
be
wrong,
I'm
sure,
there's
some
d3
wizard
out
there
or
whatever,
who
could
have
done
some
really
great
work,
maybe
just
as
quickly
but
it's
it's
yeah.
This
stuff
is
really
powerful.
The
fact
you
got
all
these
interactivity
features
which
you
can
plug
into
other
parts
of
your
system,
etc.
It's
it's
all
just
been
really
well
designed
and
and
and
really
wonderful
to
work
with
so.
A
I
just
had
one
quick
question:
I
mean
the
documentation
is
pretty
pretty
comprehensive
and
there's
lots
of
examples.
So
if
somebody
was
just
studying
I
guess
it's
just
a
matter
of
just
jumping
in
and
trying
things
out
and
experimenting
is
there
is
anything
and
you'd
recommend
to
help
understand
the
kind
of
wider
context
of
like
data
visualization
and
things
that
as
well
yeah.
B
Yeah,
actually,
for
that
I'm
going
to
share
my
screen
again,
I
think
one
of
the
best
ways
of
just
getting
a
sense
for
what's
possible
with
with
Meghan
bagel,
I
and
I
mentioned
this
before,
but
I'm
glad.
You
asked
your
question
because
it
reminds
me
that
the
examples
is
this
right
is
yeah.
No
examples
see
oh
right.
B
Okay,
I
think
I
know
what
it
is:
big
samples,
yeah
cool
there
we
go,
you
can
go
to
either
Vega
dot,
github
that
I
Oh
Vega
light
examples
or
they
get
I,
didn't
how
about
Vega
examples
and
we'll
duplicate
this
tab,
so
you
can
see
both
of
them
but
yeah.
So
just
going
through
the
Vega
light.
Examples
really
quick.
This
just
I
mean
there's
some
silly
stuff
here,
like
cows
and
sheep
and
stuff
right,
see,
I
mean
even
with
mega
light.
There's
a
lot
of
you
really
do
have
a
lot
of
flexibility.
B
As
far
as
you
know,
what
what
you're
able
to
do
with
the
framework
and
yeah
I
mean
I
think
just
what's
his
name,
his
name's
escaping
me:
gosh
who's,
the
data
visualization
guru,
Tufte,
yeah,
Tufte,
edward
tufte,
who
you're
not
familiar
with
these,
are
in
some
great
books
about
data
visualization
and
really
I
mean
yeah.
He's
he's
a
lot
of
his
books.
Talk
about.
B
You
know
how
to
sort
of
strip
down
your
visualizations
to
just
kind
of
the
bare
essentials
and
not
be
sort
of
sharing
more
than
you
need
to,
and
so,
if
you're,
looking
for
kind
of
a
more
kind
of
theoretical
side
of
things,
I'd
really
recommend.
Tufte
is
a
great
great
place
to
start
for.
Thinking
about,
you
know,
principles
of
data
design,
but
one
of
the
things
that
he
talks
about
there
isn't
it
brought
him
up
here.
Is
this
idea
of
he
has
a
term
for
it
too.
B
But
this
idea
of,
like
oh
yeah
and
it's
the
put
a
fine
point
on
one
of
the
things
he
actually
recommended
in
one
of
his
talks-
is
that
you
know
if
you
want
to
learn
about
something:
don't
do
a
google
search?
Do
a
google
image
search
because
just
by
scanning,
through
a
bunch
of
images
related
to
whatever
it
is
that
you're
looking
at
you're
able
to
kind
of
pick
up
this,
you
know
the
visual
part
of
your
brain
is
able
to
sort
of
absorb
all
this
information.
B
A
higher
level
than
you're
able
to
just
reading
words
right
I
mean
the
old
adage
of
picture's
worth
a
thousand
words
really
rings
true
here
and
so
part
of.
Why
I'm?
You
know
slowly
scrolling
through
all
of
these
examples
is
just
that
you
really
start
to
absorb
this
sense
of,
like
all
the
kind
of
crazy
things
that
are
possible
with
Vega
light,
even
just
with
a
light
again,
there's
just
a
ton
of
great
examples
here,
but
going
in
real,
quick
and
kind
of
doing
the
same
thing
with
with
Vega.
B
You
can
see
that
there's
definitely
right.
There's
you'll
notice.
It's
a
little
bit
more
kind
of
diversity
and
some
of
the
things
that
folks
have
worked
on
like
wind,
vectors,
volcano
contours
circle,
packing
tree
maps,
I
mean
there's
really
just
word:
clouds
I
mean
the
list
goes
on
and
on
right.
Actually,
this
is
a
little
shorter
than
the
big
light
one,
but
yeah
it's
right.
This
even
a
Monte
Carlo
simulation
thing
here.
Right
I
mean
this
is
just
crazy.
B
You
can
go
and
play
the
number
of
number
of
points
in
the
simulation
here
and
see
how
the
see
how
that
converges
and
as
you
see
the
the
vegas
classifications
are
quite
a
bit
longer.
So
that's
you
know
worth
keeping
in
mind,
but
but
also,
if
you're
starting
off
with
the
vegas
spec,
sorry
vega,
light
spec
and
compiling
it.
You
can
get
a
lot
of
that
work,
done
kind
of
pretty
quickly
for
you
and
go
in
and
just
edit
the
pieces
you
need
to
so
yeah
I
mean
again.
B
Does
it
kind
of
get
back
to
the
original
question
here?
The
best
aside
from
you
know,
reading
Tufte
or
others
in
the
field
to
talk
kind
of
about
principles
and
ideas.
If
they
designs
are
sorry
of
data
visualization,
I
think
just
you
know
going
online
and
looking
at
all
the
examples
that
are
possible.
Usually
when
I
start
trying
to
visualize
something
you
know
I
come
through
here
and
I
kind
of
scan
like.
Oh,
you
know
yeah,
something
like
this,
maybe
looks
good.
Maybe
I'll
start
with
that,
and
then
you
know
find
another
visualization.
B
That
shows
some
other
aspect
of
things
that
I
might
want
to
look
at
and
then
kind
of
thread
that
in
you
know,
the
the
documentation
for
Vega
light
and
Vega
is
very
thorough
and
really
will
give
you
most
of
what
you
need,
but
it's
not
great
at
kind
of
explaining
I,
don't
think
it's
the
best
way
to
just
like
start
at
the
top
and
read
through
right.
So
I
think
you
know
if
you're
interested
in
big
and
big
light
and
want
to
get
started.
B
My
recommendation
is
actually
just
to
start
from
the
examples,
because
you
can
take
something
that
looks
like
what
you
want
and
start
to
adapt
it
to
something
that
you
is
closer
to
what
you
actually
need
and,
and
usually
that
involves
finding
one
plot-
that's
pretty
close
to
what
you
want
and
then
another
one
that
has
some
other
functionality.
You
want
to
add
and
figuring
out
how
to
merge
them,
and
you
know
there
I'll
admit
there
is
a
little
bit
of
a
learning
curve
here,
because
I
mean
with
with
data
specifications.
B
You
know
you
kind
of
have
to
know
what
the
structure
is
and
learning
some
of
the
underlying
patterns
there.
It
can
take
a
little
bit
of
time,
but
it's
definitely
worthwhile
I
mean
pretty
quickly.
You
start
to
see
those
patterns,
you
know,
after
a
few
weeks
or
so
figure
out
which
which
which
things
can
be
moved
to
where
in
the
specification
and
and
as
that,
as
that
starts
to
settle
in,
you
really
start
to
appreciate
the
full
power
of
the
framework.
B
A
I
think
we're
at
time
so
again.
Thank
you
very
much
Christopher,
for
this
talks
being
very
great
and
yeah
I
hope
everybody
else
is
going
to
get
engaged
with
the
project
and
help
you
out
with
creating
new
issues
and
new
poll
requests
as
well.
So
again,
thank
you
very
much
for
your
time.
Thank
you.
Thanks.