►
Description
In this meeting, we've had a talk with Vlad Protsenko about Reveal.
https://vlaaad.github.io/reveal/
Vlad also presented cljfx, the Clojure wrapper for JavaFX that is used for building Reveal.
https://github.com/cljfx
Towards the end, Vlad gave a live demo, showing how to extend Reveal for heatmap visualizations of Neanderthal matrices.
Moderator: Daniel Szmulewicz
Slides: https://tinyurl.com/y4bs4s49
Text chat: https://tinyurl.com/y5trszzr
Clojurians Zulip discussion: https://clojurians.zulipchat.com/#narrow/stream/151924-data-science/topic/reveal.20meeting
Relevant Clojurians Slack channels: #reveal #cljfx
A
Hello,
everybody.
This
is
yet
another
psych
clutch
meeting
where
we
are
studying
the
story
of
the
data
science
and
scientific
computing
enclosure,
and
today
we
will
have,
as
our
speaker,
vlad
senko,
who
will
speak
about
reveal
reveal
the
new
user
interface,
which
is
a
wonderful
variation
of
a
rebel
that
we'll
learn
about
so
vlad.
Would
you
like
to
present
yourself.
B
B
B
B
B
It
was
a
really
really
fun
and
like
enabling
environment,
because
I
could
just
write
code
and
see
something
on
the
screen,
but
the
language
itself
didn't
feel
very
powerful.
So
when
I
discovered
java,
I
was
blown
away
by
its
powers,
which
might
sound
a
little
bit
silly
now
in
retrospect,
but
compared
to
actionscript,
like
being
able
to
use
generics
to
express
myself
felt
very
liberating,
and
then
I
found
scala,
which
was
even
more
powerful
in
terms
in
terms
of
what
I
can
express
with
types.
B
But
I
guess
during
that
time
I
started
feeling
that
that
I'm
more
spending
time
on
like
playing
with
the
type
checker
and
trying
to
express
my
problem
in
a
way
that
will
be
fully
confirmed
by
by
compiler,
which
is
a
very
a
very
big
task.
So
then
I
discovered
closure.
I
was
again
blown
away,
but
by
what
can
I
do
with
it?
B
B
Can
be
done
with
the
ui
programs,
for
example,
I
can
like
there
are
two
types
of
profiling:
the
performance
one
is
like
measuring
the
execution
time
and
the
other
is
seeing
like
where
the
execution
is
spent
and
using
ripple.
I
can
combine
tools
that
do
both
and
get
get
more
meaningful
insights,
for
example.
B
Here
you
can
see
that
I'm
benchmarking
merge
and
into
when
I'm
for
mentioning
small
maps,
and
you
can
see
that
for
small
maps
merges
faster
than
into
which
is
might
be
a
bit
surprising
because
usually
intel
behaves
more
fast
due
to
transducers.
So
this
is
like
the
place
where
profiler
can
give
a
more
meaningful
information.
For
me,
it's
like
saying
where
the
time
was
spent,
so
I
can
see
that
in
a
introversion
there
is
like
a
lot
of
time
spent
in
converting
a
data
structure
to
transient
so
like.
B
For
example,
I
might
have
like
a
very
big,
a
very
big
chunk
of
data
like
a
byte
array.
That
is
there,
but
all
I
see
is
like
individual
bytes
without
knowing
what
are
where
do
they
come
from
and
they
might
come
from
like
me
using
some
binary
serializer
in
the
code
so
like
I,
I
could
produce
this
this
battery
myself,
but
using
the
ui.
B
But
there
are
some
problems
with
the
ripple.
One
of
the
big
problems,
I
think,
is
inspecting
big
data
or
well
big
data
structures
and
pretty
printing
helps
only
to
a
certain
point.
If
you
want
to
inspect
like
a
small
piece
of
data
you
found
in
this
big
data
structure,
you
have
to
manually
track
where
it
come
from
and
like
perform
a
bunch
of
get-ins
to
see.
What's
in
there.
B
Another
problem
is
that
rebel
is
just
the
stream
of
characters.
So
I'm
not
it's
not
expressive
enough
to
tell
me
like
what's
going
on
in
some
cases
here,
for
example,
you
see
that
there
are
two
functions:
fu
and
bar
that
return
ratio,
given
an
instance
of
radio,
but
they
those
are
different
ratios.
Can
you
can
you
guess
like?
What's
the
difference.
C
B
B
B
B
B
So,
given
a
particular
type,
you
can
have
only
one
implementation
for
that
protocol.
So,
for
example,
if
you
have
identification
for
string
that
returns
like
a
reflection
information,
you
can't
really
add
anything
to
that.
It's
like
if
you're
using
java
9-
and
you
have
now
model
information
that
you
want
to
to
see
like
you
can't
just
edit
there,
because
it
will
override
the
existing
implementation.
B
B
B
B
B
B
B
B
B
D
B
B
And
another
thing
which
is
which
I
think
is
very
important-
is
that
those
views
like
those
figures
they
were
produced
from
data,
so
vue
is
not
a
leaf.
You
don't
have
to
to
give
up
your
ability
of
inspecting
data
just
by
showing
it
differently.
So
here
you
can
still
select
the
night
and
get
the
value
back
and
keep
exploring.
So
this
is
what
it
is
readable,
visualize
loop.
B
B
So
I
I
used
to
use
print
statements
for
debugging.
I
think
prints
are
like
actually
a
very
good
debugging
technique,
because
it
doesn't
stop
the
execution,
so
you
can
more
easily
straighten
it
and
when
you
print
something
you
usually
you
print
only
the
things
you
want.
So
it's
like
very
like
a
focused
way
to
debug
your
program,
but
the
problem
with
prints
is
that
a
ripple
that
works
with
printing
can
only
work
with
character
streams,
because
this
is
what
print
is.
B
B
B
B
Where
reveal
is
available,
so
you
can
get
a
better
understanding
of
your
objects,
and
I
think
it's
very
might
be
very
useful.
For
example,
you
might,
you
might
have
a
look
at
the
class
closure
and
keyword,
and
you
can
see
that.
Oh,
there
is
a
bunch
of
stuff
like
package
names,
but
there
is
also
protection
domain.
I
wonder
what
it
is.
B
B
Your
data
better,
I
don't
know
someone-
might
find
it
useful,
but
I
mean
I
didn't
know
that
it
exists.
I
learned
it
that
every
every
class
has
a
a
reference
to
a
file.
It
comes
from
only
after
I
implemented
this
feature.
So
I
think
it's
a
very
interesting
that,
like
if
you're
dealing
with
you
know
some
java
libraries,
you
might
want
to
inspect
stuff
easily
and
you
can
do
it.
B
B
So
I
am
able
to
use
my
ide
to
send
forms
to
reveal
so
it
can
send
forms
to
browser
so
that
can
evaluate
code
and
give
results
back,
so
real
isn't
limited
to
be
only
a
a
tool
for
inspecting
like
a
gvm
process.
It's
like
like
a
apple.
It
can
talk
to
remote
processes,
but
you
have
to
understand
that
there
is
some
limitations
coming
with
it
is
that
the
only
finger
wheel
can
inspect.
B
B
Extend
the
multimeter
to
provide
your
own
custom
formatters
here,
for
example,
you
can
see
how
it's
done
so
there
is
a
blood
reveal
x,
namespace
that
is
used
for
extensions,
and
there
is
like
a
small
language,
that
of
like.
There
is
like
a
very
small
set
of
functions
that
can
be
combined
to
produce.
B
B
And
that
allows
you
to
add
about
any
inspection
to
any
objects
that
you
might
think
of
and
generally
it
is
not
a
problem
for
performance
because
for
ui
to
feel
responsive
there
is
like
around.
I
know,
30
milliseconds
window
to
run
all
those
predicates
like
all
those
actions,
and
this
is
well
unless
you
do
some
disk
io.
B
So
if
any
action
returns
an
object
which
is
a
clg
fix
description,
which
we
will
talk
about
in
the
second
part,
then
it
will
show
this
returned
value
as
a
clg
fix
node
node.
So
it
will
kind
of
convert
them
to
javafx
nodes
and
to
present
them
as
like
display
graphs,
and
it
it
is
basically
done
by
checking
that
return.
Value
is
a
map
that
has
fx
slash
type
keyword.
B
I
think
one
of
the
bigger
okay,
huge
wins
that
really
really
might
gain
is
that
access
to
a
to
web,
because
there
are
lots
of
very
good
data,
visualization
libraries
for
for
browser
and
currently
review
doesn't
exist,
doesn't
have
access
to
them,
which
is
not
100.
True
because
reveal
can
show
any
reveal.
Can
embed
like
web
browsers.
B
I
also
plan
to
to
change
how
the
the
output
looks.
I
will
probably
well
I
mean
I
haven't,
really
fought
that
through
like
completely,
but
current
plan
is
to
be
able
to
show
like
the
results
as
a
tree
instead
of
a
single
top
pane,
so
the
more
context
is
preserved
for
where
your
output
comes
from,
and
I
think
it's
also
useful
to
be
able
to.
B
B
B
D
Thank
you
very
much
for
this.
For
the
first
part
of
the
presentation
I
apologize
for
the
sound
when
I
just
when
we
just
started.
I
think
it's
fixed.
Now
I
just
it's
not
so
much
a
question
as
a
a
word
of
appreciation
for
your
work,
because
I
was
playing
with
reveal-
and
I
don't
know
if
it's
clear
to
everyone,
but
you
don't
lose
anything
by
plugging
in
reveal
into
your
workflow.
D
Environments
had
a
degree
of
liveness
which
was
never
matched
since
then,
like
even
today,
with
our
fancy
rebels.
We
don't
have
the
type
of
liveness
that
people
had
in
small
talk
environments
and
you
have
to
play
with
a
small
talk
environment
to
understand
what
I'm,
what
I'm
saying
you
can
download
the
stuff.
You
know
there's
still
a
lot
small
talk,
images
and
environments
that
you
can
that
you
can
use
to
just
get
a
feel
for
it.
D
People
are
not
even
aware.
Most
people
are
not
aware
that
we
have
rebels
in
the
mainstream
communities
and
in
the
least
communities.
We
are
not
aware
that
we
are
missing
out
on
the
liveness
of
small
talk
community,
so
it
is.
There
is
a
kind
of
irony
here
and
and
kind
of
sweet
sweet
revenge
as
well.
So
that's
what
I
was
wanting.
That's
that's
what
I
wanted
to
say
here.
Thank
you.
B
E
B
Yeah
so
reveal
used
to
have
tests
when
it
was
a
private
repo
in
my
github
like
earlier
versions
of
that
had
tests,
but
I
actually
it
was
quite
quite
nice.
I
I
really
like
them,
because
I
try
to
invest
in
spec
and
just
like
aspect,
my
like
the
main
data
types
that
reveal
uses
underneath
and
verify
that,
like
a
bunch
of
stuff
works,
and
it
was
very
slow
but
very,
very
good
and
finding
hidden
bugs
but
yeah,
I
didn't
really.
B
D
E
D
B
There,
actually,
there
are
some
specs
in
the
code
sprinkled
here
and
there,
and
I
use
them
mostly
for
myself
for
documentation
like
to
remember
what
is
what
is
there
but
yeah.
I
think
it's
like
it's
hard
to
test
the
ui,
and
I
mean
it's
reveal-
is
mostly
ui.
It's
like
the
only
good
way
to
validate
is
to
see
how
it
behaves.
B
E
G
F
H
It
was
introduced
in
closure,
1.10
and
it
puts
values
it
returns,
true,
which
is
a
little
weird.
So
when
you
use
it,
you
get
true
back
if
it
succeeds,
which
means
it's
a
little
weird
to
stick
it
into
threading
expressions,
but
it
puts
it
on
a
channel
and
then
various
things
can
listen
to
that
channel.
You
can
have
watches
for
tap
and
those
watch
functions
get
every
value
that
is
sent
to
tap
and
can
do
things
with
it.
H
So
you
know,
if
you
you're
doing
some
sort
of
debugging,
you
can
add
a
tap
watcher
and
capture
the
values,
and
then
you
can
take
the
tap
watcher
away
when
you
don't
need
it.
So
you
can
actually
leave
tap
in
production
code,
which
is
really
nice
because
it
really
puts
very
little
overhead
and
it
just
throws
data
away.
Once
it's
gone,
it's
got
more
than
a
thousand
values,
and
so
that
means
that
you
could
connect
into
some
production
process.
H
H
H
You
could
use
it
for
logging,
but
there
is
essentially
one
tap
channel
in
the
system,
so
everything
that's
tapped
in
your
system
will
go
through
the
same
place
and
if
you
are
tapping
values
faster
than
they
can
be
dealt
with,
it's
a
dropping
buffer
in
core
async,
and
so
once
there's
more
than
1000
2024.
I
think
values
it
just
starts,
throwing
them
away.
So
it's
not
intended
for
like
production
level
stuff,
but
it's
intended
for
you
know
being
able
to
attach
to
something,
examine
it
and
then
take
that
thing
away.
H
H
H
Some
just
some
key
yeah,
it's
it's,
it's
just
some
sort
of
little
tiny
thing,
yeah!
No,
it's
it
just
looks
a
bit
like
that
and
that's
kind
of
an
easy
way
to
explain
it
but
yeah.
It's
not
designed,
for
you,
know,
production
leverage,
it's
much
more
designed
for
tooling,
and
it's
used
in
rebel
as
well.
D
B
Okay,
now
that
seems
then
I'll
I'll
go
on.
Okay,
yeah,
if
you
update
sure
yeah,
I
probably
should
have
started
saying
that,
but
now
that
the
moment
has
gone
yeah,
so
the
first
part
of
this
talk
was
about
trivial.
The
second
part
is
about
clj
fix,
which
is
a
ui
library
that
reveal
is
built
on
and
the
one
you
use
for
creating
custom
use,
and
after
that,
if
you
will
have
time
left,
I
might
make
a
a
demo
session
where
I
use
reveal
to
extend
some
data
science
stuff.
B
B
So
clg
fix
what
is
it?
It's
a
react-like
wrapper
of
javafx
and
what
is
a
javafx
javafx
is
a
a
java
framework
or
library
for
creating
desktop
applications
using
gvm
so
like
it
exists
in
the
gvm
and
it
uses
all
the
objects
that
are
in
the
vm
and
before
we
go
into
details.
I'd
like
to
give
a
somewhat
unbiased
comparison
to
electron,
which
is
the
elephant
in
the
room
when
it
comes
to
creating
desktop
applications.
B
B
B
B
B
So
it
is
first
of
all,
it
means
that
you
still
have
to
have
some
knowledge
of
javafx
that
is
behind
clg
fix,
but,
like
the
translation
of
terms
is
pretty
straightforward,
so
javafx
has
properties
like
text
and
clj
fix
just
uses.
Keywords
like
text
for
that
and
for
listening
listeners.
It
uses
like
on
exchanged
convention.
B
B
Imperatively
configures,
the
text
field,
but
there
is
a
benefit
to
data,
is
that
we
can
have.
We
can
work
with.
It
is
data,
and
that
means
that
when
the
data
changes
we
might,
we
can
create
a
diff
like
to
see
what
exactly
changed
and
do
a
minimal
updates,
and
this
is
like
one
of
the
killer
features
of
react,
and
this
is
sort
of
the
thing
that
clg
fix
is.
B
Some
prop
programmatically
is
just
a
single
as
search
while
in
regent.
You
have
to
like
pick
a
second
element
check
if
it's
a
map,
if
it's
not
a
map,
you
just
insert
new
map
and
and
do
a
bunch
of
stuff
and
another
reason
for
you
for
going
with
maps-
is
that
hiccup
by
default
allows
allows
like
every
object
to
have
children,
and
this
is
this-
goes
from
the
somewhere
html
approach,
where
almost
every
dog
can
have
children
and
you
can
put
children
anywhere.
B
But
this
is
not
true
in
geofix,
so,
for
example,
text
field
it
doesn't
really
have
children,
there's
just
nowhere
to
put
them.
So
why
make
it?
Where
you
make
it
expressible
and,
in
addition
to
keyword,
effects
types,
you
can
use
functions
and
clgfix
will
call
them
for
you
and
expand
that
to
a
resulting.
B
B
B
B
Grids
and
and
the
way
to
layout
your
notes
in
grid
pane
and
then
there
is.
There
are
text
such
as
label
and
hyperlink,
and
I
should
mention
that,
after
text,
there
are
like
these
four
categories
of
inputs,
virtualized
lists
and
charts
in
multimedia
and
those
are
like
the
areas
of
javafx
where
things
start
to
get
a
bit
messy.
Sometimes.
B
Those
are,
I
guess,
that's
just
because
they're
implemented
as
a
mutable
soup
of
mutation,
there
are
just
bugs
here
and
there
that
come
up
from
time
to
time.
It's
not
horrible.
But
beware
so
yeah
there
are
various
inputs,
such
as
texts
and
buttons
and
select
boxes,
and
there
are
virtualized
lists
that
allow
you
to
show
like
a
huge
collections
of
elements
without
creating
like
nodes
for
all
of
them.
B
B
B
B
B
B
B
B
Tables
are
that
reveal
uses
are
also
available
as
a
custom
view,
which
is
a
table
view,
but
the
difference
with
the
built-in
action
is
that
you
have
to
provide
columns
by
yourself
and
basically,
the
built-in
action
that
allows
you
to
view
data
as
tables.
Just
just
has
a
little
bit
of
heuristic
how
to
how
to
find
the
columns
like
what
they
should
be.
B
Then
there
is
observable
which
is
sort
of
similar
to
refwatchers,
but
the
difference
is
that
observable
view
allows
you
to
create
your
own,
your
own
view
completely,
while
the
refwatchers
only
shows
them
using
this
built-in
streaming
formatting,
and
this
might
be
very
useful,
for
example,
if
you're
inter
iterating
on
some
on
some
function,
that
does
some
complex
data
processing
and
you
want
to
to
like
to
see
how
it
works
on
some
input
data.
While
you
are
working
on
it.
B
But
for
the
sake
of
example,
I
will
use
here
a
map
invert,
which
should
be
very
straightforward
to
implement
and,
as
you
can
see
so
first,
I
define
a
dummy
map,
invert
function,
and
then
I
create
an
observable
that
watches
it.
So
now
I
have
a
view
that
always
shows
the
result
of
calling
that
function
with
my
input
and
then
I
write
some
code
and
re
revaluate
it
and
just
as
I
evaluate
the
form
that
that
the
changes
map
invert
variable,
it
immediately
updates
the
view.
B
B
I
mean
it's,
not
the
thing
you
you
always
do,
because
rebel
is
already
quite
a
fast
feedback,
but
it
happens
from
time
to
time
when
I
have
like
some
piece
of
data
and
some
data
transformation.
I
have
in
mind-
and
I
just
I
used
to
like-
redefine
the
function
then
try.
It
then
redefine
the
function
then
try
it
here.
I
can
just
iterate
on
the
function
and
see
the
results
immediately.
B
For
example,
I
might
have
two
brokers
that
I
used
to
buy
stocks
and
I
might
want
to
to
compare
them
in
a
various
way.
For
example,
I
can
use
pie
chart
to
see
like
how
the
combined
portfolios
look
like
what
this
my
most
and
least
popular
stocks,
and
then
I
can
use
bar
charts
to
compare
them,
and
it's
all
pretty
easy
to
do.
I
just
create
a
data
like
in
the
in
the
correct
shape.
B
B
B
B
You
create,
it
doesn't
have
like
a
pop-up
with
associated
value
by
default.
You
provide
it
yourself
and
that
way
you
can
create
a
explorable
views
here.
For
example,
you
can
see
an
atom
with
a
number
and
I
created
an
observable
view
of
that
atom
that
shows
it
as
a
slider
with
a
callback
that
updates
an
atom.
B
So
whenever
I
move
the
slider
the
value
in
the
item
changes,
but
in
addition
to
that,
I
wrap
it
in
the
pop-up
view
where
I
reference
this
atom.
So
now
I'm
able
to
press
space
or
click
with
the
right
mouse
button
on
this
slider,
and
I
can
then
work
with
like
with
that
atom
as
an
atom
like.
So
I
can
get
back
to
the
data
that
was
used
to
produce
this
view.
D
H
D
Actually,
the
comparison
should
have
maybe
been
between
electron
and
java
effects
right
because
javafx
is
is
maintained
by
or
supported
by
a
whole
ecosystem,
so
clj
fixes
a
wrapper
on
dsl
over
java
fix.
But
it's
not
I
mean
it's
when
you
compare
electron,
you
maybe
can
also
bring
in
the
the
you
know
the
the
positive
points
about
java
effects
right.
B
E
Yes,
I
was
wondering
about
specifically
about
clj
effects,
simply
because
there's
always
the
possibility-
and
of
course,
let's
hope
that
doesn't
happen,
but
it
can
happen
that,
as
you
are
adding
a
new
layer
on
top
of
java
effects,
there's
also
the
chance
that
bugs
could
be
added
as
well.
And
that's
probably
I'm
asking
what
blood
meant
by
enterprise
support
right.
E
E
H
E
B
B
E
D
Yeah,
that's
exactly
what
that's
exact!
That's
a
very
good,
a
very
good
point
in
my,
in
my
opinion,
this
is
this
is
how
you,
when
you
choose
a
your
dependencies,
you
have
to
understand
that
every
time
you
add
a
layer,
you
add
risk
and
you
have
to
assess
how
how
much
worth
it
is,
and
this
assessment
is,
is,
is
being
done
by
by
you
right.
A
B
Yeah
yeah,
I
think
I'm
not
sure
I'm
seeing
what
you're
asking
because
reveal
as
a
rebel
like
has
the
whole
output
as
a
text
that
you
can
select
and
copy
and
save.
So
this
is
sort
of
like
there
is
a
linear
history
of
forms
sent
and
results
received
it.
It
is
not
a
notebook,
but
that's
because
I
didn't
try
to
make
one.
B
B
It's
like
there
are
relationships
and
obstructions
and
like
the
relationships
between
those
abstractions,
are
like
very
intense.
There
is
like
a
huge
web
of
everything
connected
to
everything
that
I
have
to
have
in
mind
when
I'm
programming,
and
I
don't
think
there
are
good
visualization
tools
for
that.
B
Maybe
I'll
come
up
with
something
but
yeah.
This
is
sort
of
the
thing
I'm
thinking
about
from
time
to
time.
It's
like
how
can
I
visualize
what
I
have
in
my
head
when
I'm
developing
like
a
program
that
is
not
that
visual
yeah,
but
yeah
so
reveal,
doesn't
try
per
se
like
to
be
a
data
science
tool.
It
just
happens
to
be
data
science
tool.
I
Hi
everyone
great
great
presentation,
thank
you.
I'm
gonna
go
and
play
with
this
tomorrow
when
I
wake
up
not
anymore
today,
but
a
short
comment.
I
I
think
I
mean
what
danielle
said
that
last
daniel
said
is
very
true
that
you
have
in
data
science.
You
have
a
lot
of
this
linear
exploration,
notebook
way
of
working,
but
it
is
not
the
only
one
I
mean
there
is.
I
There
is
also
when
you
do
explore
explorative
data
science.
You
use
often
sort
of
a
rebel
like
experience,
and
I
see
there's
a
lot
of
promise
in
what
we
saw
now.
But
I
was
a
bit
interested
in
because,
if
I
understood
correctly
the
visualization
abuse
they
come
from
the
javafx
library
right
or
are
they
something
that
you
built?
On
top
of
it.
B
B
I
guess
the
it's
like,
as
I
mentioned
earlier
like
earlier
when
I
was
like
giving
sort
of
a
short
overview
of
different,
like
areas
available
in
java
effects.
Is
that
the
like
the
more
complex
you
go,
the
the
buggier
it
gets,
and
so
like
it's
some
it's
like
I'm
not
sure.
I
agree
that
javafx
is
very
mature.
B
B
B
They
are
too
too
big
these
circles
and
I
would
prefer
them
to
be
smaller,
and
so
I
feel
they
are
it's
like
they
are
not
designed
for
data
science
or
for
like
very,
like
configurable
use
cases
very
like
sensitive
use
cases,
but
I
think
it
is
really
useful.
So
that's
why
I
am
also
wanting
to
have
a
a
support
for
using
like
javascript
libraries
for
visualizations.
B
B
B
F
On
board
into
closure
yeah,
I'm
I'm
trying
to
get
more
adoption
in
my
company
and
on
my
team
foreclosure
and
a
lot
of
people
said
well,
it's
just
so
different
than
what
we're
used
to,
but
having
some
sort
of,
I
don't
know
tutorial
some
some
something
that
you
can
step
through
yourself
and
learn
the
sort
of
rebel
workflow
like
this
of
run.
It
see
it
watch
it
change.
F
D
I
think
that's
exactly
what
the
consequence
would
be
with
a
tool
like
like
reveal,
because
your
rapper
suddenly
becomes
a
rebel.
The
the
print
becomes
a
visual
visualization
thing,
so
it's
it's.
What
it's
the
gift
of
reveal
is
that
you
can
certainly
write
your
code
in
in
the
rebel
and
visualize
it
differently
more
more
in
with
more
liveness
than
in
your
normal
rebel.
B
B
B
D
D
H
I
got
a
little
frustrated
with
rebel
because
it
wasn't
being
evolved
very
quickly
by
cognitect,
but
it
was
certainly
very
slick
and
they
were
clearly
using
it
all
the
time
in
their
work.
So
when
I
first
started
looking
at
reveal
it
didn't
kind
of
give
me
enough
of
the
rebel
experience
and
I
chatted
with
vlad
online
quite
a
bit,
and
he
sent
me
a
snippet
of
code
that
essentially
stores
the
tapped
values
in
an
atom
and
always
displays
the
last
tapped
value
in
a
table
using
whatever
table
view.
H
It
is,
and
that
gave
me
almost
rebel
experience
and
what
I've
done
is
extended
it
out
into
two
panes.
So
now
I
have
it
automatically
display
the
metadata
and
the
table
value,
and
so
you
know
that's
my
sort
of
day-to-day
work
environment.
Now
I
have
atom
taking
up
most
of
the
screen
where
I'm
developing
the
the
way
I
work
with
atom
with
chlorine
is
that
it
doesn't
have
a
panel
that
you
can
type
into
it.
H
H
I
certainly
find
that
it,
the
visual
representation
of
the
data
structures,
is,
it
saves
me
having
to
drill
into
a
lot
of
the
data,
because
that's
what
I
was
finding
before
when
I'm
working
in
the
repo
and
I
get
a
print
out
of
some
massive
data
structure.
I've
got
to
go,
oh
like
I
need
to
take
the
first
one
of
those.
What
does
that
look
like?
H
I've
never
seen
that
before
and,
of
course
you
know
it
makes
perfect
sense
now,
knowing
what
I
know
about
reveal
and
coj
effects,
but
I
think
there's
a
lot
more,
that
you
could
do
in
terms
of
building
a
customized
visualization
rebel
that
suits
your
own
workflow.
So,
if
you're
doing
something
that
is
heavily
visual,
where
you
want
to
produce
graphs,
you
could
set
it
up
so
that
it
automatically
produced
a
graph
from
whatever
value
you're
evaluating.
F
F
I
I'm
imagining
there's
plenty
of
people
out
there
like.
If,
if
you're
knowledgeable
enough
to
look
for
closure
and
look
for
resources
on
closure,
you
can
copy
and
paste
something
into
a
terminal
right.
I
think
that's
a
reasonable
assumption
and
from
there,
if,
once
we've
got
them
doing
that
and
opening
a
repel
and
following
along
with,
like
I
mentioned,
a
tutorial,
I
find
tutorials
useful.
I
think
you
can
see
the
reple
workflow.
You
can
see
how
closure
works.
You
can
watch
how
you
know.
F
Like
I
said,
standard
built-in
functions
are
modifying
data
and
go
oh.
This
is
this
is
closure.
This
is
it.
I
don't
have
to
go
rewrite
like
how
many
times
I've
rewritten
for
loops
to
do
basic
data
modification
that
is
just
available
to
me,
and
I
think
that
that's
a
good
learning
process
for
people
and
that
that's
as
we
were
talking
about
this,
it's
all
I
all
I've
been
thinking
about.
So
I
think
it's
a
really
cool
tool
and
I'm
I'm
excited
to
see
it.
D
Great
and
I
would
be
very
curious
to
see
how
you
managed
to
incorporate
this
tool
in
the
process
of
onboarding
in
your
company,
if
you're
doing
that,
if
this
is
part
of
your
responsibility,
I
would
love
to
hear
more
when
you
get
when
you
get
a
bit
more
experience
with.
How
does
how
does
it
work
with
your
team
or
with
the
people
who
needs
onboarding,
really
curious,
because
it's
a
it's
a
big
question:
how
we
do
that?
How
we
help
people
get
on
board.
A
H
As
you
say,
on
the
onboarding
side,
I
think
if,
if
you've
got
a
good
curated
setup
for
developers,
that
is
a
sort
of
standardized
way
for
the
team
to
work
that
helps
a
lot.
I
mean
we,
we
don't
on
board
new
developers
at
our
place.
Very
often
we
have
very
low
turnover,
but
we
have
scripts
essentially
to
build
your
development
environment
and
a
lot
of
the
tooling
that
we
kind
of
recommend
to
developers
is
built
into
our
repo.
H
So
I
mean
we're
all
on
the
closure,
cli
and
stuff,
and
so
there's
sort
of
a
whole
bunch
of
standard
aliases
in
that
where
we
say
okay,
you
know
this.
This
is
how
you
start
a
rebel
with
your
tests,
and
we
could
say
you
know.
This
is
how
you
start
a
rebel
with
reveal,
and
then
you
just
attach
your
editor
to
it
and
off
you
run
kind
of
thing.
That
said,
you
know,
closures
developers
as
a
whole
are
pretty
heterogeneous
and
the
tooling
they
prefer
is
is
quite
a
broad
spread
of
things.
H
D
H
H
I
think
the
nice
thing
with
something
like
reveal
is
it's
very
composable
with
that
kind
of
approach,
and
I
do
sort
of
wish
more
people
would
look
at
onboarding
new
developers
by
starting
them
with
very,
very
simple,
tooling
and
showing
composition
of
tooling,
which
is
kind
of
the
closure
way
rather
than
you
know.
Oh
here's
line
again
it
it
slices
it
dices.
It
builds
jaw
files,
it
deploys
things,
it
does
all
this
stuff,
it
runs
your
tests
and
the
same
kind
of
goes.
You
know
with
some
of
these
other
packages.
H
A
H
A
C
H
B
B
So
let's
try
yeah.
I
prepared
a
little
bit
of
code
for
that,
but
the
idea
was
is
to
try
and
show
how
you
can
adapt
various
tools
to
reveal
and
to
show
its
extensibility
features
here,
for
example,
yeah,
and
the
idea
is
that
I
I
can
show
you
how
to
like,
adopt
neanderthals
mattresses
representation
to
to
make
it
like
more
explorable.
B
B
C
B
And
like
this
scales,
two
very
big
numbers
so
when
the
numbers
get
too
big
they're
just
like
shown
as
exponents-
and
I
extracted
the
logic
in
the
fixed
width
number
yeah.
But
as
you
can
see,
the
problem
with
that
is
that
those
numbers
are
not
precise.
So
you
might
want
to
be
able
to
to
look
at
those
numbers.
B
B
Now
in
reveal,
there's
there's
x,
namespace
that
I
use
for
for
using
its
extensibility
mechanism,
and
I
can
there's
a
function
called
s
that
streams
like
the
formatting
for
some
value
using
a
different
representation,
so
like
default
representation
for
a
number,
looks
like
this,
and
s
allows
us
to
to
override
this
representation
here.
Here's
how
it's
done
so
you
you,
you
format,
this
number
using
some.
B
B
Mattresses,
so
it's
done
with
the
stream
macro,
which
is
a
sort
of
a
sugar
for
a
dev
method,
but
it
has
some
additional
stuff
in
there
to
annotate
the
value
to
annotate.
The
printed
text,
with
the
like,
with
the
value
that
was
used
to
produce
this
text
to
to
enable
this
pop-up
loop
of
exploring
data.
B
B
B
B
Yeah,
okay,
so
I
just
vertically
stream
every
row
and
from
that
row,
which
is
a
neanderthal
object.
I
just
horizontally
stream
every
item,
which
is
a
number,
so
we
are
almost
there
as
you
can
see:
they're
just
numbers,
but
yeah.
Now
we
have
to
apply
this
streaming
formatting
to
that
that
makes
them
fixed
with.
B
Another
example
would
be
to
creating
a
custom
view
using
clg
fixes,
nodes
and
yeah.
I
don't
really
know
much
about
linear
algebra,
but
I
thought
that
those
numbers
from
one
to
zero
from
zero
to
one
they
might
represent,
like
a
heat
map,
for
example-
and
we
might
want
to
look
at
this
matrix,
not
as
a
numbers
but
as
a
heat
map
to
see
like
where
it's
hot
and
where
it's
not
and
that
can
be
done
sort
of
quite
easily.
Let's
try
it.
B
C
B
B
B
B
C
E
B
B
B
And
yeah,
let's
see
like,
for
example,
this
looks
quite
quite
red
and
this
number
is
quite
close
to
one
and
like
this
is
completely
dark
and
it's
yeah.
It's
pretty
close
to
zero
and
we
still
have
all
those
exploration
capabilities
retained.
So
we
can
just
have
a
look
or
maybe
maybe
I
might
want
to
to
provide
here-
a
bit
more
information.
So,
instead
of
well
just
showing
like
the
entry
in
this
matrix,
we
can
also
show
like
what
is
the
row
and
what
is
the
column,
and
I
know
why
not
the
matrix
itself.
B
Yeah,
let's
have
now
yeah
so
quite
easily.
We
can
add
a
bit
more
information
here
to
see
like
where
this
number
comes
from.
Okay,
it's
this
row.
Let's
go
so
now.
We
have
this
heat
map
function
that
just
can
show
us
a
heat
map,
and
I
mean,
as
you
see,
this
is
just
a
function
that
takes
data
and
returns
data
and
we
can
then
use
it
somewhere
else.
For
example,
let's
define
an
action.
B
B
D
D
A
And
maybe
could
I
suggest
maybe
something
there
is
something
that
we
sometimes
do
after
the
talks.
We
organize
small
meetings
where
we
need
to
hack
something
without
bothering
the
library
author
I
mean
the
library
auto
can
join,
but
we
do
not
need
them.
We,
the
non-experts,
meet
and
try
to
do
something,
maybe
a
session
of
this
kind,
and
then
we
can
get
a
feeling
of
how
it
is
and
then
maybe
we
can
start
thinking
how
much
we
could
use
it.
E
Yeah,
I
think
this,
this
kind
of
meetings
are
very,
very
useful
for
everybody,
because
sometimes
it
happens
that
one
is
learning
about
specific
tool
or
library,
in
this
case,
for
instance,
I'm
learning
about
spec,
and
sometimes
you
have
a
silly
error
that
takes
you
maybe
a
week
to
figure
out,
and
you
just
ask
someone
who's
experienced
with
the
tool.
You
are
trying
and
say:
yeah.
D
E
A
Usually
there
are
those
people
who
prefer
a
gui
and
those
who
prefer
to
code,
and
these
two
cultures
might
not
be
meeting
a
lot,
but
now
vlad
opens
a
door
that
allows
to
do
both
at
the
same
time
and
they're
actually
actually
very
specific
applications
that
we
know
of
those
guis
that
are
actually
useful
for
data
exploration.
But
now
we
could
just
have
them
as
a
view
of
a
rebel
data
structure,
so
we
must
try
to
use
it
in
these
very
concrete
cases.
A
For
example,
you
have
you're
doing
the
machine
learning
and
you
have
a
decision
tree.
So
you
wish
to
explore
this
tree
and
many
people
do
that
in
a
visual
way
and
there
are
tools
that
cost
money
that
allows
you
to
walk
in
the
tree
and
look
into
the
numbers,
and
now
it
could
just
be
a
view.
So
there
is
like
giant
potential
here
for
things
that
could
happen
now.