►
From YouTube: Clojure visual-tools meeting 3
Description
Summary: https://clojureverse.org/t/visual-tools-meeting-3-summary-video/
In this monthly meeting of the Clojure visual-tools group (2022-03-05), we discussed three main topics:
* Fabricate, a Clojure tool for static site generation:
https://github.com/fabricate-site/fabricate
* An experiment in composing different tools (Portal-Cler-Kindly-nREPL):
https://github.com/scicloj/visual-tools-experiments/tree/main/portal-clerk-kindly-nrepl-1
* The state of Clojure in VSCode: Collaboration between Calva & Clover (possibly bringing some of the REPL-Tooling ideas to Calva), and different options for embedding visualizations.
https://calva.io/
https://github.com/mauricioszabo/clover
https://github.com/mauricioszabo/repl-tooling
Zulip topic thread: https://clojurians.zulipchat.com/#narrow/stream/313390-visual-tools/topic/meeting.203
B
A
A
C
Hi,
I'm
lucas,
my
main
project
is
omnitrace,
it's
a
little
tool
that
allows
you
to
see
what
your
program
is
actually
doing
and
what
functions
call
which
function
and
so
on,
and
because
I
wanted
to
integrate
it
better
of
other
tooling.
I
started
helping
out
with
orchard
and
then
helping
out
with
calva,
and
recently
I
got
sponsored
by
closures
together
to
try
to
extend
or
church
to
be
able
to
work
more
on
kojoscript.
D
D
How
can
we
interrupt
or
in
co-exists
with
libraries
and
other
tools?
So
this
very,
I
think,
that's
the
connection
into
this
this
group.
Actually
it
is
a
very
much
lucas
when
it
comes
to
that
cowboy
is,
of
course,
this
yeah
a
bit
of
a
full-blown
ide
for
for
this
code
for
working
with
closure
code
and
focusing
a
lot
on
interactive
programming.
Yeah,
that's
what
I'm
a
big
fan
of.
E
Hey,
I'm
andrew
I'm
a
data
scientist
by
by
profession
a
day-to-day
basis,
my
kind
of
hobby
project
is
it's
a
static
website
generator,
which
I
mentioned
earlier
called
fabricate.
I'm
you
know
interested
in
how
it
fits
into
the
to
the
broader
landscape
of
visual
tools,
that's
emerging
and
yeah.
I
don't
really
have
that
much
to
do.
Don't
really
have
that
much
else
to
say
just
that,
I'm
glad
to
be
here
and
I'm
you
know.
E
You
know
as
a
data
science
practitioner
myself,
it's
like
been
very
encouraging
to
see,
and
you
know
it's
now
reached
a
level
where,
like
I
am
comfortable,
doing
a
lot
of
my
day-to-day
work
in
closure,
which
was
not
true
a
few
years
ago.
So
I
think
that
you
know
it's
conversations
like
this.
Are
you
know
an
important
part
of
like
you
know,
pushing
that
pushing
that
forward
so
yeah
glad
to
be
here.
I
will
call
on
mauricio.
F
F
I
also
get
lots
of
help
from
peter
from
trying
to
find
out
the
bizarre
situation
of
the
vf's
code,
api
and
everything
and
yeah
I'm
here,
because
my
tooling
also
have
visualizations
and
other
like
custom
elements
that
the
user
can
interact,
and
I
would
be
very
glad
if
I
could
reuse
some
of
the
uis
from
other
toolings
or
consider
that
they
are
included
script
or
javascript
so
yeah.
This
could
be
like
very,
very
interesting.
F
For
me,
I
mean
the
idea
of
evaluating
something
and
displaying
in
the
way
that
you
want,
even
if
it's
not
textual
representation.
I
may
be
able
to
do
a
video
this
week
about
a
code
that
I
did.
It
was
a
chess
board
with
this
idea
of,
like
visually
incrementing
things
to
be
well
to
show
more
what
I
mean
with
that,
so
stay
tuned
and
I'm
gonna.
I
don't
know
name.
F
G
You're
very
close
I'll
do
the
same
thing.
I
always
do
it
kind
of
partly
visual,
partly
spoken
word
kind
of
thing,
so
I
helped
to
organize
those
conference
help
to
maintain
this
project,
which
is
a
bridge
to
orphan
language
and
and
the
conference
is,
I
don't
know
if
you
know
the
conscious,
but
it's
it's
been
a
virtual
conference
for
the
last
two
years
and
before
that
it
was
conference
in
london,
and
I
built
this,
which
is
a
web
app
for
research
and
different
kinds
of
things.
G
B
Okay,
good
david
arm
healing
from
chicago
in
the
united
states,
I'm
interested
in
visual
tools
largely
well
there's
two
levels.
One
is
what
a
lot
of
us
have
already
said:
being
able
to
visualize
arbitrary
data
and
have
a
way
of
doing
that,
and
secondly,
because
I
and
looking
at
a
very
macro
level
at
what's
happening
in
our
industry.
B
I
have
come
to
the
conclusion
that
web
interfaces
are
extremely
expensive
to
build
compared
to
native
user
interfaces
and
eclipse
swt
is
still
the
best
way
to
build
native
interfaces
across
platforms,
and
I
have
a
library
that
I've
been
working
on
internally.
That
does
that
that
exposes
sdbt
in
a
very
nice
closure
closurey
way
and
due
to
personal
reasons,
chaos
in
my
personal
life,
but
things
have
some
of
you
noticed.
A
But
I
think
today
I'll
try
to
kind
of
offer
an
idea
of
what
I
think
the
more
pressing
questions
are,
and
those
are
the
questions
of
compatibility
between
tools
which
are
kind
of
I
kind
of
care
about
and
have
we
all
talked.
I
think
we
have
right
yeah.
So
let
us
think
about
the
plan.
We
have
a
little
more
than
an
hour
till
the
official
time
and
then
afterwards
some
of
us
may
keep
chat.
A
And
what
we'll
have
is
an
update
by
andrew
about
fabricate,
which
is
kind
of
new
or
newish
to
most
of
us,
and
then
I
will
update
a
little
bit
about
compatibility
experiments
about
kind
of
following
up
from
the
meeting
we
had
in
the
middle
of
the
month,
and
then
we
will
have
a
chat
about
the
state
of
fierce
code
tools
which
are
clover
and
khalfa,
and
both
of
them
are
here.
And
if
there
is
any
other
topic,
then
it
is
not
too
late
to
add
that
to
the
plan.
A
E
Okay,
can
you
all?
Can
you
all
see?
Okay,
it's
not
wide
enough!
Sorry,
so
yeah!
So
this
this
page
that
we're
seeing
right
now,
which
is
page
on
my
website,
is
a
page.
That's
been
generated
by
fabricate
a
static
website,
generator
that
I've
been
working
on
for
the
past
couple
of
years.
It's
different
than
other
static
website
generators.
It
doesn't,
it
doesn't
use
markdown
or
asidoc
as
like
the
primary
input.
It's
just
plain
text
and
closure
expressions.
E
You
know
effective
presentation,
presentation
of
textual
information,
especially
on
the
web,
and
you
know
he
in
the
in
the
intro
in
the
docs
to
it.
You
know
he
he
kind
of
talks
about
pollen
as
embodying
a
point
of
view
that
you
know,
digital
books
should
be
better
than
other
books,
but
they're,
not
you
know,
and
we
could
make
better
digital
books.
E
You
know
by
exploiting
the
programmability
of
of
of
of
that,
and
so
those
are
the
ideas
and
that's
like
the
kind
of
like
context
that
I
wanted
to
bring
to
closure,
because
I
think
that
you
know
closure.
You
know
with
its
like
huge
ecosystem
of
like
library,
libraries
and
tools
and
being
able
to
leverage.
You
know
the
the
the
java
virtual
machine
as
a
platform.
You
know
it
means
that
means
that
we
have
the
ability
to
do
a
lot
of
stuff.
E
That
would
be
harder
to
do
in
a
programming
language
like
racket
because,
like
you
know,
and
the
kind
of
like
genesis
of
of
fabricate
is
that
you
know
I
started
writing
a
website
in
in
in
pollen.
But
I
wanted
to
use
closure
to
create
generative
art
for
the
website,
and
then
I
was
facing
the
impedance
mismatch
between
doing
some
stuff
in
closure
and
then
copying
it
over
into
pollen,
and
I
was
just
like
what
well,
why
don't?
E
I
just
try
to
rewrite
the
website
generation
code
enclosure,
and
so
I
started
trying
to
use
some
of
the
existing
static
website
generators
and
eventually
I
discovered
that
I
had
to
basically
rewrite
the
entire
thing
you
know
in
order
to
suit
the
workflow
that
I,
that
are,
that
I
that
I
wanted
to
do,
and
so
you
know
kind
of
like
like
like
what
david
hanemeyer
hansen
said
about
about
about
rails.
Is
that
you
know
you
know
framework
you
know,
frameworks
are
not.
E
E
You
know
I
have
my
own
criticisms
of
markdown
as
an
input
format.
They
largely
overlap
with
arguments
that
matthew
butterwork
makes
about
it,
but
I
don't
really
think
that
that's
that
important
in
general,
because,
like
I
think
like
the
problem
with
a
lot
of
static
website,
generators
is
is
broader
than
that.
You
know
you
you,
you
have
like
a
simple
design,
it's
oriented
towards
a
specific
use
case.
You
have
a
bunch
of
markdown
pages,
you
turn
them
into.
E
E
So
if
you
want
to
add
new
operations
to
fabricate,
you
just
add
stuff
to
the
finite
state
machine
which
is
defined
as
an
ordinary
closure
map
and
that's
and
that's
and
that's
how
it
works.
So
that's
kind
of
like
the
overview.
In
the
background.
You
know,
I
think
it's
probably
more
a
little
bit
more
useful
to
it's,
probably
a
little
bit
more
useful
to
kind
of
see,
see
things
in
action.
So
I'll.
Just
stop.
E
E
E
E
So
the
title
you
define
the
title,
we
define
the
page
style,
you
know
so
that
you
can
use
like
a
little
bit
of
inline
css
to
tailor
your
your
your
preset,
your
presentation
to
you
detail
the
visual
style
to
the
the
specific
content
on
the
page,
and
you
know
now
that
we
have
metadata
like
that.
We
could
use
it
right
there
in
line
in
the
document
to
do
you
know.
E
This
is
obviously
a
very
basic
basic
example,
but
you
know
the
metadata
var
contains
contains
the
title
of
this
page,
which
is
just
fabricate
and
it
gets
derived.
So
this
is
an
example
form.
You
know
we
use
a
string,
formatter
generate
generate
a
heading
and
you
know
kind
of
programmatically.
You
know
thereby
programmatically
create.
E
You
know
ordinary
htl
html
forms,
and
there
therefore
allows
us
to
do
more
to
program
the
overall
structure
of
the
document
that
I
think,
like
the
kind
of
traditional
markdown
plus
code
block
format
does
so
you
know
this
is
this.
Is
this?
Is
the
page
that
I've
been
working
on?
You
know
thinking
about
how
to
document
it,
how
to
understand
it.
E
Hey
that
you
might
have
seen
down
and
down
and
down
in
my
rebel
that
there
were,
there
are
a
bunch
of
bunch
of
operations.
So
what's
happening
in
the
background
here
right
is
that,
like
I
have
a
website
a
local
web
server
running
it's
based
on
iliff
like
it's
like
a
just
like
a
local
basic
static,
web
server,
running
locally
to
visualize,
visualize
the
results,
and
then
there's
also
the
file
a
file
watcher
watching
the
input
directory
and
picking
up
changes
to
files
and
then
re-rendering
them.
E
So
you
know
when
I,
when
I,
when
I,
when
I
save
the
buffer,
you
know
the
sentence
that
sentence
that
that
I
just
I
just
wrote,
you
know,
gets
gets
picked
up
here.
So
you
know
each
each
page
gets
re-rendered
in
a
loop,
that's
defined
by
by
the
the
finite
the
finite
state,
finite
state
machine.
So
you
know
it
has
it
reads
it
in
as
a
file
it
parses
it
using
a
grammar
that
I
defined
for
these
pages
using
instaparse.
E
It
evaluates
the
embedded
expression
and
then
it
turns
it
into
html
output
and
then
writes
it.
So
you
know
when
you
know
using
this,
this
combination,
this
combination,
you
know,
having
having
each
page
be
a
closure
namespace
allows
us
to
do
things
like
you
know,
loop
through
all
of
the
namespaces
of
fabricate
and
pull
the
doc
strings
out
of
them
to
like
generate
like
our
own.
E
You
know
generate
documents
much
much
in
the
way
that,
like
tools
like
clg,
dot,
cl
clj
doc
does,
for
example-
and
you
know
I
wanted
to
I
wanted
to
support.
You
know
arbitrary
extensibility
and
the
best
way
to
get
arbitrary
accessibility
is
just
to
you
know
you
bring
the
whole
power
of
the
programming
language
into
the
process
of
writing
a
document
and
that's
and
that's
what
what
I
think
fabricate
brings
to
the
table
that
you
know
is
is
present,
but
not
totally.
E
You
know
realized
in
other
static
website,
generate
generation
tools.
You
know
I
just
I
I
don't
know
like
you
know.
I
always
thought
it
was
kind
of
weird
that,
right
that,
like
we
have
code
in
our
in
our
in
our
as
as
input
right
like
if
you
have
like
a
markdown
block,
for
example,
the
the
code
that
is
in
that
markdown
block
is
maintained
totally
separately
from
like
the
the
code
that
exists
elsewhere
in
the
code
base.
Right
like
it's
not
alive,
you
can't
run
tests
against
it.
E
Necessarily,
though
I
think
some
people
have
have
developed
tools
that
allow
you
to
pull
out.
You
know
stuff
from
your
readme
and
turn
it
into.
I
think
sean
corefield
has
a
tool
like
that
that
allows
you
to
pull
examples
out
of
your
readme
and
then
run
tests
against
them,
but,
like
you
know
like
that,
I
just
don't
really
see
why
that
that
that
should
be.
E
You
know
we
shouldn't
have
this
like
dead
code
over
here
in
one
part
of
our
of
our
documentation
and
living
code
somewhere
else
like
all
of
the
code
should
be
alive
and
all
the
code
should
be,
we
should
be
able
to
run
tests
against
it.
You
know
visualize
it
how
we
want
to
and
stuff
like
that,
and
that's
that's
the
kind
of
like
ethos
and
point
of
view
that
that
I
think
fabricate
embodies.
But
you
know
it's
it's
still.
It's
still
very
much
like
kind
of
it's
in
its
early
stages.
E
You
know
I
don't.
I
don't
even
have
like
a
public
release
of
this
on.
Clojures
is
up
on
github
I'll,
send
a
link
to
it.
But
you
know
that's
that's
where
I'm,
where
I'm
coming
from
with
fabricate
and
yeah,
I'm
kind
of
happy
to
answer
any
additional
questions
you
might
have
at
this
point,
but
I
will
stop
sharing
my
screen.
G
B
G
G
B
E
I
have
because,
like
it's,
a
it's
racket
you
know
has
like
has
like
much
more
has
much
more
robust
support
for
for
accessibility
and
domain
specific
languages
than
closure
does,
like
you
know,
just
terms
of
the
design
of
the
languages
like
racket
was
written
to
make
reading
like
the
reader
as
extensible
as
possible,
whereas
like
that
was
a
that
was
a
non-goal.
As
far
as
I
understand
it
with
closure,
I
think
rich
hickey
was
like
no.
E
If
you
he
saw
that
like
reader
macros
and
common
lisp
had
like
could
sometimes
become
like
really
difficult
to
understand
and
did
not,
and
I
think
he
did
not
want
to
make
it
as
extensible.
So
so
there's
there
isn't
as
much
flexibility
in
like
the
you
know,
the
way,
the
way
that
the
way
that
you
know
like
the
input
gets
represent
represent
represented
enclosure.
But
that's
fine.
I
mean
like
I
have
you
know
like
I.
G
So
there
is
some,
that's
that's
like
some
sort
of
pre-processing
step.
That's
what
you're
saying
did
you
play
around
with
the
because
you
know
from
from
the
presentation.
We
know
that
you're,
an
emacs
user
so
have
you,
have
you
ever
tried
to
play
around
with
auric
modes
or
babble
and
sort
of
literate
programming
in
org
mode
and.
E
Yeah
yeah,
I
have
I
mean
I
I
I
think,
like
I'm
one
of
those
emacs
users
that
like
goes
back,
attempts
to
use
org
mode
every
couple
of
years
and
fails
like
every
single
time.
I
just
I
don't
know.
I've
tried
to
use
like
orgrome
in
the
past
and
like
and
like
it's
a
cool
tool,
but
I
don't
know
like
I
for
me
personally.
I
was
more
interested
in
a
writing
tool
than
like
a
note-taking
tool.
E
I
think
it's
a
different
choice
of
emphasis
primarily
because,
like
I
think
notes
are
mutable
and
writing
is
immutable
like
when
you
publish
an
essay
right
like
it's
just
published
right
like
you
know
it
has
a
time
stamp
on
it.
You
know
I
mean
it
could
be
revised
right.
There
are.
There
are
revisions,
but
like.
G
E
And
published
documents
like
they're,
more
immutable,
whereas,
like
notes
like
especially
digital
notes,
are
more
mutable
and,
like
I
don't
know,
I
guess,
like
kind
of
person
on
a
personal
level,
see
the
benefits
of
see
more
benefit.
For
me,
you
know
just
improving
my
understanding
by,
like
writing,
immutable
documents
that
reflect
my
point
of
view
at
a
particular
point
in
time,
rather
than
trying
to
like
keep
everything
up
to
date
all
the
time.
So
I
think
that
that's
like
one
reason
and
also
like
that.
E
I
think
that,
like
or
or
babel
is
a
lot
more
and
org
mode
is
a
lot
more
capable
than
markdown
is,
and
it
has
like
a
lot
more
structure
to
it
than
markdown
does,
but
it
still
has
that
you
know
total
separation
between
you
know,
code
blocks
and
and
non-code
blocks
like.
I
can't
use
closure
to
insert
a
bunch
of,
like
you
know,
org
mode
headings
into
like
my
document.
E
You
know
and
like
derive
the
entire
structure
of
my
document
programmatically
and
that's
more
of
what
I
wanted
to
do
so
you
know
that's
you
know
I
I
I
I
I
have
used
and
encountered
the
limits.
You
know,
at
least
for
my
purposes
of
of
org
mode
in
the
past,
and
I
think
that
that
experience
has
informed
the
design
choices
that
exist
within
fabricate.
C
I
find
your
then
interesting
to
see
that
you
chose,
like
the
other
way
around,
to
represent
closure
code
in
text
form
right
x,
all
the
new
tooling
notebook,
whatever
things
are
like
okay,
so
we've
got
valid
closure,
and
now
we
need
to
get
some
text
in
there
and
because
closures
strings
are
annoying
to
write
over
multiple
lines
and
stuff.
We're
just
gonna
put
it
in
comments
or
like
some
other
way
where
we
tell
the
compiler.
C
Please
ignore
this
part
we'll
do
something
special
with
it
later,
which
helps
that
we
can
now
like
write
clover,
the
clerk
code
in
some
editor
that
already
understands
my
closure
code.
If
I
was
to
write
the
f4
names,
it's
always
good
but
like
if
I
was
to
write
something
in
your
library,
I
would
have
liked
the
problem
that
the
closure
code.
I'm
writing.
C
E
That
like
would
allow
syntax
highlighting
and,
like
all
the
you
know,
closure
tooling,
with
cider
and
stuff
like
that
inside
of
the
the
fabricate
blocks,
using
the
using
a
library
called
poly
mode,
but
like
that's
just
for
emacs
and
that's
just
because
I
use
emacs
right
like
if,
if,
if
fabricate
is
to
be
useful
to
other
people
who
use
other
editors,
that
is
a
problem.
That's
gonna
need
to
be
solved.
It's
not
it's!
Not
it's
not
a
it's!
Not
it's!
Not!
E
It's
not
uncharted
territory
for
other
editors
by
any
means,
because,
like
the
syntax
that
fabricate
uses
is
pretty
similar
to
like
erb,
like
the
ruby,
which
I
think
is
like
the
ruby
style,
templating
expressions
so
like
other
editors,
have
the
ability
to
do
like
context,
sensitive
mode
and
syntax
changes,
but
you
know
like
I
don't
I
don't
really
know
what
the
developer
experience
for
using
fabricate
is.
You
know
for
like
a
vs
code
user
or
you
know,
for
a
vm
user
like
so
that
would
be.
E
B
I
it's
not
a
an
avenue
explored
much
in
my
case.
What
I
needed
was
very
much
like
what
edward
tufte's
work
is
not
time
to
describe
it.
If
anyone
doesn't
know
it,
go,
google
him,
there's
a
a
css
library
called
tufty
css
that
lets.
You
write
edward
tufte
style
documents
for
the
web
and
I
I
just
wound
up
just
using
that
and
building
on
top
of
that
and
building
closure
code
that
would
transform
into
tough
to
css
elements
inside
of
markdown
there's
actually
a
markdown
library
that
goes
with
tufty
css
as
well.
E
And
you
know
he
says
that,
like
if
you're
trying
to
you
should
approach
the
primary,
the
the
the
design
and
presentation
of
you
know
primarily
textual
information
as
mostly
a
graphic
design
problem
and
rely
on
interactivity
as
a
last
resort.
So
you
know
where
I
think,
like
fabricate
and
and
the
point
of
view
that
embodies
fits
into
this
ecosystem.
Is
that,
like
you
know
like
that,
it's
it's
it's
it's.
I
hope
it
lets.
E
Authors
think
more
about,
like
the
the
graphic
design
problem
you
know
of
like
presenting
the
information
that
they
want
to
present
and,
like
you
know,
use
the
benefit
of
closure
code
to
come
up
with
context-sensitive
ways
of
describing
information
that
are
never
less
static
and
non-interactive
but
suit
their
own
use
case,
and
I
still
think
that,
like
that's
like
an
important,
you
know
dimension
to
you,
know,
writing
and,
and
digital
writing.
That's
like
not!
E
You
know
that
is
is
not
as
good
as
it
could
be,
and
I
I
think,
like
part
of
the
reason
is,
is
some
of
the
limitations
of
the
tools
that
we
we've
been
using
for
a
while,
so
yeah
I'm
I.
I
definitely
am
interested
in
the
programmability
of
documents
as
as
an
authoring
tool,
but
not
necessarily
as
much
like
have
as
much
on
on
on
interactivity
in
the
in
the
in
the
finalized
output.
I
mean
that
said,
nothing
prevents
you
from
embedding.
E
You
know
like
a
vega
light
plot
or
whatever
into
a
fabricate
document.
I've
done
that
too
you
can.
You
could
use
some
of
the
visualization
ecosystem
that
exists
and
you
could
put
a
little
iframe
in
that.
Has
you
know,
closure
script
and
and
and
have
some
interactivity
that
way
if
you
wanted
to
it's
certainly
possible
but
like
in
terms
of
like
the
primary
emphasis?
It's
it's
it's
a
lot
on
kind
of,
you
know
static
presentation
of
information.
E
E
B
E
A
Yeah
and
we're
hoping
to
see
more
in
future
meetings
as
as
much
as
you
could-
and
I
guess
we'll
now
continue
through
the
other
topics,
so
I'll
have
a
short
update
about
compatibility,
experiments
and
then
we'll
focus
mostly
on
vs
code.
I
guess,
on
the
remaining
time
we
have
35
minutes
to
the
official
time
now
so
I'll
shut
the
screen
for
a
moment.
A
G
A
Make
it
simple
so
often
what
we
do
is
explore
something
and
what
we
are
exploring.
It
could
be
some
data
set
or
some
new
function,
we're
developing
some
algorithm
or
anything,
a
library,
we're
learning
so
we're
doing
some
exploration,
and
then
we
are.
We
want
to
be
very
playful
and
dynamic
in
that
phase,
but
at
some
point
we
want
to
document
our
exploration
and
then
we
want
to
kind
of
create
some
narrative
of
what
we
just
did
right
and
then
we
want
to
share
the
documents,
and
then
we
want
others
to
pick
that
document.
A
A
A
The
format
of
what
we
are
sharing
would
be
a
namespace,
a
code
right
just
closure
code,
because
it
is
kind
of
the
common
ground
to
what
most
tooling
can
handle,
and
we
use
that
as
a
way
of
sharing
what
we
have
been
doing
and
also
maybe
some
html
rendering
of
of
the
same
narrative.
So
it
is
kind
of
this
double
way
of
of
of
telling
the
story.
One
is
the
code
and
another
is,
is
the
html,
but
the
the
that
is
what
that
is
the
way
we
are
documenting
right.
A
We
are
documenting
something
which
is
a
namespace,
an
html,
and
then
there
is
a
question
of
how
we
document
what
tool
we
could
use
to
to
have
this
flow,
where
a
namespace
can
be
used
as
as
a
source
for
html,
and
then
there
are
tools
like
calls
and
clerk
and
node
space
and
others
right
and
and
and
then,
how
do
we
explore?
So
some
people
like
to
use
alls
and
clear
you
can
load
space
to
explore,
but
it
is.
A
Maybe
ours,
maybe
clerk
to
turn
it
into
a
document
be
without
having
to
bother
about
any
details
of
of
of
formatting,
of
notation
between
the
tools
and
at
the
moment
it
is
just
not
the
case
yet,
because
each
of
these
tools
has
its
own
way
of
kind
of
specifying
the
details
saying
this
thing
should
be
rendered
as
a
vega
spec
or
if
it's
a
vega,
light,
spec
or
svg
or
html
or
pickup.
Whatever
right
all
these
formatting
questions,
they
the
different
tools,
have
different
ways
to
specify
them
right.
Is
it
making
sense
any
questions?
A
Yeah,
so
the
hope
is
that
we
could
possibly
come
up
with
one
way
of
representing
our
code.
That
could
be
shared
across
tools
and
then
people
could
be
writing
tutorials
of
the
explorations
and
others
would
be
able
to
pick
those
tutorials
and
explore
further
with
their
favorite
tools,
and
that
is
what
I'm
trying
to
do,
and
my
approach
recently
is
to
write
tiny
projects
really
tiny
projects
which
are
demonstrations
of
concepts
and
the
main
goal
is
to
get
some
feedback
to
kind
of
see.
A
If
we
could
agree
on
details-
and
we
might
not
find
it
easy,
but
I
think
that
is
to
me
the
most
blocking
short
stem
problems
to
solve
figuring
out
a
way
to
document
and
explore
in
the
unified
way
so
that
we
could
grow
our
collection
of
tutorials
etc,
and
it
has
been
problematic
for
us.
And
so
here
is
you
know
yet
another
experiment,
and
after
this
meeting,
maybe
in
a
day
or
two
I'll
share
the
code
after
some
polish
and
this,
this
project
is
called
portal
clear,
kindly
and
recall.
A
We
can
see
the
code,
evaluations
and
other
events,
the
interaction
between
our
closure
runtime
and
the
tool
in
some
protocol-
and
I
guess
some
of
the
other
friends
here
will
would
comment
more
about
and
rappel,
and
I
know
mauricio
is
very
much
cares
very
much
about
other
alternatives
and
anyway,
here
I'm
using
an
record
in
order
to
listen
to
interactions
between
the
tool.
The
editor
vs
code
with
calva
and
the
closure
rank,
and
kindly
is
this
tiny
library
we
have
been
using
to
specify
kinds
of
things
like
say.
A
This
thing
is
of
kind
vega
right,
and
here
I
just
copied
some
part
of
it,
so
it
is
not
actually
using
kindly
so.
Everything
here
is
self-contained
in
really
little
piece
of
code
to
just
bring
in
some
ideas.
Clerk
is
this
literate
programming,
documentation,
tool
and
portal.
Is
this
tool
for
now
navigation
data,
navigation,
data
exploration
data
authorization?
A
So
let
us
just
play
with
it
for
a
moment.
So
here
I
I
have
already
started
portal
and
you
see
we
can
have
portal
running
inside
this
code
alongside
our
kalva
experience,
and
then
we
could
evaluate
some
code
and
what
just
happened
was
that
the
little
library,
little
ad
hoc
code
that
I
wrote
here
was
listening
to
the
and
rebel
protocol
and
figuring
out
okay,
we
did
evaluate
this
code
and
got
this
value
back,
so
we
could
show
it
on
the
portal
tool.
A
A
I
guess
most
people
use
portal
with
the
tab,
the
tab
function
and
I
think,
since
we
are
looking
for
a
way
to
actually
have
the
same
code,
the
same
code
in
our
namespace
and
in
our
interaction
with
portal.
I
wanted
to
avoid
this
need
to
write
tab
everywhere.
So
right.
So
here
I'm
just
listening
and
kind
of
hiding.
This
needs
to
submit
things
to
potter,
and
then
here
is
another
piece
of
code.
It
is
a
delay,
daniel
yeah.
A
D
A
So
we
can
interact
with
the
record
too
and-
and
that
is
also
recorded
in
in
portal
and
yeah
thanks.
Thank
you
for
this,
and
so
what
happens
when
we
have
a
delay.
This
thing
where
you
know
this
piece
of
code,
if
you
evaluate
it,
it
returns
a
delay,
value
which
is
not
computing.
Yet
it
needs
to
be
dereferenced
to
be
computed.
A
So
if
I
now
evaluate
this
piece
of
code,
then
you
see
we
needed
to
wait
for
two
seconds
and
we
did
get
the
return
value
here.
Visualized,
and
I
think
this
practice
is
quite
useful,
because
what
you
often
wish
to
do
is
be
able
to
evaluate
your
whole
namespace
quickly
without
waiting
for
slow
things
to
compute.
A
But
sometimes
you
wish
to
explore
some
things
and
then
you
could
use
them
this
way.
It
is
actually
kind
of
similar
to
the
use
of
rich
comment
blocks
right,
where
you
kind
of
avoid
evaluating
it
on
the
namespace
evaluation,
but
it
is
a
bit
different
and
yeah.
Maybe
we
shouldn't
dive
into
it.
So
much,
but
I
just
wanted
to
share
this
practice
now.
A
Here
is
a
another
piece
of
code,
and
so
here
we
have
these
metadata
attached
to
the
code
and
thanks
to
the
brilliant
new
additions
to
kalva,
this
now
works
and
you
can
evaluate
this
piece
of
code.
Thank
you
peter,
and
so
this
would
specify
that
this
kind
of
thing
is
of
kind
hiccup,
so
this
code
should
be
rendered
as
hica
right
and
it
works,
and
so
you
see
we
did
get
this
hiccup
rendered
as
html,
and
last
time
we
met
in
the
middle
of
the
month.
Vlad
commented
that
we
might
not
want
to
do
that.
A
We
might
not
want
to
rely
on
metadata
data
on
the
code
side,
but
rather
on
the
return
value
side,
and
that
is
another
flavor
of
this,
and
you
know
we're
still
exploring,
and
I
think
we
will
need
to
kind
of
decide
what
we
prefer
and
what
and
and
I'm
so
so
much
looking
forward
to
feedback.
So
here
is
another
flavor
of
this.
Where
you
see
we,
we
are
applying
some
function
and
this
function.
What
it
does
consider
consider
function.
A
It
just
takes
the
return
value
of
this
expression
and
attaches
some
metadata
to
it
and
and
that
works
too
right.
So
these
are
two
different
ways
and
maybe
just
another
example
with
the
vega
light
plot.
So
this
works
too
right
nicely.
So
so
we
can
kind
of
have
this
experience
with
portal,
where
we
have
our
code
and
we
can
pass
it,
we
can
just
evaluate
it
and
we
get
it
visualized
dynamically.
A
A
A
This
java
java
class
java
object.
That
represents
an
image,
so
you
would
like
it
to
just
render
as
an
image
without
bothering
about
it.
So
sometimes
it
is
useful
to
dispatch
on
time,
and
so
here
this
thing
would
be
rendered
as
big
big
text
using
this
hiccup
notation
really
fun
anyway.
These
are
just
some
thoughts
about
how
we
could
interact
with
bottle
and
about
how
we
could
specify
kinds
of
things
in
a
way
which
is
tool
agnostic,
so
the
tool
specific
details.
G
A
This
is
of
kind
hiccup
without
without
bothering
about
what
to
use
now.
The
hope
is
that,
without
doing
anything
without
any
any
other
detail,
I
could
just
now
ask
to
render
exactly
the
same
code
in
clerk
and
get
the
document
or
maybe
in
ours.
So
you
know
in
all.
You
could
also
render
a
presentation
with
slides.
A
Why
wouldn't
it
be
the
same
code
and
it
didn't
work
for
me
yet,
but
it
should
work
and
anyway,
that
is
where
we
are,
and
I
hope
to
keep
sharing
small
experiments
this
way.
So
I'm
not
sure
if
we
wish
to
continue
so
much
with
it
now,
but
any
feedback
would
be
so
much
helpful
and
I
guess
we
could
discuss
just
briefly
now
and
then
move
to
the
other
topic
to
actually
discussing
ps
code
itself.
B
Maybe
it's
like
whether
it's
maybe
maybe
attaching
more
than
one
kind
to
a
data
structure
is
the
wrong
thing
wrong
level
of
abstraction,
but
that
just
that
use
case
of,
if
you
have
a
thing
it
might
be,
you
might
want
to
render
it
as
odds
you
might
want
to
render
it
as
a
table.
You
might
want
to
render
it,
as
you
know,
any
number
of
different
ways
of
things
and
as
I'm
thinking
out
loud,
maybe
like
I
said,
maybe
that's
the
wrong
level
of
abstraction,
but
I
would
be
curious
about
what
this
group
thinks.
E
E
Can
you
can
you
plot
it
and
plot
the
numeric
value
against
the
distribution
that
it's
drawn
from
or
just
plot
it
on
its
own?
You
know
like
that.
That
kind
of
that
kind
of
thing
has
has
kind
of
come
up,
sometimes
like
when
I'm
like
thinking
about
the
background
of
like
certain
problems
that
I've
worked
on
it
at
work,
that
I've
used
clerk
to
visualize
would
be
like
you
know,
using
using
metadata
to
kind
of
preserve,
contextual
information
about
the
provenance
of
like
values,
because
I
know
that
that
was
a.
E
A
C
Yeah,
I
think,
there's
a
problem
with
having
multiple
kinds
on
the
same
thing.
If
you
want
to
solve
your
problem,
danielle
because
like
if
I
send
it
to
portal,
there
should
be
one
thing
coming
out,
probably
and
yeah
cool
I
can
switch
around
in
it
but
whatever
but
like.
If
you
want
to
then
like
just
give
somebody
that
namespace
and
he
should
get
the
same
result
as
you.
C
C
So
this
thing
always
prints
like
this,
no
matter
where
I
sent
it
all
right
because,
like
that's
the
thing
that
you
actually
want
to
accomplish
in
the
end,
so
even
if
you
had
multiple
kinds
on
the
same
thing,
you
would
now
need
a
different
concept
where
you
can
say:
well,
okay,
it
has
these
five
kinds,
but
I
would
not
want
to
choose
one.
So
if
I
send
this
thing
over
yeah
sure
these
are
the
bajillion
kinds,
I
don't
care.
C
I
want
you
to
represent
it
like
this,
and
every
tool
should
respect
like
the
thing
I
chose.
Otherwise,
you
can't
get
the
same
output.
You
had
in
multiple
things
right
and
the
other
thing
I
was
thinking
about
your
problem
is
clerk
doesn't
have
like,
even
if
you
get
the
same
namespace
to
running
clerk.
The
way
kirk
shows
the
data
is
just
different
than
it
would
be
shown
in
portal.
C
Yeah
sure
the
vega
thing
would
look
more
or
less
the
same,
but
if
you
said
well,
I
want
to
have
a
portal
view
with
a
table
or
whatever
this
table
thing
now
works
differently
in
clerk
which
is
kind
of
problematic
for
you.
If
you
want
the
same
output,
but
after
seeing
the
way
you
do
it,
I
thought
we
could
maybe
make
portal.
C
Work
as
a
library
as
well
so
portal
currently
like
is
has
two
parts
like
the
part
that
runs
in
your
runtime
and
the
part
that
run
that
shows
stuff.
We
could
pull
the
showing
stuff
in
as
a
library
as
well
and
then
be
able
to
say,
okay
cool,
please
don't
display
it.
Just
give
me
the
html
and
now
any
function
that
calls
that
can
either
be
passed
to
the
portal
thing.
That
then
displays
that
as
html,
which
is
fine
and
because
it
would
be
the
same
thing
as
running
it
in
the
in.
C
A
C
A
D
G
Should
keep
it
for
that?
You
have
the
whole
sort
of
lingo
like
kindly
consider
this,
and
you
can
like
just
just
take
away
the
most
difficult
things
about
naming
stuff.
You
have
the
whole
sort
of
idea
of
you
know
a
lot
of
different
ideas
around
that
that
you
can
use
for
naming
stuff
and
and
actually
works
quite
well.
G
A
B
I
can
get
this
in
real
fast.
The
thing
that
I
was
observing
is
that
when
we
talk
about
hiccup,
what
we're
really
talking
about
is
a
set
of
a
set
of
things.
You
can
stick
inside
of
closure
data
structures.
In
other
words,
it
is
a
schema
that
we're
imposing
on
closure
data
structures
and,
and
that
schema
happens,
to
also
correlate
one-to-one
with
html
elements,
so
we're
giving
it
a
an
interpretation
I'll
stop
there
give
andrew
a
chance
to
jump
into.
A
D
D
I
guess
I
don't
know
where
the
limits
are,
so
this
code
is
very
strong.
In
that
sense
I
mean,
since
it
can
allow
this
web
views,
you
can
do
anything
inside
inside
the
webview,
but
you
can't
like
mix
it
in
in
the
text
in
the
text
editor
almost
at
all,
it's
it's!
It's
there's
an
old
issue.
I
think
from
2016,
where
someone
like
asks
for
a
for
a
graphical
widget
that
you
can
like
show
stuff
in
line.
D
D
F
F
D
F
F
B
A
F
F
F
I
can
only
draw
things
with
html
and
everything
here.
That's
the
web
view
that
peter
was
was
telling,
and
the
trouble
only
begins
here,
because
this
webview
can't
access
the
internet
like
you,
you
can
whitelist
some.
I
think
paths
that
you
can
access,
but
you
can't
like
whitelist
everything
and
say:
okay,
you
are
a
browser
right
now
and
that's
where
things
get
complicated,
because
I
can
send
things
statically
here
and
get
it
rendered.
So,
for
example,
I
can.
F
F
F
F
F
F
I
don't
want
to
draw
everything
that
I
want
to
draw
by
hand
all
the
time
I
could,
if
I
had
some
some
way
of
like
sending
a
blob
of
javascript
blah
blah
blah
blah
blah
to
the
web
view,
but
it
just
me
either
needs
to
be
a
file,
a
single
file
or
a
bunch
of
files
that
the
web
view
starts
to.
I
don't
know,
take
full
control,
so
this
have
to
be
a
bundle
with
web
back
or
browser.
F
If
I
or
whatever
js
word
uses
now,
and
if
I
could
send
all
this
to
the
web
view,
then
I
could
like,
for
example,
support
vega
and
and
everything
else
as
a
tool,
so
I
could
get
like
100
support
for
everything
that
javascript
word
offers,
but
I
don't
have
this
capability
right
now.
I
was
trying
to
write
a
tooling
from
for
this.
F
I
could
not
finish
yet
but
anyway,
that
that's
the
gist
of
things
like
it's,
not
only
that
you
can't
render
things
inside
the
editor.
It's
also
the
web
view
it's
quite
limited.
Otherwise
I
just
like
inject
a
script
tag
here
and
css
file
and
well
everything
works
as
a
browser.
But
no
it's
not
parking
like
a
browser.
D
F
B
D
F
F
F
F
C
So,
like
the
the
two
major
things
would
be
like
the
clover
rebel
thing
works
just
very
differently
from
the
caller
apple
right,
because,
however,
it's
just
texts
and
just
throws
out
eaten
representation
of
whatever
you
ran,
and
you
can
actually
do
some
visual
stuff
in
there
and
javascript
stuff
and
whatever
and
like
since
clover
is
in
written
enclosure.
Script
you're
working
together
with
other
closure
codes,
is
a
bit
easier
than
on
the
kalva
site.
C
Where,
since
like
I
built
in
stuff
like
okay,
I
can
now
extend
calves,
tooltips
and
so
on,
and
for
you
to
clover
it
would
have
been
probably
a
lot
easier
if
I
wanted
to
display
something
else
in
the
clover
tooltips
or
whatever.
So
like,
I'm
like
I'm
imagining
how
we
could
like
make
either
a
clover
better
or
cover
better
or
in
the
end.
It
doesn't
really
matter
just
like
make
visual
studio
code
better
for
like
everyone
who
uses
it
in
a
cultural
space.
C
So
if
it
would
be
possible
to
pull
the
clover
ripple
into
cover
as
well
or
we
could,
you
can
then
choose
since,
like
I
never
touched
the
clothes
that
calvary
as
in
I
type
in
there,
it
just
doesn't
happen
right,
I'm
just
like
okay
cool.
This
is
my
output
now,
but
I
don't
ever
go
in
there
and
so
the
clover
wrapper
might
be
better
for
me.
C
I
don't
know,
maybe
so
it
would
be
interesting
if
I
could
then
choose
to
use
this
one
as
the
output
instead
of
the
cover
vapor,
if
I
have
like
anything
to
gain
from
it
and
the
same
with
the
contact
launcher
script
thing
that
you
have
where
I'm
currently
trying
to
add
this
more
or
less
into
cover.
But
if
we
could
use
your
version,
I
would
save
a
lot
of
time
and
we
could
build
some
other
cool
stuff
in
the
cover.
Instead
of
repeating
your
work.
F
Yeah-
let's
say
I'm
thinking
here
honestly
it
it's
also
a
fun
story.
I
don't
have
an
input
here,
because
originally
this
was
going
to
be
in
vsco
and
in
the
atom
editor,
and
it
was
quite
hard
to
get
the
the
ui
right.
So
I
just
like
delayed
and
when
I
added
support
for
clojusclip,
then
the
ui
didn't
make
sense
anymore,
because
I
was
like
okay,
I'm
evaluating
this.
What
happens?
F
C
F
C
D
F
Oh
wonderful,
thanks
and
well
anything
that
is
inside
the
clover
it's
inside
this
tooling,
the
the
repo
tooling
library.
So
you
may
be
able
to
just
check
the
code
that
I
did
there
and
reuse
it.
I'm
not
sure
how
reusable
it
is
outside
of
the
closure
of
the
outside
of
chlorine
clover
thing
because
there's
like
some
internal
tooling
internal
state
being
passed
around,
but
maybe
I
don't
know
you
send
me
a
pr
to
separate
things
better
and
I
just
merge
it
and
everything
works.
C
D
D
D
C
F
Okay,
so
yeah
the.
I
think
if
we
can
like
somehow
separate
the
the
work
into
things
that
are
not
dependent
on
internal
state
this,
this
should
work.
I
mean
sure,
reporting
project
is
kind
of
big,
but
I
think
the
that
code,
removal
from
shadow
will
simply
say.
Okay,
I
don't
need
like
eighty
percent
of
the
of
the
tooling
so
that
your
bundle
will
be
small.
C
F
D
C
D
A
Maybe
I'll
share
something.
If
it
is
time
I
thought
for
a
moment,
we
could
look
into
the
python
experience
with
vs
code.
There
are
a
few
visual
things
that
the
vs
code
team
added
and
I
think
those
things
are
python
specific.
They
didn't
make
it
extensive
and
I
think,
but
probably
they
hope
to
because
there
are
other
languages,
so
we
could
hope
to
it
for
it
to
become
extensible,
but
maybe
just
let
us
see
how
it
behaves
so
that
we
could
see
what
we
could
hope
right.
So
so.
A
Here
what
I
have
here
is
just
a
small
python
file
with
a
tutorial
of
this
macroclip
library,
and
you
see
there
is
this.
These
marks,
where
you
could
mark
parts
of
your
code
as
cells
as
they
call
them,
and
this
thing
is
clickable
and
you
could
say
I
wish
to
run
this
cell
or
this
one
right.
Then
you
could
also
kind
of
evaluate
with
key
bindings
and
and
you
see
on
the
other
side,
on
the
right
side,
we
have
a
web
view
and
it
could
contain
visual
outputs.
A
A
So
this
does
work
for
python
this
interactive
view,
so
that
is
one
flavor
of
kind
of
visual
experience
and
another
one
is
editing
a
jupiter
file
in
the
using
the.
I
think,
both
ways.
Both
visual
ways
here
are
using
the
jupiter
protocol,
but
this
one
is
more
similar
to
the
what
is
usually
considered
the
usual
jupiter
notebook
experience
where
the
actual
failure
editing
is
composed
of
these
cells
and
you
could
evaluate
one
of
them
and
get
the
visual
output
in
the
same
in
the
same
editor.
A
Oh,
what
is
that?
Oh
unrelated
some
zombie,
oh
yeah,
so
I
should
evaluate
from
scratch
so
I'll
evaluate
this
and
this
this
and
we
do
get
the
visual
output
in
the
editor
in
a
sense.
So
just
just
like
a
little
taste
of
what
the
python
people
have
in
visco
and
I'm
not
sure
how
difficult
it
is
to
have
on
another
language.
F
Oh
sure,
it's
just
that
I
did
see
this
api.
It
landed
in
vs
code
after
I
did
all
the
closures,
clover,
stuff
and
well.
It
will
not
work
exactly
that
well
for
clover,
because
it
somehow
needs
to
get
the
it
has
a
structure.
I
mean
you
can't
just
evaluate
javascript.
You
have
to
evaluate
like
html,
plus
something
else
or
images
you
can't.
F
C
You
can
only
type
in
the
bottom.
You
can't
like
interact
with
the
star,
the
other
stuff.
You
can't
just
type
in
there
or
eval
code
in
there
and
enclosure
you
we
would
kind
of
expect
to
be
able
to
just
go
into
the
middle
type
in
some
code
or
evolve
that
code
or
whatever
and
in
python.
That
doesn't
really
make
any
sense.
So
it's
not
that
bad
to
not
have
it.
C
D
Yeah
the
canvas
webview
used
to
be
that
was
just
that
was
just
an
editor
full-blown.
You
can,
you
can
type
in
the
beginning
and
and
whatever
so
that
was
problem
was
user
expectations
when
you
had
that
and
then
they
they
were
working
in
an
editor
and
they
started
wondering
why
doesn't
it
work?
Why
can't
I
do
this
in
this
editor,
but
not
in
this
editor,
and
you
know
so
it
was
just
chasing
the
real
editor
experience
and
then
then
I
decided
that
that
wasn't
worth
it.
B
D
C
C
D
C
D
C
I
think
really
types
a
lot
into
the
rebel
part,
maybe
like
I
type
in
there
like
once
every
week
or
something
because
I
want
like
some
specific
thing
that
I
don't
want
to
show
up
in
my
code
for
reasons,
but
usually
I'm
just
back
and
typing
it
into
the
comment
and
so
on.
So
I
think
it
might
actually
be
nice
to
not
allow
people
to
type
into
their
document.
C
F
C
I
mean
there
are
probably
people
who,
like
typing
into
their
apple,
and
I
don't
want
to
destroy
their
workflow,
but
if
we
pulled
in
clover
or
we
would
still
have
like
the
output,
the
cover
dot
rebel.
Whatever
file,
I
can
never
remember
the
name
so
like
the
people
can
choose
this
one
or
this
one
and
if
they
like
typing
in
it,
they
can
always
like
type
in
it
and
it
works
in
there.
B
You
know
you
when
I,
when
I
started
working
in
enclosure,
emacs
was
pretty
much
the
only
game
in
town
and
I've
been
using
emacs
since
I
was
in
middle
school,
so
I
won't
say
how
long
that
ago
that
was,
it
was
quite
a
while,
and
so
the
experience
was
like.
Okay,
you
have
this
rebel,
you
can
type
here.
B
You
can
see
answers,
it's
just
you
know
automatic
it's
fast
and
then
you
go
to
the
cider
web
page
and
there's
these
pages
and
pages
and
pages
of
commands,
keyboard
commands
and-
and
it's
like
well,
how
do
I
know
what's
more
important
than
what
and
unless
you
have
somebody
there
at
your
shoulder
saying
no
don't
do
that.
Do
this,
these
commands
are
the
most
important
ones
you
need
to
know.
For
example,
then
it's
just
the
the
the
discoverability
of
that
kind
of
way
of
interaction
isn't
high,
especially
coming
from
another
language.
B
C
Can
do
in
caldwell
right?
I
think
we
can
do
the
annotations
yes,
and
the
other
thing
is:
we've
got
your
two
critiques
on
the
other
way
like
closure,
interactivity
works
for
beginners
and
there's
the
getting
started
rebel
thing
that
it
actually
tells
you
which
commands
to
which
thing
and
on
the
calver
side
there's
a
these.
Are
the
10
most
important
commands
things
which
are
like
okay,
so
ignore
like
the
bajillion
things
we
have?
B
B
B
B
C
D
E
E
Right
like
if
you
wanted
to
like
have
your
own
like
have
a
value
display
its
own
custom
actions
right,
you
could
annotate
it
with
the
right
metadata
and
then
use
and
then
like
map
the
metadata
value
annotations
to
code
lens
actions,
so
that
specific
values
can
have
specific
actions
associated
with
them
like,
for
example,
if
you
had
like
a
simulation,
you
know
you
could
have
like
a
rerun
simulation
button.
That
would
be
context
specific,
as
opposed
to
just
these
kind
of
generic
run,
debug
go-to
type
type
things
which
would
be
pretty
interesting
and
pretty
powerful.
C
Yeah,
it's
not
as
super
easy,
as
you
would
think,
since
calvar
runs
in
a
different
runs
in
the
vs
code
process
and
your
code
and
your
annotations
would
be
in
the
rebel.
So
there's
two
different
things
and
you
would
now
need
to
run
your
dev
or
whatever
to
see
what
the
metadata
is
and
then
ask
the
ripple
for
it
as
kalba.
So
you.
C
Server
running
right,
we've
got
the
connection
running,
but,
like
you,
your
function
definition
might
call
a
macro
that
formats
your
hard
drive.
So
I
don't
want
to
just
run
your
code
just
to
know
the
metadata
on
it.
It's
probably
not
gonna
format
your
code,
but
I
don't
know,
maybe
so
it's
a
little
bit
harder,
it's
not
like
impossible
to
solve,
and
that
needs
to
be
like
some
way
to
tell
me.
Please
don't
run
this
thing
because
it's
gonna
explode
the
world,
but
it's
probably
possible
to
say
yeah.
The
code
can
choose
what
annotations
are
there.
C
D
F
Well,
honestly,
I
would
like
to
see
some
more
demos
on
on
some
of
the
visual
tools
here.
I
remember
on
my
last
meeting
that
I
attended
with
you.
There
were
people
saying
things
like.
Oh,
I
want
to
make
closure
like
a
small
talk
experience
when
you
just
don't
know,
but
things
in
the
in
the
interaction
you
interact
with
the
code
while
you're
running
it
and
that's
kind
of
what
I
want
clover
and
chlorine
to
do
so.
F
B
F
F
It
was
like
very
really
cool
experience
and
I'm
probably
doing
something
stupid
right
now,
I'm
trying
to
do
a
revival
of
the
atom
editor
with
some
my
more
modern
architecture,
enclosure
script.
It
might
be
something
stupid
to
do
so.
I'm
not
sure
if
I'm
gonna
continue
doing
that.
It's
just
a
lot
of
work.
E
F
F
So,
for
example,
I'm
getting
the
components
trying
to
extract
them
in
a
way
that
makes
sense
and
put
something
together
that
kind
of
resembles
an
editor
but
can
be
more
configurable
and
don't
have
too
many
assumptions
happening
and
enclosures
get
and
yeah
it's
kind
of
working
kind
of
not
some
bumps
in
the
road,
but
it's
almost
happening,
but
I'm
not
sure
if
I'm
gonna
continue
because
well
I
have
chlorine
and
I
have
clover
and
I
have
work
and
I
have
a
daughter.
It's
just
too
much
work.
B
So
that
same
idea
is
on
my
road
map.
I
don't
know
if
I'll
ever
get
to
it
for
the
same
reasons,
but
my
thinking
was
to
approach
it
from
codemirror6
building
on
top
of
the
work
that
next
next
journal
has
been
doing,
they
have
a
a
very
good
but
very
basic
closure
editor
with
all
the
things
that
you
need
to
do.
Basic
closure,
editing
already
done,
and
it's
a
teeny
tiny
bit
of
code
built
on
top
of
code
mirror
6..
F
F
Yeah
it
somehow
is
because
I'm
kind
of
doing
over
monaco.
For
now
I
thought
about
code
mirror,
but
I
I
thought
oh
maybe
monaco
would
be
a
good
choice,
I'm
not
sure
if
it
is,
but
the
idea
would
be
to
make
everything
plugging.
So
you
don't
like
monaco.
You
just
plug
in
cloud,
mirror,
write
a
fusade
or
something
like
this
that
adopts
the
api
and
everything
works.
It's
almost
the
same
idea
that
I
had
with
chlorine
and
clover.
F
They
both
use
the
same
tooling,
that's
completely
editor-independent.
They
just
adapt
some
callbacks
and
everything
works
and
in
fact
I
was
trying
to
target
call
on
the
mirror
in
the
past.
I
remember
that
I
was
going
to
name
the
project.
I
think
it
was
silver
chloride
or
something
like
this,
but
I
never
got
time
to
make
it
work,
and
I
also
want
to
extract
some
parts
of
their
pure
node
to
be
able
to
run
a
synchronous.
B
B
So
if
somebody
wants
to
do
something,
some
heavy
lifting
with
their
current
editor,
they
can
just
jack
in
and
they're
they're
good
to
go
so
and
then
people
I
my
thinking
my
hope
is
that
people
will
get
tired
of
having
to
jack
in
to
do
non-trivial,
work
and
start
contributing
to
the
editor
experience
and
make
eventually
that
will
become
viral.
But
you
know
you
never
know
until
you
try
and
I
see
people
looking
like-
maybe
we're
I'm
I'm
feeling
like,
maybe
I'm
losing
part
of
our
audience.
So
maybe
we
should
take
this
offline.
F
A
Yeah,
so
does
anybody
wish
to
say
anything
any
concluding
remark
any
hope
for
the
coming
weeks.
Anything
that
would
be
useful
for
you
any
kind
of
meeting
we
should
set,
or
there
were
some
thoughts
about
organizing
kind
of
study
meetings
about
some
of
the
technologies,
and
if
there
is
any
idea
of
that,
you
could
think
about
it
offline.
If
you
like
and
organize
something
about
any
topic,
you
may
find
useful
andrew
davis.
A
E
Like
to
just
name
like
the
just
the
topic
of
databases,
so
one
of
the
things
that
I'm
kind
of
like
working
on
in
terms
of
like
very,
very
sketchy
experimental
work
is
parsing
out
all
of
the
contents
of
fabricates
pages
after
evaluation
and
putting
them
into
asami
the
schema-less
graph
database
and
then
using
data
log.
Queries
against
that
database
as
a
writing
tool.
E
And
so
I'm
thinking
about
you
know
in
very
broad
terms.
Nothing
hardly
anything
is
concrete,
but
I
do
have
some
some
kind
of
demos
and
concepts
of
that.
But
thinking
about
how
to
implement
more
fabricates
like
data
model
and
features
in
the
context
of
database
operations
and
just
kind
of
generally
thinking
about
how
you
know
the
what
what
I
consider
to
be
like
one
of
closure.
E
The
closure
community's
like
greatest
strengths
is
like
the
the
the
choice
of
these
like
data
log-based
databases
that
we
have,
as
you
know,
and
how
and
how
those
might
overlap
with.
You
know
the
tools
that
we're
trying
to
build,
because
I
think
it
could
be
like
bi-directional
right,
like
visual
tools
could
be
a
way
of
exploring
databases,
but
also
like
a
database
could
be
a
powerful
backend
for
storing
state
and
and
managing
state.
With
for
these
tools,.
F
Okay,
can
I
share
also
something
with
your
owner?
I
am
doing
an
experiment.
In
fact,
I
am
also
using
it
in
chlorine
and
clover.
That
is
a
way
to
not
get
an
api
from
the
the
chlorine
and
clover
just
priority
things
with
eco.
So
with
patho,
and
it's
been
like
an
interesting
thing.
I
mean
like,
for
example,
supposing
that
I
want
to,
I
don't
know,
interact
with
some
code
in
my
in
my
repo,
so
I
have
them
like
this.
F
F
Us
is
if
it's
sync,
so
no
more
promesa
and
and
other
things
in
enclosures
group,
and
I
think
the
most
powerful
part
of
everything
is
that
everything
gets
customizable
to
the
car.
If
I
want
to,
I
don't
know,
but
clergy
lsp
in
the
in
the
game,
I
just
make
a
query
in
equal
and
it
will
query
the
repo
or
lsp,
depending
on
what's
available.
What's
more
it
trusts
more.
You
can
also
merge
the
results
in
in
a
way
so
yeah
this
this.
F
F
Bathroom
two
have
a
lot
of
overhead.
Three
doesn't
have
so
much,
but
it
does
have
you
just
have
some
overhead,
the
operation
that
I
migrating
are
quite
heavy
on
on
the
repo,
so
they
do
interactions
with
the
repo.
So
for
me
it's
not
a
problem
like
if
python
gets,
I
don't
know
15
milliseconds
more
of
the
wrapper
interaction
gets
100
milliseconds.
So
whatever
one
of
the
things
that
I'm
I'm
trying
to
do
is
to
cache
some
of
the
steps,
so,
for
example,
in
a
way,
sometimes
I
get
the
supposing
supposingly.
F
F
F
E
That
sounds
super
super
interesting.
It
sounds
like
it
overlaps,
but
also
departs
from
codec,
like
the
the
cognitect
project
that,
like
loads,
an
entire
history
of
a
closure
git
project
into
atomic,
and
allows
you
to
to
query
it
query
using
atomic.
That's
definitely
like
kind
of
been
a
conceptual
point
of
reference
for
me,
as
I'm
thinking
about
some
of
these
problems.
C
E
A
B
B
C
That's
interesting
because
we're
using
actually
a
data
hike
with
data
script,
I
mean
data
hike,
is
just
the
safe
layer
of
the
data
script
to
do
the
codec
stuff.
So
you
don't
actually
need
to
use
the
atomic
in
there
and
you
can
use
any
dental
lock
thing
you
probably
have
to
rewrite
a
bit
of
it,
but
still.