►
Description
In this short report, we discuss one of our current challenges -- creating compatibility layers across different Clojure visual tools.
As a proof of concept, we walk through an experiment connecting Portal, Clerk, Kindly, and nREPL:
https://github.com/scicloj/visual-tools-experiments/tree/main/portal-clerk-kindly-nrepl-1
A
A
It
is
related
to
the
new
visual
tools
group
you
see
in
the
new
cyclos
website.
You
can
see
the
different
dev
groups
and
study
groups,
and
one
of
them
is
the
visual
tools
group,
where
different
authors,
creators,
maintainers
of
closure,
tooling,
projects
can
meet
and
collaborate
and
share
experiences
and
hopes
and
problems,
and
the
problem
we
hope
to
discuss
now
is
the
problem
of
compatibility.
A
A
This
very
dynamic
way
of
literate
programming,
of
creating
visual
documents-
maybe
less
known,
is
kindly
which
is
part
of
the
notes.
Project.
Kindly
is
about
specifying
kinds
of
things
which
means
specifying
what
kind
of
visual
view
we
hope
to
have
for
a
given
thing
and
and
rappel,
which
is
this
protocol
that
connects
different
closure
tools
to
closure,
runtimes
or
other
runtimes.
A
Actually,
and
here
we
will
try
to
connect
all
of
them,
and
maybe
the
less
known
part
kindly
is
what
something
that
could
be
a
bit
surprising
and
we're
actually
not
depending
on
it
here,
we're
actually
containing
a
self-contained
self-contained
adapted
version
of
it.
So
that
it
would
be
very
much
clear
and
simple
to
see
what
we
are
doing
and
in
a
moment
we'll
talk
about
why
we
care
about
this
hope
for
harmony
between
different
tubes,
and
you
see.
A
So
here's
the
statement
of
the
problem
and
the
problem
is
this
amazing
diversity
of
tools-
and
you
see
we
collected
here
a
few
closure
and
visual
notebooks
of
different
flavors
that
allow
us
to
document
things
in
a
visual
way.
For
example,
this
recent
color
tutorial
by
our
friend
tomasz,
which
is
written
in
clerk.
Let
us
also
see
the
source
code,
so
here
is
the
rendering
that
we
open
in
a
moment.
A
Maybe
first
let
us
see
the
source
code,
so
you
see
it
is
depending
on
some
custom
clerk
function,
that
tomasz
added,
which
is
as
this
nice
symbol
for
it.
And
this
way
we
can
say
please
render
a
center
a
certain
color
right.
So
this
function
is
specific
to
the
tooling
we're
using
here
and
a
user
picking.
This
piece
of
code
would
have
to
use
clerk,
and
actually
this
custom
function
for
things
to
work,
and
you
see
it
is
an
amazing
tutorial.
A
It
is
simply
beautiful
and
it
has
those
really
amazing
color
ideas
and
also
those
dynamic
plots
and
yeah.
You
should
look
into
it,
but
we
want
to
be
able
to
create
such
beautiful
documents
and
others
in
a
way
that
users
would
be
able
to
just
pick
them
and
use
them
in
whatever
tool
they
like,
and
each
of
these
documents
in
this
list
actually
has
its
own
differences
about
notation
about
how
things
are
specified
and
we
hope
to
create
some
thin
layer
of
compatibility.
A
You
know
actually
in
an
actually
usable
and
accessible
way
right.
So
I
hope
that
is
clear
and
I
would
love
to
discuss
it
more,
but
that
is
what
we
are
caring
about
now
and
what
we
are
having
here
is
is
just
a
tiny
proof
of
concept
of
this,
of
what
a
possible
solution
could
look
like
and
it
is
not
trying
to
be
complete.
A
And
so
let
us
first
go
and
see
how
things
look
in
clerk,
I'm
skipping
the
setup
a
little
bit.
We
later
have
the
live
demo,
but
you
see
we
have
this
function
that
does
some
setup
to
adapt
the
behavior
of
clerk
to
render
things
and
in
a
way
that
we
like
and
clerk,
is
very
much
customizable
and
flexible.
A
So
it
allows
us
to
do
that
and
we
are
doing
something
similar
in
portal
before
sending
before
submitting
values,
to
be
visualized
important,
and
that
is
kind
of
happening
behind
this
pipeline
staff
function,
and
so
here,
how
can
we
specify
the
kind
of
visualization
to
be
used?
So
one
way
to
do
it?
Is
this
kindly
consider
api
that
says
you
take
this
value
and
please
kindly
consider
it
as
something
of
this
kind.
So
in
this
example,
this
vector
is
to
be
considered
as
a
hiccup
format.
A
What
this
call
to
consider
does
is
just
adding
some
metadata.
It
does
not
change
the
value,
so
we
could
keep
processing
our
vectors,
our
hiccup
structures,
but
we're
just
considering
them
to
be
viewed
this
way.
So
you
see
it
worked
right,
it
worked,
it
was
supposed
to
show
a
small
hello
and
it
does
another
way
to
specify.
A
The
kind
of
thing
is
not
by
attaching
metadata
to
the
value
as
we
did
here,
but
by
attaching
metadata
to
the
code,
and
I'm
mentioning
it
here,
because
it
is
something
we
have
been
enjoying
in
north
space,
for
example,
and
at
the
moment
I
couldn't
get
it
right
in
clerk.
It
wouldn't
work
in
all
tools,
and
maybe
it
is
a
reason
to
not
make
it
part
of
our
desired
compatibility
layer.
A
Say
that
closure
of
ours
are
of
kind
vow
and
then
we
could
define
a
kind
behavior
for
this
kind
of
thing
we
just
invented-
and
here
is
how
we're
specifying
the
kind
behavior
by
specifying
this
certain
layer
of
behavior
for
each
relevant
tool
and
both
clerk
and
portal
are
so
friendly.
How
they
allow
us
to
specify
these
things,
and
so
you
see
we
just
want
to
see
not
only
the
name
of
the
verb,
but
also
the
documentation
if
it
has
one
and
let
us
test
it.
A
So
here
is
our
famous
vowel
reduced
from
the
closure
standard
library,
and
here
it
is
rendered
now
in
clerk,
as
we
defined
right
so
just
another
way
of
defining
kinds
of
things.
So
to
recap
we
like
to
define
kinds
of
things
and
we
can
do
it
by
metadata
or
by
protocol,
and
we
can
define
behaviors
of
tools
for
those
certain
kinds,
and
maybe
let
us
look
into
a
few
other
examples
that
we
like.
One
of
them
is
delays.
A
A
You
could
ask
for
it
to
be
done,
but
if
you
don't
ask,
then
I
don't
do
it
and
then
we,
some
of
us,
like
delays
as
a
way
of
inserting
the
exploration
code
into
our
closure
namespaces
and
having
this
code
would
not
make
our
namespaces
slow,
even
if
evaluating
the
code
would
be
slow
because
the
delay
doesn't
evaluate
it.
But
typically,
if
we
render
the
document
the
visual
document
documenting
our
flow,
then
we
would
like
them
to
be
dereferenced
as
they
call
it.
A
We
would
like
the
thing
to
be
evaluated,
and
so
our
thin
layer
of
compatibility
does
that
here
it
asks
clerk
to
please
dereference
so
that
we
would
see
the
value
of
the
delay
and
it
does
a
similar
thing
with
portal
when
submitting
the
values
to
portal.
So
we
would
have
this
ability
to
explore
things
without
making
our
whole
namespace
loading,
slow
and
another
thing
that
both
portal
and
clerk
support
is
nesting
of
different
viewers,
and
here
we
just
see
that
we
can
do
it.
A
So,
for
example,
we're
defining
something
of
kind
failure
alive
this
data
visualization
format,
and
then
we
are
creating
a
few
of
these
and
collecting
them
into
something
of
kind
hiccup,
which
is
this
way
of
generating
html.
So
we
can
nest
things
and
we
will
later
see
it
working
not
only
in
there,
but
also
important
and
yeah.
Another
thing
that
some
of
us
like
to
render
visually
is
unit
tests.
So
here
we
have
this
kindly
check
function.
That
is
something
we've
been
using
for
so-called
literate
testing
or
testable
documentation.
A
Okay,
so
you
see
there
is
some
setup
here
and
we
will
begin
by
starting
the
wrapper
and
we
need
to
have
this
alias
to
a
certain
setup
that
makes
the
end
and
wrapping
middleware
work
and
calva
offer.
This
knife
offers
this
nice
way
of
asking
us
what
aliases
to
use
when
running
the
router.
So
you
see
it
is
here
using
this
dedicated,
alias
that
we
created
to
make
sure
the
middleware
works,
so
that
our
process
would
be
able
to
listen
to
our
code
evaluations.
A
A
Have
the
portal
window
inside
kalva?
We
are
not
doing
it
here
now,
but
it's
very
much
durable
and
beautiful
and
yeah.
So
so,
let's
see
what
we
have
here.
So
maybe
I'll
not
bore
you
so
much
with
the
setup
when
you
we
have
some
useful
workflow
function,
calls
for
both
total
and
clerk
and
let
us
just
play
with
bottle.
So
you
see.
A
It
does
work
too
right
and
what
about
delays
yeah
so
a
little
bit
delay
because
we
made
it
slow
this
one
two
so
yeah
things
are
working
and
also
this
nest,
nested
nested
structure,
it
does
work
right
so
and
see
it
is
not
looking
exactly
the
same
as
the
clerk.
Of
course,
there
are
those
different
aesthetics,
and
that
makes
sense-
I
guess,
but
it
is
essentially
the
same,
and
that
means
that
the
user
could
pick
this
document
and
explore
it
in
portal,
which
is
the
point
of
this
whole
exploration.
A
A
That's
the
hope
and
that's
the
problem
and
maybe,
as
we
may
have
said,
unlike
our
big
hopes
and
amazing
ideas
that
some
visual
tools
offers
offer
this
one,
I
think,
is
a
problem
of
the
short
term.
It
is
something
that
we
actually
need
to
solve.
Really
soon
because
we
hope
to
create
those
documents,
any
feedback
would
help.
Thank
you
so
much
for
listening
and
please
also
consider
joining
our
visual
tools
group,
because
you
know
having
you
in
those
discussion
would
help
us
in
this
thinking
process.
A
Many
other
amazing
things
are
happening
there.
This
one
is
the
most
boring
one
in
a
sense,
really,
I'm
amazed
by
the
beautiful
ideas
that
the
tool
creators
are
bringing
and
the
other
friends
in
this
group
who
are
so
helpful
and
creative,
and
I
think
you
would
enjoy
it
so
please
join
us
and
take
care.