►
Description
Daniel Slutsky discusses Clojure interoperability with the R programming environment, presenting the draft of the Clojure Speaks Statistics project:
https://github.com/scicloj/clojuress
A
All
of
you,
it's
my
pleasure
to
to
be
the
moderator
today
on
this
side,
closure,
community,
meeting
the
psychosis
meeting,
that
discusses
science,
data
science,
machine
learning,
tools
and
techniques
and
just
a
short
introduction.
Also
about
myself.
My
name
is
some
Cullinan
and
I
will
moderating
today
and
and
try
to
try
to
help
making
things
smooth
for
everything
and
and
and
see
that
everything
works.
A
B
A
A
I
should
also
mention
that
Daniel
is
one
of
the
main
motors
of
this
community
has
been
building
this
and
coordinating
a
lot
of
these
meetings
and
getting
it
going.
So
we're
also
all,
of
course,
very,
very,
very
happy
that
that
that
he's
doing
is
wonderful
work,
but
today,
of
course,
it
will
be
about
our
and
enclosure
I
interrupt.
A
A
Also
in
previous
presentations,
a
similar
work
is
being
done
with
regards
to
to
Python
and
and
the
tools
are
other
tools.
So
this
is
a
logical,
logical
step
to
have
this
discussion,
I
guess
and
if
I
understand
correctly,
then
I
will
be
speaking
a
bit
of
prior
art,
but
what
has
been
done
before
in
this
field
and
also
some
future
opportunities?
And,
of
course
it's
it's.
It's
it's
nice
to
see.
A
There
are
a
few
few
few
authors
here
who
have
contributed
in
the
same
same
space
like
I,
can
see
that
Joel,
who
Buland
not
sure
I'm
pronouncing
this
correct.
The
author
of
our
encounter
is
here
that's
that's
great
and
of
course,
also
Chris
Nuremberg
er,
who
who
is
building
their
tech
ml
dataset.
So
looking
forward
to
these
these
conversations
that
that
we're
going
to
have
today
and
then
just
a
few
points
that
we
always
make
in
these
meetings
also
previously,
we
hope
for
active
discussion.
Anybody
feel
free,
we're
not
many.
A
B
A
We
like
to
encourage
the
people,
use
the
camera.
It's
it's
nicer
for
the
presenter
to
see
the
faces
of
the
people
that
that
you
are
talking
to,
but
that's
of
course,
depending
on
how
high
you
are
among
kind
of
equipment
you
are,
but
but
that's
that's
that's
always
nice
and
of
course,
when,
when
listening,
we
try
to
keep
the
microphones
off.
So
we
don't
get
too
much
random
noise
from
the
back
from
yeah.
But
that's
there
are
practical.
Things
are
now
over
to
you,
Daniel,
I'm,
very
stoked
and
and
excited
about
this.
B
B
B
That
is
what
I've
been
trying
to
do
and,
and
so
one
is,
is
to
experiment
to
see
how
how
the
API
could
look
like
how
we
may
like
to
use
from
closure,
and
what
I
wish
to
see
today
is
how
to
use
function,
functions
as
a
central
tool
as
a
central
building
block
in
the
API,
and
another
thing
is
zero
copy.
How
how
could
we
use
are
from
closure
without
copying
return,
values
all
the
time
back
and
forth
and
I
will
discuss
that.
B
So
these
are
the
goals
but
I
hope
we'll
come
out
with
some
priorities
around
these
and
maybe
other
goals
that
you
may
wish
to
suggest,
and
so
just
a
little
quickly.
The
history
begins
for
us
10
10
years
ago
with
the
work
of
Joel,
and
there
is
this
beautiful
blog
post
back
in
those
days.
I
think
I
didn't
know
about
closure,
but
later
I
saw
this
and
it
was
so
useful
to
me
Joel.
Would
you
like
to
say
something
about
it?
Maybe
later
hi.
B
That
would
be
more
robust
to
all
kinds
of
you
know:
memory,
leaks
and
things
that
may
happen
that
one
wouldn't
want
to
bike
the
JVM,
and
later
there
was
the
the
folk
called
virtue
by
caste
&
Belling,
who
was
in
the
last
few
months.
It
was
a
little
bit
in
this
group,
and
this
was
mainly
about
compatibility
with
Co
matrix,
that
set
of
protocols
with
working
with
data
sets
and
matrixes,
and-
and
here
we
are-
and
so,
if
one
wants
that
there
is
a
lot
of
interesting
details
in
this
history.
B
So
I
put
some
links
into
a
presentation
and
and
as
some
more
background,
we
can
see
that
there
are
a
lot
of
ways
one
could
use
are
from
the
JPM
and
the
main
mentioned
here.
One
called
Jaya
Jaya
I,
which
is
been
based
on
Jane
I
and
the
other
us
of
all
those
well
most
useful
for
closure.
And
we
will
it
stick
mainly
with
ourselves
with
what
we
show
today
and
mainly
because
it
seems
to
be
other
robust
in
mind,
experience
and
allows
for
many
sessions
and
also
yeah.
B
We
will
see
that
and
and
easy
install
and
some
kind
of
transparency
and
a
easiness
that
are
so
important,
and
it
is
worth
mentioning
that
both
GI
and
other
he'll
have
this
common
obstruction
about
them,
which
is
called
our
engine.
It
is
just
a
set
of
Java
classes
that
obstruct
the
main,
are
data
types
and
if
we
look
in
the
code,
it
is
I
think
that
it
is
other
interesting
to
see
these.
These
are
all
they
are
all
called
I'll
accepting,
which
is
something
like
RS
expressions
and
they
are
all
actually.
B
They
all
present
some
kind
of
list
Oh
at
least
the
data
types
of
list,
not
the
one
bank
which
is
on
the
other
side
on
the
outside,
and
it
is
quite
nice
to
eat
this,
and
it
is
quite
readable,
a
description
of
the
main
data
types
of
up.
If
one
wants
to
understand
this
stoic,
so
it
is
other
accessible
and-
and
there
are
others
other
ways
that
we
could
use
that
I
mentioned
here.
One
interesting
is
ranging,
which
is
pure
joy,
beer.
B
It
is
a
few
JVM
implementation
of
the
core
of
our
the
base
language,
but
it
does
not
include
all
the
libraries
and
another
is
fast
are
of
the
Guardian.
That's
new
JVM
that
we
sometimes
mention
and
fast.
Our
is
a
little
bit
more
complete
than
Renji,
but
the
in
talks,
though
we
would
be
a
little
bit
more
difficult.
Maybe
if
we
have
time
we
can
discuss
that
and
yeah.
B
So
that
the
priorities
that
that
I
wish
to
suggest
is
to
have
a
good
solution
for
us,
based
on
our
selves,
like
the
current
version
of
mojo
and
then
later
go
to
engine
and
fast
out
and
have
some
obstruction
about
above
all,
B's
that
can
make
this
choice
of
implementation
plans
balanced.
But
we
should
begin
I
guess
with
ourselves.
B
Any
questions
so
far,
please
stop
me
all
the
time
so
so,
as
we
said,
the
idea
is
to
have
one
common
obstruction
about
all
the
different
backends
of
Earth
and
the
way
I
I
am
building.
What
I'm
writing
now
is
looking
into
these
main
two
use
cases
which
are
most
known
to
me.
One
is
the
usual
are
for
ourselves
and
the
other
is
ranging
that's
huge,
a
DMR
which
are
a
little
bit
similar
to
each
other.
B
They
are
similar
in
that
they
both
have
set
of
Java
classes
that
obstruct
the
type
system
on
the
Java
side,
and
they
both
allow
one
to
type
in
Java
and
reasoning
about
the
are
types
and
handling
them
and
manipulating
them
of
call
the
ourselves
plus.
Our
engines,
Joey
also
heads
as
our
as
a
separate
process,
and
that
it
speaks
speed
and
and
then
another
question.
So
so
we're
a
full
Java
story
that
a
complete
story
of
our
intro
and
the
question
is:
does
it
have
to
be
some
part
of
our
API?
B
If
we
are
building
a
closure
solution
and
one
approach
could
be,
let
us
have
it
as
abstract
as
it
could
be
and
hide
all
the
Java
details
and
and
it's
kind
of
a
dilemma,
because
sometimes
one
may
wish
to
have
the
more
low-level
Java
stuff
available
and
what
I
chose
to
do
for
now
is
yes
expose
the
Java.
The
Java
story
is
part
of
the
API
that
we
are
writing
in
closure.
So
we
have
like
three
presentations
of
the
our
story.
B
How
can
we
work
with
our
without
getting
all
the
time
cookies
in
the
JVM
of
the
our
data
structures
that
we
are
working
with,
and
it
is
a
bit
problematic,
because
the
delightful
is
were
using
specifically
our
engine
about
above
answer
that
library
it's
when
it
gets
a
return
value
return
value
for
our
that
value
is
automatically
converted
to
Java.
So
we
pay
this
cost
of
conversion
every
time
we
do
some
computation
and
get
the
data
back
and
we
wouldn't
run
back
every
time
and
what
should
we
do
with
this
automatic
conversion
of
return
types?
B
So,
of
course,
one
thing
to
do,
and
that
is
what
I'm
trying
to
do
is
do
not
return
the
values
of
the
our
computations
that
will
and
just
keep
them
on
the
outside
and
just
return
a
handle
a
way
to
access
them
later.
Does
it
make
sense
any
questions
about
that
yeah?
So
the
story
for
now
is
that
we
are
talking
with
our
and
doing
all
kinds
of
our
computations
and
we
are
keeping
things
in
memory
in
the
outside
and
keeping
handles
on
the
closure
side,
and
maybe
maybe
I'll
just
do
an
example.
B
B
So
what
do
we
get?
So
what
has
happened
now?
A
an
our
self
process
has
started
on
the
default
port
and
we
got
some
results,
which
is
an
our
object,
which
is.
This
is
the
handle
to
the
theme
that
we
are
keeping
on
the
outside
and
we
have
an
object
name.
That
is
the
object
which
is
kept
in
the
our
memory
and
in
later,
because
we
are
painting
it.
We
do
have
the
conversion
to
Java,
do
some
Java
class
and
then
to
closure
to
the
vector
of
random
number
3,
which
is
the
results.
B
Does
it
make
sense?
Ok,
so
what
we
have
done
is
create
a
handle
to
an
our
object
and
only
on
printing
convert
it
to
Java
and
closure
to
be
able
to
print
it
so
that
that
is
what
we
will
do
all
the
time
and
and
we
of
course
we
could
define
something
like
that
and
then
no
conversion
took
place.
So
we
have
this
object
on
the
outside,
but
not
on
the
closure
side,
and
what
we
have
on
the
closure
side
is.
B
B
Okay,
so
we
are
keeping
all
kinds
of
stuff
on
the
our
memory,
and
how
can
we
do
it
responsibly?
I
mean
how
could
we
release
stuff
when
we
need
to?
How
can
we
keep
track
of
all
that
and,
of
course,
the
answer
is
technically
sauce
that
new
cooled
likely
by
Chris
that
maybe
some
of
you
have
seen
the
blog
post
about
it
and
for
me
it
was
a
lifesaver.
It
made
so
much
stuff
so
simpler,
and
so
it
is
a
joy
now
to
handle
resources
and
get
them
free,
automatically
and
transparently.
B
B
Something
which
is
an
object
of
class
Alex,
double,
which
means
our
expression
of
which
is
a
vector.
One
is
technically
the
Java
presentation
of
an
a
vector
and
and
the
way
it
is
painted.
We
already
see
their
closure
conversion
of
that
which
is
just
a
closure
vector.
So
we
can
keep
converting
and
from
Java
to
closure,
and
we
see
that
we
just
get
close,
but
we
don't
have
to,
and
we
don't
have
to
do
these
conversions
doesn't
make
sense.
Is
it
ok
so
far,
yeah?
B
B
Is
it
ok
and-
and
we
can
also
have
this
X
so
X
to
be
these
square
numbers
and
we
can
have
Y,
be
the
mean
of
X
and
we
can
say
a
queen
to
get
the
conversion
of
another
way
to
act,
the
same
thing,
but
what
was
happening
now
behind
the
scenes?
So
we
created
an
object
X
and
we
keep
created
another.
Our
object,
Y,
actually
x
and
y
are
closure
objects
which
are
handles.
Those
are
objects
and
we
have
all
that
memory
on
the
outside,
which
is
waiting
to
be
released.
B
It
has
probably
it
has
not
been
released
yet
because
no
garbage
collection
happened
on
the
closure
side,
but
eventually
we
took
the
Y
object
and
got
the
return,
value
and
I
guess.
If
we
will
do
a
garbage
collection
on
the
JVM,
then
we
see
that
many
objects
on
the
outside
we're
released.
Thank
thanks
to
their
tech
resource
library,
which
is
so
that
is
just
a
little
little
taste
and
maybe.
A
B
Thank
you,
Joe
and
so
I
guess.
What
we're
not
seeing
yet
is
is
how
it
may
connect
to
there
our
encounter
story.
The
old
API,
which
has
lots
of
syntactic
sugar
and
all
all
kinds
of
nice
surprises
that
make
writing
are
fun
and
I
guess
it
could
be
interesting
to
see
how
these
things,
connect
and
I
would
love
to
discuss
that.
B
But
for
now
these
are
just
like
very
basic
experiments,
and
so,
as
we
saw
down
these
data
conversions
from
out
between
our
in
the
jar
and
between
Java
and
the
closure
layer,
and
both
of
these
conversions
depend
on
our
choice
of
back-end,
which
is
at
the
moment
it
is
ourselves
we
will
abstract
it
away
and
support
other
vacancies
as
we
discussed
and
and
actually
the
writing.
The
data.
B
Conversions
is
rather
demanding
just
to
understand
the
type
system
and
the
little
details
of
how
things
could
relate
to
to
one
another,
and
there
I
learned
a
lot
from
the
I
encounter
and
wardrobe
storage,
but
there
is
still
a
lot
to
learn
because
we
wish
to
be
compatible
with
some
new
closure
and
photo
course
and
abstraction.
And
so
let
us
talk
a
little
bit
about
functions.
B
B
B
B
Okay,
so
we
got
the
result,
is
an
object
that
when
printed,
we
see
that
the
closure
conversion
of
it
is
10.
It
seems:
okay,
yeah,
okay
and
five
functions.
Sometimes
they
may
have.
You
know
default
values,
so
we
can
say
Y,
then
C
when
e,
so
we
redefine
F
and
we
can
avoid
y&z
and
get
33
5,
1,
plus
2,
plus
10
plus
20,
that's
33.
B
We
chose
default
values
and
we
can
also
specify
some
arguments
by
name.
For
example,
we
skip
Y
and
specify
skew
as
1000.
So
what
will
we
get
here?
1
+,
2
+?
What
is
y
Y
is
10
and
Z
is
1000,
so
we
get
1013.
Is
it
okay,
so
here
I'm
trying
to
play
with
the
syntax
and
see
how
how
to
support
both
unnamed
arguments
and
named
arguments,
and
maybe
maybe
Chris?
You
have
some
lessons
from
the
Python
story,
which
is
similar.
B
So
maybe
we
keep
discussing
that,
and
so
these
are
functions
and
maybe
we'll
come
back
to
that
later.
So
now
we
have
some
notion
of
functions,
another
thing
sessions,
so
behind
the
scenes
what
was
happening
we
saw
in
the
beginning
that
transparently
and
also
process
they
began.
Our
selves
is
that
thing
that
is
happening
on
the
outside.
That
is
serving
us.
B
B
B
And
go
back
to
the
one
foot
before
there,
so
we
have
many
sessions
as
many
sessions
we
may
like,
and
we
can
also
release
those
sessions
quickly
and
with
no
other,
because
it
is
just
a
separate
session
and
so
and
I
wonder
how
how
to
make
it
comfortable,
keep
act
of
yeah.
We
discussed
and
another
thing
is
days.
So
and
probably
you
know
that
in
our
we
have
this
central
notion
of
a
data
frame,
data
frame
and
enclosure.
B
B
Are
we
communicate
between
a
three-layer
closure,
Java
and
R,
and
we
just
convert
when
we
wish
to
convert
and
another
way
it
could
be
keep
things
on
the
outside
and
have
them
implement
the
protocols
of
the
camera
data
set,
and
that
is
something
that
I'm
still
working
on
I'm
still
a
bit
confused
about
all
those
portables
of
column
and
they
said
I'll
have
to
learn
more
from.
Please
make
it
work
fast.
So
now
it
seems
workable,
and
there
is
no
reason
it
will
not
happen.
And
then
why
is
it
important?
B
Because
Tech
ml
dataset
supports
all
kinds
of
beautiful
ways
to
handle
data
sets
and
to
manipulate
them,
and
it
will
just
be
wonderful
to
use
that
on
data
sets
which
are
waiting
on
the
outside
without
any
copy,
and
so
it
seems
doable
very
soon
and
I
hope
to
update.
Take
about
it.
And
so
let
us
do
just
a
little
example
of
the
first
point
that.
B
B
B
B
So
what
just
happened?
We
clear,
isn't
our
object
and
there
are
object
that
we
have
a
handle
off
from
the
closure.
Sun
is
an
object
of
class
data
plane,
that's
we
know
we
have
created
that
they
take
a
plane
on
the
outside
and
then,
since
we
are
painting
it,
we
can
see
the
full
film
that
shows
the
Java
conversion
and
the
closure
version,
which
is
just
the
data
that
we
started
with,
seems.
Okay,
any
questions.
B
B
Then
we
can
do
a
mg
and
then
we
get
the
dataset
after
the
filter
and
after
the
computation
another
column
and
no
copy
took
place
between
the
operations.
Only
in
the
end
when
we
have
to
put
it
so
that's
we
can
work
with
our
data
file
and
again
there
is
the
I'll
encounter
story,
and
maybe
maybe
we
can
look
into
it
and
because
there
are
all
kinds
of
ideas
of
data
manipulation
there.
There
are
so
much
fun
and
I
wonder
how
they
they
may
combine
with
what
you
are
doing
here
and
they
should
combine.
B
There
are
more
on
the
usability
level
of
making
things
fun
to
use
the
way
I
see
and
they
could
work
on
this
back
end,
which
is
like
taking
care
of
the
little
details
for
clothing
or
coffee,
so
I
hope
to
look
into
that,
and
so
we
looked
into
dataset
and
other
data
types
that
you
know
while
some
work,
so
it
for
the
type
of
matrixes
and
factors.
Factors
are
those
are
types
or
go.
B
A
couple
variables
that
have
set
on
possible
values
and
and
extolled
efficiently
without
replicating
the
values
of
all
the
time
and
I,
know
that
the
tech
ml
dataset
have
a
similar,
similar
notion.
So
some
conversion
between
the
two
notions
is
still
necessary,
still
confused
about
the
details,
and
now
what
I
wish
to
show
and
I
guess,
we
will
be
able
to
finish
this
presentation,
15
15
minutes,
and
then
we
discuss
what
I
used
to
show
now
is
our
map
now.
So
what
is
our
knockdown?
B
It
is
an
extension
of
the
markdown
format
that
allows
write
code
in
it
and
whether
that
code
into
visual
stuff
and
and
I'm
up
down
is
very
one
of
those
beloved
things
on
the
earth
community.
It
is
a
the
current
way
of
doing
the
so-called
literate
programming
that,
in
in
back
in
the
days,
was
done
in
different
ways
in
the
art
community.
B
But
now
it
is
like
a
few
joy
of
a
mother
and
then
also
it
has
great
tooling
there,
so
so-called
our
notebook,
which
is
part
of
the
our
studio
and
all
like
there's
this
kind
of
harmony
of
things
working
together
and
how
could
we
enjoy
that
enclosure?
So
here
it's
namespace,
some
examples
and
the
idea
is
that
enclosure
will
hiccup
hiccup.
Is
this
way
of
fighting
hTML
is
data,
its
closure
and.
B
So
we
could
convert
she
cut
to
HTML
and
in
a
sense,
hTML
is
valid
markdown,
because
markleham
can
contain
HTML
elements,
so
you
can
convert
hiccup
to
HTML,
which
is
markdown,
which
is
a
subset
of
a
markdown,
so
we
can
create
our
Mountain
Omega,
and
that
is
what
we
will
try
now
and
another
thing
that
we
are
going
to
like
with.
Is
this
and
Gigi.
B
Finally,
you
may
remember
by
Johnny
Hudson
and
she
did
Posse
LJ
offered
like
a
lightweight
closure,
syntax
above
the
earth
in
text,
and
so
you
could
write
this
kind
of
closure.
Eden
data
structure
translate
to
our
code.
In
this
case
they
translate
to
our
gd+
code
that
is
floating,
and
so
you
could
write
those
even
data
structures
and
get
those
is
reputations
and
we're
going
to
play
with
that.
Now.
B
B
Then
what
are
we
doing?
We
take
this
kicker
code,
which
is
like
thicker.
If
you
know
it's
HTML,
but
inside
we
have
a
special
block.
A
block
of
represented
is
even
which
is
some
codes
that
translate
to
our
code
for
plotting
and
and
then
we
convert.
Please
pick
up
to
our
map
down,
which
means
just
do
the
usual
hiccup
to
HTML
conversion,
but
take
care
of
these
little
blocks
to
make
them
are
cold
blocks
on
the
arm
of
downside,
and
then
we
do.
B
The
rendering,
usually
using
I,
mean
using
the
package
for
ArmA
the
rendering,
and
we
do
it
using
the
data
that
we
have
and
what
does
it
mean?
It
means
that
on
the
leveling,
using
our
map
down,
we
find
to
the
data
so
that
it
is
available
on
the
rendering
stage.
I
won't
go
into
the
are
details
of
what
width
means,
but
the
point
is
that
it
was
simple
to
do,
and
so
we
just
created
an
HTML
and
view
it
see
what
how
it
looks.
B
B
So
X
is
many
on
the
numbers.
Why
is
exploring
data
is
now
a
data
set
in
the
sense
of
deck
ml
data
set,
and
so
now,
when
we
pass
it
to
the
outside,
we
have
it
on
our
available
as
an
our
data
frame
and
we
use
the
usual
ggplot
library
and
so
called
grammar
of
graphics
of
duty
block
and
we
say
yeah
X
Y
will
be
our
X
s
and
we
do
the
same
thing
as
before.
So
it
is
just
a
different
way
to
do
something
and
we
get
it
again.
B
B
Some
function
of
X
Z
with
will
be
used
for
color
and
again
take
the
data
set,
and
now
we
have
this
kicker.
So
this
we
are
creating
a
big
hiccup
feel
right
because
we
have
a
loop.
So
we
have
many
deals
inside
each
team
will
plot
a
jillion
plot
with
a
different
number
of
samples,
and
they
all
this
big
hiccup
will
be
again
converted
to
our
markdown
and
rendered
without
data
and.
B
B
Little
data
cases
so
when
looking
into
a
city,
I
need
to
look
into
many
streets,
so
I
I
always
have
the
sequence
of
Atlanta
and
I
wished
weather
them
quickly
and
in
the
visual
useful
way.
So,
for
me,
just
became
a
habit
to
create
this
markdown
huge
markdowns
from
pick
up
and
usually
I,
did
it
using
our
in
front
and
rajo.
But
now
it
is
just
like
a
little
different
way
to
do
it
and
so
I
hope
to
continue
with
that
and
make
it
more
like
systematic.
B
C
B
Yeah
and
I
guess,
as
we
said
earlier,
there
are
already
other
economic
of
I
encounter
and
I
still.
It
does
not
connect
in
my
head
how
all
this
should
connect
together,
but
I
really
hope
it
will
uh-huh
and
you
know
let
us
discuss
it
and
I
wanted
just
maybe
two
ways:
there
are
questions
that
we
could
discuss
and.
B
But
first,
if
it
is
okay,
let
us
talk
about
the
other
direction
for
a
moment
and
which
is
not
what
you're
looking
into
here.
But
it
is
working
focus,
and
that
is
the
thing
that
is
happening
at
my
work.
Facet
localize,
because
I
stick
in
a
room
full
of
our
people
of
our
users
and
sometimes
they
may
need
closure.
You
know
that
our
back
end
is
with
an
enclosure,
and
that
is
one
reason
for
the
our
users
to
be
curious
about
closure.
B
But
there
are
other
little
reasons,
and
one
of
them
is
that
our
users
are
curious
about
lists
and
functional
programming,
or
maybe
at
least
there
are
sometimes
curious
about
it,
and
here
I
can
tell
by
hearing
about
it
from
our
people
and
I,
can
tell
by
hearing
from
my
own
story
that
wasn't
exactly
like
that.
But
because
I
did
I
didn't
know
so
much
about
functional
programming
and
I.
B
Didn't
know
that
I
was
at
least
when
I
was
using
it
because
it
was
somehow
hidden
in
a
way,
but
using
are
made
me
want
something
just
a
little
bit
cleaner
and
more
more
concise
and
pure,
and
so
seeing
closure
was
a
moment
of
happiness
and
for
me,
I
was
the
thing
that
prepared
me
to
be
happy
about
closure.
I,
think
and
I
see
that
I
think
in
other
our
users
and
another
reason
that
our
users
could
be
happy
about
closure.
Is
that
I
see
them
subtly
with
nested
data
structures?
B
B
So
there
is
some
potential
here
so
for
our
users
to
enjoy
closure
and
what
we
are
trying
to
do
and
we
cannot
release
it
yet
because
it
is
not
well
polished
enough,
but
we
are
trying
to
expose
our
to
explore
closure
as
a
tool
for
article.
The
first
we
tied
it
to
Jay
and
I,
and
there
were
all
kinds
of
problems
about
it
and
now
we're
trying
to
an
American
portico,
and
so
that
is
one
part
of
the
story.
Another
part
of
the
story
is
our
tooling.
B
That's
already
exist,
or
not
your
tooling,
but
this
time
use
it
form.
These
are
tools
so
that
these
are
two
things
that
we
can
look
forward
to
and
I'm
excited
about,
and
and
I'm
thankful
to
the
our
people
around
me
that
that
you
know
that
direct
me
to
think
about
this
kind
of
stuff
that
I'm
not
used
to
and
and
I
also
wanted
to
say
that
we
could
think
what
we
could
learn
from
the
ecosystem
and
our
community.
And
maybe
one
thing.
Maybe
it
is
like
a
topical
open
discussion.
What
we
could
learn.
B
So
one
thing
that
I
wanted
to
discuss
is
the
kinds
of
protocols
that
would
be
useful
for
for
objects
to
implement.
When
we
have
this
kind
of
handle,
often
our
objects.
What
closure
protocols
would
be
like
it,
and
another
thing
is
how
it
may
relate
to
the
Python
interrupt
story.
Should
we
hope
for
one
obstruction,
one
kind
of
convention
of
function
calls
and
they
utterly
the
little
details
of
the
ergonomics
of
inter
and
also
can
we
create
this
triangle
of
three
languages:
five
from
our
enclosure.
B
That's
just
work
together
in
harmony,
which
is
not
the
case
at
the
moment,
because
we
are
talking
about
different,
interrupt
libraries
with
different
notions
of
translation.
It
is
a
bit
complicated
at
the
moment,
and,
and
another
thing
I
really
wish
to
discuss
is
how
it
combines
with,
as
we
mentioned
with
Alan,
can
tell
and
Waldo,
and
also
anything
you
might
say
about
priorities
about
what
would
be
important
to
work
on,
and
so
these
are
the
questions
which
I
hoped
we
could
discuss
and
thank
you.
A
A
E
So
the
there
are
a
lot
of
protocols
in
the
data
set
and
column
system
and
so
I
think
the
the
pathway
that
was
chosen
I
think
was
the
best
possible
one.
So
for
now
I
don't
the
best
one
is
to
copy
into
the
library
and
just
for
now
use
table
saw
if
you're,
if
you're,
using
tech
data
and
all
the
data
set
you're,
essentially
using
the
table,
saw
library
as
a
column
store.
So
it's
a
JVM
in-memory
columnstore
with
an
efficient
implementation
for
missing
elements
and
strings,
so
I
think
it's
difficult.
E
B
E
B
So
actually,
the
all
that
is
not
you,
it
was
just
there
waiting
and
I
know.
I
do
not
know
how
well-known
it
is,
but
when
they
in
ggplot
the
libraries
were
there
waiting
in,
and
that
is
one
of
the
things
that
I'm
curious
about
people
are
doing
with
our
intro
nowadays,
because
it's
already
exist.
I
guess
there
are
lots
of
those
small
experiences
of
people
I.
E
A
Yeah
Daniel,
what
would
you
you're
and
sort
of
workflow
be
if
you
would
do
more
exploratory
and
we're
with
data,
and
you
would
have
to
do
visualizations
a
bit
bit
joining
to
their
previous
discussions
as
well?
Aha,
but
using
this
tool?
How
would
it
look
like
to
you
remember
data
constantly
when
you're,
when
you're
working
with
it.
B
Yeah
so
I
guess
that
is
the
one
of
those
things
that
I
always
feel
that
I
I
miss
somehow
so
I
do
not
know
if
I'm
doing
it
the
right
way
so
to
speak,
and
that
is
one
of
the
things
that
we
discussed
in
the
all's
meeting.
I
think
that
there
is
a
lot
to
we
think
about
the
data
flow
of
visual
rendering
of
what
we
create
at
the
record.
B
How
can
we
keep
the
lapell
experience,
but
the
same
time
creates
something
in
the
browser
and
what
happens
when
we
interact
with
that
on
the
browser,
and
these
are
important
questions,
because
naturally
one
may
want
to
interact
in
the
browser
and
keep
track
of
that
just
as
well
as
working
with
the
repeal
and-
and
this
opens
many
questions
out
of
the
scope
of
this
meeting
and
I
hope
to
discuss
them
one
day
and
and
for
now
my
usual
habits
are
just
to
create
huge
markdowns
and
help
them
as
statically
code.
So
it
would.
B
C
B
And
so
so
I
guess
one
thing
we
could
discuss
now
is
the
is
the
topic
of
other
backends
and
and
so
yeah.
We
talked
about
ranging
and
fast
our
first
other
thing
that
walks
on
guard
here
and
I.
Wonder
how
interesting
it
is,
how
important
it
is
to
people
to
be
able
to
run
on
pure
JDM
or
pure
nard,
Ian
and
I.
That
is
one
of
our
main
questions.
Now.
B
Is
it
important
to
be
on
the
field
really
and
I
know
I
hear
from
people
that
they
they
were
using,
for
example,
ourselves
in
production,
and
maybe
there
is
no
reason
not
to
and
and
and
that
is
the
one
of
the
those
things
that
I
wonder
about
in
terms
of
priorities.
Is
it
important
if
there
are
any
opinions
about
it?
E
B
A
The
technical
issues
such
as
the
rocks
container,
some
of
them
indeed
are
at
what
would
then
be
the
advantages
where
you
don't
need
to
to
orchestrate
your
your
your
info
to
get
the
advantages
from
these,
for
instance,
using
using
something
like
draw
broadly
and
which
I'll
I
understand
this
developing
very
fast,
fast
and
they're.
Adding
more
and
more
support
to
to
to
many
of
the
libraries
as
well.
Would
there
be
I
guess,
I'm
looking
for
sort
of
a
opinions
of?
B
So
I've
done
a
small
experiment,
just
being
able
to
call
it,
and
we
actually,
we
discussed
it
in
a
local
meetup
a
week
ago,
and
there
was
someone
well
with
who
knows
more
about
darlin
and
we
kind
of
discussed
the
different
interpreters
that
they
are.
You
know
gal
VM
supports
learning
many
languages
thanks
to
that
social
infrastructure.
B
They
can
speak
with
each
other
and
share
data
actually
share
data
structures,
so
these
are
our
and
Ruby
and
JavaScript
and
Python,
and
what
else?
Scanner,
maybe
and
all
these
dolls,
sovereign
citizens
of
the
JVM
and
closure,
is
not
closure.
Is
there
because
it
lands
on
the
JVM
I
think,
but
it
does
not
work
on
the
TOEFL
interpreter
and
Java
does
not
either
so
closure
and
Java,
and
us
somehow
unprivileged
in
the
in
table
story
on
Garvey
M,
because
they
do
not
enjoy
this
sharing
of
data
structures,
and
so
some
some
ceremony
is.
B
And
playing
with
the
data,
conversions
seems
a
little
bit
harder
on.
Golf
am
compelled
to
ong,
for
example,
and
it
seems
that
there
is
a
lot
of
work
to
be
done
just
to
make
sure
that
the
day
conversions
are
usually
enough.
Communicating
between
and
closure,
and
the
question
is:
is
it
important
to
us
and
about
that
I'm?
Not
sure
yet
and
as
Chris
says,
for
my
news
cases,
maybe
just
using
new
hour
as
a
separate
process,
is
just
good
enough.
B
A
E
B
Yeah,
you
and,
and
here
there
could
be
different
meanings,
so
that
one
could
be
data,
conversions
and
the
other
would
be
implementing
protocols
right
I
mean
there
are
these
ways
to
consume
and
our
data
frame
or
Python
data
frame
one
way
to
consume
it
is
to
convert
to
a
tech
ml
data
set
and
another
is
to
just
make
it
implement
everything,
implement
all
necessary
protocols.
I
yeah.
B
B
E
What's
it
like,
when
you
have,
you
know
a
a
tab,
separated
value,
zipped
file,
that's
four
hundred
Meg's
on
disk
and
you
load
it
into
Clojure,
and
you
want
to
use
it
and
do
things
with
it
and
I'm
getting
to
really
test
out.
Do
numeric
abstraction
under
text
data
type,
because
the
data
is
very
heavy.
It's
really
really
big,
so
eight
megabyte
on
an
auto
says
a
megabyte
float
images
if
you
can
imagine
that
and
lots
and
lots
and
lots
of
them
and
reading
up
into
them
in
various
different
projections.
And
things
like
this.
E
A
E
The
u.s.
we've
seen
such
a
huge
impact
from
schools
that
have
just
taught
data
science
in
like
a
nine
month
to
one
year
time
frame
and
in
that
time
frame
you
don't
have
the
time
to
teach
lots
of
languages,
and
you
don't
have
the
time
to
teach
a
lot
of
things
that
you
would
find
in
a
computer
science
curricula.
In
that
time
you
get
really
good
with
our
and
you
get
really
good
with
Python
and
really
good
at
data
science
and
so
and
then
the
language
stuff.
E
A
A
F
Questions
as
well
I
do
institutional
research
for
a
university
here
in
Oregon.
So
a
lot
of
what
I
do
is
just
you
know,
reports
and
data,
but
I
I'm
wanting
to
apply
more.
You
know
statistical
methods
and
stuff
to
what
I'm
doing
is
I
get
to
use
cloture,
sometimes
and
in
special
projects,
and
so
this
seemed
seems
like
a
good
tool
set
to
start
with.
A
Okay,
Daniel,
if
you
have
the
other
questions
in
in
the
list
as
well,
did
we
want
to
look
at
those
you
you
were
you?
Would
there
was
the
priorities
question
I
think
we
discussed
that
as
well
the
lawyer
for
that
the
third
one.
What
was
that
yeah,
the
relationship
to
existing
libraries?
That
may
be
a
question
that
that
I
believe
Java
as
as
good
could,
could
have
some
some
opinions.
B
So
so,
and
what
I
wonder
about
is
how
what
we
have
discussed
today
may
connect
to
existing
API.
So
it's
our
encounter,
and
that
is
thank
something
that
I
wish
to
look
into
and
maybe
maybe
look
a
little
bit
under
API,
just
recall
the
beautiful
stuff
that
is
happening
there
and
because
I
think
there
is
a
lot
to
be
thought
about
about
syntax
and
and
about
how
to
make
things
work
together.
B
And
and
here
what's
what
we're
seeing
here
is
one
of
those
nice
nice
things
that
is
happening.
It's
a
I
encountered
and
I
think
it
is
a
good
example
of
affair.
What
could
be
imagined
as
a
combination
of
two
languages?
What
is
happening
here
is
a
code,
a
block
of
code,
where
we
have
both
R
and
closures.
It's
two
languages
together
as
a
usual
as
a.
B
That
is
time
to
see
how
how
to
do
stuff-
and
maybe
that
is
the
challenge-
to
create
some
feeling
of
how
money
between
the
tools
and
I
think.
That
is
what
we
do
not
have
yet,
and
it
must
go
through
lots
of
tutorials,
probably
just
fighting
lots
of
examples
and
then
seeing
seeing
how
they
make
maybe
start
feeling
systematic
and
and
I
am
coherent.
C
B
C
B
A
sense
it
hides
the
story
of
that
is
happening
behind
the
scenes
and
to
create
those
F&G
functions.
We
had
to
write
some
our
code,
so
we
did
mix
our
enclosure
code
and
I
wonder
how
to
do
that
and
I
agree
with
you
that
I
like
functions
as
a
way
to
communicate
and
but
still
we
did
have
to
write
some
syntax
here.
Sure.
E
B
Nice
yeah,
so
in
a
sense
what
you're
describing
is
close
to
well,
the
odds
workflow
is
going
nowadays.
The
way
I
understand
it.
I
thought
what
Christopher
small
deal
in
all's
is
create
some
kind
of
figure.
We
like
workflow
for
closure
data
analysis,
and
so
maybe
that
is
an
experiment.
We
could
do
and
see
how
we
could
add
an
archive
to
that
and
yeah.
That
is
so
inspiring.
I
really
wish
to
find
that
so
I
got
some
homework
and
now
I
am
happy.
A
B
C
Be
interested
to
see
what
something
like
the
lied,
Python
that
Chris
has
done.
What
looks
like
lower
level
integration
with
the
interpreter.
You
know
I
would
be
interested
to
you
know
to
try
something
like
that
with
our
and
not
have
to
go
through
the
the
Java
layer
that
the
that
they
put
together.
I
don't
know
if
it
would
be
easier
to
use
or
not,
but
it
would
be
interesting
to
try
I
think
and
maybe
it
may
make
it
simpler.
E
C
Also,
have
a
question:
I,
don't
really
you
know,
I've
never
really
used.
Are
that
much
I
just
made
the
wrapper
and
what
what
type
of
what
typing
does
our
have?
Is
it
like
duck
typing
like
if
you
gave
it,
if
you
gave
it
a
handle
to
a
data
frame
coming
from
closure,
would
would
our
be
able
to
handle
that.
B
B
Yeah
and
then
what
is
it
actually
so,
in
a
sense
in
the
internal
representation,
it
is
just
a
list
of
columns
and
named
list
of
columns,
but
it
has
this
additional
metadata
in.
Oh,
that
is
maybe
the
radio
you
would
call
it
enclosure
in.
Oh
it
it
is
called
attributes
and
the
attributes
say
everything
about
the
type
and
all
the
polymorphic
functions
will
use
these
attributes
as
a
way
to
to
dispatch.
And
so,
if
we
look
into
the
object
we
created
D.
B
C
B
Yeah
I
remember
John
several
years
ago
that
you
said
that
you
would,
if
you
had
time
you
would
write
something
in
J&A
and
and
I
think
it
could
be
fun
and
maybe
the
hard
part
is
doing
it
in
DNA,
I
guess,
which
is
which
requires
some
learning.
But
the
path
is
already
there.
If
we
think
it
is
important.
Yeah.
C
B
Yeah,
what
I'm
hearing
from
people
who
use
are
with
Python
that
there
is
that
reticulate
library
and
from
Colleen
Python
from
she's
a
nice
name
for
a
library
that
colors
Python,
and
so
one
of
the
troubles
that
they
have
is
that
they
cannot
restart
the
Python
without
crashing.
There
are
because
there
are
somehow
connected
in
the
same
process,
and
that
is
the
limitation
and
I
wonder
if
it
could
be
overcome
steel
by
doing
something
of
the
mono
level
kind
that
you're
describing.
Oh.
C
E
B
Yeah
and
then
possibly
what
we
could
do
is
on
more
than
one
JVM
and
then
be
in
control
again,
but
still
use.
They
all
have
all
the
power
of
lip
Python
clj
and
it's
abstractions,
but
without
this
kind
of
trouble
of
same
process
crashes
right
and
maybe
that
is
one
possible
direction
to
use,
say
to
JVMs
one
for
your
closure
level
and
the
other
for
the
closure.
Learning
Python.
C
D
E
You
really
have
to
have
a
specialized
use
case
where
that
really
really
mattered,
though,
because
just
translating
a
bunch
of
numbers
over
a
network
socket
is
pretty
fast
if
they're
densely
packed.
So
what
what
are
the
range
of
problems?
Where
that's
really
like
the
deciding
point
between
you
making
money-
and
you
know.
A
B
To
ask
that
I
think
I
think
it
would
be
great
to
keep
discussing
the
protocols
story
and
and
be
able
to
understand
better
the
tech,
amel
story
of
protocols
and
how
it's
a
can
relate
here
but
say.
Maybe
we
can
keep
doing
that
offline
and
I
have
a
lot
to
study
about
tech
ml
dataset.
That
is
not
what
I
learned
in
the
last
few
days.
There
is
so
much
to
learn
and
I
guess
we'll
keep
writing
and
reading
about
that.
E
A
A
We
had
here
today,
super
fascinating
and
and
there's
a
lot
lot
of
work
to
be
done
still,
which
is
good,
of
course,
but
yeah
special
of
course.
There,
the
main
gratitude
to
Daniel
here.
Thank
you.
It
was
super
super
nice
I
guess
we
can
close
the
official
part
of
the
of
the
meeting
now
and
and
if
they're
best
some
some
casual
discussion
series
feel
free
to
stay
on
the
line
and
and
and
discuss.