►
From YouTube: Clojure visual-tools meeting 6
Description
In this monthly meeting of the Clojure visual-tools group (May. 6th, 2022), we had a few updates about ongoing projects.
Summary: https://clojureverse.org/t/visual-tools-meeting-6-summary-video/
Zulip topic thread: https://clojurians.zulipchat.com/#narrow/stream/313390-visual-tools/topic/meeting.206
A
A
What
you
know
from
from
various
people
who
are
working
on
interesting
projects
in
the
community
and
other
potential
projects.
People
are
thinking
of
doing
so.
It's
just
a
place
to
come,
sort
of
hang
out
and
nerd
out
about
closure,
data,
stuff
and
yeah.
I
guess
we
can
maybe
get
started
go
around
with
the
updates.
I
don't
know
what
do
you
think
cool
cool,
so
yeah?
B
The
idea,
I
call
this,
the
the
saturn
there
it
is
like
do
most
what
atom
did,
but
with
less
dance
code.
What
I
meant
by
that
is
like
I
don't
want
the
when
I
tried
to
hack
on
atom.
I
saw
that
they
did
lots
of
things,
so
there
are
lots
of
plugins
and
npm
modules
and
everything
else
that
they
decided
to
do
by
themselves
and
that's
not
really
a
good
idea.
B
If
I
want
a
really
small
team
to
handle
the
editor-
and
in
fact
probably
one
of
the
reasons
that
is
like
currently
dying
and
not
receiving
attention
is
because
it's
simply
too
much
work
for
to
feel
people
so,
but
there
are
some
ideas
that
atom
did
that
are
really
good
that
I
want
to
implement
then
so
atom
decided
to
use
the
plugins
the
most
possible.
So
I
want
to
even
go
further
but
avoid
the
problems
of
not
invented
here.
So
we
use
the
community
packages
most
time
and
not
do
anything.
B
B
Slower
code,
but
well
that
can
be
handled
with
blue
gains
and
also
I
want
to
target
electron
but
possibility
for
other
environments
like
the
console
with
some
kind
of
react
binding,
and
that
is
the
hardest
part
like
reuse,
plugins
from
other
editors.
So
I
want
to
reuse
some
things
from
autumn
and
from
vs
code
to
generate
this
whole
idea.
B
B
B
So,
for
example,
a
clojury
repo
plugin
provides
autocomplete
and
the
atom
itself
consumes
the
autocomplete,
so
any
other
plugin
can
consume
autocomplete
and
do
whatever
he
wants
with
the
with
that
data.
That's
amazing
because
well
a
plugin
can
know
the
existence
of
other
plugins
even
through
and
out
on
itself
like
can
choose
to
not
know
what's
happening
in
this
in
this
communication,
so,
for
example,
for
me
the
best
example
is
the
tab
bar
the
status
bar.
Oh
sorry,
the
stop
spot.
B
The
stats
bar
provides
the
status
for
the
plugins
and
other
plugins
consume
the
status
and,
like
add
information
and
so
on
and
so
forth.
So
the
atom
editor
does
not
even
know
that
there's
a
status
bar
in
the
ui,
it's
simply
a
plugin,
that's
drawing
on
the
screen
and
autumn,
say:
okay
sure,
communicate
between
you
and
decide
what
you
want
to
do.
So
it's
amazing
and
that's
a
good
idea
if
we
want
to
like
get
things
modeled
and
everything
else.
So
I
want
to
explore
more
of
this
plugin.
B
B
B
If
you
want
to
save
configs
well,
plugins
loading
extensions-
well,
maybe
not,
I
think
saturn
must
be,
must
do
something
right.
I
mean
otherwise
what's
the
deal,
but
I
don't
know
maybe
a
different
way
to
load
extensions
like
you
put
in
this
there's
a
default
that
you
put
in
a
specific
path
and
everything
gets
reloaded
or
you
can
just
have
a
configuration
with
text
files
that
we
can
like
put
in
the
dot
files.
B
So
it's
it's
good
to
explore
the
idea
and
the
configuration
manager
yeah
look
into
so
the
saturn
will
provide
a
default
for
all
this,
but
they
all
can
be
replaced
and
the
question
are
we
there
yet?
So
this
is
the
ui
of
saturn,
as
you
can
see,
it's
exactly
the
same
as
the
atom
as
of
as
of
now,
with
the
exception
of
the
editor.
So
this
editor,
it's
the
monaco.
The
signal
that
you
see
is
being
used
on
vs
code.
B
If
I
click
something
here,
I
can
open
this
files.
I
cannot
save,
I
don't
have
autocomplete
and
nothing
else
works
for
now,
but
at
least
it
I
can
open
things.
So
it's
really
really
in
the
beginning
and
how
opening
a
file
works?
Well,
it's
kind
of
complicated,
but
it's
it's
needed
for
the
for
the
plug-in
architecture.
So
when
saturn
boots
it
will
consume
the
services
called
layout
and
the
layout
plugin
will
start
eventually
and
provide
the
layout
and
ask
to
consume
presentable
things.
B
The
monaco
editor
will
eventually
boot
and
say:
okay,
I
want
to
provide
a
presentable
so
when
the
user
asks
to
open
the
file,
tmp
file,
cljs
the
editor-
or
in
this
case
the
saturn
core
asks
layout
this
file
and
the
layout
plugin
will
check
if
that
uri
is
already
open.
If
it
is,
it
will
just
focus
and
return
if
it's
not
that
it
was
the
presentable
for
some
object
to
show
on
the
screen,
and
then
you
return
this
everything
is
asynchronous
because
well,
it
needs
to
be.
Node.Js
is
like
that.
B
So
it's
a
also
a
good
idea
to
be
a
synchronous,
because
you
can
like
not
require
a
plugin
unless
it's
needed.
So,
for
example,
I
could
just
hide
the
trivial
and
not
even
load
it,
so
the
editor
will
put
faster,
even
though
that
review
is
something
that's
needed
in
most
of
the
cases
and
finally,
I
decided
to
do
a
different,
a
new
plugin.
That's
run
the
tests
on
the
editor,
so
to
show
a
little
bit
how
flexible
the
exact
architecture
is.
B
I
decided
to
put
the
tests
in
the
inside
the
editor,
so
when
I'm
developing,
I
can
see
the
result
here,
and
these
are
clickable,
so
the
idea
is
to
develop
saturn
in
itself
in
the
future.
For
example,
if
something
fails,
I
could
click
here
and
open
this
file,
and
this
this
line
and
column
add
the
editor
inside
saturn
and
handle
the
things.
B
B
B
Some
of
ideas
in
the
future
would
be.
I
don't
know
when
you
ask
to
go
to
a
definition.
You
don't
go
to
that
file.
You
just
open
that
definition
below
and
you
can
like
handle
that
if
you
want,
I
don't
know
a
quick
fix
for
somebody.
You
don't
need
to
open
the
editor
and
lose
all
the
context
on
what
you're
working
on
right.
Now
you
could
like
just
open
a
fragment
below
handle
that
save
and
everything
will
be
like
updated.
E
A
D
Let
me
tell
you
that
this
is
a
brilliant
idea
and
I
I
think
that
is
very,
very
helpful,
and
I
think
that,
because
two
things,
first
of
all,
the
research
studio
code,
the
the
carver
plugin,
is
written
in
typescript,
which
is
very
unclosurey.
I
would
say
so.
That
is,
I
would
say,
adobo
as
a
as
a
long-term
solution
for
enclosure
editor
and
all
the
other
components
like
this
code
mirror
editor,
which
is
also
from
javascript
land,
is
very
difficult
to
interact
with
from
foreclosure.
D
So
I
am
very
happy
to
see
that
you
are
going
this
this
route
and
I
would
like
to
use
that.
My
question
is:
is
this
so
you
did
this
in
closure
script,
but
you
wrapped
up
the
the
electron
wrapper.
Is
it
possible
to
consume
all
of
this
just
from
a
normal
shadow,
cljs
project
and
use
it
in
the
browser
without
electron.
B
B
The
to
this,
produce
like
a
via
a
console
layout
with
blessing
license,
is
like
a
fork
of
incursions
for
for
node.js,
so
it's
possible
to
use
the
same
architecture,
but
probably
some
plugins
will
have
to
be
rewritten,
but
it's
possible
to
use
the
same
architecture
to
just
lay
out
things
in
any
way
that
you
want.
It
does
not
need
to
be
electron.
B
As
of
now,
I
believe,
there's
nothing
specific
about
electron
all
the
code,
with
probably
the
exception
of
opening
files
and
everything
else.
So
if
we
could,
I
don't
know,
make
the
file
opener
not
depend
on
the
node
counterpart
and
depend
on.
I
don't
know
on
a
websocket
that
connects
to
the
server
and
then
opens
the
file
and
then
streams
the
file
to
the
browser.
B
B
D
B
A
A
D
D
I
think
we're
missing
a
main
point,
and
the
point
is,
I
would
say
there
is
a
clear
hierarchy
of
three
levels
that
I
have
identified,
and
I
want
to
talk
about
that.
So
the
first
layer
is
the
layer
to
generate
what
I
would
say
is
the
visualization
specification
that
could
be
as
simple
as
a
closure.
Script
render
function
and
the
data,
or
it
could
be
a
little
bit
more
complex
to
have
and
like
a
hiccup
vector.
D
D
So
this
is
this
is
where
you
basically
want
to
inspect
some
sort
of
object,
and
you
want
to
dynamically
explore
what
what
you
can
do
with
it.
So
this
this
layer
of
the
rebel
is
basically
convert
and
eval
convert
a
value
that
you
got
from
from
some
sort
of
rebel
and
play
around
with
it
in
a
dynamic
way.
D
D
So
this
this
rebel
layer,
I
would
say,
is
what
is
driven
by
the
interactivity
as
soon
as
you
are
done
playing
around
with
something
you
are
no
longer
interested
in
this
sort
of
data
structure.
But
there
is
one
static
layer
to
this.
That
is,
if
you
sometimes
you
want,
you
might
want
to
have
a
specific
view,
sort
of
in
the
state
that
you
selected
and
have
that
archived
for
a
notebook.
D
And
then
we
have
the
the
sort
of
third
layer
which
is
the
the
notebook
layer
which
is
effectively
making
something
shareable
a
sort
of
document
whatever
it
is
a
word
document
or
a
google
document,
or
whatever
jupyter
notebook
and
so
on
and
there.
What
is
the
relevant
thing?
Is
you
want
to
be
able
to
load
and
displayed
and
what
seems
to
be
the
focus
of
danielle
a
lot
to
have
it
in
a
static
html
page
without
the
server
and
so
on?
D
And
I
think
that
this
layering
we
should
make
it
more
clear
as
to
on
which
level
are
we
operating
with,
because
the
the
requirements
are
are
quite
different
and
they
they
built
on
top
of
each
other.
So
this
is
why
I
would
suggest
we
look
more
into
all
of
this
space
like
that,
because
the
complexities
of
each
of
the
layers
are
are
big,
not
sure
if
that
was
helpful
or
not.
D
D
D
Just
by
writing
a
sci
closure
script
code-
and
I
have
been
experimenting
with
this
for
and
an
app
I
use
in
production.
That
is
one
of
my
companies
uses
it
and
it
works
really
nice.
You
can
build
entire
websites
that
run
fast,
that
you
can
build
in
record
speed
by
just
basically
writing
some
sort
of
page
templates
with
sci
closure
screen.
D
C
A
A
C
C
That
would
just
work
with
some
of
the
current
tools
like
portal
and
clerk,
and
we
began
with
looking
into
portal
and
clerk
mostly
because
there
is
lots
of
community
attention
to
these
tools
nowadays
and
lots
of
support.
But
there
are
other
other
relevant
tools
to
consider
here,
of
course,
and
and
the
idea
is
to
offer
this
this
way
of
expressing
ourselves,
so
maybe
maybe
I'll
I'll
show
the
screen
and
right.
So
what
we
see
here
is,
I
think,
for
windows
right
so.
C
So
we
have
already
started
this
system
and
it
is
running
and
the
way
we
started
it
is
this
call
to
start,
and
you
see
we
are
specifying
the
tools
we
are
interested
in
and
in
this
case
we
wish
to
be
kind
of
interacting
with
three
tools
and
also
we
can
specify
some
extensions
for
other
libraries
where
we
want
the
values
from
those
libraries
to
render
in
a
sensible
way.
So,
for
example,
we
have
this
decamble
dataset
library
here,
where
we
want
its
datasets
to
be
viewed
in
all
relevant
tools.
C
So,
for
example,
maybe
let
us
take
some
value
here
like
here-
is
a
data
set
right?
We
have.
Maybe
let
us
take
this
example
right.
So
we
have
those
two
columns
x
with
six
numbers
and
y
with
six
keywords
and
we
are
creating
a
tablecloth
data
set
which
is
just
a
way
to
a
way
of
creating
a
technical
data
set
data
set,
and
when
we
evaluate
it,
we
can
see
it
in
all
tools.
C
Each
tool
has
its
own
view
of
a
table,
but
the
point
is
that
play
is
taking
care
of
making
all
tools
understand
that
we
just
evaluated
something
and
got
a
deficit
and
maybe
not
go
into
it
now,
but
there
it
is
to
have
this
common
way
of
expression
of
saying
what
kind
of
view
we
ex
expect
things
to
have.
So
that
is
one
thing
we
have
here
and
another
thing
that
I've
been
focusing
on
in
the
last
month.
Is
this
skittle
view
that
we
have
on
the
left?
C
So
maybe
I'll
close,
the
clerk
view
and
the
portal
view,
and
now
we
can
focus
on
the
skittle
view
and
skittle
with
one
of
those
projects
by
michigan
bulkhead,
which
are
based
on
the
sci
interpreter,
is
a
way
to
write
html
pages
with
closure
script
in
them,
and
it
is
a
way
to
to
have
something
of
the
usual
web
development
experience
in
a
sense
where
you
know
you
just
can.
Let
me
have
as
much
as
you
like
of
javascript
and
css,
and
all
that
the
usual
way
without
so
much
of
the
closure
script.
C
Compilation
adventures
just
having
this
interpreter
right
running
for
you,
so
I've
been
using
it
to
render
pages
and
so
far
it
looks
very
much
useful
and
easy.
So
here
is
this
namespace
rendered
using
the
skittle
tool.
So
you
see
we
can
have
visual
outputs
and
it
is
all
a
static,
html
page
that
we
just
generated
and
I'm
trying
to
focus
on
that
of
this
way
of
generating
what
one
would
expect
from
html
pages.
C
Well,
you
know
text
is
just
text
so
that
we
can
have
things
in
a
format
which
is
friendly
to
search
engines
and
all
that.
So
in
this
sense
it
is
kind
of
following
what
us
did
and
in
a
very
more
basic
way,
because
all's
is
actually
solving
hard
problems
on
the
way
of
static
rendering,
and
here
we
are
just
creating
a
tiny
html
page
and
so
far
it
is
useful
to
me
and
I'm
hoping
to
explore
it
more.
Maybe
one
last
thing
to
show
a
little
update
about
creating
interactive
widgets.
C
C
You
know
have
some
back
ends
functionality
in
this
case
it
is
just
a
basic
functionality
where
we
click
something,
and
it
tells
us
what
day
it
is.
So
it's
not
so
interesting,
but
it
is
tiny
yeah.
The
syntax
is
kind
of
inspired
by
godly,
but
what
we
have
here
is
really
tiny.
It
is
just
tiny,
html
page
with
everything
needed,
and
it's
such
a
tiny
web
server
with
just
a
little
bit
of
what
is
needed,
and
I'm
exploring
that
too.
C
C
So
that's
a
little
update
about
clay
and
the
hope
is
to
keep
kind
of
drive
it
following
the
ideas
of
this
group,
and
maybe
if
today
we
talk
about
the
cookbook
idea,
then
maybe
I
could
try
to
make
itself
this
need
of
a
cookbook
or
this
need
to
document
things
and
see
if
it
helps
us
in
that
direction.
Yeah.
So
that's
a
little
update,
thank
you
and
feedback,
and
any
thought
would
help
so
much.
Of
course,.
C
Yeah,
thank
you
yeah.
It
helps
this
question.
So
portal
is
great
for
data
navigation,
where
we
have
nested
data
structures
and
all
kind
of
things,
and
we
wish
to
dive
in
and
it
has
a
whole
user
interface
around
it.
That
allows
some
kind
of
nice
key
bindings
and
all
everything
one
may
expect
to
just
dive
into
data
and
then
sometimes
one
way
we
also
visualize
things
sometimes
nested
inside
nested
data
structures.
We
can
have
visual
things,
and
so
portal
is
very
modular
and
extensible
in
this
way
of
nesting
things
together.
C
So
that
is
for
them.
Something
for
dynamic
exploration,
clerk
is
about
creating
documents
and
actually,
in
the
document
we
just
saw,
we
didn't
use
the
clerk
the
view
of
a
document,
but
we
did
use
it
as
a
computational
engine.
So
the
way
we
computed
the
whole
document
that
you
used
clerk
and
its
caching
and
all
all
this
efficiency
that
it
has
and
and
the
skittle
tool
is
about
creating
web
pages
easily.
The
way
I
see
it
and
frankly,
that
is
what
I
use
most
of
the
time.
Nowadays.
C
If
I
need
to
create
a
dashboard
that
work,
then
I
do
it
this
way
or
if
I
need
to
create
a
tiny
document
or
something
like
that
and
yeah.
So,
but
the
idea
is
that
more
tools
are
coming.
Amazing
things
will
happen
in
a
moment.
We
might
hear
about
alls
and
amazing
things
happening
there
and
we
want
to
somehow
create
a
way
for
these
things
to
talk
together
and
that's
a
maybe
that's
a
challenge
right.
That's
the
hope.
A
Yeah
yeah,
no,
this
is
really
cool
for
sure,
because
I
definitely
you
know
that
yeah.
I
see
like
a
lot
of
really
interesting
tools,
but
then
you
know
it's
good
to
like
minimize
the
duplicated
effort.
Basically,
so,
like
each
of
you
know,
it's
useful
to
have
the
different
tools
that
have
different
purposes,
but
this
way
you
can,
you
see
them
kind
of
all
in
one
place
and
it's
cool
to
see
them
like
side
by
side.
That
way,
and
obviously
it
saves
a
lot
of
work.
A
If
you
want
to
you,
know
yeah
like
explore
the
data
with
portal,
but
you
know
make
a
notebook
or
something
or
a
web
page
as
well
with
the
same
the
exact
same
data,
so
that's
really
cool
something
yeah
table
cloth
is
really
cool
too.
That
I
just
wanted
to
point
out
like
I
just
came
across
that
for
the
first
time
a
couple
weeks
ago,
and
I
saw
you
use
it
there
as
well.
It's
really
really
cool
library
interesting
to
have
like
a
little
show
and
tell
about
it
sometime,
maybe
anyway,
yeah
thanks.
F
Little
more
details
of
the
mechanisms
for
of
how
skittle
is
being
used
like
when
you
say
I
just
I
don't
I
haven't
used
it,
so
I'm
just
not
totally
unsure.
I
understand
how
the
generation's
happening
like
where's,
the
compilation
occurring
like
what
does
it
really
mean
just
curious?
I
don't
know
I
guess
both
how
it
works
on
its
own,
like
independently
of
of
clay
and
then
how
clay
is
making
use
of
it.
E
Yeah,
so
you
got
to
remember
so
with
with
anything
related
to
psy.
This
was
this
is
sort
of
a
a
revelation
for
me
because,
like
it
keeps
doing
like
it's,
import,
dude
keeps
doing
cool
stuff
right
and
like
it
seems
to
never
get
crazy
and
part
of.
I
think
what
makes
all
that
sort
of
tick
is
that
psy
is
an
interpreter
right.
It's
a
small
closure
interpreter.
E
So
it's
you
know
what
you
actually
have
inside
there.
It's
not
doing
any
compilation,
it's
interpreting
the
closure
code
using
something
that's
been
compiled
down
into.
Like
a
you
know,
viagra
like
a
closure,
sorry
a
javascript
asset,
and
so
then
it
just
runs
basically
as
a
javascript
program
that
evaluates
the
the
the
closure
code.
The
skittle
code
does,
that
is
that
gonna
help.
F
C
Yeah,
so
briefly,
we
get
the
value
that
the
user
evaluated.
We
no
longer
use
n
repel
for
this.
We
use
tab
and
the
setup
is
easier
and
then
we
have
a
value,
and
we
have
some
information
about
what
kind
of
value
it
is.
Maybe
it
is
some
metadata
added
explicitly.
Maybe
it
is
some
dispatch
on
type,
but
we
somehow
know
what
kind
it
is
say
a
data
set,
and
then
there
is
a
little
function
that
for
each
tool,
says
how
to
show
something
of
this
kind.
C
So
specifically
for
the
skittle
tool,
it
will
be
just
a
function
that
generates
a
little
snippet
of
a
little
hiccup
and
then
one
of
two
things
can
happen
either
it
would
be
a
reagent
component.
If,
if
we
need
react
for
anything
about
it
or
it
would
be
plain
html
to
be
generated,
and
then
we
just
create
a
document
with
all
these
values.
F
C
Happening
yeah,
I
think
that
is
something
that
needs
some
thinking,
and
it
is
very
much
related
to
the
comments
of
lawyer.
So,
if
you
like,
I
would
love
somebody
to
have
a
look
into
this
code,
which
is
just
very
simple
code
and
actually
think
what
we
desire,
what
barrier
we
could
wish
for,
because
now,
I'm
not
sure
about
the
right
way
to
put.
A
C
A
Yeah
that'd
be
cool.
This
would
be
a
cool
one
to
dive
into
for
sure.
I'm
really
curious
too,
like
how
it's
I
guess
I
can
imagine
like
how
you
know
how
it
might
work,
but
I'm
curious
how
you
did
it?
It's
really.
It's
really
cool.
It's
really
interesting,
so
yeah
thanks
so
much
for
sharing
yeah.
We
still
have,
I
guess,
a
bit
of
time,
probably
like
half
an
hour.
So
it's,
I
think
so
was
it
chris
wanted
to
talk
about
oz
or
someone
wanted
to
have
another
update.
Was
there
was
that?
E
Is
that,
like
you
know,
sometimes
it's
kind
of
nice
to
have
multiple
implementations
or
something
so
you
can
kind
of
see
like?
Oh
actually,
the
way
that
this
was
approached
in
this
case
is
you
know,
it's
kind
of
interesting
has
some
interesting
features
and,
like
that
actually
kind
of
pairs.
Well
with
what
someone
else
is
doing
over
here.
E
That
could
be
that
could
be
reused
and
one
of
those
pieces,
the
one
that
I'm
really
thinking
about
right
now
is
kind
of
the
the
build
infrastructure
side
of
things.
So,
as
I
mentioned
in
kind
of
my
most,
my
most
recent
talk
to
talk
at
what
was
what
we
we
doing,
the
forgetting
which
conference
it
was.
E
Parallelization,
because
of
the
global
interpreter
walk,
but
once
you've
kind
of
broken
things
out
into
these
separate
programs.
You
know
you're,
basically
running
out
shell
commands
right
and,
and
you
can't
actually
call
python
functions
as
separate
threads.
Obviously
you
can't
share.
You
know:
there's
limitations
there,
because
it's
you
know
it
has
to
be
a
full
separate
thread
for
it
to
run
simultaneously.
A
E
So
this
gives
you
a
really
nice
super
fast
sort
of
reload
experience
like,
as,
as
things
are,
being
computed
in
in
parallel,
getting
getting
the
feedback
as
quickly
as
possible.
All
that
has
been
really
great,
but
what
has
been
sort
of
challenging
is
then
getting
that
work
that
I
got
working
to
sort
of
integrate
fully
with,
with
the
all
the
other
kind
of
build
assets
and
so
generalizing
over.
E
How
would
I
design
this
so
that
it
like
the
the
the
the
functionality
the
dependencies
and
everything
are
sort
of
as
modular
as
possible?
And-
and
you
have
like
a
clear-
you
know-
kind
of
the
unix
philosophy.
Right,
like
you,
have
a
clear
tool,
a
piece
that
can
be
that
can
be
reused,
that
that
is
like
a
good
design
criteria
can
can
be
valuable,
but
it
kind
of
you
know.
E
The
cure
brought
up
that
you
know
if
we,
if
we
want
to
be
sharing
our
work
with
each
other.
Like
one
of
the
things
you
know,
I'm
taking
advantage
right
now
of
of
the
the
file
watcher
system
from
from
clerk,
because
it
does
a
great
job.
There
were
problems
with
the
one
that
see,
I'm
forgetting
where
I
even
where
I
even
got
this
from.
But
what
is
it
called?
It's
called
yeah.
E
So
I
think
that
it's
great
to
see
what
everyone's
working
on
and,
to
the
extent
that
you
know
folks,
are
doing
it.
It's
great
to
see
things
being
sort
of
attempted
at
least
to
build
in
modular
ways
or
ways
they
can
like.
I
mean
like
with.
I
really
love
what
what
you're
gonna
daniel
with
with
clay,
because
it
is
sort
of
this.
It's
not
even
it's
not
even
trying
to
like
be
the
one.
E
E
The
final
release,
non-alpha
release
of
oz
2.0,
is
just
to
get
to
to
not
only
get
these
design
problems
right
for
like
how
I
solve
the
problems
that
I'm
working
on
right
now,
but
also
how
I
make
those
potentially
reusable
outside
of
outside
of
this
one.
You
know
outside
of
this
one
context,
yeah,
and
I
guess
let's
see,
I
think,
that's
that
maybe
wraps
it
up
for
me.
The
one
thing
I'll
say
is.
E
If
so
I
know
I
was
in
like
1.6
point
something
alpha
for
for
a
very
long
time.
It
became
very
stable
and
I
was
I
left
it
in
alpha
because
I
was
you
know
this
was
all
still
since
having
built
in
the
the
you
know,
initial
sort
of
notebook
like
reload
experience
and
recognizing
that
that
was
like
kind
of
a
hard
problem
that
there
were
lots
of
aspects.
E
Exactly
how
he
knew
I
wanted
to
ultimately
solve
it
getting
closer
there
now
right,
but
that
you
know
I
wanted
to
leave
that
open,
but
that
that
api
is
very
stable
everything
there
should
work.
If
you
go
back
to
the
most
recent
one
point,
you
know
six
dot,
whatever
the
currents
you
know
what
it
shows
on
and
I
should
I
need
to
update
the
readme.
E
So
it
doesn't
confuse
people,
but
the
current,
like
you
know,
most
recent
tag,
if
you
go
to
the
readme
on
github,
is
pointing
to
the
2.0
alpha
release,
which
some
things
that
work,
if
you
just,
if
you
just
run
it
on
closure
code
as
like
an
open
notebook
like
experiment,
experience,
excuse
me
it
works
or
if
you're,
just
using
the
raging
components.
Actually
there
should
be
some
nice
new
things
in
there,
but
for
some
of
the
some
of
the
build
stuff
is
a
little
bit
off.
E
E
Yeah
yeah,
absolutely
yeah
and
what's
great
about
it
too,
is
that
in
the
in
the
visualization
that
you
get
the
the
okay.
So
this
is
if
I
can
go
into
a
little
something
related
to
this,
just
as
a
bit
of
detail,
that's
kind
of
that's
kind
of
fun.
One
of
the
challenges
that
I
really
had
in
adapting
to
2.0
was
thinking
about
some
very
specific
design
decisions
that
I
had
around
templating.
E
I
had
made
this
kind
of
decision
that,
like
templating
works,
you
have
a
template
function,
you
pass
it
into
like
these
build
functions
and
everything
and
the
template
function
will
take
a
a
vector
of
blocks
or,
like
some,
you
know,
interval
blocks
and
it
will
you
know
and
we'll
place
them
in
some.
You
know
hiccup
con
form
right
and
that
very
specific
decision
had
all
these
implications.
E
For
how
I
approached
you
know,
once
I
started
thinking
about
parallel
computation
of
of
blocks,
or
I
mean
really
any
sort
of
well
yeah,
especially
then,
but
but
even
just
in
general
thinking
about
like
what
do
I
want
this
experience
to
feel
like
right,
like
as
things
are
running
and
computing
like,
I
want
feedback
from
my
tool
right
and
so
like.
I
don't
want
to
have
to
wait
till
everything
computes
to
see
results.
E
E
E
E
E
C
E
Yeah
yeah.
Thank
you.
Thanks
for
yeah,
for
making
reference
to
that
yeah
I
mean
that's.
That's
a
a
lot
of
the
state
of
things.
Is
you
know,
maybe
a
little
bit
beyond
there
right
now
I
mean
the
stuff
I'm
working
on
right
now
hasn't
is,
is
all
still
it's.
What
will
really
like
tie
that,
together
with
the
rest
of
the
build
system
for
processing,
markdown
files
and
and
all
the
other
kind
of
stuff
that
it
could
do
so
yeah.
A
A
A
You
know
why?
Wouldn't
you
use
r
or
python
or
whatever
and
like
for
me,
the
answer
is
just
like
okay.
Well,
because
I
like
closure
and
that's
what
I
work
with,
and
so
I
just
anything
I
want
to
do.
I
figure
out
how
to
do
it
with
closure,
but
I
do
think
even
if
you're
not
already
a
closure
developer,
it's
a
it's
a
it's
a
really
good
choice
for
for
lots
of
stuff,
including
data
science.
So
anyway
like
if
there's
any
thoughts
or
questions
or
concerns
like
I
don't.
A
I
haven't
like
started
anything
or
put
much
effort
in,
but
I
was
kind
of
thinking
like
like
I
was
like
oh
yeah
like
I
could
build
something
like
that,
for
you
know,
data
visualization
with
closure.
I
think
I'm
like
familiar
enough
with
the
tools
and
what's
available,
but
it
could
be
cool
to
include
other,
like
branches
too,
like
if
there's
people
doing
other
cool
stuff.
A
So
I
was
kind
of
picturing
like
an
open
source
like
kind
of
collaborative
type
project,
but
anyway
it's
it's
obviously
not
like
there's.
No,
like
nothing
concrete,
nothing.
You
know,
no,
I'm
not
asking
for
any
commitments
or
anything
I'm
just
like
want
to
throw
that
out.
There
see
what
people
think
or,
if
or
if
there's
something
that
already
exists,
that
I
haven't
found,
maybe
or
something
like
that.
C
C
D
D
I
currently
made
only
eaton
files
that
have
this
sort
of
visualization
specification,
not
any
sdi
code,
but
that's
not
an
issue
to
add
that
to-
and
I
just
put
all
together
in
a
file
called
snippets
and
then
send
it
from
there,
and
I
would
think
there.
So
if
we
have
a
project
that
basically
compiles
all
the
snippets
that
are
out
there,
we
can
then
send
it
to
wherever
we
want
to
send
it
to
and
on
the
as
in
regards
to
the
snippets.
D
D
D
I
don't
care
about
that.
So
what
I,
what
I
want
to
do,
but
haven't
done
it
yet
is
right.
Now
goldie
can
accept
visualization
specifications
or
a
page
specifications.
We
are
an
http
post
request
and
can
render
it
on
the
scratch
pad
so
that
functionality
means
you.
You
do
not
even
have
to
start
your
own
visualization
engine
browser
whatever
you
could
just
send
it
to
a
publicly
running
visualization
server.
That
would
then
show
the
stuff
to
you.
D
B
A
Yeah
thanks
thanks
for
joining
and
showing
me
marie
say
I
was
gonna
say
where
this
is
the
end
of
the
time
we
you
know
said
we
can
stick
around
if
anyone
wants
to,
but
otherwise
yeah
thanks
thanks
for
coming,
and
thanks
for
sharing,
brainstorming
but
yeah,
sorry
daniel.
If
there's
something
you
wanted
to
to
chat
about
briefly,
we
can
either
maybe
keep
recording
or
we
can
post
it
in
the
chat
or
something
if
anyone
wants
to
see
how
it
goes
but
yeah.
This
is.
This
is
where
we
said
we'd
end.
C
B
B
C
E
A
Just
yeah,
it
was
kind
of
so
like
I've,
been
just
like
kind
of
poking
around
data
visualization
stuff
with
closure
and
started
like
just
learning
about
it
out
of
interest.
Basically,
and
was
you
know,
as
I'm
looking
around
for
like
resources
and
stuff,
I
noticed
that
this
is
like
a
common
format
that
other
languages
do
like
like
python
r
javascript
like
it's
like
a
comment.
A
E
E
And
I'm
not,
I
forget,
there's
a
pr
on
that
right
now
on,
like
the
vega
website.
So
if
anyone's
like
hey
yeah,
like
let's
finish
making
that
happen,
I
think
it's
maybe
in
review.
I
don't
think
it's
been
merged
yet
but
yeah
it
would
basically
make
it.
So
you
could
add
different
tabs
for
like
other
language
specifications
on
the
github
page.
It's.
E
Yeah,
which
is
super
super
handy
because
yeah
it's
annoying
right,
because
then
you
go
to
the
web
pages
for
the
examples
and
you're
like
oh
there's
a
great
example
and
I
basically
have
to
type
it
out
from
scratch
which
yeah
at
the
end
of
the
world,
but
yeah
it'd
be
a
lot
nicer.
If
you
know
you
could
just
grab
that
stuff
out
as
regular
closure
data,
this
might
be
a
good
place
to
start
yeah,
yeah
yeah,
but
yeah
I
mean
it
needs.
E
So
actually
I
I
I
almost
chimed
in
there,
but
I
I
really
do
substantially
say
but,
like
I
part
of
why
I
kind
of
care
about
this,
because
I
spent
I
I
mean,
like
my
mom-
was
a
teacher.
My
grandpa
was
a
teacher.
I
like
tutored,
all
throughout
college
and
high
school
and
and
afterwards
and
so
yeah
yeah.
I
I
guess
I
think
a
lot
about,
like
you,
know
the
educational
side
of
things,
and
I
also
designed
a
course
for
fred
hutch
cancer
research
center.
E
E
So,
like
I
mean
I
think
that
things
look
very
different
and
when
you're
kind
of
in
one
language,
space
and
you're
kind
of
making
assumption
about,
you
know
a
more
a
more
well-defined
ecosystem.
Shall
we
say,
although
maybe
not
I
don't
know,
because
because
it
does
get
interesting
right,
because
we
we
have
a
lot
of
power
at
our
fingertips.
E
Lots
and
lots
and
lots
of
content
that
kind
of
you
know
walks
you
through
through
the
mental
model
and
everything
you
know,
especially
with
us
kind
of
coming,
at
a
disadvantage
with
fewer
people.
Knowing
closure
like
it
has
to
be,
you
know,
like
the
onboarding.
There
has
to
be
that
much
like
more
of
a
joyous
sort
of
wonderful
experience
and
you're
going
to
be.
You
know,
kind
of
going
out
on
this
limb,
trying
some
something
your
crazy
programmer
friend
told
you
about.
A
Yeah
exactly
yeah,
no,
that's
really
cool,
that's
yeah!
It's
interesting
yeah,
I'm
interested
too
and,
like
the
whole,
like
educational
side
of
things
and
like
how
to
teach
people
and
get
people
in
because
yeah,
I
think
I
don't
know,
I
think
closure
can
seem
intimidating
or
feel
like
like
niche
or
something
for
people.
But
it's
really
like
there's,
especially
like
the
last
couple
years.
There's
been
a
lot
of
like
really
cool
work,
especially
in
the
data
science
side
of
the
closure
community.
A
Like
all
these
new,
like
really
cool
tools,
I
think
are
making
it
like
an
actual
legitimate
option
for
like
people
who
need
to
do.
I
mean,
like
a
lot
of
the
tools,
came
from
people
who
are
using
closure
in
like
non-programming
professional
settings
and
like
wanted
something
you
know
better
than
what
they
were
using.
So
just
like
you
know,
polishing
a
little
bit
and
like
writing
up
some
cool
guides,
I
think,
could
make
it
really
like
accessible
more
accessible.
Maybe
is
what
I'm
looking
for
so
yeah.
B
A
Yeah
lots
to
think
about
it's
like
it's
a
big
project-
and
I
was
just
like.
Oh
man
like
I
can't
write
a
whole
book
but
like
maybe
like
just
one
little
thing
at
a
time
you
know,
and
then,
but
I
was
thinking
it
would
be
cool
to
also
include
more
than
just
like
data
visualization,
there's,
obviously
like
so
much
other.
A
So
many
other,
like
you
know,
branches
of
of
what
the
community
is
working
on.
So
I
think
it
might
be
cool
to,
like.
Maybe
collaborate
make
it
like
a
more
of
an
open
project,
and
if
people
are
you
know,
interested
or
inspired
or
whatever
to
to,
you
know,
add
guides
for
whatever
they're
working
on
that
could
be
cool.
E
E
Some
specs
that
you
liked,
or
whatever
I
mean
you,
can
kind
of
take
it.
We
potentially
take
it
in
pieces
right
and
like
build
up.
You
know
we
can
start
it
just
as
just
a
list
and
then
kind
of
build
some
narrative
around
that
to
kind
of
turn
into
something
a
little
bit
more.
But
what
I
wanted
to
share
was
it's,
like,
I
guess,
I'll
have
to
type
it
in
on
my
phone.
Well,
yeah
I'll,
just
say:
well,
yeah
I'll,
say
it.
You
could
write
it.
E
They
want
it
to
be
able
to
be
like
dynamically
generated,
which
isn't
kind
of
good,
because
it
like
rules
out
altair,
I
don't
know,
building
a
automatic
code.
Generator
for
altair
would
probably
be
kind
of
hard.
I
think,
although
they
may
already
have
dedicated
alter
examples,
I
forget,
but
actually
yeah-
maybe
that's
not,
but
but
yeah,
so
it
it
does.
It
advantages
yeah,
right,
you're
not
going
to
be
able
to
like
dynamically
generate
like.
E
A
E
E
A
Cool,
I
think
this
would
be
an
awesome
place
to
start
for
sure,
because
that's
kind
of
what
I
was
picturing
like
like
for
sure
for
the
visualization
stuff
would
probably
be
like
vegalite
and
hanami
like
I
was
kind
of
originally
started
because,
like
so
I'm
working
on
another
hanami
workshop-
and
I
was
like
oh
it'd-
be
cool
to
have
like
a
hanami
cookbook,
because
that's
kind
of
like
what
like,
like.
Basically
all
we're
doing,
is
like
going
through
some
art,
cookbooks
or
python
cookbooks
and
being
like.
How
would
you
do
this
enclosure?
A
A
So
I
think
it'd
be
cool
to
get
some
input
from
like
actual
data
scientists
and
like
what
you
know
see
what
what
kind
of
resource
would
be
useful
if
you
were
like
imagine,
you
are
like
a
somewhat
programming,
savvy
data,
scientist
and
you're
looking
for
a
new
tool
and
you
come
across
r
and
python
and
javascript
and
whatever
and
like
what
kind
of
resource
or
book
or
whatever
would
make
like.
Closure
seem
like
a
great
option
for
your
your
cool
new
project
that
you're
working
on,
because
I
think
there's
some
of
that.
A
I
mean
it's
like
that
with
everything
like
even
for
web
development
like
there's,
I
find
it's,
it
can
feel
a
little
bit
like
hostile
or
a
little
bit
like,
not
not
like
the
obvious
choice,
even
though
I
think
it's
a
great
choice.
So
anyway
yeah
I
don't
know
that's
what
got
me
thinking
about
it,
but
yeah.
A
You
know
thing
with
like
a
couple
like
a
few
examples,
a
handful
of
the
stuff
we've
done
with
hanami
already,
for
example,
maybe
and
like
it,
can
obviously
be
a
thing
that
evolves
and
changes
and
grows
but
yeah,
maybe
that's
a
cool
yeah.
I
like
that
idea,
just
like
yeah
just
start
and
like
just
do
something
and
then
we
can
iterate
and
improve
it
as
you
go
because
that's
always
the
thing
is
like
you
know,
daydreaming
for
years
before
you
actually
do
something,
but
really
you
just
need
to
just
need
to
do
it.
F
Well,
it
seems
like
the
idea
of
the
cookbook
is
really
appealing
and
then
there's
like
different
ways
to
execute
on
it.
Not
they're,
not
necessarily
usually
exclusive,
and
one
of
them
sounded
like
is
this
kind
of
connected
to
the
the
suggestion
from
carson
with
respect
to
the
existing
vega
and
vega
light
docks
yeah?
F
E
Do
a
visualization
you
go
to
the
examples
site
you
like
scroll
through
you
see
like.
Oh,
this
one
might
be
cool
to
try
out
you
like
copy
out
the
code
you're
like
oh
wait.
This
is
json
and
then
you
like
go
and
you
edit
all
the
tags
and
like
it's,
it's
sort
of
an
annoying
thing
right
now
you
could
just
like
yourself
grab
the
json
like
and
run
like
this
jet
command.
I
mean
that,
actually
you
know
what
that
we
can
kind
of
solve
the
problem
like
right.
E
F
F
E
F
E
F
F
A
Yeah,
that's
often
like
how
I
start
like
for
hanami
things.
It's
just
like
copy
paste,
the
json
into
like
an
eat-in
converter
and
then
like
paste
it
into
like
vega
light
viewer
or
whatever,
and
then
you
can
start
tweaking
it
or
editing
it
from
there,
but
yeah
yeah.
That's
basically
like
all.
We
did
in
that
that
workshop.
D
Okay,
so
you
you
explained
how
you
are
basically
doing
like
a
graph
of
what
needs
to
be
fetched,
calculated
and
so
on,
and
then
this
gets
done
now.
This
problem
happens
if
you
develop
whatever
any
kind
of
web
app,
and
so
it
would
be
very
interesting
to
have
this
as
a
sort
of
library,
because
yeah
based
on
yeah
what
you
could
then
do.
D
A
D
So
you
you
separate
the
you
separate
the
estrogenicity
from
the
visual
presentation
really,
so
I
would
be
very
interested
interested
to
use
a
library
like
that,
but
not
not
tailored
at
all
to
us,
with
with
with
all
the
things
that
you
bring,
because
this
is
not
like
you
bring
another
web
server,
you
bring
another
websocket
management
and
so
on
and
so
on,
and
so
on.
Yeah.
E
Yeah
yeah
yeah
and
that's
that's
kind
of
it's
really
did
you.
You
say
that,
because
that
assumption
that
I
had,
which
is
that
this
might
be
generally
useful
right
so
like
and
and
yes,
you're
right,
like
it's,
it's
absolutely
a
way
that
you
could
build
build
static
assets
that
then
get
fetched
up.
So
I
mean
you
know
like
yeah
right
like
it
may
or
may
not
make
sense
for
every
kind
of
like
application
you
might
want
to
build,
but
for
a
lot
of
applications.
It's
it's!
E
It's
a
really
nice
model
and
that's
exactly
kind
of
the
direction
that
that
I'm
thinking
in
for
like
this
underlying
kind
of
build
layers.
That
would
be
something
that
you
could
like
effectively
build
like
a
data
pipeline
out
for,
and
I
mean
that
that
that
be
something
that
could
be
flexible
enough
to
be
used
in
like
a
development
or
development.
E
E
So
if
you
run
like
a
slurm
cluster,
you
can
submit
jobs
to
the
cluster
right
and
that'd,
be
like
a
super
easy
way
to
do
some
amount
of,
like
you
know,
paralyzing
things,
but
it
wouldn't
be
the
level
of
like,
like
a
storm
stream,
processing
cluster
or
something
right
where
it's
like
you
have.
You
have
lots
of
nodes
that
are
that
are
that
are
processing
messages
at
a
more
fundamental
level.
E
E
E
But
like
the
rest
of
the
pipeline
is
kind
of
tractable,
then
you
should
be
able
to
get
something
that
that
that
still
works,
so
hopefully
that
kind
of
makes
sense
that
the
distinction
I'm
trying
to
draw,
which
is
like
you
wouldn't
want
to
like
the
thing
that
I'm
going
to
be
building,
is
not
like
a
zookeeper
replacement.
That
or
not
necessarily
zookeeper
was.
I
was
the
one
that
I'm
yeah,
it's
not
a
storm
replacement.
I
guess
it's
the
better.
The
better
comparison.
E
You
know,
like
maybe
I'll,
leave
public
functions
in
there
that
you
can
tinker
around
with,
but
that
that
are,
you
know,
come
with
a
heap
of
of
of
warnings.
You
know
until
we,
until
we
sort
of
like
start
everything
out
but
yeah,
that's
sort
of
my
intent
and
and
to
your
to
your
question
about
like
how
you
made
a
question
or
statement
or
something
along
the
lines
of
like
how
closely
like
linked
with
oz.
E
E
You
know
oz
build
or,
as
you
know,
runner
or
something
like
that,
I
don't
know,
but
the
bottom
line
being
that,
like
I,
wouldn't
be
making
any
assumptions
around
how
things
are
gonna
be
visualized,
for
example,
right
that,
like
all
of
that
stuff,
be
sort
of
pluggable
at
this
at
this
layer
and
having
that,
then,
is
the
basis
that
that
the
rest
of
the
work
that
I'm
doing
uses
to
kind
of
plug
into.
If
that
makes
sense.
E
D
I
mean,
I
think,
it's
very
interesting
because
I
think
whatever
app
you
do
or
a
dashboard
or
whatever
you
need
to
separate
the
sort
of
layer
that
that
determines
what
needs
to
be
done
and
how
and
decide
whatever
you
are
showing
a
table.
But
you
don't
have
the
table
data
yet
so
you
want
to
show
something
else
or
not,
and
so
it
this.
This
is
a
very,
very
important
thing
and
I
think
we
need
for
for
whatever
notebooks
and
and
whatnot
like
like
in
in
my
case
in
goldbe
with
a
simple
dashboard.
D
D
D
If
you
have
something
where
you
let's
say
you
have
the
same
table
viewer
right,
but
you
just
want
to
page
it
through
and
not
have
the
entire
the
entire
table
in
the
browser,
but
you
want
to
have
it
in
the
notebook.
So
let's
say
you
have
a
table
that
is
10
million
rows,
and
this
in
this
table
is,
is
part
of
a
notebook
and
the
either
file
for
that
or
a
csvd
file
for
that
can
be
read
by
the
browser.
D
C
E
E
E
F
F
F
F
E
F
F
C
F
A
A
E
Yeah,
so
I
would
a
couple
of
thoughts
here
yeah.
I
know
that
it
is
this
is
this
is
a
valuable.
This
is
a
valuable
question,
so
two
thoughts.
My
first
thought,
which
I'm
really
maybe
is
not
like,
is
incomplete,
is
like
you
ask
like:
what's
the
sort
of
like
shareable
unit
right,
that's
my
initial
thought
was
like
okay.
Well,
like
any
of
these
tools
should
be
able
to
spit
out
like
an
html
file.
That's
like
that.
A
A
Making
setting
up
a
closure
id
like
really
like,
really
easy
and
accessible,
so
there
might
be
even
ways
to
run
it
in
the
browser,
because
I
know
like
vs
code
can
run
like
you
know,
just
like
in
a
browser,
so
you
could
maybe
yeah
maybe
come
up
with
some
like
way
to
just
like
click,
a
button
to
say,
like
yeah
like
copy
this.
You
know
copy
this
example
to
start
your
own
project
or
something,
and
that
could
like.
F
F
If
you
think
about
it,
yeah
these
it's
sort
of
recapitulating,
some
of
the
I'm
now
remembering
like
some
of
the
thoughts
like,
I
think
well
I'll
say
like
if
you
think
I
don't
know
about
so
much
about
r.
But
if
you
think
about
like
the
jupiter
notebook
thing,
those
aren't
actually
great
shareable
things
right
and,
and
the
setup
for
for
jupiter
is,
is
pretty
rough.
A
A
Well,
that's
I
think,
like
a
big
positive
for
closure
is
like,
like
every
time
I've
ever
had
to
work
with
python,
it's
an
absolute
nightmare
like
the
python
environment,
like
every
time
I
get
a
new
computer.
I
like
avoid
installing
it
because
it's
the
like
the
ecosystem
is
just
like
frustrating
and
messy
to
work
with,
and
I
find
that's
you
know
doesn't
have
to
be
that
way.
F
F
A
A
Though
they
have
support
for
it,
that's
a
big
pro.
Also
like
a
clerk.
Notebook
is
just
like
a
closure
file
that
you
can
yeah.
You
can
really
easily
diff.
You
can
see
like
changes
you
can
submit
like
pull
requests
against
it,
yeah
yeah
it
doesn't
have
to
necessarily
be
clerk,
whatever
people
are
like
whatever
people
are
converging
on,
but
it
seems
like
that
one's
yeah.
E
Was
that
because
our
conference,
this
conversation's
so
hot,
is
that
so
many
hot
takes
that
right
so
at
the
project
level,
docker
containers
actually,
because
I
think
that
I
mean
maybe
not
any
data
science.
So,
like
there's
a
lot
that
you
can
do
without
say,
you
know
plugging
into
python
or
r,
but
there's
a
lot
more.
You
can
do
if
you
plug
into
python
r
right
so
like
having
examples
of
that.
E
As
docker
images,
I
think
is
just
that's
just
gold,
because
that
gives
you
a
complete
environment
to
just
get
running
with,
especially
with
like,
like
with
ours,
not
quite
as
bad,
but
but
but
with
python.
It's
just
a
nightmare.
I
mean
to
build
the
the
dependency
management
and,
like
everything,
ecosystem,
there
is
still
just
you
know
not
so,
but
miles
behind
yeah
miles
behind
what
we're,
what
what
we
have
and
part
of
it
like
it's
harder
right
like
you,
do
have
native
binaries
and
stuff
that
you
need
to
that.
E
E
It's
a
known
problem
that
like
getting
an
environment
set
up,
can
be
a
pain
with
python,
and
docker
is
a
great
way
to
get
around
that,
and
if
you
have
a
docker
image
that
when
it
runs
it
just
like
spins
up,
you
know.
First
of
all
I
mean
to
build
it.
It
like
installs
everything
that
you
need
to
run
python
and
have
that
linked
with
with
closure
and
then
yeah
fire
up
like
a
rebel.
E
Basically
with,
like
you
know,
a
command
that
also
starts
up
a
a
you
know,
whatever
notebook
port,
you
know
you're
using
that
it
just
automatically
opens
that
I
do
kind
of
have
an
example
of
this
for
yeah.
It's
a
little
bit
weird,
though,
to
get
it
working,
but
I
have
an
example
of
this.
For
my
my
my
day,
job
the
computational.
E
For,
like
these
analysis,
notebooks
that
that
we
have
there's
like
a
docker
docker
image
thing
that
will
that
will
spin
up
and
it'll
open
up
like
the
oz
ports
for
you
and
so
basically
like
you
just
you
know,
you
run
this
thing
and
it
it'll
paste
out
a
link
that
you
can
copy
then
and
open
up.
It's
it's
not
quite
as
nice
as,
like.
E
I
think
earthquake
does
this
too,
but
like
if
you
like,
when
you
first
fire
it
up,
it'll,
actually
open
up
like
a
firefox
tab
or
a
chrome
tab.
Whatever
you
have
your
default
browser
sets
you
for
you,
you
can't
do
that
like
through
the
docker
image
that
part's
like
a
little
bit
unfortunate,
but
you
can
still
like
print
a
message.
C
I
think
we
want
something
that
would
be
seamless
to
use
for
anybody
who
has
some
closure
environment
and-
and
it
is
still
a
challenge
to
make
docker
just
work
with
whatever
you
use,
kalva
or
emax,
and
I'm
saying
that
because
because
there
is
this
template
that
cast
and
created
with
docker
and
closure
and
python
and
orbit
and-
and
we
tried
some
user
sessions
well,
we
wanted
to
just
hack
on
that
and
just
work.
And
then
there
were
troubles.
E
I
I'm
not
remembering
what
that
was
now
what
the
details
were
but
like
as
long
as
you
have
that
getting
spit
out,
then
most
tooling
should
pick
up
on
that.
I've
tried
it.
I
think
I
tried
it
with
kalva,
I'm
not
sure,
but
it
definitely.
It
definitely
works
with
vim.
If
it
doesn't,
though,
that's
you
that's,
maybe
we
just
need
more
parts
open
or
or
whatever,
but
I'm
you
know
yeah.
I
I
can
maybe
help
take
a
look.
Take
a
look
at
that
because,
because
yeah,
it
would
be
like.
E
E
F
F
F
D
F
C
A
But
yeah
yeah,
I
take
your
point.
I
think
yeah,
like
I've,
had
similar
experiences
with
docker.
It
can
be
frustrating
to
work
with,
but
if
there's
any
way,
we
can
like,
basically
just
make
it
as
easy
as
possible
for
people
to
to
get
started,
especially
like
starting
from
examples.
If
you
want
to
publish
any
because
yeah
it's
true,
it's
not
useful
to
have
like
a
whole
library
of
examples.
If
it's
not
obvious
like
how
to
how
to
use
them
or
set
them
up
on
your
own
computer
for
sure.
C
A
Yeah,
I
guess
we
can
probably
wrap
up
unless
there's
anything
else.
We
can
always
carry
on
like
conversations,
I
think,
I'm
in
the
zoolop
and
slack
and
close
reverse.
I
just
get
email
notifications,
so
kind
of
feel
free
to
keep
in
touch
but
yeah
any
other
final
final
thoughts
after
this
marathon
meetup.
A
Yeah
yeah,
it's
all
very
exciting.
I
always
just
wish
I'm
like.
I
just
want
to
like
do
this.
I
just
want
to
like
come
up
with
cool
ideas
and
do
them
and
there's
so
much
other
stuff
to
do
in
my
life,
but
anyway,
whatever
someday
but
okay
cool.
Well,
maybe
maybe
it
makes
sense
to
wrap
up
then
and
we
can
yeah.
A
We
usually
do
these
like
at
least
once
a
month,
but,
like
you
said
daniel,
maybe
if
maybe
it
would
make
sense
to
coordinate
some
side
ones
with
like
mauricio
or
any
other.
If
there's
any
other
like
more
specific
topics,
people
want
to
talk
about
like
it's,
it's
all
very
informal,
so
you
know
we
can
always
set
up
a
an
extra
little
meeting.
If
that's
useful,
I
guess
yeah.
Otherwise,
we'll
see
you
guys
around
the
universe.