►
Description
On Nov 27th, 2022, the Clojure visual-tools group had its 16th meeting.
https://scicloj.github.io/docs/community/groups/visual-tools/
Lukas Domagala and Chris Badahdaha presented Calva Notebooks, their integration with Portal, and other Portal updates.
https://calva.io/notebooks/
https://github.com/djblue/portal
A
Hello,
everybody.
This
is
meeting
number
16
of
the
visual
tools
group,
a
group
where
closure
developers
and
users
discuss
the
emerging
stack
of
tools
for
data
visualization
and
literate
programming
and
such
and
today
we
will
have
a
presentation
about
kalva
notebooks
and
their
integration
with
Porter,
and
we
have
both
Lucas
and
Chris,
the
maintainers
and
creators
presenting
these
topics
and
we
we
begin
with
everybody
telling
just
a
little
bit
about
themselves
and
then
we'll
have
the
presentations.
So
maybe
Joe.
Would
you
like
to
begin?
Maybe
tell
something
about
yourself.
Your
interests
sure.
B
Hello,
everyone
so
I
I'm,
not
a
professional
developer,
but
I
do
a
lot
of
work
with
data
and
some
interested
to
use,
see
what's
available
for
closure
and
see
what
tools
I
can
use
and
sort
of
move.
Some
data
analysis
that
I
typically
do
in
Python
to
closure
and
I'm
excited
to
hear
what
you've
got
on
in
store
today.
Thank
you
for
organizing
this.
C
I'm
Peter,
so
I
guess
my
claim
to
pay
him
here
is
my
the
creator
of
Calvin
and
yeah
other
than
that
and
the
big
closure
plan,
and
also
I
guess:
I'm,
not
usually
using
closure
so
much
for
data
analysis
and
and
the
things
that
often
a
topic
for
this
group,
but
I'm
super
interested
in
in
the
use
case
and
and
yeah
so
that
Lucas
now
I
am
others
in
the
calendar
team
can
can
support
using
closure
with
calva
for
for
data
analysis
or
whatever
you
guys
do.
So.
F
B
A
The
wonderful
it's
so
nice
to
meet
are
you
related
Maybe,
yeah,
yeah,
that's
beautiful,
so
nice
to
eat.
Thank
you.
I'm
Danielle
I.
Do
statistics
mostly
and
a
little
bit
involved
in
organizing
study
groups
in
the
closure
community
on
a
little
bit
of
related,
tooling
and
I'm
so
much
interested
in
these
projects
we
discussed
today,
just
because
they
are
so
much
relevant
to
some
of
the
workshops
and
study
meetings
were
planning
and
Ben.
Would
you
like
to
tell
something.
G
Sure
hi
I'm
Ben
I'm,
like
a
closure,
Enthusiast,
I,
guess
and
I
started
when
I
learned
started,
learning
closure,
I
guess
about
four
months
ago,
I
was
using
emacs
and
once
I
understood
how
Rebel
driven
development
works,
I
switched
to
vs
code
and
Galva,
and
it's
just
been
really
really
wonderful
to
use
and
it
makes
writing
code
super
fun.
So
thank
you
to
Peter
and
Lucas
and
Chris
as
well.
I
just
started
using
portal,
so
I'm
excited
to
be
here
and
learn
more
thanks.
A
E
But
since
I'm,
not
a
data
scientist
I
like
I
care
about
the
community
a
little
bit
but
I,
don't
use
that
stuff
myself.
In
that
context,
I'm
more
interested
in
seeing
like
I
said
earlier.
The
the
results
of
my
executions
in
a
more
Rich
format,
like
the
rebel,
is
really
nice
and,
like
it's
nice,
to
see
the
data
but
like
I
can't
do
extra
stuff
with
it
like
I,
can't
show
it
as
a
table.
E
I
can't
show
it
as
a
graph
I
can't
whatever
like
a
lot
of
extra
stuff,
plus
the
inline
way
of
throwing
it
in
Visual.
Studio
code
is
pretty
limited.
We
can
like
show
one
line
or
maybe
two
and
which
is
really
annoying
like
we
just
don't
have
the
access
into
the
visual
studio
API
to
do
it.
So
notebooks
is
a
way
around
that.
For
me,
at
least
where
I
can
basically
show
anything,
I
want
in
between
two
lines
of
closure
code
and.
E
Why
we
built
our
notebooks
is
also
a
little
bit
different
from
other
namespace
based
notebook,
thingies,
that
we
have
enclosure
like
Clerk
or
whatever,
where
it's
usually
like
in
something
like
rock.
You
would
like
have
your
namespace
and
then
a
bunch
of
things
that
actually
execute,
but
when
I
work,
I
can't
like
put
executing
stuff
into
my
namespace
right,
other
devs
would
kill
me
on
the
project.
That's
mostly
like
here's,
the
adaf,
here's,
the
def,
here's,
the
death
and
here's
a
deaf
and
whatever
and
then
I'm
done
now.
E
C
E
Yeah,
like
at
least
like
I,
don't
use
something
like
lurk
very
much
either
I'm,
just
like
going
from
the
examples
and
stuff
I
see
online
from
other
people
using
it.
That
is,
it
usually
looks
like
well
I'm
gonna,
like
Define
a
little
bit
of
data,
then
I'm
gonna
run
a
function
on
it
in
the
same
namespace,
then
I'm
going
to
run
another
function
whatever.
E
A
E
A
A
E
E
E
You
can
just
connect
to
the
rebel
you
do
with
like
you,
like
you,
usually
develop,
and
then
you've
got
like
your
normal
files.
Well,
I
mean
you
probably
don't
write
your
code
as
bad
as
we
do
in
our
testing
environment,
but
maybe
who
knows,
but
as
you
can
see
in
here,
this
is
just
a
normal
namespace
and
the
things
that
I
meant
with
like
executing
code
are
like
this
full
thing.
E
You
wouldn't
usually
have
that
in
the
namespace
right
because,
like
you,
don't
want
this
to
run
on
Startup,
you
want
this
like.
Maybe
you
do
but
like
usually
you
don't,
and
so
you
would
have
this
in
comments,
but
other
than
that.
That's
a
normal
namespace
right
and
a
normal
closure
file.
There's
nothing
special
in
here
and
the
idea
being
now
that
you
can
just
right.
E
E
When
you
do
this
well,
food
doesn't
have
very
much
of
a
result
because
it's
just
printing
and
whatever
map
does-
and
it's
pretty
big,
can
I
still
scroll
yeah,
it's
a
pretty
big
result,
but
at
least
I
can
get
it
in
line.
If
I
do
the
same
thing
in
here
and
execute
this
I
get
all
of
this,
which
is
like
yeah
sure
like
I,
can
see
a
tiny
bit
of
that.
E
But
we
can't
see
the
whole
thing
and
I
wanna
like
see
the
whole
thing
and
now
I
would
have
to
go
into
the
rebel
and
look
at
that
and
then
there's
like
it's
printed
weirdly
and
whatever
you
can
set
all
that
that
up,
but
I'd
like
to
see
the
result
right.
Next
to
the
thing
right
and
in
here
we
have
the
possibility
to
actually
show
that
yeah
anyway,
we
can
run
a
bunch
of
other
stuff,
which
is
not
super
interesting.
The
interesting
bit
is
down
here.
E
So
you
can
now
have
Rich
comments
in
your
account
and
like
to
the
documentation
in
there
or
whatever,
and
we're
already
used
to
having
this
there's
already
a
bit
of
portal
preview
here,
as
you
can
see,
Chris
is
going
to
show
you
like
how
this
looks
when
you
run
it
in
Portal,
but
probably
not
this
exact
example,
but
something
similar
and
yeah
as
I
said.
The
idea
behind
the
whole
thing
is
that
you
can
just
like
take
any
normal
closure
code.
E
D
E
C
E
Yes,
the
currently
these
are
the
three
things
I
put
in,
because
I'm
kind
of
lazy
and
I
don't
want
to
redo
the
work
that
other
people
already
did
so
I'm
gonna,
just
like
tell
Chris
to
like
integrate
with
that
and
he's
gonna
like
do
all
the
hard
lifting
and
I'm
just
gonna
sit
back
and
pretend
it's
all
mine
and
I
can't
so
tiny
preview
I
can't!
Well,
that's
not
super
interesting.
E
E
But
I
can
also
change
this
x.
Application
even
and
oh
I
seem
to
not
have
portal
installed
in
here
anyway,
the
idea
being
that
anybody
can
write
a
renderer
as
its
own
thing
for
a
vs
code.
That's
as
well
I
understand
this
x,
application,
slash
even
thing,
and
then
they
can
show
their
own
viewer
in
here.
So,
like
portals
stuff,
oh
no,
this
is
actually
already
running
a
portal
now
that
I'm
seeing
this
yeah.
This
is
already
a
portal
stuff.
Well,
this
is
not
I.
E
Yeah
yeah
yeah,
so,
as
you
can
see,
we're
already
like
sending
this
in
Portal
and
we're
doing
this
by
just
having
portal
installed.
But
Chris
is
going
to
talk
more
about
this,
but
we
could
have
like
a
bunch
of
our
own
viewers
in
here.
I.
Just
don't
really
see
the
point
and
when
it's
so
easy
to
like
integrate
with
somebody
else's
stuff,
we
don't
need
to
reinvent
the
wheel,
the
wheel
here
and.
D
E
B
C
E
C
F
E
And
have
a
lot
of
test
cases,
but
there's
probably
a
few
ways
where,
like
when
you
save
in
the
notebook
there's
gonna,
be
like
a
tiny
bit
different.
It's
mostly
around
white
space,
usually
when
saving
to
a
closure
file.
But
if
it
comes
out
differently,
it's
a
bucket.
We
can
fix
that,
but
most
of
the
craziness
that
you
can
do
should
come
out.
Fine.
E
The
one
thing
that's
like
still
a
major
thing:
that's
missing
in
the
notebooks
themselves
is
integration
into
into
closure
LSP.
So
you
don't
get
all
the
special
tooling
like
find
reference
or
Auto
completes
or
whatever
the
like,
that's
being
actively
worked
on
and
like
it
should
hopefully
arrive
soon
in
a
straight
Mark,
but
other
than
that,
like
every
other
calva
thing
is
working
in
there,
which
is
really
nice
and
yeah.
E
C
Yeah,
that's
a
great.
There
was
a
discussion
Twitter!
Okay!
Maybe
it
was
yesterday
or
like
someone
highlighted
this-
that
it
that
it
is
a
bit
tricky
with
just
a
regular
textile
and
regular
repo
output
to
to
work
when
the
data
gets
big.
It's
hard
to
work
with
it
and
and
people
are
showing
in
like
a
portal
and
and
everything
in
there,
and
this
I'm
super
interested
in
here
with
Princess
about
that.
But
but
it
looks
really
awesomeness.
C
C
E
Yeah
I
usually
like
have
portal
just
open
in
another
monitor
and
like
always
tap
a
bunch
of
stuff
over
there,
but
then
you've
got
like
50
values
on
the
different
screen
and
it's
difficult
to
jump
in
between
those
right
and
I'm.
Already
having
the
my
text,
editors
displaying
my
code
right
and
I'm,
jumping
between
different
values
in
the
code
and
now
I'm
sending
them
tapping
them
over
now.
E
I
need
to
find
them
in
Portal
and
whatever
it's
nice
when
I
have
the
notebook
where
the
value
is
right
next
to
the
actual
content
of
their
value,
but
I'm
still
getting
the
full
Rich
interaction
with
the
actual
content
and
not
just
well.
Here's
a
bunch
of
text
that
usually
isn't
doesn't
fit
on
your
screen,
because
it's
some
huge
hashmap
or
whatever
yeah.
E
Like
you
have
with
you're
just
playing
basically
a
normal
closure
file
as
a
notebook,
but
when
you
hit
save
it's
just
like
it,
it's
just
saving
to
the
same
file
like
I
initially
saw
the
namespace
as
a
text
editor
right
and
then
opened
it
in
a
notebook.
If
I
had
changed
a
bunch
of
stuff
and
hit
save,
it
would
have
saved
to
that
same
file
and
hopefully
not
destroyed
any
stuff
with
like
a
white
space
or
whatever.
E
E
A
F
Well
wait
so
you
guys
can
CVS
code
right
now:
okay,
the
little
green
things
that
showing
up
so
I'm,
not
sure,
okay,
but
yeah
I'll
share
some
updates
about
portal,
if
there's
time
but
yeah
so
I
think
the
the
really
nice
thing
about
this
setup
is
that
you
only
have
to
do
two
things
install
the
kalva
extension
install
the
portal
extension
in
vs
code
and
then
you're
like
good
to
go.
There's
there's
no
other
setup
required.
I.
F
Think
that
can
kind
of
be
like
an
issue,
especially
for
newer
users,
is
coming
in
they're
like
okay,
I
need
to
install
this
and
I
have
to
connect
it
to
that
and
then
I'm
getting
errors
and
I.
Don't
know
what
to
do
so.
Hopefully
what
this
does
is
give
them
like
a
very
streamlined
way
to
get
their
environment
set
up,
but
yeah
so
kind
of
like
Luke's
presentation.
I
have
a
closure.
Notebook
I
have
a
little
helper
here.
F
Now
you
can
see
that
I
have
all
these
blocks
and,
like
kind
of
like,
similarly
with
what
Lucas
said,
you
can
start
to
evaluate
so
kind
of
here's.
Here's
like
the
a
first
example
of
kind
of.
Let
me
show
you
what
it
would
look
like
with
the
default
presentation
or
I
guess
the
text
plane,
presentation
right
which,
like
it's
kind
of
readable,
but
it's
like
not
structured
in
a
nice
way
and
I'm
like
well
I-
have
a
viewer
in
Portal
exactly
for
this
type
of
data.
F
So
if
I
change
it
back
to
portal
here
and
it,
the
really
interesting
thing
is:
there's
two
levels
of
dispatch.
There's
like
you
can
choose
the
presentation
from
the
vs
code
side,
but
then
also
portal
has
a
bunch
of
presentation
options
as
well,
so
on
the
right
over
here
you
can
see
that
there's
different
ways.
F
But
yeah,
you
can
kind
of
see
all
the
different
data
types
of
supports.
A
lot
of
the
closure.
Idioms.
Sorry
not
close.
The
portal
UI
idioms
are
kind
of
brought
over
into
the
medium
of
notebooks,
so
you
can
kind
of
collapse
and
expand
it
still
with
space.
You
can
open
up
the
command
menu
and
choose
for
toggle
expand,
which
is
what
I
was
doing,
which
is
spacer
e,
so
you
can,
you
can
still
like
select
data
run,
run,
commands
I'm,
not
sure
who's.
F
F
So
this
is
a
feature
that
is
considered
in
in
portal
for
a
long
time
and
I
kind
of
have
like
an
implementation
for
it
here
for
notebooks
I'm,
not
sure.
If
I'll
keep
it,
it
seems
to
work
relatively
well,
it's
kind
of
nice
to
be
able
to
be
like.
Let
me
focus
in
on
this,
but
it
kind
of
gives
you
like
a
very
quick
and
dirty
way
to
kind
of
go
from
your
code
evaluation
and
then
just
like.
We
actually
do
this
other
thing
really
quickly.
F
With
the
data
selected
in
hand,
because
sometimes
you'll
have
like
a
big
piece
of
data
and
I
can
come
up
here
and
change
the
code
to
select
it
or
I
can
literally
just
click
it
and
then
click
this
is
it
yeah
it's
and
then
I
can
do.
Let's
see
Vector
so
I
have
two
elements
in
my
hand
and
I
call
Vector.
F
F
You
can
use.
Actually
that's
probably
the
main
thing
that
I
don't
have
over
here,
because
I
don't
know
how
I
wanted
to
do
it,
but
you
kind
of
get
the
more
full-fledged
UI
and
it's
based
on
what
you
have
selected
as
well.
So
if
I
just
select
one
and
I
click
open,
it'll,
just
select
it'll,
just
open
up
that
value,
which
is
nice
right,
because
sometimes
you
want
to
be
like
take
this
over
here.
Let
me
do
some
other
stuff
with
it.
F
F
Let's
see,
look
let's
go
through
some
more
of
the
interesting
viewers.
So
let's
is
this
one
interesting
it's
it's
kind
of
interesting.
It
kind
of
demonstrates
some
of
the
special
viewers
that
portal
has
so
portal
has
like,
like
general
purpose,
viewers
for
like
maps
and
stuff,
but
then
some
data
structures
you
get
have
semantics
so
like
exceptions,
datify
a
certain
way
and
I
can
match
that,
based
on
a
spec
and
then
be
like.
Oh,
this
is
a
this
is
an
exception.
Let
me
render
it
in
a
better
way.
F
So
let
me
just
like
double
click,
this
real
quick.
So
the
the
this
is
what
exceptions
look
like
in
in
portal
and,
what's
really
nice
is,
if
you
use
something
like
ex
info,
you
can
supply
data
right,
arbitrary
data,
and
what
happens
is
that
you
can
like
grab
onto
that
data
within
the
portal
of
exception.
Viewer
right,
because
data
can
contain
more
data,
can
contain
more
data
right.
F
So
anyway,
it's
nice
when
it's
all
just
data,
so
that's
exceptions,
there's
another
thing
that
I
commonly
do
with
dates
is
like
yo,
you'll
have
an
instant
but
you're
like
when
was
that
so
this
is
like
a
little
helper,
I
have,
which
is
like
relative
time,
so
you
guys
can
see
that
I
generated
this
timestamp
49.
You
know
minutes
ago
what
else?
F
C
F
Oh
I
saw
a
hand,
but
I
was
like
oh
wait:
oops,
okay,
so
yeah
you
can
run.
You
can
run
select
keys
on
some
data.
So
I
want
to
select
this
this
and
this
and
then
I
click
enter
and
now
from
that
full-fledged
map.
I've
selected
those
values.
So
this
is
like
that
UI
from
the
full
fetch
photos
created
over
to
like
notebooks
and
then
you
can
go
back
to
like
where
you
were
and
then
you
can
also
do
another
one.
Just
so
she's
a
cool
closure
function.
F
F
So
portal
supports
like
special
strings.
So
it
knows
that
if
you
have
this
string
format,
it's
a
color,
so
it'll
render
the
color
it's
a
nice
little
helper.
Let's
see
diff!
So
there's
like
a
diff
viewer
in
in
portal,
which
will
take
data.
That's
like
in
a
list
of
things
and
it'll
diff
them
like
two
by
two
as
it
goes
through
them.
F
So
let
me
show
you
the
underlying
data
for
this
really
quickly
by
going
to
the
inspector
and
so
I
have
this
like
vector
of
values
and
I've
set
metadata
on
it
to
say:
hey
make
the
default.
Viewer,
the
diff
viewer
and
the
semantics
are:
take
this
value.
Take
this
value
and
like
dip
them
make
a
second.
So
if
I
do
that
and
I
go
to
the
diff
viewer,
this
is
what
it
looks
like
and
it's
showing
you
that
this
key
was
removed.
This
value
was
changed.
It
changed
from
this
to
this.
F
This
was
removed.
This
was
added
right,
so
I
I
like
this,
especially
for
like
UI
States,
so
I'll,
usually
like
tap
a
bunch
of
UI
States
I'll
have
like
State
one
state,
two
state
three
and
then
I
can
diff
them
all
to
be
like
what
has
changed
through
all
my
like
State
transitions.
Essentially
so
that's
kind
of
what
I
like
to
use
this.
This
viewer
for,
let's
see,
there's
some
other
viewers
that
I've
built
based
on
like
use
cases
that
I've
had
so
usually
when
you're
working
with
programs.
F
They
have
standard
output
and
standard
error
as
like
targets
for
output.
So
here's
like
this
thing,
I
call
the
P
reple
viewer,
because
it's
leveraging
like
the
format
of
p-reple,
which,
if
like
let
me,
take
that
data
and
put
in
a
table,
and
now
you
kind
of
have
a
sense
of
what
the
actual
underlying
data
structure
looks
like
it's
a
map.
Well,
I,
guess
let
me
go
to
petebrand
really
quickly.
F
F
So
you
can
have
you
kind
of
have
an
interlacing
of
standard,
half
and
standard
error
which
I
I
just
found
this
useful
for,
like
portals,
build
output
as
well,
so
I
can
output
like
Rich
stuff
from
my
build
but
yeah
it
looks
like
this
and
then
you
can
toggle
and
expand
it.
So
there's
some
other
data
structures
that
are
interesting,
that
I
use
daily,
which
is
like
logs.
F
So
logs
are
another
common
type
of
thing
that
you
interact
with,
which
is
like
here's,
the
thing
that
happened
in
when
you
know
here's
what
you
got
so
the
let
me
show
you
the
the
table
viewer
for
the
same
data.
This
is
what
it
looks
like
right.
You
have
all
this
information.
You
have
a
time.
You
have
a
run
time
which
is
kind
of
cool
I'll
use
that
to
like
show
this
icon
to
be
like
hey
this.
F
E
E
I've
got
like
a
million
things
coming
now
and
I
want
to
get
rid
of
some
of
them
and
I,
don't
know
what
this
one
is,
and
then
you
start
tapping
stuff
by
like
putting
it
into
a
vector
and
having
a
string
at
the
beginning,
yeah
just
to
like
still
remember
where
it's
coming
from
or
whatever,
and
that's
really
not
great
interaction
right
and
especially
because
tap
also
only
takes
one
value.
So
you
can't
even
just
put
a
string
and
the
thing
in
there.
E
You
need
to
now
wrap
it
in
a
vector,
and
then
the
vector
is
also
not
maybe
not
expanded,
initially
and
whatever,
like
there's
a
bunch
of
annoying
things,
and
if
you
just
like
log
it
with
a
portal,
you
get
a
way
nicer
interaction
with
it,
and
you
also
know
where
it's
actually
coming
from.
So
it's
easy
to.
Like
remove
it
or
like
find
the
value
you're,
looking
for
in
a
when
you're
tapping
a
lot
of
stuff
and
whatever
yeah.
F
F
There's
like
a
mapping
for
this
for
timber
timber
I'm,
not
sure
how
you
say
it.
I've
heard
many
pronunciations
right,
but
there's
like
closure
logging
tools
that
have
mappings
to
this
data
structure
and
you
can
leverage
those.
So
what
I
do
at
work
is.
We
have
our
like
logging
piped
to
portal
is
like
a
specific
instant,
that
instance
that
isn't
Taps
and
it's
it's
mapping.
Both
the
closure
and
closure
script
logs,
so
you
can
kind
of
see
an
interlacing
of
the
backend.
F
Did
this
the
front
of
the
disc
to
back
into
this
the
front
end
of
this
because
you
you
have
access
to
the
runtime,
but
it's
like
all
the
data
for
it
too
and,
like
the
UI,
isn't
doing
that
on
purpose
and
the
back
end
isn't
like
it's
all,
just
being
funneled
through
the
like
logging
stuff,
and
we
we
can
all
play
this
game
of.
If
you
have
the
right
data
you
can
use
for
this
viewer,
but,
like
I've
shown
here,
you
can
also
change
it
right.
F
You
can
you
say
no
I
I,
don't
want
to
see
it
this
way
right
now,
I
want
to
see
it.
This
way
right
now,
I
want
to
see
it
as
a
table.
It's
going
to
give
a
better
sense
of
what
it
what
it
looks
like
and
again
right,
I
showed
you,
the
relative
viewer,
so
I
should
be
able
to
click.
This
instant
and
I
should
be
able
to
change
it
to
relative
time,
so
this
was
16
years
ago.
F
F
This
is
a
long
time,
so
here's
another
interesting
viewer
which
it
will
take
the
data
structure
and
render
it
as
hiccup
via
reagent.
So
if
I
show
you
what
this
looks
like
as
a
tree
down
here,
so
this
data
right
here,
which
I'm
using
the
tree
viewer
to
display,
if
you
use
the
hiccup
viewer
to
display,
will
look
like
this
and
there's
there's
this
cheat
code.
It's
not
quite
hiccup.
It's
like
a
superset
pickup
in
that
you
can
go
from
normal
Dom
to
portal
inspector
viewer
stuff.
F
So
there's
like
a
recursion
happening
here,
where
you're
going
from
data
rendering
into
Hiccup
and
then
date
and
then
rendering
data
as
data
again.
So
if
you,
if
ever
you
want
to
be
like
okay,
this
is
actually
data.
Please
just
render
it
using
any
of
the
portal
viewers
that
you
have
available.
You
can
put
a
keyword
there
and
then
render
it
so
and
what's
really
nice
is,
then
you
can
in
your
hiccup
output.
You
can
select
it
and
then
change
stuff
like
pretty
print
or
the
soch
right.
We
saw
that
trick.
F
D
C
I
have
a
question
yeah,
so
so
this
you
are
blowing
my
mind
all
over
here,
but
let's
take
a
few.
Whatever
you
have
here,
it's
I'm
working
in
a
project
where
we
have
both
hiccup,
but
we
also
have
an
st
of
the
Dom
or
the
HTML
some
something
so
could
I
write
a
viewer
for
for
that
PST
directly
here
or
would
I
have
to
turn
it
into
hiccup
first
and
and
then
view
it
too.
F
Well,
so,
if
you
have
like
an
ASTM,
is
it
like
super
recursive
like
data
structure,
I
would
just
use
the
tree.
Viewer
I
use
this
one
a
lot
for
like
so
like
in
my
job.
We
have
a
lot
of
like
hiccup
htsls
that
aren't
hiccup
right,
but
they're,
inspired
by
hiccups,
they're
like
a
little
like
a
tiny
logic,
language
with
ands
and
ORS
and
other
keywords
and
I'll,
just
I'll
usually
dump
it
into
the
tree
viewer
because
it's
going
to
be
very
nested
and
that
that'll
usually
like
my
first
thing.
F
C
F
Oh
yeah
so
yeah,
if
it's,
if
it's
data,
that's
like
unknown
to
Pearl,
you'd,
have
to
write
a
viewer
to
it
or
you'd
have
to
transform
it
into
something
like
ready
to
write
a
viewer.
Okay,
yeah
I
have
documentation
that
I'm
writing
for
extensibility.
It
would
be
okay.
This
is
like
another
limitation
of
in
Notebook
integration.
Is
that
not
all
the
features
that
are
available
in
like
full
fetchbook
available
here
and
one
of
those
is
extensibility,
so
you
would
write
your
extension
on
like
the
full-fledged
portal.
F
You
won't
be
able
to
use
it
here
yet
right.
That's
like
potentially
future
work,
because
I
just
I'm
not
sure
how
I
want
to
do
it
yet,
but
right,
because
this
is
a
different
environment
and
it's
like
loaded
a
little
bit
differently.
So
there's
like
subtleties
to
that
yeah,
but
in
my
case
I
can
certainly.
F
Yeah,
thank
you.
Okay.
That
makes
sense.
Let's
see
so
there's
the
hiccup
viewer.
The
tree
viewer
this
markdown
viewer,
which
isn't
really
as
as
useful,
because
you
can
already
add
markdown
in
a
notebook.
But
if
you
had
a
string
that
you
wanted
to
render
it's
marked
down,
so
here's
the
portal
readme
rendered
as
a
markdown
right,
it's
just
the
entire
readme
and
you,
but
you
can
like
select
it.
You
can
expand.
That's
a
little
big!
You
can
collapse
it.
You
can
change
it
like
you
can
view
the
string
for
it.
F
You
can
view
it
as
text
yeah
text,
that's
like
another
viewer.
That's
kind
of
nice
to
have
is
like
take
this
string,
but
let
me
render
it
as
text
because
usually
text
might
have
some
white
space,
so
here's
the
actual,
like
markdown
source
for
it
and
oh
yeah,
so
like
right.
There
there's
the
the
way
to
change
the
viewer.
Is
you
like
click?
F
The
thing
you
want
to
change
the
viewer
for
you
go
up
here
and
you
have
this
like
list
of
things
to
change
it
or
you
can
use
this
command
right
here
called
select
viewer
which
is
V.
So
if
you
like
click
it
and
you
do
V
it'll
pop
this
up
and
then
you
can
filter
quickly
for
the
thing
you
want
so
I
wanted
like
inspector.
F
So
and
then
you
can
again
click
on
this
and
expand
and
collapse
it
with
space
for
E.
So
hopefully
there's
like
a
like
once.
You
learn
something
it's
useful
in
more
than
one
context.
That's
usually
like
how
portal
tries
to
structure
its
ux
is
like
teach
you
a
thing
once
and
then
let
you
leverage
it
as
much
as
possible.
So
one
of
those
is
expand
and
collapse.
F
Here's
the
exception
viewer
again,
which
we
don't
need
to
go
through
because
I
already
went
through,
but
it's
nice
right
because
you
can
have
data
in
it.
The
test
report
viewer
is
kind
of
something
I've
been
working
on
stuff
using
for
a
bit
which
is
like.
So
when
you
run
tests,
closure
will
generate
this
type
of
data
for
you.
Let
me
go
to
P
print
first,
and
this
is
what
it
looks
like
there's
like
a
vector
of
maps
and
they
represent
like
the
oh.
Do
you
sorry
do
you?
E
F
E
F
No
so
I
haven't
I
haven't
done
that
because
usually
what
I
would
say
is
like
if
you
have
something
that's
super
nested
you
and
you
want
to
see
a
lot
more
of
it
at
once.
I'd
say:
try
the
tree
viewer
right,
because
then
you
can
kind
of
get
a
better
sense
of
it
all,
because
that's
that's
the
big
distinction
between
the
default
inspector
and
the
tree
viewers
when
you
want
to
see
more
stuff
at
once,
but
I
don't
know
if
that's
a
good
answer
for
a
lot
of
people
like
maybe
that's.
F
E
Think
it's
nice
a
lot
of
the
time
but
like
if
you
specifically
want
to
see
it
in
in
the
viewer
that
you
need
for
like
some
sub
stuff
right.
It's
not
super
helpful
to
like
have
it
in
a
tree
because,
like
then
they're
like
everything
is
in
the
tree,
you
can't
have
like
bits
of
it
be
in
different
kinds
of
years
yeah.
E
So
it
would.
It
would
be
nice
to
just
have
a
command
like
expand.
All
children
like
don't
expand
everything,
of
course,
because,
like
yeah,
one
of
the
nice
things
about
bottle
is
that
it's
also
like
being
able
to
Lazy
load
stuff
and
like
not
explode
through
your
thing
and
then
we'll
destroy
it.
But
like
expand,
children
like
and
you
kind
of
need
to
know
what
you're
doing.
F
Yeah
yeah
no
I
could
definitely
see
like
how
that
could
be
very
useful,
so
so
stuff
to
look
into.
But
it's
it's
good
feedback,
though
okay
but
yeah.
So
the
test
report
viewer
takes
the
data
that
you
get
and
we'll
there's
like
a
a
common
theme
here,
which
is
like,
like
there's
a
lot
of
sources
of
data
in
your
like
development
life
cycle,
whether
it's
like
Standard
air
standard
out
from
processes
or
log
data
or
test
data.
F
One
of
the
things
I've
really
been
trying
to
do
is
like
taking
data
that
already
exists
and
that's
everywhere
and
like
just
having
a
little
bit
nicer
way
of
viewing
it.
So
this
is
an
example
of
like
taking
the
test,
output
and
kind
of
giving
you
a
way
to
visualize
it
a
little
bit
nicer
because
right.
So
this
is
what
it
looks
like
as
the
inspector
and
then
here's
what
it
looks
like
it's
a
test
report
and
you
can
kind
of
go
through
and
you
can
see
like
Okay.
So
this
failed.
This
succeeded.
F
F
Let's
see
and
I
I
wanted
to
throw
one
more
thing
is
like
which
is
there's
like
there
is
Vegas
support
too
so
like
if
I
come
over
here.
So
you
usually
a
lot
of
people
get
leverage
from
doing
stuff,
with
big
and
bigger
light
to
render
charts
and
stuff.
So
if
I
go
to
the
tree,
viewer
you'll
see
that
this
is
a
Vega
data
structure
which
has
its
own
like
semantics,
and
everything
like
that.
F
So
that's
kind
of
the
more
data
sciencey
like
it's
it's
weird,
because
portal
is
like
a
data
visualization
tool,
but
not
so
much
as
in
the
like
traditional
sense
of
data.
Visualization.
There's
like
a
lot
of
Dev
specific
viewers
here
right,
but
you
can.
We
can
still
use
other
things
like
vegan
Mega,
light
with
everything
right,
so
I
think
that's
pretty
much
all
the
demo
I
had
yeah.
Those
are
all
the
interesting
viewers.
E
E
F
F
This
is
for
people
who
are
curious
about
how
they
can
Implement
their
own
present
presented
things
yeah.
If
I
go
to
the
package
Json.
No,
that's
the
package
lock,
that's
not
useful!
Json!
Inside
of
vs
code,
you
add
a
notebook
render
section
under
your
contributes,
and
you
say
for
this
mine
type,
which
is
what
Lucas
was
saying
earlier
right
at
X
application
Eden,
which
means
you're
going
to
get
a
string
of
Eden,
and
you
can
do
whatever
you
want
with
it
and
what
I
say
is
hey
call
this.
F
F
Which
extent
I
think
if
I
do
notebook
there
we
go.
So
this
is
what
the
actual
this
is:
the
entire
implementation
of
the
integration.
Everything
else
is
like
portal
specifics.
This
is
the
vs
code.
Specific
bits
is
you,
you
have
these
two
functions
activate
and
reload
and
when
what
you
do
is
the
archive
function
returns?
This
JavaScript
object
that
has
render
output
item
and
all
I
do
is
I.
F
Take
the
text
from
the
day
that
they
gave
me
and
I
parse
it
as
Eden,
and
then
I
just
render
it
with
all
the
hiccup
or
all
the
reagent
stuff
that
already
exists
in
in
portal
to
the
element
that
they
also
give
you.
So
this
is
essentially
all
you
have
to
do
is
like
you,
you
get
a
string,
it's
presumably
Eden
you
parse
it,
and
then
you
can
do
stuff
with
it
here,
I'm
just
rendering
to
the
Dom.
F
This
act
thing,
which
is
just
doing
some
portal
specific
stuff
right,
but
this
is
not
a
lot
of
code
right.
That's
the
nice
thing
here
is
like
I'm,
mostly
pulling
in
stuff
that
already
existed
in
the
portal
UI
source
code
and
I'm
just
gluing
it
together,
and
then
it
like
what's
really
nice
here-
is
that
any
bugs
I
fix
in,
like
the
mainline
portal
automatically
like
propagate
here
like
this,
was
a
very
easy
integration.
F
I
did
have
to
like
this
ux
was
special
for
notebooks
and
stuff
over
here,
so
I
kind
of
figured.
How
I
wanted
to
do
that
to
kind
of
take
full-fledged
portal,
which
is
this
is
what
it
looks
like
by
default
right,
there's
like
a
lot
more
UI
to
it
and,
like
you,
don't
want
to
see
this
again
and
again
and
again
and
again
for
every
result.
You
don't
want
to
see
this
guy
and
this
guy
so
trimming
that
down
was
a
little
bit
of
work,
but
other
than
that.
E
Yeah
so
like
most
of
the
tooling
from
other
notebook
kinds
are
already
based
on
that
right,
where
they
get
like
some
kind
of
closure
data,
which
is
usually
like
something
even
style,
and
they
produce
some
kind
of
JavaScript,
whatever
craziness,
and
now
they
can
just
like
hook
into
this
as
well,
where
it's
like
they
don't.
They
need
to
write
like
what
is
this
like
44
lines
of
code,
which
is
mostly
like
Euler
plate
copy
paste
stuff
and
they
can
integrate
it
with
it.
Don't
like
perfectly
probably
not
right.
E
Like
you
said
you
didn't,
you
did
some
special
stuff
to
not
have
the
same
output
but
yeah
like
sugar
on
top
right
I
mean
you
didn't
have
to
do
that.
It
would
have
like.
Initially,
when
I
came
to
you
and
said,
can
we
have
the
portal
viewers
in
there?
I
was
completely
fine
with
like
having
the
actual
full
portal
integration
in
there,
and
that
would
already
have
been
great
doing
some
extra
stuff
to
it
like
to
slim
down
your
eyes
really
just
like
extra.
F
D
A
It
is
what
I
guess.
One
part
of
this
is
just
how
to
write
this
code.
Extension
right.
Another
part,
is
how
to
communicate
with
kalva
notebooks
and
another
one
is
how
to
use
Photo
as
a
UI
library
in
a
way
right
and
yeah,
and
then
you
know,
I
see
you
use
reagent
and
then
I'm
wondering
which
one
of
these
is
actually
responsible
for
the
choice
of
reagent,
which
one
of
these
is
actually
responsible
for
mounting
the
Dom.
F
Yeah,
so
to
like
clarify
right
that
the
yeah
from
the
vs
code
side
right
there
is
well
so
I,
don't
know
it
was.
It
was
an
advantageous
position.
The
portal
was
in
because
it
already
had
a
vs
code
extension
right.
It
made
this
much
easier
if
I
had
to
start
by
building
an
extension
first,
it
would
have
been
a
little
bit
harder,
but
so
building
an
extension
right.
There's
like
a
ton
of
stuff
online,
but
you
like
have
this
package
Json
and
it
specifies
like
all
this
stuff.
F
F
So
once
you
connect
that
dot
of
like
AVS
code,
here's
a
notebook
render
here's
the
Mind
type
I
support.
Then
we
go
into
Shadowland,
which
says
okay
to
build
that
esm:
module
right.
Here's
the
namespace
right
here,
portal,
extensions,
vs
code,
notebooks,
so
here's
so
then,
then
we
go
into
there
right.
So
if
we
like
thread
the
needle,
we
like
go
there
so.
A
E
You're
welcome
to
one
tiny
little
bit
where
you
set
X
application,
even
which
I
think
that's
not
actually
a
thing.
That's
what
we
both
like
agreed
to
like
call
the
data
type,
the
mime
type
right
coming
out
of
cover
notebooks
and
that's
actually
all
there
is
to
the
basically
thing
that
you
need
to
agree.
Initially,
this
calvar
produces
this
x
application.
Even
mime
type
and
saying
well,
I
need
a
renderer
for
this
thing
and
whoever
wants
to
do
it
I,
don't
care
you!
E
It's
all
up
to
you
and
anybody
else
in
your
vs
code
can
say
well.
I've
got
like
a
renderer
for
this
thing,
and
please
give
me
that
data
I'm
gonna
do
the
thing
and
Chris
was
like
the
first
one
who
said
well.
I've
got
a
thing
that
can
render
Eden
and
that's
basically
all
he
had
to
do
to
like
get
the
data
and
I'm
getting
back.
Basically,
his
well
I'm,
not
even
like
getting
it
back
like
at
this
point.
C
E
Yeah
so
like
there's
already
a
bunch
of
renders
included
like
the
ones
that
were
that
I
showed
initially
like
the
HTML
and
the
the
markdown
viewer
and
like
the
text
viewer
like
there's
a
few
of
them
already
and
all
I
had
to
do
like
to
get
these
displayed
is
to
say
well.
This
I've
also
got
this
data
and
these
types
so
I'm
actually
like
when
you
run
one
of
the
excels
I'm
taking
the
result
of
enrapple
and
saying
well.
B
E
E
E
Read
that
word
with
the
integration
and
portal
right
or
like
into
anything
because,
like
we
said
I'm
just
giving
you
the
Eden,
that's
coming
out
of,
unravel
and
telling
you
well,
please
like
render
this
in
some
kind
of
fashion
and
you're
now
saying
well
cool.
This
is
what
I
want
to
render
it
as
you.
E
C
D
C
E
F
But
also
like
they
Define
nav,
like
so
portal,
will
support
that
you
can
Implement
like
your
own
datify
in
your
own
nav,
but
it's
on
objects
and
or
it's
like
you
have
a
function
on
like
in
a
map,
but
those
things
when
you
sterilize
them
is
Eden.
You
lose
all
the
in-memory
stuff,
so
anything
that's
based
off
of
having
in-memory
reference
in
a
live
runtime.
Anything
like
that.
It
will
doesn't
currently
work.
B
E
More
run
long
whatever,
where
it's
like,
how
can
we
get
the
data
to
like
be
more
connected
to
the
thing
where
it's
coming
from
right?
For
usually
it's
the
jvm,
but
I
mean
it
could
be
a
closer
script
environment
which
would
make
it
even
crazier,
but
whatever
and
the
thing
that
present
I
came
up
with
after,
like
having
a
long
discussion
of
like
who's
supposed
to
do
it
and
whatever,
like
we
had
a
few
different
ideas,
but
in
the
end
we
thought
it
kind
of
makes
sense.
E
If
the
library
displaying
the
thing
is
kind
of
responsible
for
printing,
nothing,
because
then
it
can
print
whatever
it
wants
and
like
only
parts
of
the
data
are
more
data
or
it
can
even
send
execution
stuff
along
with
it
right.
Soldiers
has
the
nice
thing
that,
like
the
execution
of
the
thing
just
looks
like
Eden
right,
so
Chris
could
send
function,
calls
basically
to
the
cell
instead
of
sending
the
data.
E
So
our
ideas
that
we
have
like
a
tiny
hook
in
Copper,
where
you
can
say
well
I,
want
to
be
like
enable
portal
enable
whatever
and
then
we're
gonna
like
look
either
like
put
the
portal
extension
Into,
the
Depths,
even
ourselves.
So
like
say
the
user
has
to
do
it
like
they're,
smart
enough
themselves,
whatever
like
we
can
go
a
little
bit,
hacky
for
version,
one
right
and
instead
of
running
the
Evo
through
the
normal
eval
of
enrapple.
E
E
That's
where
this
is
going
to
write
and
and
specifically
just
for
this
notebook
environment
and
Chris
can
now
Zen
special
stuff
along
with
the
actual
stuff,
because
he
knows
that
the
value
is
going
to
arrive
at
his
own
viewer
right
and
it's
not
gonna
write
at
like
some
normally
even
Euro,
like
on
whatever
that,
like
doesn't
understand
what
he's
sending
along.
He
just
he
doesn't
even
have
to
send
like
the
actual
value.
F
No,
no
I
think
I
think
it's
still
like
in
the
planning
phases,
but
the
the
idea
right
is
that
the
the
notebook
environment
isn't
as
Rich
yet,
but
we
plan
to
hopefully
make
it
better
and
by
training
as
like.
A
printing
problem
is
one
potential
solution,
because
then
other
implementations
that
can
like,
like
maybe
a
clerk,
wants
to
bring
their
viewers.
Well,
they
can
just
write
their
own
print
function
and
serialize
the
data.
However,
they
want.
A
A
G
F
Like
you
have
like
a
string
that
represents
the
syntax,
you
would
pass
the
guinea
plot
and
then
to
render
it
you
call
like
I,
guess
it
yeah
so
with
portal
you
can
provide
in
this.
This
doesn't
work
in
notebooks
right,
but
yeah.
You
can
provide
your
own,
like
viewers
and
they're
just
reagent
functions
that
take
in
data
and
render,
however
they
want.
F
E
But
it
should
also
like
the
nice
thing
about
portal.
Is
it
like,
unless
we're
like
in
the
notebook
environment-
and
hopefully
it's
gonna
work
there
as
well,
but
it
can
call
back
into
the
jvm
right.
So
in
theory,
you
can
like
have
a
viewer
that
calls
back
into
the
jvm.
That's
the
jvm
run
something
in
your
shell
and
gets
the
data
from
that
shell
run
back
into
Portal
portal.
Already.
Does
that
a
bunch
itself
like
Chris,
said
for
the
enough?
What's
what
are
they
called
the
navigation
things
in
jail,
terrarium.
F
Yeah
you,
you
can
register
a
VAR,
it's
like
a
command.
So
that's
what
I'm
thinking
this
is
documentation
which
I'm
working
on
currently
but
yeah.
You
could
register
like
a
VAR
as
like
a
command
and
then
your
extension
in
the
UI
could
execute
that
and
the
reason
why
you'd
want
it
as
a
command
is
so
that
people
could
then
do
that
for
arbitrary
data
and
I'm,
assuming
you'd
have
a
string
in
hand
and
you'd
pass
it
to
this
function.
A
Okay,
yeah,
wonderful,
maybe
another
question:
Chris
I
I
think
you
know
I'm
thinking
about
really
really
possibly
using
it
for
study
sessions
and
workshops
and
and
then
there
are
two
things
we
could
hope
for.
One
of
them
is
being
able
to
render
a
whole
notebook
as
an
HTML
page.
You
know
to
show
it
in
a
blog
post
or
something.
Another
thing
is
to
somehow
make
it
accessible
to
people
who
use
maybe
emacs
with
cider,
say
right
and
I.
E
A
F
Of
yeah,
if
if
so,
what
I'm
thinking
is
you'd
have
like
a
JavaScript
someone
in
there,
you
could
pull
down
into
your
web
page
and
it
presents
like
an
embedding
API,
because
then
what
I
could
do
is
use
that
within
clerk.
If
you
want
to
use
some
of
the
portal
viewers
in
there,
you'll
be
able
to
pull
it
in
and
you'd
have
a
JavaScript
API.
You
could
use
to
say,
render
this
Eden
string
or
this
JavaScript
value
or
something
right
kind
of
like
how
we
did
for
the
notebooks.
F
You
right,
you
would
import
this
Library
get
this
JavaScript
API
and
say
render
this
here
and
then
so.
You
would
do
a
little
bit
of
gluing,
but
it
would
be
really
easy
to
embed
it
anywhere
right,
whether
it's
in
a
clerk
notebook
or
a
HTML,
published
page
that
you
have
that
you
just
want
to
use
some
of
the
viewers
in
but
yeah
giving
it
like
an
I
want
to
call
it
like
an
embedding
API.
E
Yeah
I
think
it
would
also
be
nice
if
we
could
get
the
color
notebooks
to
like
produce
HTML.
That,
basically,
like
is
the
representation
of
the
thing
that's
showing
right
now,
I
think
on
the
portal
side,
not
very
much
would
have
to
change,
would
be
more
like
on
the
cover
side,
where,
like
we
need
to
like
produce
this
as
an
HTML,
now
yeah.
F
But
apparently
you
have
like
in
in
Portal
stuff,
you
have
like
copy
Json
copy,
Eden
copy
it'd,
be
really
cool,
I
think
to
have
copy
HTML,
which
would
give
you
like,
like
a
at
a
self-contained
HTML
document
that
you
could,
then
it
would
be
static,
but
you
could
you
could
paste
it
anywhere
or
you
could
share
it.
You
can
do
whatever
you
want.
E
E
A
B
E
C
C
E
Probably
yeah
I
mean
that
I
think
it
wouldn't
make
it
harder
than
it
already
is
so
yeah
it
kind
of
like
vs
code
is
sometimes
annoying
around
where
it's
like
well.
This
should
be
super
easy
because
it's
already
like
there
and
like
they
can
do
it,
but
then
you
just
don't
have
the
API
or,
like
you
have
the
API,
but
it's
private
or.
A
A
G
B
G
E
Those
notebooks
here
showed
us
like
a
little
bit
of
weirdness
around
like
calling
back
and
forth
and
like
displaying
stuff
differently
or
saving
and
preserving
white
space
or
whatever.
But
mostly
it's
not
super
crazy
and
it's
gonna
be
nice
when
we
put
some
more
time
into
it
to
like
get
all
the
other
kalva
goodness
into
the
code
cells
as
well,
because
right
now,
we've
been
mostly
talking
about
like
the
output
cells
right,
but
in
the
end
we're
still
just
writing
code,
and
so
the
code
cells
should
also
get
some
nice
sugar.
E
D
F
I'm
also
really
excited
and
I'm
I
felt
like
it
wasn't
too
hard
getting
all
this
working,
but
I
feel
like
ironing
out
like
the
ux
and
like
like
making
it
so
people
like
want
to
use
this
all
the
time
I
think
is
what
I
want
to
work
towards
so
like
yeah.
For
that,
that's
what
I
want
feedback
on
is
like
what
isn't
working
because
like
right
now,
everything
that's
in
there
is
just
gases.
F
F
E
C
I
want
to
give
you
all
that
feedback
I,
also
just
seeing
when
you
demoed
it
Chris
I
mean
the
the
ux
made
total
sense
to
me
so
but
of
course
you're
an
expert
on
it,
so
yeah
maybe
tainted,
but
I
I
think
it
was
like
genius
ux,
especially
the
thing
you
didn't
bring
like
a
mini
portal
in
in
there
in
every
cell
yeah.
It's
it's
great
so
but
I
I
would
love
to
to
yeah
to
actually
just
be
using
this
in
my
daily
daily
hacking.
C
E
Probably
produced
like
a
quick
video
of
how
to
get
all
of
this
running
from
a
naked
musical
right,
because
that's
super
easy.
Actually
you
only
like
you
install
yes,
you
install
vs
card,
you
install
kalva,
install
the
portal
extension
I
have
all
that
installed,
yeah
and
then
you're
already
done
right
because
you
right
click
any
CLG
file.
While
you
have
a
rebel
running,
you're
gonna
get
the
notebook
and
you
can
click
the
thing
and
you
get
the
portal
things
in
between
and
then
nice
thing
like
I
said
as
well.
E
E
At
the
bottom
and
get
the
stuff
and
I'm
right
now
trying
to
get
some
of
our
namespaces
at
work
where
the
bottom
Bridge
comments
are
kind
of
documentation
for
the
data
structures.
When
you
open
the
thing
in
the
notebook
in
calvar
you'd
get
like
totals
displaying
the
data
structures
in
a
nice
way,
and
you
don't
like
yeah,
then
you
can
play
around
with
that
inside
of
it.
I
didn't
have
like
super
a
lot
of
time
to
play
with
it
yet
but
yeah,
it's
already
looking
pretty
nice.
C
So
it's
another
thing:
I
just
want
to
mention
that
when
I
saw
saw
the
like
test
reporter
stuff
there
and
the
disputes
and
all
that
we
have
this
very,
very
nice
and
promising
like
a
test
Runner
thing
in
in
Cala,
but
it's
hard
it's
a
bit
hard
for
us
to
to
maintain
I,
think
because
it
it
takes
a
lot
of
effort
to
bring
it
to
the
at
some
Next
Level.
So
it's
it's!
C
It
looked
a
bit
like
like
similar
to
how
I've
been
a
bit
stressed
about
Cowboys
a
bit
bad,
a
tunneling,
large
data
structures.
So
then
most
often
people
have
to
use
something
else
if
they
have
that,
but
now
portal,
and
especially
with
this
integration,
look
like
takes
that
all
the
way.
No,
no,
now
you
can
nothing
you
can
use.
Color
and
portal
will
take
care
of
that
that
use
it
beautifully.
C
E
D
F
F
So
one
of
the
things
that
I
didn't
cover,
but
there's
interruple
middleware
that
exists
in
Portal
that
you
can
add
and
one
of
the
cool
things
it
does
is
if
you're
evaluating
a
test
form,
it
will
capture
test
output
for
you
by
default
and
make
it
available
with
the
test
report.
Viewer
and
all
you
have
to
do
is
Eve
out,
like
I.
Think
one
of
the
things
I
forget
is
like
what
what's
the
what's
test
command,
how
do
I?
How
do
I
run
this
test,
but
not
that
test
and
I
I.
F
Don't
like
that
way,
working
the
way
I
like
working
she's
like
going
to
the
code
for
the
test
and
just
running
it
like
just
evaluating
the
form.
The
issue
is
that
the
default
is
like
nil
or
true
or
false,
or
something
it's
like
not
useful,
and
then
it
pretty
prints
sucks.
But
it's
like
again.
Sometimes
it
can
be
not
useful
so
by
having
this
end
up
on
middleware
it'll
capture,
that
as
data
and
then
dump
it
out
using
tap.
F
And
if
you
don't
like
the
way
it
looks
by
default,
which
some
people-
don't
you
can
you
can
in
your
TAP
Handler,
take
the
data
that
the
unrep
will
think
produced
and
change
it?
You
can
say
I
only
care
about
this
stuff
and
tap
that
sub
data
or
this
or
that,
but
so
there's
like
room
for
customization
there,
but
what's
cool?
Is
that
because
that
data
conforms
to
the
spec
that
I
have
set
up
for
the
viewer?
E
But
that's
nice
about
the
notebook
thing.
I
think
that's
like
there's!
Basically,
no
setup
like
you
install
two
extensions
you
already
had
to
install
one
anyway
and
then
you
right
click
on
the
file
that
you
don't
even
write
a
special
file
or
just
that
if
you
can
get
the
rebel
running
in
Colville,
you're
kind
of
done
already
and
can
use
all
this
stuff,
and
we
can
now
make
it
better
by
like
making
you
install
like
the
dependency
or
whatever,
but
even
just
like
installing
two
extensions
already
gives
you
90
of
the
stuff.
C
Yeah
that
and
another
thing,
I
start
to
think
of
when
you
two
people
speak
here,
is
that
you
know
the
the
Calvin
output
window,
slash
Rebel,
which
is
both.
That
is
just
a
regular
text,
pile
just
regular
viscode
document
that
we
take
some
control
of
to
create
the
prompt
or
something
like
it's
it's
it's
it's.
D
E
C
C
E
E
Yeah
I
could
maybe
I
think
yeah
we
would
like.
Probably
it
would
make
sense
to
have
like
a
second
notebook
implementation
that
acts
a
little
bit
differently.
Where
you
don't
see
the
thing
as
code
right,
you
just
see
the
outputs
and
because,
like
you're,
not
interested
in
the
code,
bits
maybe
well
I
mean
it
would
be
interesting,
because
we
have
a
setting
where
we
can
say
in
the
repo.
C
D
B
C
A
I'm
just
looking
forward
to
to
seeing
this
like
presented
in
in
some
of
some
larger
scene,
where
right
like
where,
because
that
workflow
I'm,
not
a
data
scientist
I'm
guessing
like
the
designs,
are
more
used
to
this
kind
of
workflow,
but
as
like
a
developer
work,
so
it
will
get
this
like,
hopefully,
yeah
also
this
world.
For
me,
it's
at
the
same
time
as
it
is
like
super
ex
exciting
stuff.
It
also
looks
very
easy
to
use
like
even
easier
than
than
a
regular
closure
file
is
so
it's
it's.
E
E
But
like
that's
not
the
way
you
want
to
make
people
do
it
and
it
would
be
nice
if
the
first
thing
they
see
is
like
actually
notebook
where
it's
play
buttons
you're
not
supposed
to
take
the
thing
and
place
it
into
the
rebel
you're
supposed
to
not
write
your
code
and
execute
the
code
and
send
it
to
the
rebel
right
and
the
notebooks
kind
of
encourage
you
to
do
that.
More.