►
Description
Martin Kavalar demonstrated Nextjournal, the new polyglot notebook written in Clojure and Clojurescript. Nextjournal embraces immutability as a central design principle.
This was the third meeting of the Scicloj community, on June 20th, 2019, 2pm UTC -- an open online gathering of the Clojure data science community.
More details here:
https://twitter.com/scicloj/status/1139272636675035138
Meeting's text chat:
https://docs.google.com/document/d/1MN3crvwRAFyzJH88imURfclow12vti1rkk1a8kXRl5U/edit?usp=sharing
A
Oh
hello,
and
so
this
is
meeting
number
three
of
psych
lodge
that
group
that
has
emerged
in
the
last
few
months,
where
we
are
pushing
forward
the
closure
ecosystem
for
scientific
computing,
computing
and
data
science,
and
today
we
will
have
marking
traveler,
who
is
already
here,
and
we
will
talk
about
next
Jonah
and
maybe
just
to
let
more
people
the
chance
to
join.
Let
us
use
these
two
three
minutes
to
tell
about
what
wish
to
do
in
the
near
future.
A
So
so
the
idea
is
to
create
a
group
where
we
can
think
together
about
the
ecosystem,
that
we
are
building
and
hear
stories
of
success,
but
also
do
some
thoughts
about
what
is
missing
and
I.
Think.
The
story
that
we
are
about
to
do
today
is
of
this
kind.
It
is
already
inspiring,
but
also
may
give
some
vision
of
what
could
be
and
is
not
there
yet
and
what
what
we
have
done
so
far.
A
We
had
two
meetings
about
machine
learning
and
where
this
very
special
meeting
today
and
then
we'll
have
like
a
cup
of
couple
of
meetings
on
the
subject
of
intro
in
the
next
month.
So
we
talked
about
interoperability
with
Python
and
phone
closure
and
afterwards
we
are
planning
about
four
meetings
of
data
visualization
and
then
at
the
end
of
the
year,
we'll
have
some
probabilistic
computing
and
other
stuff
of
this
time.
A
So
that
is
the
plan
for
now,
but
if
any
of
you
wishes
to
suggest
a
talk
of
your
own
and
a
subject
that
you
feel
is
missing,
then
it
is
a
good
idea.
Let
us
talk,
and
also
today,
after
we
hear
and
talk
about
next
journal,
we
will
be
able
to
talk
about
other
stuff.
So
if
any
of
you
have
a
topic,
you
wish
to
discuss
for
a
few
minutes,
maybe
a
story
of
yours
or
maybe
some
thought
about
the
future.
A
B
This
is
because,
partly
because
I'm
much
more
experienced
today
but
I
think
it's
also
because
I
have
much
better
tools
at
my
disposal
and
the
one
to
will
I'd
like
to
highlight
is
get
now.
Get
really
has
made
experimentation
for
us
as
developers.
So
much
cheaper,
like
branching,
that,
like
on
subversion
or
CVS,
which
you
might
have
been
using
before,
like
on
bigger
repositories,
was
so
painfully
slow
that
you
try
to
avoid
it
like
I.
B
First,
this
paper
was
published
in
2014
is
like
a
shining
example
of
reproducible
research.
This
means,
like
the
authors,
have
have
tried
to
publish
their
whole
methods
and
make
it
easy
for
readers
to
run
them
as
well,
and
they
are
really
following,
like
what
I
think
are
best
practices
and
using
tools
we,
as
developers
are
used
to
so
they
put
their
code
up
on
github.
B
B
This
problem
and
I
do
have
managed
to
get
further
there's
more
problems,
waiting,
there's
a
problem
of
like
installation
as
well
as
runtime,
like
some
of
those
libraries
have
to
be
compiled
from
source
that
just
takes
a
long
time
and
also
when
I
do
run
the
analysis.
Now.
This
is
a
pretty
simple
example.
B
This
is
just
using
the
our
language,
but
still
this
analysis
takes
50
minutes
to
run
from
top
to
bottom,
which
I
think
is
a
long
time
to
wait
to
get
to
some
point
where
somebody
else
has
previously
already
before
and
but
it's
not
always
as
simple
as
that
and
I.
Think,
like
the
more
complex
problems,
have
again
more
problems.
B
Now
dis
involved,
like
both
simulation
software
libraries
in
different
languages,
there
was
Java
Python
as
well
as
scripts
to
flutist
together
and,
like
I
said.
I
was
doing
this
on
a
number
of
different
systems.
So
there's
like
the
problem
of
of
already
having
run
something
and
trying
to
use
this
on
another
system.
This
often
involves
like
manual
intervention,
because
these
systems
are
different
in
unexpected
ways.
I
think
something
you
might
also
like
experience
when
you
do
data
science.
Also
there's
the
problem
of
data
management,
like
the
previous
example
Heather's.
B
These
simulations
they
benefit
from
having
GPUs
and
then
like
when
time
came,
not
to
start
my
write-up
there's
a
problem
of
keeping
everything
in
sync,
so
I
was
starting
to
write
up
already,
while
there
was
still
more
data
coming
in
and
like
yeah
keeping
everything
up-to-date
copying
pasting
that
from
images
like
into
My,
Lai,
Tech
and
getting
tables
in
there
was
just
yeah,
pretty
challenging,
and
so,
like
collaboration
like.
Yet
when
time
came
to
to
have
my
supervisor
review
my
work
like
emailing
around
to
PDF
and
getting
feedback.
B
This
way,
obviously
also
isn't
I
think
the
best
way,
necessarily
so
yeah.
To
sum
up,
like
I,
think
this
is
a
list
of
problems
that
we
might
encounter
when
we
do
like
science
or
data
science
and
I
mean
like
I,
think
like
fundamentally,
these
problems
are
are
the
same
in
both
domains
and
but
what,
if
we
could
have
a
system
like
that
would
do
away
with
a
lot
of
these
problems
and
I?
B
Think
like
functional
programming
and
especially
immutability,
is
like
pointing
us
towards
a
future
where
it
is
actually
within
our
reach
to
to
fix
a
lot
of
those
problems
like
yeah.
What,
if,
instead
of
struggling
with
this
dependency
management
problem,
we
had
a
saner
approach
to
this
and
we're
just
able
to
like
easily
save
whatever
state.
We
have
like
share
the
complete
image
with
others
without
having
to
care
about
like
giving
these
images
names
and
accidentally
overwriting
them
later.
B
What
if
we
could
skip
this
whole
process
of
like
rerunning
stuff,
to
just
get
to
a
point
where
somebody
else
has
already
been
before
what?
If
we
could
share
this
whole
process,
stay
and
yeah?
What
if
we
were
freed
of
having
to
pick
names
for
files
and
everything
would
just
automatically
be
versioned
also
reuse
could
be
a
lot
cheaper
if
we,
if
we're
working
in
the
system,
that
automatically
records
all
our
steps
and
makes
it
just
easy
to
build
on
top
of
that.
B
Now
this
is
the
stuff
yeah
I'd
I'd
like
to
show
you
now
and
we'll
return
to
the
example
of
the
wood
paper
in
a
bit,
but
first
I'd
like
to
walk
you
through,
like
how
some
of
the
like
we're,
definitely
not
not
there,
yet
that
we
solve
all
of
those
issues,
but
I
do
think.
Like
yeah
I
can
hint
at
at
how
some
of
them
can
be
solved.
B
So
here
we
are,
and
so
just
to
give
you
an
overview
like
I'll
walk
you
through
some
of
the
basics
of
like
how
to
work
with
code
and
data,
and
next
journal
like
how
we
use
immutability
at
at
all.
Those
different
levels
like
we
use,
like
we
version
data
separately
from
the
notebook
that
you're,
seeing
as
well
as
the
computational
environment.
B
B
B
If
we
do
have
time,
also
briefly,
look
at
like
the
closure
tools
and
our
closure
workflow
that
we
use
and
to
jump
into
this
I
actually
want
to
start
also
with
a
feature
that
that's
like
basically
the
fruit
of
of
having
this
immutability
at
all
levels,
and
this
is
what
we
call
remakes.
This
is
analogous
to
yeah,
like
forking
a
repository
on
github
and
when
I
do
press
this
button
here,
I
immediately
get
a
copy.
B
B
Now
it's
it's
starting
to
download
those
dependencies.
As
you
see
generally
code
is
executed
here
inside
a
runtime
which
is
a
darker
container
and
as
you
see,
we
have
multiple
of
those
here
in
this
notebook
and
yeah.
We
have
like
the
whole
app
is
written
in
closure,
as
well
as
enclosure
spirit.
So
we
do
have
good
support
for
yeah
all
the
closure,
data
structures
and
the
second
time
I'm
executing
yourself
ear.
It's
it's
nice
and
fast.
B
B
B
We
use
pace
58
encoding
with
a
library
called
multi
hash
that
allows
us
to
change
the
hashing
format
in
the
future
and
so
Multi
multi
hash
is
a
library
that
it
has
like
an
identifier
for
the
hashing
algorithm
that
we're
using
in
there
and
yeah.
We
can
make
changes
in
the
future
and
still
being
able
to
and
I'm
actually
quite
surprised,
like
we're
using
a
pretty
simple
approach
here.
B
So
so
far,
all
uploaded
data
and
results
are
just
being
stored
in
one
Google
bucket
and
that's
been
serving
us
really
well
so
far,
so
the
three
years
that
we've
worked
on
next
journal,
yeah
we're
still
running
on
this
single
bucket
and
yeah.
That's
actually
not
a
whole
lot
of
code
to
do
this,
hashing
and
yeah
it
I
guess:
there's
yeah
it
currently
like
the
largest
single
file
that
we
have
I
think
is
like
100
gigabytes,
so
yeah
I.
B
B
B
B
So
this
is
Python
is
the
language
here,
and
this
little
batch
behind
it
is
a
link
to
the
environment
and
the
environment
is
actually
provided
by
another
notebook
and
to
see
how
what
this
notebook
contains
I'm.
Just
following
this
link
getting
taken
to
this
other
notebook-
and
this
creates
a
reusable
environment,
and
this
in
turn,
we
can
again
dig
deeper
and
see
what
this
is
built.
On
top
of
this
is
using
like
our
default,
Python,
3,
environment.
Again,
I
can
drill
down
deeper
here
and.
B
So
this
starts
with
a
like
a
showcase,
showing
you
how
to
use
the
default
packages
that
come
with
our
environment,
like
pluckley,
matplotlib
stuff
you
might
be
using
for
visualization
and
when
I
click
down
here
on
the
setup,
you
can
actually
see
how
this
is
being
built.
So
this
starts
by
installing
anaconda
and
again,
I
can
drill
down
deeper
here
to
see.
This
is
again
turn
built
on
top
of
our
batch
environment,
and
here
this
actually
comes
to
an
end.
B
B
Another
thing
so
yeah,
you
can
also
see
how
this
is
being
built,
so
timezones
is
being
set
up.
Some
packages
are
being
installed,
locales
are
set
up
and
then
we're
doing
configuration
to
ensure
that
GPUs
work
automatically
with
all
our
default
images,
and
so,
if
you're
running
on
a
machine
with
a
GPU
we
automatically
mount
and
video
container
runtime
and
yeah.
You
have
drivers
setup,
which
yeah
typically
is
quite
a
pain.
B
B
B
All
right
there
we
go
and
yeah
so
I'm
getting
the
error
again.
So
if
we
pretend
this
other
environment
to
reuse,
it
didn't
exist.
We
can
like
add
a
batch
cell
here,
do
a
bit
install
and
then
we
can
run
this
and
it's
running
again.
But
this
is
yeah.
This
isn't
without
a
problem,
so
I'm
not
specifying
a
version
here,
so
the
latest
version
is
being
installed
and
after
I
run
this
two
months
from
now,
I'm
probably
gonna
get
a
different
version.
B
Now,
not
not
every
ecosystem
places
as
much
value
on
backwards
compatibility
as
the
closure
community.
So
yeah
there's
a
high
likelihood
that,
if
you're
using
a
lot
more
dependencies
that
these
things
changing
like
that
over
time
will
lead
to
breakage
and
so
to
save
that
and
like
save
this
exact
version,
all
I
have
to
do
bring
up
the
runtime
settings
and
check
this
export
the
environment
box.
B
Then
this
this
prompt
here
pops
up
and
it's
asking
me
to
review
the
changes
and
I
I-
do
I,
do
see
like
a
diff
of
the
file
system
here
and
I'm,
either
able
to
to
save
this
image
as
is
or
like
Receptus
to
its
originating
environment,
and
run
this
from
top
to
bottom,
and
this
is
I
think
also
something
that's,
that's
typically
pretty
hard
and
finicky
to
do
on
your
local
machine
like
yeah.
You
can
do
this
with
with
containers
locally,
but
yeah.
This
is
resetting
back
to
to
a
known
state.
B
Yeah
is,
is
pretty
annoying,
often
times
I
find,
and
so,
when
I
do
try
save
here
we're
committing
the
environment
as
a
darker
image
and
are
uploading
it
to
our
registry,
and
this
is
being
stored
in
our
registry.
Again,
we
reference
it
by
the
char
and
you
can
also
go
and
and
pull
this
image
to
reuse
it
locally.
B
You
more
how
that
works
in
a
bit
and
actually
like
one
thing,
I
forgot
to
mention
like
there's
currently
there's
a
final
step.
You
have
to
do
to
actually
reuse
this.
You
have
to
to
publish
the
notebook,
but
we're
working
on
on
removing
that
extra
friction
so
allowing
you
to
reuse
environments
from
notebooks
that
that
are
still
in
draft
state
and
yeah
if
you
like,
I,
can
also
show
you
how
to
use
custom
resources
as
well
as
GPUs
I.
B
B
So
this
is
a
non
poke
I
created
earlier
today.
That's
using
the
closure,
FX
library-
and
this
is
actually
makes
use
of
the
optic
GPU.
If
I
run
this
without
one,
it
will
complain
about
the
display
not
being
set
and
like
also
like
we're
still
running
or
default.
Closure
environment
is
still
on
Java
8,
so
I'm
actually
yeah
installing,
like
importing
open,
JDK
11
here
installing
the
lip
open,
GFI
library-
and
this
also
has
in
the
runtime
settings-
you
see-
it-
has
a
more
powerful
full
machined
and
our
default
configured
so
by
default.
B
When
you
run
on
an
instance
with
about
4
gigabytes
of
RAM
and
without
GPU,
but
you
do
have
the
ability
to
attach
different
GPUs
as
well
as
yeah,
basically
like
on
our
a
free
plan,
you're
currently
restricted
to
15
gigabytes
of
RAM
max
but
yeah.
When
you
do
join
a
paid
plan,
you
can
yeah
unlock
these
much
more
powerful
machines
and
yeah
as
I
run
this
it.
B
It's
always
a
bit
like
yeah.
These
estimations
are
a
bit
there's
some
variants
in
this
like
depending
I,
guess,
hello,
yeah.
How
fast
Google
is
able
to
provide
those
machines
for
us
and
because
this
is
quite
a
big
environment
here
with
X,
Server
and
stuff
extraction
takes
like
20
or
30
seconds
as
well.
B
B
B
B
So
because
we
we
do
have
like
all
those
things
version
separately,
again
document
layer,
then
the
data
layer,
the
environments
layer,
we're
able
to
like
show
you,
the
history
and
you
can
like
go
back
and
also
like
restore
previous
versions
and
like,
if
we
add
the
data
just
in
the
docker
container,
which
would
also
be
possible.
You
would
always
have
to
like
download
and
extract
the
whole
image
in
order
to
like
be
able
to
see
different
results
like
this
and
yeah.
B
B
And
I'm
able
to
access
this,
and
this
is
like
the
only
part
yeah-
that's
that's
actually
mutable,
and
that
has
to
be
mutable
yeah,
because
when
secrets
to
external
services
change
yeah,
you
do
want
to
be
able
to
to
update
them
and
reference
the
latest
version.
It
doesn't
make
sense
for
them
to
be
immutable
and
they're
stored
encrypted
involved.
We're
using
like
the
hash,
II
Corp
stack.
B
B
Just
drag
them
in
there
and
then
I'm
able
again
to
to
reference
them,
and
this
works
like
via
this
insert
file
menu
like
I
said.
This
is
because
yeah,
where
this
data
isn't
actually
stored
in
the
container,
but
it's
being
mounted
into
it,
and
so,
like
you
see,
I,
can
access
this
CSV
file
here
and
another
thing
I'd
like
to
mention
this
are
like
results
directory.
This
is
like
a
special
directory
on
which
you
can
write
files
to
and
after
every
execution
of
the
cell.
B
B
B
B
B
If
I'm,
lucky
and
I
think
I
am
lucky
in
this
case,
because
yeah
Jupiter
actually
doesn't
like
it
doesn't
have
a
way
of
specifying
all
the
all
the
dependencies
that
this
notebook
needs
to
run.
But
in
this
case,
like
psy,
PI
and
SK,
learn
matplotlib
are
actually
yeah
part
of
our
default
environment.
So
I
like
to
run
these
cells.
B
B
But
what
I'm
doing
now
is
importing
the
official
bash
image
from
docker
hub,
so
I'm
just
hitting
import
here
now.
This
is
going
to
docker
hub
downloading
the
image
and
again
checking
like
resolving
the
tag.
Looking.
What
the
latest
content
saw
of
this
is
and
to
use
it
in
this
environment
I
in
this
run
time,
I
bring
up
the
environments.
Drop-Down
can
select
this
image
now
and
when
I
do
rerun
this,
you
see
that
we're
now
using
Alpine,
Linux
and
actually
like,
because
all
we
need
to
to
execute
like
Bosch
cells.
B
In
these
images,
all
we
need
as
having
Bosch
be
present
there.
This
is
what
allows
us
to
like
do
this
sort
of
environments
bootstrapping
that
you've
seen
before
so
yeah
take
these
bear
images
and
install
stuff
into
them,
which
is
something
you
couldn't
do
with
Jupiter,
where
the
colonel
must
be
present
in
the
image
which
yeah
requires
like
a
whole,
Python
installation
and
obviously
like
yeah,
installing
Python
dependencies
or
upgrading.
A
Python
version
from
within
this
image
is
like
a
shaky
shaky
ground
and
there's
typically
problems
with
managing
dependencies
into
pair.
B
B
So
I
have
my
personal
github
talking
here
and
clone
this
to
use
it
in
this
runtime.
You
also
again
have
to
add
this
as
a
mount,
and
this
requires
a
really
start
of
the
runtime
currently
and
then
I
should
actually
be
able
yeah
to
browse
this
file
and
I
think
I
have
it
somewhere
over
here.
Here
it
is
so
you
see
yeah.
B
This
is
a
private
repo
and
it
does
contain
those
files
in
it
and
so
by
default
like
when
you
work
with
it
like
that,
this
repository
yeah
lives
on
on
this
instance
that
we
provision
for
you
and
when
the
shutdown's
after
some
idle
time
yeah
your
repository
will,
with
all
its
like
private
data,
will
be
gone
again
and
yeah
pretty
much
the
same
way.
You
can
also
mount
buckets
either
from
Amazon
s3
or
the
cloud
storage.
B
We
have
like
target
for
this
again
same
thing
at
this
as
a
mount
and
can
choose
a
destination,
restart
the
run
time,
I'm
able
to
browse
this
so
yeah.
This
is
this
is
getting
getting
data,
docker
images,
notebooks
files
in
there
on
the
exporting
side,
we
do
support
Martin,
export
and
so
bringing
up
to
settings
here.
There's
my
Martin
export
and.
B
B
So
yeah
you
see,
it
comes
out
nicely.
It
even
references
the
resulting
images
where
that's
possible
here
in
the
case
of
SVG
or
images
and
down
here
at
the
very
bottom.
We
we
have
like
an
Eden
code
cell
that
contains
all
the
metadata
that
when
you
import
this
back
into
next
journal
and
first
this
is
still
runnable.
So
this
contains
all
the
environment
and
information
and
other
metadata
that
you
need
to
make
it
runnable
again.
B
And
yet
this
combination
of
like
yeah
having
markdown
as
well
as
this
like
Eden
appendix,
has
worked
pretty
nicely
for
us
yeah,
in
that
we,
like
typically
gamma,
less
used
a
lot
for
or
this
kind
of
stuff,
but
and
this
doesn't
support
all
the
closure,
datatypes
yeah,
which
would
have
been
quite
painful,
and
this
games
gave
us
a
nice
and
simple
solution
to
support
all
the
closure
stuff.
We
need,
while
still
having
it
be
in
a
format
where
yeah
non
closure.
People
can
work
with
it.
B
Yeah,
getting
data
out
like
I've
shown
you
how
how
to
copy
individual
images
like
if
you
need
to
get
more
data
out,
I'd
suggest
mounting
a
bucket
and
copying
that
over
here
and
I
also
shown
you
how
to
how
to
import
or
how
to
use
the
darker
or
I
guess.
I
can
still
show
you
this.
So
let's
say
you
would
you
want
to
use
this
SVG
right,
environment,
locally,
yeah,
just
copying
this
your
allottee
in
here
and
bring
out
the
terminal.
B
B
B
B
B
B
B
B
A
A
B
No
sure
yeah,
so
I
yeah.
This
is
this-
is
I
guess
down
here
so
yeah
I
mean
this.
Anyone
who's
working
with
notebooks
and
especially
people
collaborating
on
notebooks
like
the
there's,
a
huge
hidden
state
problem
right,
you
you
define
some
variable
at
the
top
and
and
then
you
accidentally
override
it
at
the
bottom,
and
you
need
to
restart
your
whole
kernel
and
yeah
start
over
basically
yeah
I
think
this
is
a.
This
is
a
huge
problem
and,
like
observable,
has
is
if
you're
familiar
with
this,
it's
this
JavaScript
notebook
for
visualization.
B
B
This
is,
and
this
is
also
open
source.
They
have
a
runtime
which,
which
10
mils
this
for
you.
So
cells
are
referencing,
other
cells
and
yeah.
You
you
don't
have
this
like
you,
don't
even
like
there's
no
notion
of
executing
single
cells,
but
you're,
just
updating
the
notebook
and
then
everything
is
always
up-to-date
and
yeah.
I.
Think
there's
there's
a
huge.
B
Ya
opportunity
there
to
also
take
this
to
more
languages
than
JavaScript
and
I
think
it
can
be
done
very
well
with
closer.
This
is
actually
like
what
what
Matt,
who
Burt,
has
also
shown
in
his
demo.
This
is
@p
x16
dot.
Map
dot
is
like,
which
is
like
a
beautiful
dataflow
implementation
in
enclosure
script,
and
that
also
doesn't
have
these
these
problems.
That's
that
we
also
like
when
we
started
out.
B
We
also
noticed
that,
like
we
try
to
put
this
like
data
flow
like
thing
on
these
other
languages,
even
with
some
very
drastic
approaches
like
we
would
like
use,
this
checkpoint
restore
in
user
space
to
save
the
process
state
after
after
every
execution
and
turn
cells
could
build
on
top
of
each
other,
and
but
we
could
also
always
to
go
back
to
to
a
previous
state
but
yeah.
This
doesn't
really
work
well
for,
like
I.
B
Think,
like
closures,
also
like
the
repple
driven
development
workflow
is
teaching
us
that
we,
we
can
do
a
lot
more
things
when
we
allow
for
these
escape
hatches
and
give
give
the
users
control
over
when
they
want
to
run.
What
like
I,
don't
think
you
also
want
yeah,
you
want
to
drag
a
slider
and
some
10-day
machine
learning
training
starts
right
away.
It's
it's
not
always
so.
B
I
think
this
visualization
stuff,
like
the
the
kind
of
things
that
observable
is
doing
like
when
you're
working
on
visualization
is
really
best
suited
for
this
and
but
I
do
think.
Yeah
there's,
definitely
and
just
definitely
something
we
want
to
look
at
to
to
make
that
go
to
more
areas
and
no
I
think
that's.
It's
certainly
an
opportunity,
but,
like
we
decided
to
like
after
after
quite
a
bit
of
experimentation,
we
started
to
say
alright,
like
Jupiter
notebooks
are
useful.
People
are
using.
B
C
B
B
Yeah,
so
this
is
an
notebook
that
that
starts
with
an
explanation
of
the
concept,
and
then
here
this
is
importing
environments
from
from
different
notebooks
and
like
to
include
a
new
environment
in
our
default
set.
All
we
do
is
is
import
another
environment
here
and
yeah
like
we
opted
this
like
forcing
us
to
to
use
the
system
more
and
and
like
using
or
building
larger
parts
in
it.
Yeah
will
will
have
opposed
to
build
a
better
system
and
to
build
something
more
useful,
and
so
we're
already
applying
this
to
environments.
B
B
This
is
actually
connecting
back
to
our
closure
application
that
this
notebook
is
executing
on,
and
so
this
allows
me
to
like
yeah,
put
up
this
system
that
contains
the
the
atomic
connection
and
I'm
able
to
like
interact
with
the
database
here,
and
so
we
use
this
to
like
debug
issues
and
I.
Think
is
this
yeah?
It's
just
a
nice
way
to
yeah
the
not
perform
at
is
well-suited
to
that.
So
somebody
inspects
like
an
issue.
B
But
this
way
we're
just
doing
this
over
just
a
notebook
and
I
think
that's
that's
just
yeah,
it's
sometimes
easier
than
having
to
like
you
do
something
like
you
connect
to
the
production
system
to
run
something
on
your
database,
but
then
you
don't
commit
it
and
share
it
with
others
and
I.
Think
yeah.
This
can
be,
can
be
a
useful
application
and
also
another
thing
to
mention
is
like
art,
and
so
we
do
have
experimental
closure
script
support,
but
it's
it's
not
useful
enough.
B
But
we
have
this
yeah.
This
editor
process,
runtime,
and
so
this
is
actually
running
inside.
This
is
running
inside
the
same
process
that
that
our
main
app
is
now
running
in,
and
we
think
this
could
be
pretty
useful
for
for
debugging,
like
yeah
I,
actually
have
the
whole
app
TB.
I
can
inspect
here.
So.
B
But
I'm
subscribing
to
this
node
here
and
rendering
a
reagent
component
so
yeah.
You
can
see
this
this
being
reactive
here
and
yeah.
You
could
imagine
other
visualizations
that
look
at
some
specific
problem
of
your
app
state
that
you're
trying
to
debug,
and
we
can
also
drop
this
stuff
in
when
we're
actually
when
we
do
have
a
problem
in
the
current
browser
session.
B
Yeah
I
think
this
is
also
yeah
can
be
useful
and
also
like,
where
I
think
this
could
go
is
eventually
making
this
component
creation,
like,
like
the
github
component,
first-class,
allowing
users
to
create
and
and
actually
the
the
code.
That's
running
so
this
is
basically
some.
This
is
something
that's
persisted
in
the
document,
and
it
has
like
a
couple
of
this
is
just
basically
a
closure
map
with,
like
the
repository
name,
the
reference,
if
you
fill
it
out
and
what
happens
behind
the
scenes.
This
is
actually
also
a
notebook.
B
Does
the
repository
cloning
and
provides
you
like
exposes
amount
that
you
can
then
add
to
your
runtime
and
we
think
yeah,
this
kind
of
stuff
like
trying
to
find
a
minimal
abstraction
like
and
having
things
go
yeah
through
the
file
system
or
being
able
to
turn
notebooks
into
into
like
users
or
friendly
components
in
the
NPR
has
quite
a
lot
of
potential
in
the
future
and
yeah
we're
also
using
them
notebooks
to
to
test
this
kind
of
stuff.
So
yeah
here
you
see
a
couple
of
different
tests
like
for,
for
this
other
notebook.
B
Yes,
so
what
we
are
also
working
on
is
yeah
on
bootstrapping
aspect
is
like
we're
already
running
our
continuous
integration
in
next
journal,
so
we're
using
our
infrastructure
there,
but
yeah
like
making
all
the
things
that
are
needed
for
this
first
class.
So
you
can
add
an
API
endpoint
to
a
notebook
and
have
it
like
schedule,
more
work,
I
think
could
be.
It
could
be
quite
cool
like
especially
like
it's
often
I
think
frustrating
having
to
go
through
these
long
feedback
cycles
like
when
we're
constantly.
B
You
have
to
push
something
and
then
you're,
you're
debugging,
some
failure
in
CI.
That
happens
like
I,
don't
know
after
after
10
minutes
or
something
into
your
CI
run
when
it
comes
to
the
point
that
it's
yeah,
that
the
failure
occurs
and
yeah
I
think
this.
This
could
be
like
this
move
either
way
to
to
take
like
yet
to
get
to
a
certain
point
and
then
being
able
to
to
abstract
this
and
make
it
reusable.
B
Another
thing
like
I
think,
which
is
a
big
opportunity
down.
The
road,
is
like
adopting
these
more
functional
package.
Management
approaches
like
Tucker,
is
definitely
problematic
in
a
lot
of
ways
like
there's
the
blackbox
abstraction
problem.
This
is
I,
guess
more
interesting
to
the
people
in
science,
then
too,
when
you're
applying
it.
B
That
docker
has
like
that
like
changing
something
at
the
top
and
the
dockerfile
invalidates
everything
downstream
and
creates
a
completely
irreproducible
new
binary
blob
that
you
then
have
to
download
again
and
also.
Lastly,
I
think
this
is
also
it's
making
the
note
first
class
in
the
atomic
like
currently
we,
our
document
is
like
a
big
blob.
That's
updated
through
event,
sourcing
and
I.
B
Think
that,
representing
all
the
things
that
are
relevant
to
the
computation
graph
like
making
them
first-class,
could
allow
for
some
exciting
different
views
and
foodists
this
thing,
so
you
wouldn't
have
to
always
start
with
with
this
notebook
approach,
but
you
could
also
like
currently
this
is.
This
is
hard
for
us
to
do
like.
A
B
Yes,
absolutely-
and
this
is
I-
do
think
we
have
some
like
functionality
around
that
so
I
mean
this
is
this
is
like
our
like.
We
used
to
call
these
things
article
we're
now
calling
them
notebook
and
we
have
been
renamed
this
consistently
throughout
the
system
yet
but,
for
example,
I
guess
we
look
at.
B
So
these
are,
this
is
like
our
current
format
like,
for
example,
you
see
like
this
being
a
cold
cell,
so
it
references
the
runtime.
With
this
link
and
like
a
note
in
an
our
document,
is
it's
just
a
map
currently
and
like
the
test
sectioned
and
has
a
list
of
subsections
and
content
again
and
I
should
even
be
able
to
let's
see
this.
So
this
is
the
paragraph
here.
B
B
Of
course
not
a
function,
are
we
on
the
right?
Well,
whatever
this
gonna?
What
yeah
we
we
do
want
to
enable
this
kind
of
generation
like
health,
have
cells,
return
data
like
operations
to
to
change
the
document
and
to
create
new
documents
and
to
execute
them
and
yeah
I.
Think
there's
yeah
like
if
you
have
a
simple
model
for
this
I,
think
this
yeah.
This
could
be
exciting
for
for
people
yeah,
not
not
so
much
interested
in
this.
What
you
see
is
what
you
get
interface.
B
I
think
yeah
should
be
5
more
minutes
or
something,
and
then
we
can
go
into
a
proper
discussion
yeah.
So
like
we
started
working
on
next
journal
like
three
years
ago,
like
we
started
up
with
elixir
and
elm
and
like
it
was
sort
of
this
like
in
Elm
like
integration
with
existing
j/s
libraries.
Was
it's
really
painful,
like
you
get
all
these
great
guarantees
and
elm
like
this?
B
This
really
magic
like
if
it
compiles
it
runs,
which
yeah
really
is
is
quite
impressive,
but
yeah
when,
like
here,
we
we
have
to
integrate,
like
with
a
ton
of
libraries
like
cotton
area
for
the
code,
editing
and
yeah.
This
like
we're
using
prose,
mirror
for
the
rich
text,
editing,
stuff
or
content
editable,
and
that's
how
we
actually
ended
up
with
with
closure
script.
B
So
yeah,
we
didn't
know
anything
about
closure
before
really
and
I
think
it
happened
recommended
a
couple
of
times
to
me,
but
I,
just
looked
at
the
syntax
and
yeah
always
avoided
its
and
yeah
was
quite
surprised.
How
like,
after
really
like
being
forced
to
try
it
like
how
fast
we
were
able
to
get
productive
in
it
like
and
to
syntax
barium,
which
seemed
so
huge
upfront
really
went
away
really
fast,
like
within
weeks
and
I.
B
Think,
like
our
our
main
struggle
had
been
with
tooling
initially
in
like
yeah,
we
we
jumped
around
quite
a
bit
there
like
started
out
with
lining
and
and
had
like
issues
and
thought.
Switching
to
boot
might
fix
them,
but
it
was
more
that
we
didn't
really
understand
lining
and
well
enough
at
at
the
pointed
that
we
could
also
quote
yeah
used
syntax
quotes
or
yeah
in
our
project
closer
and
yeah.
We
finally,
like
I,
think
we
invested
quite
a
bit
to
to
make
us
productive
to
become
productive
there
and
are
now
from
lambda.
B
B
And
yes,
so
we
finally
settled
on
on
tool
steps
as
a
as
a
build
tool
which
we're
really
happy
with
now,
which
I
think
it
has
read,
removed
a
lot
of
complexity
for
us
and
just
given
us
a
much
more
reliable
set
up,
also
like
on
a
on
the
web.
Server
part
or
framework
we're
using
pedestal
and
like
the
Interceptor
pattern
is,
is
like
once
we
were
able
to
understand.
That
has
been
also
like
really
big
win
and
we're
also
using
that
to
to
schedule
the
code
execution.
B
So
this
looks
like
do
any
to
Buddha
run
time,
do
I
need
to
pull
a
darker
image
and,
and
then
it
in
cues
other
interceptors
that
are
doing
the
actual
side-effects
and
having
this
separation
is,
is
great
for
testing
and
also
yeah.
It
allows
us
to
it.
It
works
pretty
nice
to
have
like
these
things
like
all
right
now.
The
execution
start
and
I
want
to
take
the
time
it
takes
until
it's
over.
B
So
we
have
like
an
interceptor
before
and
after
the
execution
of
each
cell
to
do
this
kind
of
yeah
and
profiling
and
yeah
also
like
I,
guess
the
atomic
for
us
really
was
the
reason
to
to
do
the
switch
to
closure
coming
from
elixir
on
the
back
end
as
well
like
yeah.
It
wasn't
so
much
wanting
to
use
closer
at
the
time,
but
really
wanting
to
use
the
atomic
I
think
yeah
it's.
It
fits
us
incredibly
well
like,
for
example,
we
we
have
the
goal
of
never
breaking
URLs.
B
B
B
You
see
how
fast
this
can
be
when
you,
when
you
have
it
reload
at
the
repple.
So
we
have
like
a
small
Emacs
like
we
allow
you
to
opt
out
of
life
reloading
in
the
closure
script
Apple
or
in
the
closure
Apple.
So
you
turn
think
we
like
freeloading
off
and
then
then
you
we
have
a
key
command
and
Emacs
to
like
evaluate
the
form
you're
in
and
send
like
a
reload
command
to
fig
wheel
and
yeah.
The
result
is
that
you
see
the
effect
of
the
change
after
like
0.1
seconds.
B
B
A
A
B
Let's
see
what
do
I
find
hard
I
mean
yeah,
especially
like
I
guess,
coming
coming
from
Elm
on
I
do
sometimes
wish
they're
like
this
yeah.
This
way
the
Elm
compiler
can
be
helpful
for
you
and,
like
catching
errors,
upfront
that
I
think
is
is
definitely
something
yeah
I,
sometimes
miss
and
I.
Think
yeah,
like
maybe
like
this
gradual
typing
stuff,
like
can
be,
could
be
useful
there
for
us,
like
that.
B
I
think
Ambrose's
is
working
on
making
easier
with
with
speck
and
I
mean
the
the
main
thing
for
us.
I
think
what's
been
difficult,
like
yeah
we've,
we
struggle
our
fair
share,
like
I
think
with
with
the
tooling,
and
things
are,
are
settling
down
there,
but
yeah
it.
It
definitely
still
is
a
problem
like
I
guess
also
this
yeah
like
when
you
want
to
run
on
these
on
on
different
targets.
There's
always
like
slight,
like
I
guess
like
before
I
was
doing
closer
as
well.
B
Like
I
think
before
I
did
it
I
imagined
it
would
be
easier
to
to
share
the
code
and
cross
these
platforms.
I
guess
that's
also
like
a
consequence
of
the
tight
host
Interop
right.
On
the
one
hand,
it's
it's
really
great,
because
you
are
so
close
to
the
target
platform,
but
and
when
you
do
want
to
share
stuff
across
it,
it
is
quite
a
bit
more
work
and
there's
also
like
subtle
differences
between
between
node
and
like
node
as
a
target
and
then
targeting
the
browser
and
stuff
like
that.
B
We
haven't
been
near
that
at
all
like
I'm,
not
sure
if
we
all
if
we
ever
will
get
there.
That's
also
like
a
bit
problematic
because
of
this
editor
bootstrap
runtime
that
I've
shown
like
if
you
would
like
you,
can't
really
optimize
the
names
away
for
this,
or
so
it's
limited
to
what
you
can
optimize
and
have
that
working,
but
yeah,
that's
I
think
also
definitely
been
a
struggle
yeah.
B
A
B
B
So
we
were
starting
out
and
yeah
linked
and
asking
Maps
like
what
he's
using
as
a
framework
and
he's
written
his
own
thing,
of
course,
because,
like
yeah,
he
said,
reframe
didn't
perform
well
enough
for
for
his
use
days
and
and
did
leader
and
and
yeah,
then
there's
precept
coming
out,
which
I
think
it's
like
I
I
do
think
it's
like
reframe
has
now
like
it's.
It's
served
as
incredibly
well
and
I'm.
Also
really
yeah
I'm
surprised
like
how
easy
it
is
in
the
end
in
like
coming
coming
from
other
languages.
B
These,
like
maybe
yeah.
What
I
just
said,
is
a
bit
I'm
true
as
well,
because
these
decisions
aren't
as
consequential
as
as
you're
used
to
when,
when
you
settling
on
the
framework
in
in
these
other
languages
right,
because
when
you
have
them
a
specific
problem
that
reef
and
doesn't
solve
for
you,
you
can
also
like
combine
it
with
the
small
other
library
or
the
small
other
thing
that
you've
written
to
make
it
to
what
you
want
and
yeah
so
I
think.
That's!
That's
rather
gonna
be
our
approach.
B
Definitely
I
think
yeah.
That's.
That,
certainly,
is
something
like
we
think
about
it.
A
lot
and
I
think
this
was
like,
maybe
the
the
most
brilliant
invention
of
or
the
most
brilliant
idea
behind,
github,
just
like
there
you're
out,
structure
and
and
the
way
they
they
put
the
like
profile
and
the
cold
front
and
center
and
like
yeah,
when
you
compare
to
SourceForge
where
it
was
really
yeah
a
pain
to
like
to
get
to
the
code.
B
Where
yeah
you
don't
have
the
problem
of
who's
paying
for
the
compute
but
yeah
I
like
ideally
yeah.
We
we
find
some
way
to
to
make
that
work
like
yeah.
We
can
so
there
the
idea
what
me,
similarly
to
to
get
up
to
yeah,
do
a
lot
for
these
open
communities
while
being
able
to
to
finance
that,
through,
like
people
using
the
thing
in
private
but
I.
B
Think,
like
tearing
down
this
wall
between
like
who's
the
author
of
something
and
who's
the
reader,
and
because,
like
being
able
to
play
with
stuff
and
experiment
to
in
order
to
better
understand
it
yeah
his
is
really
crucial
and
yeah.
We
we
want
to
cut
the
black
tear
down
this
wall
as
as
best
as
we
can.
A
B
Yeah
I
mean
yeah
like
yeah,
our
remix
and
somebody's
is,
is
the
equivalent
of
a
fork,
but
yeah
I
mean
like
regarding
this
being
able
to
work
locally.
This
is
this
is
also
definitely
something
we
we
want
to
enable,
but
for
now,
like
our
focuses
on
providing
a
really
good
user
experience
online
and
then
tackling
this
like
local
problem
in
a
second
step,
but
at
yeah
I
do
think
like
a
lot
of
the
technology
is
also
starting
to
to
appear
and
Peter
like
like
how
you
can
transfer
like
content
address
data
with
like
trustless.
B
You
only
need
to
know
that
the
hashes
of
things,
and
then
you
can
like
verify
that
you're
getting
the
right
data
and
yeah
applying
this
yeah
I
think
would
enable
I
could
enable
this
being
able
to
like
again.
This
is
immutability
like,
like
ipfs,
is
using
it
or
Myrtle
Myrtle
trees
that
could
enable
this
pretty
fast
local
workflow
as
well
and
yeah.
That's
definitely
something
we
like
to
do
when
we
get
around
to
it.
A
Yeah
and
nothing,
would
you
like
to
to
tell
a
little
bit
about
your
walk
on
different
languages
and
I
mean
one
one
interesting
question
would
be
your
efforts
in
making
everything
walk
with
Python
and
our
and
Julia
I
guess
what
was
difficult?
What
took
a
lot
of
work
from
you,
and
why
and
another
question
would
be:
are
you
thinking
about
in
population
between
the
different
languages
or
what
ways
can
one
use
to
to
share
data
and
between
the
different
runtimes?
A
B
See
if
I
can
maybe
show
something
but
I
don't
guarantee
that
this
world,
or
now
that's
better
than
it
probably
won't
work
well,
so
we
this
is
actually
like
when
we
started
out.
We
we
thought
about
themselves
as
being
more
this.
These
referentially,
transparent
things
that
return
a
result
as
data,
and
so
then
other
cells
could
reference
the
results
of
them
and
have
basically
this.
B
B
And
and
then
having
like
a
small
layer
that
basically
like
encodes
this
to
to
certain
data,
serialization
format,
maybe
Jason,
maybe
transit,
maybe
c4
and
yeah-
that
that
being
transparent
to
you
as
a
user
and
I
think
yeah
that
that
can
go
yeah
can
go
quite
a
way,
but
yeah
the
devil
is
definitely
in
the.
In
the
details
like
you
will
often
encounter
things
that
that
don't
fully
round
trip
between
those
languages
like
you
can
make
a
make.
B
This
work
for
closure
very
nicely,
but
yeah
as
you're
dealing
with
stuff
yeah
in
Java,
or
that's,
not
your
closure.
These
things
start
to
break
down.
It
I
think
this.
This
was
also
our
yeah.
Our
learning
experience
definitely
to
like
focus
on
something
where
like
have
a
proven
model
and
yeah
start
out
with.
B
With
this
thing,
we
know
that
works
and
and
like
take
a
second
step
in
trying
to
yeah
improved
yeah
like
how
their
whole
system
works
or
the
I
guess
the
programming
model
behind
it,
but
yeah,
that's
definitely
something
we
do
want
to
look
at
and
I
do
think
like
for
yeah.
Of
course,
it
depends
on,
like
our
large,
the
data
is
and
stuff,
but
I
think
yeah
being
able
to
it's.
B
A
A
B
A
A
What
cannot
be
done
at
the
moment,
and
so
several
of
us
began
working
on
tutorials
and
then
some
use
to
Jupiter
and
some
use
next
journal
and
some
use
markdown
and
and
in
a
sense
we
are
trying
to
converge
to
a
way
that
we
can
share
tutorial
with
tutorials
with
each
other.
And
there
is
a
small
team
of
people
thinking
about
it.
A
Well,
we
have
meetings
which
are
typically
smaller
than
this
one
and
and
we
talk
about
a
certain
persons,
workflow
walking
with
data
and
that
person
will
show
their
own
view
of
how
they
like
to
work
and
data.
So
three
people
in
the
room
and
in
the
meeting
will
ask
questions
and
we're
planning
to
offer
interviews
of
this
kind
in
the
next
two
weeks.
So,
if
any
of
you
would
like
to
share
your
ways
of
working
with
data
or
doing
visual
stuff,
then
it
would
be
beautiful
to
interview
you.
B
B
You
often
have
the
problem
that
you
don't
want
to
show
everything
you
need
to
set
up
some
state
right
and
like
yeah
following
the
stuff
from
a
tutorial
one
by
one,
isn't
always
gonna
gonna
be
runnable
and
julia
has
a
pretty
nice
solution.
There
may
be
doing
some
something
similarly
for
for
closure.
Yeah
could
could
be
something
I
mean
and
also,
if
we're
like
I
guess
if
we
were
just
yeah
for
just
talking
about
closure,
like
also
what
how
Maria
is
like
allowing
their
exports
of
the
stuff
being
closure
files
with
markdown
comments.
B
D
Hey
it's
Jeremy
here.
My
me
interrupting.
It
said
on
this
tutorial
thing,
so
I
look
after
crooks,
so
I
did
the
bitemporal
tale
next
channel
thing
and
I
created
another
one
on
Friday
and
again
it's
like
really
quick
needs
to
do
so.
We're
thinking
at
Chuck's
you
sort
of
double
down
on
using
next
journal
as
like
a
mechanism
for
doing
these
crux
tutorials,
which,
admittedly
like
aren't
necessarily
oriented
around
data
science,
but
obviously
it's
data
management
and
I.
D
Guess
I
just
wondered
what
you
thought
of
that.
I
didn't
want
to
like
abused
your
intentions
for
next
journal,
but
you
know
I,
imagine
like
instead
of
using
CSV
files
or
whatever
to
push
data
backs
and
forwards.
If
you
had
these
like
standalone
mode
crooks
instances
as
like
the
data
format
within
the
notebook
and
that
could
be
kind
of
interesting,
I
think
for
everyone
in
the
wider
community,
yeah.
B
That's
that's
definitely
not
a
like
yeah
I
I,
really
like
the
crux
tutorial
you've
put
together
and
like
that's.
Definitely
like
not
a
abuse
on
our
system
and
I
mean
this
yeah
like
being
able
to
explore
stuff
like
that.
I
think
it's
it's
a
great
use,
and
especially
like
yeah,
like
this
kind
of
stuff,
where
you
like,
maybe
need
to
start
a
server
process
as
well,
and
this
is
this
is
yeah
things
that
are
I.
Think
often
like
painful
to
get
to
a
point
where
you
can
play
with
it
right.
B
D
I
appreciate
that,
thank
you,
yeah
I
mean
I,
guess
in
particular,
like
we
were
really
interested
in
expanding
outside
the
closure
bubble.
With
with
crooks
like
we
really
want
to
get
people
who
are
in
the
same
way
that
you
you
wanted
to
use
the
atomic
series
closure.
We
want
people
to
like
want
to
use
crux.
B
Our
exes
are
also
like
yeah,
when
we
are
like
yeah
we're
thinking
of
like
what
can
we
do
like?
What
can
we
use
it
instead
of
the
atomic
to
like
provide
people
where,
with
a
local
installation
like
yeah,
there's
a
atomic
free
but
yeah
crux,
there
is
definitely
something
we're
also
looking
at
there
get.
A
Yeah
so
so,
like
you
said
that
there
are
some
some
pain
points
in
in
doing
tutorials
nowadays
and,
and
one
of
them
is
having
to
unlock
early,
which
is
some
sometimes
a
necessity
and
and
what
we
run
into
when
trying
to
create
a
joky
tell
tutorials
is
many
times
the
problem
of
depending
on
data
and
actually
to
be
able
to
learn
a
tutorial.
One
may
need
to
have
all
the
data
just
in
place
for
everything
to
one,
and
that
is
a
bit
tricky
to
automate.
A
So
that
is
why
that
is
another
reason
that
it
was
interesting
to
see
the
elegant
solutions
today
and
and
like
I
said,
there
are
many
opportunities
here.
One
of
them
is
connecting
documentation
with
tests,
and
there
are
several
interesting
libraries
here
in
the
closure
system.
I
enjoy
using
the
library
by
Chris
link
that
helps
me
a
lot
to
generate
documentation,
form
tests,
and
then
there
is
a
question
of
whether
all
these
opportunities
play
well
with
each
other
and
at
the
moment
not
yet,
and
it
is
question
how
to
make
these
things
converge.
A
So
one
thing
that
is
important
is
a
standard
data
format
and
it
seems
that
many
tools
are
converging
to
markdown
several
variations
of
markdown
and
the
question
persists.
How
we
may
connect
everything
and
I
think
we
are
not
there
yet
and
and
I
guess.
Next,
Journal
has
its
own
data
format
for
representing
notebooks,
but
say
you
already
took
care
of
importing
importing
it
format
them.
B
So
yeah
I
mean
our
our
canonical
format
is
basically
me,
Eden
and
but
yeah,
where
we're
trying
to
like
it
like
trying
to
make
this
as
lossless
as
possible,
like
Martin,
I,
guess
the
deeper
you
you
go
into
it
and
Messier
it
becomes
right.
So
it
is
quite
a
yeah,
a
tough
problem
to
make
it
work
really
well
like
I
guess,
on
the
on
the
data
exchange,
which
I
think
like
yeah
see
poor,
looks
pretty
promising
like
if
you're
looking
to
to
share
share
data.
B
Which
yeah
is
there
their
data
model
built
on
top
of
C
bar
and
yeah?
This
is
pretty
much
like
there's
also
like
good
closure.
Libraries
for
this
and
I
guess
like
ipfs
or
something
similar
would
ya
like
cook.
Salt
is
like
getting
data
locally
problem,
I
guess
another
like
what
we're
also
thinking
about
like
maybe
is
having
having
this
like
file
system
that
you
mount.
B
We
talks
about
like
getting
a
fuse
file
system
working
enclosure
with
lit
fuse
api,
maybe
having
something
like
that
where
you
can
yeah
can
run
this
process
locally
and
and
have
this
yeah
mount
on
some
file
system
over
the
web
could
be
a
good
solution
to
enable
this.
Like
data
sharing
locally
problem,
I
mean
the
ITF
is
also
like
yeah
I'm,
not
sure
how
like
there's.
Definitely
still
it's
it's
not
a
perfect
solution,
yet
it's
I
think
quite
quite
painful
to
use
in
some
cases
but
yeah.