►
From YouTube: Scicloj status report: Notespace, 2021-11-29
Description
A status report about the Notespace tool for literate programming and visual data exploration in Clojure
https://github.com/scicloj/notespace
A
A
Let
us
begin
with
the
short
demo
to
get
an
idea
of
what
it
is
about.
So
you
see
we
have
a
browser
and
an
editor.
Just
a
closure
editor
editing
some
closure
namespace,
and
we
can
do
the
usual
things
we
do.
For
example,
we
can
change
our
code
and
then
the
browser
view
is
responding
right,
so
we
can
evaluate
the
code
and
the
browser
is
listening
and
keeping
this
responsive
update
and
we
can
also
add
some
text,
and
so
that
is
a
short
demo
of
what
node
space
is
about.
A
So
this
documentation
is
just
created
as
closed
remain
space
that
has
made
made
name
spaces,
and
maybe
let
us
look
into
one
of
them.
This
one
is
about
models,
machine
learning,
models
which
are
very
systematically
documented
here,
with
no
tables
and
visual
outputs
and
all
the
necessary
details,
and
that
was
created
using
node
space
version
3
in
this
case
and
yeah.
So
that
is
one
example.
Just
you
know
documenting
project
another
example
is
so-called
testable
documents
or
literate
testing.
A
A
So
there
is
the
ml
study
group
where
we
have
been
learning
to
use
the
emerging
stack
of
data
science
and
machine
learning.
Libraries-
and
you
know
we
study
group-
is
just
this
zulic
stream,
where
we
are
interacting
daily
and
mostly
the
weekend
meetings
and,
for
example,
let
us
look
into
the
dark
from
one
of
those
meetings.
A
So
that
is
yet
another
use,
and
there
is
also
this
video
you
might
enjoy
where
we
were
kind
of
sharing
publicly
a
few
of
our
practices
and
joys
of
this
study
group,
and
so
these
are
a
few
of
the
fast
uses
and
I
think
they
are
still
very
much
interested
in
all
of
them.
And
you
know,
node
space
is
not
the
only
tool
that
allows
for
these
kinds
of
practices.
Then
the
landscape
is
big
and
will
not
try
to
cover
it.
A
In
this
short,
video
we'll
try
to
focus
on
a
few
of
those
existing
tools,
enclosure
for
data
visualization
and
literacy
programming,
those
tools
that
follow
an
idea
that
we
like
to
call
namespace
as
a
notebook,
and
maybe
maybe
let
us
dive
in
into
a
few
of
those-
and
I
think
at
least
for
me
at
the
moment.
These
are
the
four
tools
I'm
mostly
interested
in,
except
for
node
space.
The
three
others
are
beautifully
written
and
implemented
and
very
promising
in
their
ideas.
A
Oz
has
been
the
first
one
in
it
has
been
there
for
a
long
time
and
and
kind
of
setting
the
paving
the
way
for
these
ideas
of
integrating
our
usual
editor
experience
with
the
browser
view-
and
I
think
many
of
the
other
projects
are
very
much
following
the
ideas
of
course,
and
it
is
still
very
much
useful
and
it's
useful
in
many
ways,
and
you
should
look
into
the
current
workshop.
That
is
just
happening
today
by
christopher
small
about
us.
A
A
Reload
experience
very
much
the
of
the
kind
of
offers
as
much
as
I
know,
and
clerk
tries
to
be
just
a
little
bit
more
clever
in
re-evaluating
only
the
parts
which
are
needed
following
a
file
change
and
allowing
possibly
a
quick
experience
using
some
code
analysis
and
hashing
and
caching
ideas,
and
it
is
also
very
much
extensible
in
the
client
side
very
interesting
story.
Goldly
is
it
goes
beyond
what
we
can
described
in
this
session.
So
let
us
not
try
to
describe
it
now.
A
We
have
focused
on
node
space
and,
unlike
those
we
those
two
projects,
we
were
mentioning
alls
and
clear,
which
are
very
much
reacting
to
file
changes
by
reevaluating
the
code.
Node
space
tries
not
to
cause
too
many
code
evaluations
just
to
listen,
just
to
listen
to
user
interactions
and
respond
in
a
careful
way,
and
that
is
maybe
the
main
difference
here:
the
mode
of
user
interaction
and
let
us
maybe
kind
of
try
to
state
it.
Clearly,
there
are
two
ideas
here
that
have
been
driving
note
space.
A
Thinking
could
be
useful
and
that's
an
opportunity
to
say
thank
you
to
the
very
many
people
who
have
been
contributing
ideas
and
experimenting
with
different
modes.
This
tool
has
been
going
through
and
another
kind
of
idea.
That
is
very
much
important,
especially
in
version
four
is
to
flow
with
the
record.
What
that
means
is
you
know
just
not
to
not
to
do
too
much
to
change
the
usual
experience,
but
just
to
keep
enjoying
what
the
closure
user
can
do
with
the
closure.
A
Editor
and
rapple
and
just
add
some
review
alongside
this
experience,
and
that
is
what
we
hope
to
demonstrate
now
and
how
does
interaction
work?
So
you
see
yeah,
maybe
let's
jump
to
this
section,
and
so
there
are
four
kinds
of
interaction
that
matters
here.
One
of
them
is
file
change.
You
see,
we
can
change
the
code
and
it
updates
the
view
updates.
Another
is
loading
the
whole
button,
so
you
know
if
I
load
the
whole
buffer
load-
disclosure
namespace.
A
It
also
just
updates
the
the
file,
I
could
add
code
and
it
will
also
just
update
the
file.
If
I
re-evaluate
it,
it
doesn't
add
outputs
here,
and
that
is
because
of
how
closure
works.
Loading
a
whole
closure
file
does
not
create
intermediate
results
or
evaluations,
and
so
we're
just
having
this
quick
way
of
updating
everything
and
another
thing
which
is
a
little
bit
different,
is
region
evaluating
one
region
or
part
of
the
code.
A
So,
for
example,
if
we
have
some
code
here-
and
we
not
only
can
see
the
code,
then
if
we
evaluate
it,
then
we
can
see
the
result
here
of
this
part
or
and
if
we
have
more
code
and
like
do
that
too,
then
we
can
evaluate
the
processor.
If
we
have
saved
environment,
we
can
evaluate
the
whole
region
and
we
get
all
outputs
in
the
region.
Tabs
are
those
things
that
we
see
at
the
top.
A
You
see
this
interaction,
tab
could
be
change
and
then
we
change
the
tab,
and
these
allow
us
to
kind
of
have
some
structure
that
is
sometimes
useful
in
this
slide.
Like
experience,
yeah,
another
topic
to
discuss
is
how
to
specify
the
kinds
of
renderings
one
may
have.
So
let
us
go
through
it
just
kind
of
quickly.
A
One
idea
here
that
you
can
attach
metadata
to
code
and
these
metadata
are
coming
from
a
certain
tiny
library
called
kindly
that
allows
for
these
different
kinds
of
rendering.
In
this
case,
we
are
saying
this
piece
of
code
is
for
following
the
hiccup
kind,
which
means
you
know
it
is
rendered
as
hiccup,
which
is
this
way
of
rendering
closure
data.
It's
html
also,
let
us
zoom
out
a
little
bit
so
that
we
can
see
it.
A
You
see,
we
got
a
plot
in
this
case,
but
also
text,
because
we
have
this
div
that
contains
both
code
and
text.
Another
thing
we're
seeing
here
is
this
use
of
a
special
hiccup
tag,
which
is
part
of
a
certain
library
called
gorilla
ui
that
extends
hiccup
with
additional
reagent
components
for
various
data
visualization
libraries.
A
Another
thing
we
can
do
is
attaching
metadata
to
the
value,
not
the
code,
but
the
value
at
runtime
here
we're
doing
it
with
this
kindly
consider
api
and
you
see
when
we
do
that,
and
maybe
we
should
scroll
a
little
bit
so
that
we
can
see
it
and
when
we
do
that
it
works
too,
and
it
knows
that
should
render
in
this
case
as
something
of
the
veda
time.
Another
idea
is
this
kindness
protocol,
where
one
can
specify
that
something
should
be
considered
of
a
new
kind.
A
That
is
specified
in
this
way,
so
we
are
defining
the
closure
type
here
called
big
big
text
and
by
implementing
the
kindness
protocol.
We
are
telling
how
this
thing
can
be
rendered,
and
you
know
it
just
renders
as
big
big
text
in
this
case
also
just
scrolling
a
little
bit
and
another
topic
worth
mentioning
is
delays.
A
So
you
know
closure
delays
are
those
things
that
do
not
evaluate
immediately,
and
that
is
nice
because
we
can
have
the
many
of
these
in
our
code
and
when
we
load
the
file
it
is
still
quick
to
load
the
file.
You
don't
need
to
wait
for
this
to
complete,
but
sometimes
we
may
wish
to
keep
the
some
ad
hoc
analysis
or
some
report
we
may
wish
to
get
sometimes.
A
So
here
is
one
of
these,
for
example,
and
when
I
evaluate
it,
then
you
see
node
space
decides
to
dereference
the
delay
and
get
the
delay
output,
and
in
this
way
we
get
that
behavior
of
getting
more
information
only
when
we
wish
to
not
on
every
file
evaluation.
So
we
can
keep
our
file
evaluated
valuations,
quick.
Let
us
just
look
into
just
a
few
more
examples.
So
let
us
evaluate
this
region
so
that
we
can
see
the
outputs
here
and
right.
A
A
A
The
system
is
not
always
stable,
handling
events
handling
concurrency,
it
may
be
a
challenge
and
there
are
some
bugs
and
I
would
love
to
discuss
them
with
anybody
who
is
running
into
them
and
may
wish
to
try
the
system.
Compatibility
compatibility
with
other
tools
matters
a
lot.
We
want
to
hopefully
create
a
certain
format
where
different
tools
could
share
ideas
and
also
user
notes
that
could
render
in
different
tools-
and
there
are
very
beautiful
discussions
about
it
with
the
other
tool,
authors
and
I'm
very
hopeful
about
future
integrations
and
yeah.
A
I
would
love
to
discuss
where
we're
going,
and
maybe
that
should
go
beyond
this
short
session
yeah.
Thank
you
to
everybody
who
has
been
contributing
to
this
tool.
Maybe
just
another
thing
like
in
the
demo.
You
see
there
is
this
last
valve
view
that
allows
us
to
focus
on
just
the
last
evaluated
thing,
and
that
is
typically
useful,
so
that
we
don't
always
need
to
see
the
whole
notebook.
We
can
just
evaluate
a
little
note
and
see
the
outputs
here,
and
so
this
special
tab
has
been
proven
useful
in
a
few
experiments.