►
From YouTube: Clojure visual-tools meeting 4
Description
In this meeting of the Clojure visual-tools group (Mar. 25th, 2022), we studied a bit of the internals of Clerk.
https://github.com/nextjournal/clerk
Summary: https://clojureverse.org/t/visual-tools-meeting-4-summary-video/
Zulip topic thread: https://clojurians.zulipchat.com/#narrow/stream/313390-visual-tools/topic/meeting.204
A
And
so
I
don't
know
if
anyone
was
around
or
remembers
their
sort
of
hanami
workshop
that
I
did
about
like
a
few
months
ago
in
december,
or
something
like
that.
We're
thinking
of
kind
of
updating
and
changing
that
one
a
little
bit
and
sort
of
re-running
it
in
probably
may
so.
I
guess
that's
that's
one
announcement.
A
There
will
be
a
hanami
workshop
coming
up
sometime
in
like
the
next
couple
months
and
we
were
thinking
it'll
be
similar
to
the
last
one,
we'll
go
over
kind
of
the
basics
and
and
what
hinami
is
but
we're
thinking,
maybe
more
of
focusing
on
some
of
the
ways
that
hanami
can
kind
of
help.
You
like
extract
common
patterns
and
like
minimize
the
amount
of
code
that
it
takes
to
make
like
repetitive,
visualizations.
A
B
Okay,
so
the
I
I
ran
this
workshop
about
statistics
like
basic
measures
of
statistical
inference
in
december.
It
seems
like
a
long
time
ago
for
the
re-closure
conference
and
probably
it's
going
to
be
a
rerun
of
the
original
workshop,
but
the
workshop
is
about
the
measures
of
statistical
inference,
which
you
know
we
use
in
like
everyday
testing
of
like
experiments,
things
such
as
p,
values
and
confidence
intervals
and
powers
of
tests,
like
you
know,
to
see
how
effective
they
are.
B
So
the
only
difference
between,
like
you
know,
you
know
doing
this
in
a
traditional
data
science
world,
which
you
know
assumes
that
you
know
the
math.
You
understand
distributions.
This
workshop
is
like
you
know.
If
you
can
write
loops,
if
you
can
write
like
you
know,
simple
map
reduce
and
filter
code,
you
can
actually
do
basic
statistics
like
you
know,
you
can
be
fairly
powerful
with
what
you
can
do.
B
So
this
just
explains
the
measures
or
statistical
inferences
of
statistical
inference,
and
then
it
also
explains
how
you
can
do
it
in
pure
code
without
like
knowing
any
formula
and
it
uses
a
technique
called
you
know
there.
It's
it's.
The
randomization
techniques
called
resampling,
so
I'm
taking
up
these
examples
from
the
book
statistics
is
easy
by.
B
A
Okay,
oh
sorry,
I
have
this
little
video
cover
thing,
so
I
think
that's
all
that's
like
concretely
planned
for
the
upcoming
workshops,
but
I
think
there's
like
maybe
a
couple
more
that
are
sort
of
more
vaguely
being
talked
about
and
obviously,
if
anyone
else
has
any
ideas
that
you
either
want
to
teach
or
learn
about,
feel
free
to.
Let
any
one
of
us
know
anytime.
A
There
are
a
few
people
in
the
community
who
are
like,
like
myself,
like
I
love
putting
workshops
together
and
teaching,
but
I
don't
write
open
source
libraries
or
build
the
things
that
I
teach
about.
So
if
you
have
like
a
cool
library
that
you
want
to
like
teach
or
yeah
or
if
you
want
to
run
a
workshop
yourself
just
sort
of
there
anyway,
there's
lots
of
opportunities
to
to
do
that.
A
D
Yeah,
maybe
maybe
just
that,
I
think
these
workshops
are
very
much
supporting
us
as
a
group
which
is
trying
to
to
figure
out
the
current
stack
of
libraries
and
where
we're
going.
What
is
missing
what
is
more
or
less
teachable,
and
I
think
it
is.
It
is
very
much
helping
us
in
getting
this
sense
of
direction
just
having
this
experience
of
teaching
and
learning
all
the
time.
D
So
I
I'm
so
much
looking
forward
to
kira's
and
rohit's
workshops,
because
last
time
I
learned
so
much
from
them
and
they
did
bring
this
kind
of
clarity
that
we're
looking
for
for
many
parts
of
the
ecosystem.
So
I'm
I'm
kind
of
happy
to
to
have
them
more
soon
and
have
more
clarity
coming
and
yeah.
It
will
be
great.
A
Great
yeah
thanks
so
much
daniel
and
yeah.
Sorry,
everyone,
I
know
my
connection
is
not
great.
I'm
I'm
seeing
what
I
can
do
about
that,
but
yeah
yeah
thanks
so
much
yeah
and
I
guess
that's
that's.
The
point
of
the
workshops
is
just
to
like,
like
this
whole
closure
data
science
ecosystem
is
really
exploding.
Oh
man,
I'm
thinking
I'm
frozen.
Sorry,
one
sec
no
way,
you're
good.
I
think
we
can
see
you
yeah,
okay,
interesting,
it's
frozen
on
mine,
but
yeah.
A
Just
there's
just
a
lot
of
stuff
going
on
right
now
in
in
the
data
science,
closure,
community
and
so
yeah.
It's
just
kind
of
you
know
exciting
to
like
explore
together
and
try
to
like
maybe
figure
out
how
to
like,
consolidate
all
the
tools
and
like
where
everything
fits
in
and
zero
in
on,
like
a
couple
projects
that
everyone
can
use
so
anyway
yeah.
So
that's
that's,
really
cool!
I'm
excited
about
it
too
yeah.
So
I
guess
yeah.
The
next
thing
I
don't
know
if
you
think
makes
sense,
we
could
just
go
into.
A
Oh,
I
guess
yeah
for
maybe
talk
about.
You
know
what
everyone's
doing
with
clerk
or
see
if
there's
any
questions
that
you
want
to
talk
about
like
in
this
during
this
hour
hour
and
a
half
that
we
have
left.
Otherwise,
we
can
go
into
the
code,
but
if
anyone
has
any
like
thoughts,
I'm
curious
like
how
people
are
using
clerk
or
what
questions
you
have
that
kind
of
stuff
or,
if
you're,
using
it
at
all
or
if
you're,
just
here,
because
you're
like
what's
clerk.
C
B
To
see
how
people
actually
use
it,
like
you
know
in
the
sense,
like
you
know
what
what's
a
what's
a
good
workflow
for
something
like
clerk
like
you
know,
you
start
up
the
rebel
you.
You
know
you
make
a
couple
of
changes
like
how
do
you,
how
do
p?
I
want
to
see
how
people
actually
do
like
the
really
powerful
stuff
with
clerk
like
all
these
notebooks
right
now,
you
see
that's
the
end
goal
of
the
system.
B
C
E
C
F
Yeah,
I'm
completely
new
to
clark,
but
I've
been
kind
of
following
it
and
it
seems
like
there's
a
lot
of
really
cool
ideas
that
clerk
embodies
and
I'm
also
really
interested
in
the
evaluation
model
of
basically
the
piece
of
the
functionality
between
saving
your
name
space
and
producing
all
the
values
kind
of
basically,
the
piece
in
between
writing
the
code
and
visualizing
it,
and
then
I'm
also
interested
in
kind
of
I've,
been
writing
visualizations
for
the
different
data
exploration
tools.
So
I
have
one
for
reveal
and
one
for
portal.
F
A
A
You
know
basically
like
try
to
dedupe
a
lot
of
the
work
that's
going
on
because
there's
so
much
it's
happening
so
fast
and
there's
so
many
different,
like
you
know,
ways
to
visualize
stuff
and
all
this,
like
you
know
all
these
data
science
tools
that
people
are
building
for
their
own
needs,
but
I
think
there's
a
lot
of
like
stuff
that
we
could
maybe
kind
of
you
know,
steal
from
other
projects
and
not
have
to
do
as
much
work,
basically,
which
would
be
really
cool
yeah
anyway.
So
that
sounds
cool.
C
A
A
I
think
the
like
the
common
visualization
plugins
is
a
really
interesting
one
or
like
rohit's
point
about
just
seeing
maybe
different
examples
of
notebooks
and
how
people
are
using
them.
I
don't
know
but
yeah
where
daniel.
If
there's
anything
I
know
you
were
like
interested
in
the
like
caching
and
like
lazy
loading
stuff,
if
you
want
to
like,
maybe
look
at
some
of
that,
I
don't
know.
B
I
think,
like
my
interest
in
the
caching
and
the
lazy,
loading
is
mainly
because
we're
doing
the
workshop
demos-
and
you
know
the
caching
and
the
lady
lazy
loading
actually
gets
in
the
way
of
like
you
know,
doing
something
live
right
now.
It
just
gets
in
the
way
so
or
it
feels
like
it.
You
know
I'm
just
not
doing
it
right,
so
that
would
be
something
I'd
be
really
interested
in.
A
D
D
Maybe
we
are
not
flowing
with
the
the
clerk
way
yet
and
we
are
looking
for
something
which
is:
let
us
call
it
the
old
way,
which
is
just
evaluating
on
demand
and
just
getting
the
view
and
what
I'm
practicing
these
days
is
doing
that
just
getting
the
view
of
the
current
form
alongside
clerk
without
without
losing
the
ability
to
use
clerk
fully
and-
and
so
it
is
kind
of
not
using
it
the
right
way.
But
I
think
it
has
been
useful
for
me
and
I'm
I'm.
A
Okay,
cool
well
yeah,
maybe
maybe
we
could
do
that
yeah
if
you
want
to
like
maybe
screen
share,
I
mean
yeah.
Maybe
we
could
start
with
like
yeah
like
an
example
of
where,
like
a
problem,
that
you
know
that
is
being
caused,
and
we
suspect
it's
because
of
we're
not
using
the
cash
right
or
something
like
that
and
then
just
kind
of
dive
in
and
see
what
we
can
find
out.
B
A
A
If
there's
some
way
to,
I
don't
know,
use
the
tool
differently
or
fix
that
or
something
I
guess
it
might
be
related
to
that
whole,
like
like
you're,
saying
adrian,
the
like
evaluation
process
like
whatever's,
going
on
between
that
saving
and
refreshing
the
browser
step
something's
going
wrong
in
there.
Maybe
I
don't
know.
A
A
A
D
D
D
So
you
see
the
editor
and
the
browser
right,
and
I
have
a
tiny
namespace
here,
and
this
is
one
of
those
two
visual
tools-
experiments
we're
doing
at
the
visual
tools
group
trying
to
play
with
these
things
and
use
them
the
wrong
way
and
what
we
have
now.
I
guess
we
have
clerk
serving
as
usual,
and
we
could.
D
We
could
do
the
usual
clerk
rendering
of
the
whole
notebook
right
and
but
we
could
use
it
in
another
mode
where,
whenever
we
evaluate
something,
we
already
get
it
on
demand
as
rohit
called
it.
So
we
could
get
this
number
and
there's
this
image
and
and
data
sets
and
and
a
plot
right
and
hiccup
block
with
a
few
plots
and-
and
things
like
that.
So
that
is
what
I'm
doing
at
work
at
the
moment.
D
D
A
D
D
Sorry
yeah
great
so
so
here's
the
the
clutch
source
code
right,
the
main
api
namespace
and-
and
I
guess
what
we
could
do
maybe
is
try
to
overview
what
we're
seeing
in
the
different,
namespaces
and
and
and
kind
of
see
where
we
wish
to
look
further
right.
Oh
and-
and
I
have
some
of
these
here-
that
I
should
remove
just
my
experiments
that
do
not
belong
here
and
yeah.
D
So
did
we
pick
a
question
or
should
we
just
overview?
What
whatever
we're
seeing
like?
Look
it
look
into
it
as
a
full
stack
project
and
and
see
how
it
works?
Where
is
the
web
server
and
how
we're
accessing
the
client
side
and
what
happens
when
we
call
the
main
api
functions?
Would
it
make
sense
if
we
kind
of
dive
into
the
main
main
entry
points
and
try
to
understand
them?
C
A
D
Yeah,
fantastic,
so
right
so
here
is
that
the
main
namespace-
and
I
think
there
is
this
function
clerk
show
right,
which
is,
I
think,
what
clerk
is
currently
encouraging
us
to
use
as
a
main
entry
point,
and
it
has
this
idea
of
defining
some
hotkey
in
your
editor.
That
would
just
call
this
function
over
the
file
you're
currently
editing,
and
I
think
that
is
also.
D
I
think
that
the
the
response
to
I
mean
the
response
to
autosave
is
similar
to
this
one.
If
I
remember
remember
correctly,
I
I
think
this
one
is
like
the
main
entry
point
point
they
are
encouraging
nowadays,
and
so
should
we
look
inside
and
see
what
is
happening
so
right?
So
we
are
taking
a
file
right.
We
could
maybe
yeah.
Maybe
let
us
first
start
the
server,
so
we
are
serving
clerk
and
oh,
oh,
do
we
have
the
wrapper
yeah?
We
have.
D
D
D
So
that
is
what
we
got
after
passing
the
file,
and
so
we
got
some
representation
of
a
closure
file
with
some
with.
I
guess
the
comments
assumed
to
be
blocks
of
markdown
right
and
probably
everything
else
is
assumed
to
be
code
right
and-
and
this
block
is
known
to
be
the
namespace
definition
block
right,
and
so
that
is
what
we're
getting
from
passing
the
file.
And
then
we
have
some
additional
information
like
the
title,
and
so
let
us
look
in
the
source.
D
So
this
is
the
title,
maybe
because
I
I'm
not
sure
why
it
is
recognized
as
the
title
for
some
reason
right
and
there
is
this
table
of
contents,
which
maybe
we
shouldn't
kind
of
figure
out
at
the
moment.
I'm
not
sure
if
this
is
so
important
anyway,
that
is
passing
a
file
right
is
it
there?
Am
I
doing
it
kind
of
okay
like
trying
to
look
and
see
what
is
happening
so
should
we
look
and
see
how
it
happens,
passing
the
file
so
pass
file,
I'm
jumping
to
the
function,
definitions
and,
and
then.
A
D
G
D
C
F
So
rewrite
clj
kind
of
it
pars.
So
closure
is
a
super
set
of
eden,
and
so
there's
like
things
like
reader,
conditionals
and
comments
and
other
forms
that
if
you
just
read,
eden,
get
lost
and
so
rewrite
clj.
Let
you
deal
with
others,
so
it's
really
about
parsing
code.
It
gives
you
the
ast
and
you
can
edit
the
ast
as
if
it
were
data,
but
the
big
win
with
rewrite
clj
is
that
it
also
preserves
white
space.
F
So
if
you're
trying
to
update
code-
and
you
want
to
do
some
refactoring-
you
don't
necessarily
want
it
to
mess
up
all
of
your
formatting.
So
if
you
wanted
to,
like
you,
know,
take
a
snippet
inside
a
function
and
make
it
its
own
function,
you
want
to
preserve
all
the
white
space
in
the
function
that
you're
editing
and
kind
of
play
nice
with
making
it
look
like
some.
Somebody
actually
wrote
that
code
so
yeah.
A
D
D
Right,
so
that
is
the
data
structure
that
we
got
and
it
looks
like
at
this
stage.
It
only
divided
the
code
into
blocks
right.
It
is
not
passing
the
code
yet
right,
not
turning
it
into
a
data
structure
of
where
each
top
level
form
is
converted
to
some
closure
structure.
It
is
still
a
string
right,
so
yeah,
so
maybe
we
should
read
further.
D
Oh,
no,
sorry
now
we
are
looking
at
our
state
right.
What
is
this
thing?
It
is
probably
an
atom,
because
we
have
this
the
reference
sign,
so
I'm
jumping
to
this
right,
so
it
is
an
atom
which
is
probably
some
of
our
current
state,
maybe
the
main
part
and-
and
we
are
picking
this
mapping
of
blob
to
result.
That
is,
if
I
understand
correctly,
the
cache,
I
think,
the
mapping
from
a
certain
id
to
a
value
of
previous
evaluations.
D
D
We
are
calling
this
eval
results
function
over
these
two
things.
One
is
the
mapping
between
id
to
previous
evaluation
result
and
the
other
is
the
current
document.
The
current
file.
We
were
passing
so
here.
Some
evaluation
activity
is
going
to
happen,
probably
and
maybe
in
a
moment,
we'll
dive
in
yeah.
Is
it
making
sense?
It
is
a
guess,
I
think
that
what
might
be
right-
and
I
guess
it
makes
sense
from
what
we
know
about
clerk-
that
evaluation
is
minded
to
previous
caching
right,
so
so.
D
Yeah
we're
thinking
and
in
a
moment
let
us
check.
Actually
let
us
check
right.
Let
us
see
what
it
is
so
I'll,
I'll,
evaluate
I'll
sorry
I'll
show
this
namespace
once
so
now,
we'll
have
it
rendered
in
the
clock
view
right.
So
now
this
main
club
namespace
is
rendered,
and
now
we
have
this
state
already
and
we
can
look
inside
so
now,
I'm
looking
inside
this
piece
of
state
we
have-
and
here
is
how
it
looks
this
web
server
dock
structure.
D
G
E
G
D
D
G
D
E
E
G
D
D
D
F
I
did
watch
some.
I
think
I
watched
one
video
about
where
he
kind
of
explains
a
little
bit
about
how
the
evaluation
is
done
and
the
caching.
So
what
I
think
I
remember
was
that
it
parses
the
file.
It
gets
the
ast.
It
looks
all
in
it
tracks
all
the
individual
expressions
and
it
at
the
expression
level.
F
B
F
D
D
They
need
to
somehow
represent
these
dependencies
and-
and
we
I
don't
know
how
right
we
haven't
learned
it
yet,
at
least
in
this.
Maybe
somebody
here
knows
that
I
I
I
don't
know
how
they
are
generated,
right
yeah.
So
anyway,
I
think
we
saw
this
call
to
a
function
that
does
probably
most
of
what
adrian
was
telling.
D
So
we
got
the
result
of
this
right
and
also
got
like
how
much
time
it
took.
But
the
result
is
the
main
thing
and
what
would
we
do
with
the
result?
We
are
updating
the
dark
of
of
the
web
server
right.
So
probably
this
update
dock
would
update
our
state
right.
So
so
maybe
right
it
looks
like
we
have
two
things
to
learn.
D
D
D
D
Sorry,
this
dark
value
is
the
result
of
our
evaluation
that
we
were
passing
here
right.
This
is
this
result,
and
now
we
are
taking
that
and
making
that
the
new
state
right
and
then
what
are
we
doing?
We
are
taking
the
currently
new
state,
the
new
state
and
somehow
calling
this
dock
to
viewer
function,
to
kind
of
probably
decorate
it
with
all
the
information
needed
to
actually
view
this
thing.
D
So
here
is
where
the
viewers
are
getting
into
play
right
and
then
we
are
broke
broadcasting
it,
which
means
probably
passing
it
to
the
clients
to
the
browser.
So
so
we
have
two
more
functions
to
learn
right
this,
which
is
decorating
everything
with
viewer
information
and
this,
which
is
broadcasting.
Maybe
let
us
look
into
broadcast
because
it
is
probably
the
easiest
I'm
hoping.
B
Sorry
so
daniel
one
of
the
things
I
did
notice,
like
you
know
when
I
was
trying
to
make
my
workshop-
was
I
I
just
saw
this.
You
know
it
catches
an
exception
and
throws
an
error.
So,
like
you
know
as
you're
doing
an
interactive
workshop
like
you
know,
and
you
make
errors
while
you're
writing
code
and
you
happen
to
save
it,
it
basically
takes
away
the
whole
screen
and
I
see
now
why
it
does
that.
But
you
know
that
was
one
of
the
things
that.
D
D
That
so
maybe
I
should
insert
an
error
right
like
this
thing,
should
give
us
an
o
and
then
I'll
try
to
show
the
current
file
right,
and
that
is
what
we
get
right
right:
the
view
of
an
l
right
and
where
did
that
happen?
Probably
inside
the
evil,
I'm
guessing
I'm
guessing.
We
did
not
get
to
update
dark,
but
rather
somewhere
failed
here
and
not
only
throwed
an
exception,
but
also
updated
the
view
so
that
it
knows
to
show
this
message
right.
D
Oh,
thank
you.
Thank
you.
Thank
you.
Yes
yeah.
So
it
is
here.
Thank
you
yeah,
so
yeah,
let
us
look
actually
so
show
create.
So
it
is
just
broadcasting
another
thing
and
also
resetting
the
state
of
the
error
to
be
that
error
yeah.
It
is
starting
to
make
sense
right,
yeah
and
and
and
thank
you
for
coming.
You
know
I'm
too
too
much
used
to
ignoring
the
try
catch
parts
which
is
this
habit
yeah.
D
So
that
is
what
was
happening
great
yeah,
so,
oh
I
didn't
save
so
I'm
saving
now
and
evaluating
and
yeah.
It
is
clear
again
great.
So
so
should
we
recap
what
whatever
we
were
seeing
so
far,
so
we
were
passing
our
file
and
getting
a
data
structure
which
is
not
a
detailed
passing
just
dividing
dividing
it
into
blocks
of
code.
D
Everything
that
is
need
that
needs
reevaluation
and
we
didn't
learn
how
we
were
getting
a
result
and
then
updating
the
state
with
the
result
and
also
broadcasting,
as
we
saw
here
inside
broadcasting,
a
decorated
version
of
that
to
the
clients
right.
So
that
is
what
we
were
having
and
now.
Maybe
we
should
dive
in
into
one
of
these.
So
I
think
we
had
at
least
three
things.
We're
curious
about.
D
C
D
D
D
D
No
you're
right,
yeah,
yeah,
sorry,
but
in
general
yeah,
but
the
viewers,
I
think
they
are
something
which
is
kind
of
known
on
the
user
side.
It
is
this
idea
that
clerk
can
view
things
in
different
ways
that
the
user
can
pick
and
and
right
so
when
it,
whenever
yeah.
Actually
let
us
look
into
a
clerk
namespace
like
a
notebook
that
is
typical.
C
D
D
G
D
G
G
D
Yes,
yeah
yeah,
and
I
think
we
are
curious
about
these
different
ways,
and
but
clerk
also
has
this
support
for
use
of
metadata
and
yeah.
Maybe
it
is
not
the
main
pathway,
so
I'm
not
sure
if
we
should
discuss
it
now,
but
but
yes,
it
is
the
way
of
specifying
how
a
thing
should
be
viewed,
and
so
here
is
maybe
a
more
a
bigger
namespace,
oh,
but
it
takes
time
to
evaluate
so
maybe
I
should
leave
it
yeah.
So
actually
I
should
shouldn't
have
taken
this
one
yeah
anyway
yeah.
D
D
Those
evolution
rules
which
are
kind
of
visualized
nicely,
and
so
we
have
this
example
of
defining
custom
viewers
for
certain
types
of
data
based
on
predicates
right,
which
is
something
that
clerk
allows
us
to
do
on
the
user
side,
and
since
we
now
showed
they
have
shown
this
this,
this
notebook.
We
can
look
back
into
this
message
file
that
we
are
spitting
and
see
what
we
got
here
right.
So
a
big
data
structure-
maybe
let
us
pretty
print
it.
D
All
right,
so
I'm
just
pretty
printing
it
so
that
it
oh,
but
it
wouldn't
pretty
print
because
it
has
some
things
that
would
not.
That
would
not
be
read
by
by
the
the
closure
reader.
Oh,
so
I
should
sorry
it
is
a
bit
slow
because
of
the
editor.
So
so
I'm
kind
of
a
bit
stubborn
now,
but
I'm
looking
for
a
good
one.
That
would
make
things
clear
for
us
and
yeah,
maybe
tablecloth.
D
D
D
G
D
Yeah
yeah,
so
so
this
value
is
a
certain
data
structure
and
inside
it
you
see,
we
have
certain
viewers.
For
example.
Let
us
look
for
one
of
them,
so
this
one.
What
is
it?
It
is
some
some
expression
to
be
interpreted
in
the
browser
by
the
small
closure
interpreter
that
would
turn
it
into
closure
script
runtime.
G
E
D
A
yes,
okay
yeah,
but
it
has,
is
it
it?
Has
this
alias
this
v?
Slash
is
assuming
that
a
certain
namespace
is
available.
This
alias
to
something
that
is,
that
should
be
available
to
the
interpreter
in
the
browser
side,
so
we
cannot
evalu.
We
cannot
read
this
string
here
in
the
backend
only
in
the
browser.
F
F
It's
a
map
with
the
key
next
journal
value
and
then
it's
a
tagged,
tagged
element
of
saying
that
when
you
and
you
can
have
these
tagged,
readers
and
so
next
journal
eden
is
just
saying
that
if
you
want
to
get
that
value,
you
then
it's
of
type
idiot.
So
then
you
need
to
parse
the
eden,
and
so
oh
I
see-
and
I
see
some
really
kind
of
interesting
things
just
kind
of
looking
at
that
that
heated
value.
F
F
G
F
F
F
I
guess
it's
probably
going
through
and
updating
all
the
different
elements
with
these
predetermined.
I
guess
it's
yeah,
it's
sending
the
viewer,
so
I
think
I
know
that
in
previous
discussions,
clerk
uses
psi
to
evaluate
code
in
the
browser,
because,
with
closure
script,
it's
hard
to
kind
of
get
a
vowel.
So
a
lot
of
projects
use
psi
which
does
a
good
job,
and
so
I
assume
that
that
viewer
function
is
being
both
evaluate
or
read
and
evaluated
by
psy
in
a
psy
environment.
D
G
F
G
F
F
D
What
we
saw
was
this
update
doc
function,
where
we
took
the
result,
value
this
one
and
decorate
it
with
some
viewer
information
and
broadcasted
it
to
all
clients,
and
then
we
saw
what
structure
was
being
broadcast
to
the
client
right.
So
what
we
haven't
learned
yet
is
this
decoration
with
viewers
and
mostly
the
evaluation
that
gave
us
this
talk?
I
think
we
have
13
minutes
to
the
official
time.
So
let
us
maybe
think
if
we
should
continue
a
bit
somehow
and
if
we
wish
to
make
it
yeah,
what
do
you
think
what
would
be.
G
Just
one
thing
to
mention
is
that
we
have
in
we're
relaunching
this
group
called,
and
the
intention
was
to
use
the
first
meeting,
which
would
happen
sometime,
maybe
two
to
three
weeks
from
now
as
a
to
look
at
to
look
more
at
clerk,
so
in
considering
what
we
want
to
do
now
or
whatever.
We
could
also
keep
that
in
mind
that
there's
this
other
time
coming
up
to
do
more
investigation,
and
it
could
be
something
that
specifically
come
came
out
of
this-
that
we
want
to
look
into.
D
F
A
D
Yeah
to
me
it
is
helping
a
lot
too
and-
and
I
just
want
to
say
that
what
we
didn't
get
to
discuss
was
the
usage
patterns
and
workflows,
and
that
is
what
last
week
in
the
talk
of
forest,
so
amazing.
I
think
different
people
sharing
the
flow
of
using
the
tool
and-
and
we
could
hope
to
to
have
that
kind
of
discussion
too,
and
maybe
flores
has
some
comments
about
it,
and
it
was
a
really
great
discussion.
F
D
Yeah
great,
let
us
try
yeah
you're
so
right
it
is
much
better
actually
than
spitting
yeah
yeah.
So
I'll
now
do
the
hotkey
that
is
showing
the
namespace.
So
we
did
broadcast
something
to
the
client
and
now
let
us
print
this
value.
Yes,
so
much
easier.
So
thank
you
adrian.
You
know
now
I'll
do
things
differently
in
the
coming
days,
yeah
yeah
you're
right
great,
great,
no
spitting
anymore,
so
right
great!
So
so
right,
so
we
did
have
these
two
parts
of.
D
B
C
F
B
D
D
And-
and
maybe
we
could
look
into
this
function,
is
it
is
it
kind
of?
Is
it
making
sense
that
now
only
two
main
things
we
haven't
learned
and
they
are
both?
Probably
big
one
is
the
viewer
decoration
and
the
other
is
the
evaluation
and
of
course
there
is
all
the
whole
client
side
and
the
way
it
works.
But
I
mean
these
are
the
two
main
kind
of
main
pieces,
so
yeah,
maybe
let
us
jump
into
evaluation,
is.
G
D
D
D
Yeah
here
is
evil
results
right.
So
what
is
our
our
input?
Our
input
is
two
things.
One
is
results,
last
run,
which
is
this,
this
mapping
from
hash
ids
to
values
the
cash
right.
This
is
the
cash
in
a
sense,
and
the
past
stock
is
just
this
in
a
sense,
a
sequence
of
blocks
of
code
which
are
still
text
right.
They
are
not
kind
of
converted
into
data
structures,
yeah,
they
are
strings
right,
and
so
that
is
the
input.
So
what
is
happening
now
so
we're
doing
some
analysis
right.
C
D
D
The
graph
is
a
map,
but
is
there
anything
else
after
the
graph?
Yes,
there
are
the
blocks
of
code,
which
is
which
are
also
kept
as
part
of
the
analysis,
but
this
time
not
just
the
text
but
also
the
forms.
The
forms
like
after
applying
the
closure
read
and
okay.
So
this
is
here
too,
so
we
have
a
graph
of
dependencies
that
we
look
into
in
a
moment
and
we
have
these
blocks
and
do
we
have
anything
after
that?
No,
so
that's
the
structure.
D
A
C
G
D
Let
us
see
yes,
it
does
have
a
set
of
dependencies,
yes,
you're
right
and
but
I'm
trying
to
see,
if
yeah,
is
it
making
sense
right?
So
where
is
this
coming
from
hush
store
in
cass?
Yes,
okay,
so
we
have
this
va
defined
here.
Is
it
actually
depending
on
freeze,
for
example,
oh
yeah?
It
does
right,
so
it
is
making
sense.
I
think
right.
G
But
are
those
two
equivalent
like?
Is
this
so
in
the
first
case
that
function
we're
just
looking
at
that's
a
that's
a
symbol
pointing
to
a
function,
and
then
we
have
an
the
next
isn't.
Is
that
it's
not
really
a
symbol?
I
guess
there
is
everything
else.
No,
it's
not
a
symbol
right!
It's
a
it's!
A
it's!
A
whole
expression.
D
Yeah
you're
right
yeah,
so
right
so
not
just
symbols.
Also,
this
whole
expression
you're
right
yeah.
Yes,
right
right,
and
we
have
another
one
like
that
here,
and
maybe
it
makes
sense,
because
we
need
to
take
care
of
all
top
level
forms
which
are
not
always
bound
to
symbols.
Yes,
you're
right!
Thank
you.
Thank
you.
So
that's
a
depends.
Dependency
graph,
where
probably
top
level
forms
are
marked
to
be
dependent
on
on
sets
of
symbols.
I
think.
C
G
Functions
within
the
name
like
where
I
was
asked
somebody
before
we
were
talking
about
whether
there's
dependencies
on
values
within
the
block
within
the
names
within
sorry.
If
I
have
one
block
that
refers
to
a
value
find
in
a
previous
block,
would
we
it's
also
representing
that
kind
of
independence?
Let.
D
D
D
D
G
G
F
I
know
that
it's
a
general
idea-
I
don't
know
if
they're
using
a
library
or
doing
the
analysis
themselves,
but
yeah
there
are,
I
think,
like
closure
tools.
Analyzer
will
give
you
information
that
you
can
use
to
build
graphs
like
that
and
then
building
dependency.
Graphs
is
useful
for
lots
of
different
problems.
F
D
F
Sorry,
the
other
important
namespace
that
was
just
you
could
just
see
was
closure
tools.
Analyzer
passes,
so
the
analyzer
will
do.
It
won't
necessarily
generate
that
graph
for
you,
but
it
will.
It
will
do
a
lot
of
the
work
for
you
of
like
giving
you
the
ast
and
annotating
it
with
extra
information
about
semantically.
What's
happening
like
what
are
the
free
variables.
F
D
D
D
D
D
D
But
we're
also
relying
on
the
analysis
info
on
the
on
the
graph,
but
how
let
us
try
to
see
how
right
is
it?
Am
I
made
making
sense
so
yeah,
so
we
are
reducing
over
our
graphs
over
our
graph
and
we
are
reducing
over
this
topological
sort
of
the
graph,
which
is
this
kind
of
ordering
by
which
we
can
look
into
all
all
elements.
Actually,
let
us
maybe
kind
of
do
a
depth
here.
So
that's
sorry,
so
that
we
can
make
it
concrete.
D
Thank
you
for
this
practice,
with
the
definition
so
making
things
so
much
easier.
So
that
is
the
topological
sort
of
the
graph.
So
I
think
it
is
sorting
by
dependency,
so
either
we'll
have
all
elements
appearing
after
the
dependence
or
the
other
way
around.
One
of
these,
I'm
not
sure
which
one,
and
maybe
we
could
guess
by
the
yeah.
D
D
Now,
how
are
we
reducing
so
we're
beginning
with
an
empty
map,
and
we
will
probably
be
evalu
evolving
this
map
by
associating
things
into
it
and
this
map,
we
will
call
it
the
map
of
hash
right,
the
mapping
from
a
hash
to
a
value,
so
we
will
be
associating
things
into
it.
So,
at
every
step
we
are
getting
k,
which
is
just
an
element
in
our
sequence,
and
we
are
checking
this
k.
D
D
D
F
D
D
Yeah
yeah
yeah,
it
makes
sense.
Thank
you.
Thank
you
yeah.
So
for
most
interesting
part
of
our
code,
it
will
have
an
analysis,
the
analysis
info
and
then
it
will
associate
with
our
hash
map
the
result
of
hashing.
This
code,
which
is
okay,
so
hashing,
is
always
just
hashing
over
the
code,
nothing
more
than
that
right,
great
great.
So.
E
D
D
G
D
G
D
D
Computed
the
hashes
based
on
this
analysis
of
dependencies,
and
we
are
associating
these
hashes
to
our
dock
and
we
are
also
associating
the
existing
cache
and
it
looks
like
now.
We
have
all
the
necessary
information
for
evaluation
right.
We
have
our
code
actually
as
form
after
being
after
passing.
Through
the
reader,
we
have
the
hashes
that
would
determine
which
things
should
be
re-evaluated
due
to
cash
miss
and
we
have
the
cash
right
yeah
so
great.
So
now
we
can
go
to
the
evaluation
function
and
let
us
maybe
jump
into
it
just
for
a
moment.
D
Which
is
getting
this
analyze
doc
that
contains
the
hashes
and
the
blocks
of
code
and
also
the
cache,
I
think,
yeah
and
yeah,
and
maybe
I'm
not
sure
if
we
have
time
to
dive
into
this.
But
maybe
we
kind
of
already
have
an
expectation
of
what
should
be
happening
right
and
that
is
only
evaluating
the
parts
that
need
to
be
reevaluated
and
then
updating
the
the
cache.
Accordingly.
I
guess
right
and.
D
A
D
That
kind
of
adrienne
encouraged
me
to
do
by
inserting
a
def
that
actually
mattered
so
much
for
the
exploration
just
being
able
to
capture
a
value
and
print
it
and
and
then
I
I
think
we
just
went
through
some
of
of
the
kind
of
complex
pieces
of
technology
that
that
are
there,
and
maybe
we
have
some
map
of
how
they
are
organized
can
kind
of
in
relation
to
each
other.
Where
we
saw
the
hashing
we
saw,
there
is
a
map
of
cash
we
saw.
D
There
is
a
main
evaluation
function
that
we
haven't
learned
yet
and
those
viewers
that
we
haven't
learned
yet
and
we
saw
them
somehow
flowing
between
the
main
entry
points
and
and
and
maybe
we
could
try
to
think.
I
think.
Maybe
if
this
could
be
continued
somehow
and
maybe
focused
on
one
of
those
parts
and.
F
Yeah,
I
was
pretty
impressed
how
easy
it
was
to
kind
of
follow
what
the
the
code
that
they
had
and
also
just
the
the
show
function
was
really
cool
because
it's
just
like
read
eval
and
print.
Well,
it's
not
print,
but
it
like
updates
the
view.
So
it's
like
it's
very
close
to
the
rep
or
it's
like
read
a
vowel
show,
and
it
was
almost
scary
how
straightforward
it
was.
A
Yeah,
it's
nicely
written
for
sure
if
you
like
debugging,
that
my
daniel
I'll
share
the
library
there's
a
library
called
scope
capture
that
I
use.
Sometimes
that's
really
really
nice,
like
it's.
It's
easy,
if
you
just
have
like
one
variable,
but
if
you're
ever
trying
to
capture
like
a
whole
sort
of
like
environment,
that's
being
called
so
you
want
like,
if
you
want
to
save
like
multiple
things
you
want
to
save
like
basically
take
like
a
snapshot
of
the
state
at
a
at
a
certain
point.
A
B
G
D
Portal
has,
we
could
say
it
has
one
main
entry
point
which
is
a
submit
function
whenever
you
call
that
with
a
value
you
submit
that
value,
and
it
is
somehow
being
viewed
in
the
clerk
view
and
tap
is
once
one
kind
of
ergonomics
that
you
could
wrap
this
submit
with.
But
it
is
your
choice:
how
you're
submitting
things
if
it
makes
sense.
E
F
D
F
Yeah
I
mean
I
found
it
useful.
I
mean
in
some
cases
too,
where
you
have
such
a
large
data
structure
that
it
you
just
like
it'll
kind
of
take
over
the
it'll
kind
of
like
pause
and
kind
of
root,
slow
down
your
workflow,
because
it
takes
so
long
to
print
the
whole
thing
and
it
also
works
with
cyclical
data
structures.
I
don't
know
if
you've
ever
accidentally
print
try
to
print
a
data
structure
with
like
an
atom
that
refers
back
to
stuff
that
can
just
like
kind
of
get
lost
in
itself.
F
A
Yeah,
I
think
yeah
does
anyone
else
have
any
like
last
thoughts
or
comments
or
whatever
I
think
yeah.
This
was
really
interesting
for
me.
So
thanks
daniel,
I
can
like
keep
an
eye
on
the
zulu.
I
guess
for
the
recording
and
or
announcements
about
future
ones.
We'll
probably
do
something
like
this.
I
don't
know
what
the
schedule
is,
but
every
once
in
a
while
at
least.
G
That's
one
of
the
things
I've
kind
of
struggled
with
a
bit
how
it
renders
those
data
sets.
So
and
after
this
I
was
kind
of
wanted
to
see
this,
because
I
want
to
see
like
where.
Well,
I
didn't
understand
much
of
the
flow
and
clerk.
So
this
really
helped,
but
also
I
was
kind
of
wondering
whether
it
could
help
shape
that
session
and
it
seems
to
me
I
don't
know
if
you
guys
agree
with
it.
The
viewers.
G
Where
I'd
like
to
learn
a
lot
more
about
what's
going
on,
and
so
the
current
scope
of
that
proposed
session
seems
good,
but
yeah.
Does
that
sound
interesting
to
any
of
you
guys
here,
like
a
session
kind
of
looking
more
into
playing
around
understanding
those
viewers
more
specifically,
and
maybe
even
you
trying
to
make
one
or
adjust
you
know
influence
how
clerk
renders
a
data
set?
Does
that
seem
like
a
interesting
topic.
C
B
B
C
B
G
G
D
D
A
Okay
yeah,
I
guess
so
I
guess
we'll
wrap
up
there,
but
yeah.
Let
us
know,
I
guess,
keep
an
eye
on.
Probably
I
don't
know
where's
the
best
place.
The
community
is
kind
of
like
spread
out
across
zoolip
slack
and
closure
verse,
but
we
kind
of
like
post
stuff
in
all
of
those
places.
So
we'll
try
to
announce
what's
going
on
next
and
probably
yeah
when
the
recording
comes
out.
If
anyone
wants
to
follow
along
after
I
can
do
that,
but
yeah,
I
guess
we'll
leave
it
there.