►
From YouTube: Clojure visual-tools meeting 17 - various updates
Description
On April 1st, 2023, the Clojure visual-tools group had its 17th meeting.
https://scicloj.github.io/docs/community/groups/visual-tools/
Agenda:
Markus Agwin shared a new way of blogging about SICMUtils using Klipse plus a little Scheme syntax to JavaScript compiler.
Mauricio Szabo updated about the Pulsar editor.
Matthew Downey demonstrated rendering structured output from ChatGPT interactively, through the rendergpt browser extension.
Lukas Domagala and Chris Badahdah discussed deeper Portal /Calva Notebook integration.
Daniel Slutsky discussed the Kindly convention for namespace-as-a-notebook and generating Quarto documents from Clay.
Detailed summary with links:
https://clojureverse.org/t/visual-tools-meeting-17-various-updates-summary-recording/
A
Hello
to
our
friends,
listening
to
this
recording
of
the
visual
tools,
meeting
visual
tools,
meeting
number
17:
this
group
has
been
meeting
during
2022
and
now
after
a
break.
We
are
back
with
a
few
updates
about
different
projects
in
in
the
closure
scene
of
data
visualization
and
literate
programming
and
UI
design
and
so
on,
and
we
will
have
presentations
in
a
moment
and
then
I
have
a
discussion,
but
first
as
Matthew
suggested.
A
B
Too
yeah
and
it
wasn't
a
reclosure
conference
where
a
lot
of
people
were
presenting
their
visual
tools,
something
like
Clerk
and
portal
and
other
the
Vega
based
stuff.
That
was
really
nice
and
I
wanted
my
library
to
be
able
to
integrate
into
all
of
those
and
I
wanted
to
be
like
egotistical
and
make
other
people
work
for
me
and
I
just
wanted
to
plug
it
into
that.
Somehow
and
I
was
kind
of
annoyed
at
like
every
one
of
those
basically
has
their.
C
B
So
we
should
somehow
make
a
group
where
everybody
collaborates
instead
of
building
everything
from
scratch
10
times
and
then
your
kind
of
the
next
day,
basically
right
more
or
less
inside
the
re-closure
conference.
We
started
this
the
first
session
of
this
group.
It
wasn't
officially
called
the
visual
tools
group,
yet
I
think,
but
it
was
basically
the
first
impromptu
session
of
it
where
we
took
all
those
digital
tools.
Creators
put
them
in
a
room
and
told
them
they
need
to
now
work
together
instead
of
everybody
building
their
own
thing
and
I.
D
B
E
Okay,
okay,
so
Mauricio
I
live
currently
in
Uruguay
and
I
do
windsurfing.
So
that's
a
new
thing
and
well
I
basically
worked
a
lot
on
the
chlorine
project.
They
made
the
chlorine
projects
so
I'm,
looking
for
an
atom
and
out
on
diet,
so
I
decided
to
try
a
new
editor
when
it
was
trying
almost
dying,
and
the
idea
was
to
reuse
parts
of
autumn.
E
That
was
already
that
were
already
made
it
to
make
a
new
editor
from
scratch
in
closure
script
and
when
atom
died,
I
thought
okay,
so
now
I
don't
have
the
like
the
the
basis
of
atom
to
base
myself
in
so
I
decided
to
basically
Fork
the
whole
thing
and
start
everything
else.
So
that's
why
I'm
going
to
talk
right
now
and
yeah
I've
been
out
of
cloudry
for
a
little
bit
because
of
all
this
JavaScript
nonsense
that
I
had
to
do
with
NATO
and
everything
but
yeah?
E
D
The
my
interests
in
the
the
visual
tools
thing
is
spot
by
the
re-closure
conference,
but
not
not
much
put
into
practice
yet
and
I've
played
with
various
tools,
mostly
these
days,
I'm,
using
just
using
emacs
with
the
org
mode
and
running
little
bits
of
code
from
there,
but
I'm
interested
to
see.
What's
going
what's
happening,
yeah,
that's
about
it!
For
me,
I
think.
B
F
I
have
a
physics
background
and
also
come
from
the
reclosure
2021
conference.
So
I
gave
a
presentation
there
about
visual
programming
and
that's
basically
how
I
joined
the
visual
tools
group
and
the
the
keynote
of
this
conference
was
given
by
Gerald
Sussman,
which
was
very
interesting
and
I'm
still
working
on
the
same
topic
and
trying
to
make
his
sicm
book
more
accessible
to
everyone.
G
I
think
of
the
only
acres
in
this
room,
usually
there's
more
than
whatever
so
yeah.
My
name
is
Chris,
can
use
enclosure
since,
like
2016-ish
I've,
been
able
to
work
with
it
professionally
for
the
last
three
years,
so
it's
been
a
lot
of
fun
and
in
that
time
I've
found
some
problems
that
I've
solved
with
my
tool
that
I've
been
working
on
called
portal,
which
is
is
has
been
a
lot
of
fun.
It's
been
fun
like
integrating
it
into
different,
weird
places,
so
yeah
I,
don't
know.
C
Hello
yeah
my
name's
John
I'm,
an
engineer
I've
been
doing
recently
working
with
a
bunch
of
startups
doing
closure
and
it's
been
very
interesting.
A
lot
of
data
orientated
work
there
as
well,
and
so
I've
been
spending
the
last
couple
of
months.
Trying
to
improve
the
workflow
and
portal
was
one
of
those
things
that
has
made
a
big
change
in
that,
but
I
still
think.
There's
I've
got
a
lot
to
learn
about
how
to
make
the
most
out
of
everything
that
portal
can
do.
C
So
thanks,
Chris
for
that
and
yeah
looking
forward
to
kind
of
seeing
what's
happening
with
the
other
tooling
as
well.
I
write
around
about
the
use
of
tools
and
workflows
around
closure
in
the
the
practically
books
that
I
publish
online
and
I
want
to
try
and
do
some
more
videos
around
that
as
well.
Soon.
A
D
A
And
and
yeah,
so
we
will
talk
about
data
science
more
in
coming
meetings,
even
though
this
one
is
more
about
tooling.
Of
course,
then
yeah
by
the
way,
I'm
Danielle
I
usually
do
statistics,
but
recently
I
left
my
job
and
so
I'm.
Now,
focusing
mostly
on
community
organizing
in
the
closure
community
and
yeah
Matt.
Would
you
like
to
say
something.
H
Sure,
thanks
for
inviting
me
here
came
here
through
the
slack
group,
so
I'm
excited
to
meet
you
all
and
see
everything
that
you're
working
on
I've.
Seen
a
few
of
your
previous
recorded
videos.
I've
been
working
with
closure
professionally
since
about
2018,
mostly
on
back-end
stuff,
but
recently
I've
been
playing
around
with
portal
playing
around
with
clerk
a
bit
working
more
on
UI,
stuff
and
separately
sort
of
Dipping,
my
toes
in
the
water
of
data
science
as
well.
So
it's
happy
to
be
here
and
looking
forward
to
seeing
what
everyone's
working
out.
I
Yeah
sure,
let's
see
hi
I'm
Adrian
I'm
interested
in
visual
tools
and
building
tools
that
you
can
with
direct
me,
manipulation
so
much
so
that
I
built
my
own
UI
Library.
So
as
kind
of
a
lot
of
the
tools
are
focused
on
running
visually
in
the
web,
I'm
focused
on
doing
it
on
desktop
primarily
so
kind
of
going
against
the
grain
there.
I
But
if,
hopefully,
that
can
add
to
the
conversation
of
different
environments
where
you
can
do
data
visualization
direct
manipulation
and
do
it
in
process
as
opposed
to
the
web,
which
has
its
own
challenges.
But
the
desktop
has
different
challenges,
but
has
different
capabilities
that
are
interesting.
So
yeah.
A
B
Yeah
sure
I'm
a
closure
deaf
in
Germany
sitting
in
the
middle
of
Berlin,
but
now
I
work
for
a
company
called
Scarlet.
We
do
Healthcare
regulation
stuff
and
we're
building
our
own
LSP
tooling,
on
our
own
language
and
stuff.
That's
why
I
mean
I've
always
been
interested
in
just
tooling
for
developers
like
it's
way
more
fun.
If
the
tooling
does
my
job
instead
of
me
having
to
do
my
job
I'm,
just
not
smart
enough,
so
it's
nice.
A
Thank
you
so
much
yes,
so
now
we
will
begin
with
the
presentations.
We
will
begin
with
Marcos
and
maybe
what
we
could
do
is
try
to
talk
for
10
to
12
minutes.
I,
think
that
would
be
optimal
with
the
time
we
have.
You
know
if
you
need
more
time,
then
never
mind
and
I'll
try
to
tell
you
after
10
minutes,
so
that
you
can
try
to
conclude
and
so
Marcos.
Would
you
like
to
begin.
F
F
Probably
the
most
widely
known
one
in
the
computer
science
Community,
it
is
the
wizard
book
structure
and
interpretation
of
computer
programs.
The
next
one
is
the
book.
I'm
focusing
on
is
the
structural
interpretation
of
classical
mechanics
and
the
third
one
is
functional
differential
geometry,
which
kind
of
brings
the
concepts
further
and
my
goal
since
the
re-closure
conference
is
to
make
this
mechanics
book.
It's
the
same
book
available
to
Matlab
and
python
users,
so
I'm
I'm,
trying
to
reach
to
reach
out
to
to
people.
I
H
F
Is
is
it's
a
book
about
theoretical
physics?
So
it's
not
about
data
science.
It
has
no
numbers
in
it.
It's
all
about
algebra,
symbolic,
manipulations,
so
think
of
it
more
like
Matlab
or
numpa.
It's
not
like
McLaughlin
number.
You
should.
You
should
think
more
of
it
about
as
as
mathematic
and
senpai,
but
nevertheless
I
I'd
like
to
reach
those
people
who
use
Matlab
and
numpy
currently
and
and
maybe
want
to
want
to
try
symbolic
computations,
and
these
are
really
the
the
for
main
focus
group.
F
Mit,
professor
and
it
contains
examples
about
planet
movements
and
rigid
bodies
and
many
other
physics
examples,
but
the
book
itself
only
uses
a
small
fraction
of
the
skin
language
but
uses
a
lot
of
higher
order
functions
so
functions
to
the
second
third
order.
Functions,
calling
functions,
functions
returning
functions
which
themselves
call
functions.
So
it's
all
really
really
high
order
functions
to.
C
F
Max
it's
really
using
this
concept
very
effectively
and
the
functions
they
all
interlock
and
one
can
go
as
far
as
say
because
of
this
interlocking
and
higher
order.
Nature
of
things
really,
those
functions
themselves
form
a
DSL,
a
domain,
specific
language
to
model
algebra.
Really
so
a
computer
scientist
would
say
it's
a
DSL,
a
domain,
specific
language,
mathematicians
physicists,
would
say
it
is
a
notation
it's
really
defining
or
using
and
and
and
its
own
notation.
Basically.
F
He
started
and
Sam
Richie
two
kids
way
way
further
in
the
last
years,
one
can
say
and
I
think
it's
it's
good
to
think
of
of
lisp
being
used
in
this
Library
as
a
language
oriented
language
which
is
stolen
from
racket,
so
racket
is
also
at
least
a
modern
one,
and
the
record
slogan
is
language,
oriented
language
which
means
in
this
Library.
The
computer
algebra
system
is
defined.
Really
the
the
domain
specific
language
is
defined.
The
notation
is
defined
within
the
library,
so
notation
is
used
in
the
book
and
defined
in
the
library.
F
F
Where
it
all
goes
now
to
make
the
book
accessible,
which
is
the
task
the
single
task
I
like
to
pursue,
you
have
to
connect
the
book
to
the
library
in
the
browser
and
there
are
two
ways:
I
think.
Maybe
there
are
more,
but
there
are
two
main
ways
to
do
this.
The
first
one
is
translate
the
book
itself
to
closure,
so
make
the
examples
that
are
within
the
book
that
are
scheme.
Examples
just
translate
them
to
to
closure
and
then
run
and
run
it
with
the
closure
script
Library.
D
F
I
could
give
a
short
presentation,
but
I
think
I,
don't
have
the
time
to
it
and
it
uses
schedule
because
the
main
thing
I
like
to
talk
here
is
this:
the
second
way,
which
is
the
scheme
DSL
transpiler
in
the
process.
So
the
second
way
is
just
not
to
use
closure
but
show
the
examples
like
they
are
in
the
book
in
the
browser
and
use
a
scheme
transpiler
to
transpile
things
in
that
case,
to
JavaScript,
because.
C
F
New,
this
Library
purely
as
a
JavaScript
library,
so
there
is
no
closure
stack
involved
in
this
in
this
idea
and
I
can
show
it.
This
is
the
the
main
thing
I'd
like
I'd
like
to
show,
and
this
this
is
an
HTML
file
which
includes
the
transpiler
and
all
the
100
examples
of
the
book
of
the
first
part
of
the
book.
So
this
this
is
all
skin
code
and
the
scheme
code
is
transpiled
to
JavaScript
and
seeking
you.
This
library
is
used
as
a
JavaScript
library,
which
you
can
see
you
see.
F
This
is
this:
is
the
transpiler?
It's
only
160
lines
of
code
and
it
uses
it
Imports
like
any
any
closure
script.
Library
just
has
its
namespaces
exposed
as
JavaScript
objects.
If
you
don't
use
the
advanced
optimizations
and
that's
what
I'm
using
and
so
I
can
transpile
to
JavaScript
and
call
the
library
functions
in
that
way,
and
that
works.
It
uses
grips
I'm
already
having
10
minutes
right.
F
Itself
is
is
coded
as
Eclipse
snippet
within
the
HTML
file,
so
there
is
no
external
JS
imported
or
something
it's
all,
because
the
transpiler
is
so
small.
It's
all
in
Cube
Snippets,
as
you
can
see,
for
example,
here
there
is
a.
There
is
an
example
which
which
calculates
the
cosine
of
pi
right,
which
is
-1,
but
if,
in
the
transpiler
of
course,
Pi
some
works,
we
find
it
the
transpiler
if
I
make
it
3,
not
3.14,
but
three.
Okay,
then
Clips
is
with
every
keystroke
the
this.
F
F
F
As
shown
before,
what
else
closure
namespace
is,
is
a
JavaScript
object?
It
the
transplant
itself.
Only
using
HTML
has
said
there
is
no
other
external
file.
It's
always
it,
and
and
I
developed
this
transpile
in
a
series
of
blog
posts
for
educational
reasons,
so
one
could,
in
principle,
if
one
comes
from
a
Matlab
or
python
background
and
knows
a
bit
of
JavaScript,
there
is
no
need
to
to
know
about
closure,
at
least
for
something,
because
it's
everything
a
JavaScript
and
the
transpiler
is
developed
in
JavaScript
itself
and
by
writing
the
transpiler.
F
Basically,
the
DSL
is
defined,
so
this
is
defined.
So
one
understands
by
writing
a
transpiler
understands
what
this
means
really
and-
and
it
is,
it
is
developed
along
with
with
the
math
examples
of
the
book.
So
it
transpired,
for
example,
doesn't
happen
if
it
didn't
didn't
show
up
in
the
first
part
of
the
book,
so
I
didn't
implement
it
if
it
should
show
up,
I
need
to
implement
in
a
further
blog
post.
So
it
goes
along
with
the
book.
The
transpiler
is
developed
along
with
the
book.
This
HTML
file
here
is
written
manually.
F
So
this
is
not
it's.
It's
really
that's
the
source
of
truth:
it's
not
a
kind
of
generated
by
some
other
tool,
it's
really
thtml55
and
it
can
be,
of
course,
copy
pasted
locally.
So
it
is
very
copy.
Paste
friendly.
You
can
always
look
at
the
source,
which
is
very
simple.
Really
it
does.
It
shows
basically
the
HTML
file,
it's
not
so
much
difference,
and
so
that's
very
copy
based
right
and
really
the
main
purpose
of
the
transpiler
is
to
to
write
blog
posts.
F
It
includes
the
the
you
can
include
this,
this
HTML
file
here
as
an
iframe
and
have
access
to
the
transpiler
and
use
it
and
work
and
write
blog
posts
right.
So
that
brings
me
to
the
conclusion,
which
is
the
Outlook.
What
I
have
is,
as
I
said
already,
I
have
part.
One
of
the
sicn
book
is
the
HTML
file.
F
This
is
what
I
showed
and
it
exists
also
as
an
org
file,
which
is
then
used
in
the
CLG
tiles,
which
I
didn't
have
time
to
show,
but
was
shown
in
the
in
the
enclosure
conference
in
the
last
years.
Visual
tools
meeting
so
part
one
exists
in
as
well
in
with
the
transpiler
as
well
as
in
a
graphical
form,
of
course,
in
in
the
future,
the
natural
goal
is
to
report
both
books,
sicm
and
ftg,
as
I
show
them
after
in
full
sandwich.
F
You
already
made
a
lot
lots
of
work
files
and
lots
of
works,
but
I
need
to
adapt
them
and
and
work
and
and
but
I
will
not
rush
through
it,
because
I
want
to
enjoy
working
through
the
examples
myself.
That's
why
I
wrote
the
transpiler
to
really
worked
through
the
examples
and
understand
things
for
an
educational
purpose
and
then
I
think
it's
a
good
idea
to
to
add
the
scheme
DSL,
which
exists
as
a
transpile
in
JavaScript
right
now,
as
a
macro
in
schedule.
I
F
Also
Ultra
device
is
the
trafficking,
the
graphically
tool
I
made
and
presented
in
the
conference,
and
it
uses
Hitler,
and
so
that's
a
good.
That's
I
think
it's
a
good
idea
to
also
implement
the
DSL
and
schedule
and
then
it
can
be
used
in
other
platforms
as
well.
Maria
Cloud,
for
example,
uses
Kittle
next
Channel
uses
Skittle
so
Skittle
is,
is
the
of
course
the
closure
interpreter
written
by
I,
I
hope
you
know
him
very
famous
and
then
maybe
one
could
add
schedule
to
Clips,
which
at
the
moment
doesn't
doesn't
work.
F
H
F
F
Said
before
it's:
it's
really,
you
can.
You
can
follow
the
path
of
this
process
really
and
we
will
share
the
link
then,
in
the
show
notes
it's
written
in
in
seven
sequences
of
blog
posts
and
it's
really
test
driven
development,
which
means
okay,
I.
Have
this
special
example
of
the
book
and
I?
This
needs
to
run
and
that's
the
way
I
did
it.
I
said:
okay,
I
want
to
start
with
one
plus
one
it
needs
it
needs
to
transpile
one
plus
one
into
JavaScript,
one
plus
one,
and
then
that's
how
I
work.
F
Okay
now
I
need
singles.
Okay,
now
I
need
functions,
and
so
and-
and
it's
everything
very
well
documented
in
this
series
of
blog
posts
and
with
with
all
the
the
philosophy
behind
it-
and
it's
it's
very
well
documented.
The
whole
thing
is
written
really
as
an
educational
purpose
for
people
coming
from
Matlab,
for
example,
with
no
knowledge
about
this.
No
knowledge
about
transpilers
or
something
else
just
to
to
to
give
them
an
entrance
into
into
the
book,
which
is
which
means
human,
very
dense
and
everything.
But
it's
I
think
it's
worthwhile.
A
F
Clips
is
really
from
the
terms
of
from
visual
tools,
really
I'm,
presenting
Clips
here
as
a
visual
tool,
because
that's
the
that's
the
backbone
and
and
what
it
does
you
can
you
can
write
Java
it's
you
can
easily
import
it
as
as
in
a
blog,
so
it's
it's
very
blog,
friendly
and
and
on
the
Clips
website.
This
is
a
very
nicely
documented.
How
to
in
include
a
Clips
snippet
into
a
blog
post,
HTML
file,
basically,
and
what
it
does
it.
F
F
It
supports
closure,
but
also
python,
also
Ruby
and
therefore,
of
course,
in
in
the
form
of
of
JavaScript
interpreters,
and
it
also
has
a
scheme
mode
which,
which
I
can
use
quite
quite
nicely
here,
because
it
formats
my
my
scheme
scheme
very
very
nicely
here.
So
this
is
all
the
formatting
is
done
by
clips
and
yeah,
and
you
can
you
can
hear
cosine
of
zero
well.
F
I
F
A
E
Okay,
so
here
it
is
I
suppose
you
can
see
it
right.
Yes,
wonderful!
So
yes,
basically
well
yet
another
editor
I
feel
it's
the
third
time
I'm
doing
some
presentation
on
this
on
some
kind
of
editor,
but
basically
it's
a
fork
of
atom.
As
a
as
I
said
in
the
beginning
and
I
decided
to
do
this
presentation
for
another
talk,
so
there
are
some
stuff
that
I
have
to
cut
down.
E
Hopefully
it
works,
but
wow
first
thing
is
when
I
say
that
I'm
working
on
a
fork
bottom
most
people
say
but
I,
don't
means
and
I
want
to
start
by
saying.
No,
it
isn't
I
mean
it's
not
slow.
It's
not.
It
does
not
consume
a
lot
of
memory.
This
is
how
things
happened.
Three
1.03,
1.2,
I,
think
and
atom
is
actually
pretty
fast.
E
Then,
but
posts
are
well
it's
a
slower
to
load
and
faster
to
operate,
because
we
had
to
do
some
trade-offs
for
Reviving
the
editor
and
we
already
proven
that
it
will
become
even
faster
when
you
upgrade
to
electrum
the
newest
version,
because,
as
you
can
see
on
the
newer
slides
things
are
rough
as
of
now.
So
the
first
thing
that
happened
after
Microsoft
announced
that
it
was
going
to
Sunset
the
project
we
had
to
rewrite
the
back
end.
Autumn
had
a
backend
that
says.
E
Okay,
here
are
the
packages
that
you
can
install,
here's
where
the
Telemetry
will
go
and
everything
else.
Somebody
decided
to
rewrite
the
back
end
and
I
am
really
glad
for
that
person,
because
if
it
was
not
for
this
rewrite
project,
I
would
not
be
working
on
poster,
because
it's
a
lot
of
work,
basically
and
as
soon
as
I
found
that
they
there
were
people
working
on
the
project.
I
decided.
Okay,
so
let's
make
it
easier
to
bootstrap
I,
remove
it
five
thousand
lines
of
code
that
kills
her
scripts
migrated
things
to
yarn
and
why
yarn?
E
Because
it's
the
only
one
that
works
good
job
node
for
compatibility,
it's
literally
the
only
package
manager
that
works
for
bootstrapping
and
installing
dependencies
on
the
add-on,
editor
and
I
try
to
bump
to
the
newest
electron
version
that
will
not
break
too
many
things.
It
broke
things,
but
basically
there
were
Telemetry
things
that
we
are
not
collecting
anymore
and
I.
Don't
believe
that
this
is
a
feature
nowadays,
no
Telemetry,
instead
of
a
I,
mean
so
just
a
little
bit
of
facts,
atom
diet
on
Electro
9.
E
If
you
are
famous
about
electron,
you
know
that
at
the
time
the
version
was
22,
so
we
were
11
versions
behind
the
newest,
which
in
JavaScript
terms,
that's
mean
like
an
eternity
we
were
able
to
bump
to
electron
12,
remove
adult
telemetry
on
the
process,
so
it
was
like
a
double
win
and
as
of
now,
we
can
run
the
editor
on
electron
23.
But
there
are
a
lot
of
breaking
changes
and
plugins
that
won't
work,
but
I
mean
it's.
E
It
is
a
huge
milestone
that
we
were
able
to
get
so
to
summarize
a
little
bit
of
the
breaking
changes
that
I
I
found.
If
you
want
more
details
about
that,
you
can
see
my
other
top
list
course
versus
this
pnb,
but
basically
npme8
broke
compatibility
with
7.
That's
why
we
migrated
to
yarn
electron
12
broke
compatibility
with
10,
but
that
was
out
Elementary
stuff.
So
it
doesn't
matter
13,
broad
compatibility
for
12,
and
that
affects
the
core
library
that
powers
the
editor.
So
it
would
not
have
any
editor
anymore
on
electron
13..
E
We
were
able
to
migrate
this.
This
Library
separate
string
to
one
so
now
it
works
and
Electro
14
bro
compatibility
with
the
12,
and
it
affects
one
of
our
tokenizers.
The
three-seater
so
and
21
broke
the
other
tokenizer.
So
if
we
would
not
do
anything
on
the
editor,
we
will
not
have
like
the
editor,
the
and,
if
we
could
have,
the
editor
would
not
have
any
kind
of
syntax
highlighting.
E
So
that's
kind
of
amazing
that
things
are
are
working,
so
we
decided
to
move
really
fast,
make
it
easy
to
hack
and
one
of
the
things
that
I
hate
when
I
see
like
open
sources
projects,
especially
especially
considering
editors,
is
like
when
you
go
to
the
GitHub
page
and
see
well
to
to
run
this
code.
Clone
install
these
things
then
build
a
binary
and
I
was
like
no
I
want
a
binary
to
try
right
now.
E
So
around
the
first
moment
we
already
were
offering
binaries
even
on
like
feature
branches,
so
people
would
be
able
to
Simply
jump
and
use
the
latest
latest
thing
or
multiple
operating
systems
even
sign
it.
So
it's
kind
of
interesting
this
and
we
made
the
CI
working
again,
not
green,
just
work,
so
you
can
imagine
the
state
that
things
were
we
disabled,
Rebellion
pixel,
broken
test.
It's
still
a
working
progress.
We
are
trying
to
removing
house
dependencies.
E
There
are
a
lot
of
them,
but
we
don't
have
manpower
to
to
basically
maintain
them
and
rewrite
receiver
that,
like
insanely,
that
was
done.
We
could
do
that.
So
we
now
have
like
a
newer
tree
sitter
that
basically
works
the
same
as
everyone
else,
not
in
my
gonna
or
the
implementation,
but
here's
the
core
of
the
thing.
E
Why
bother
and
like
the
the
editor
the
atom
had,
at
least
in
my
opinion,
one
of
the
most
interesting
plug-in
season
I
ever
saw,
and
it
was
really
really
well
documented
and
I
try
to
write
plugins
for
an
lvim
to
even
to
MX
and
vs
code
and
still
up
to
this
day,
I
think
the
atom
is
one
of
the
most
interesting
that
I
ever
saw,
and
one
of
the
reasons
of
that
is
that
they
call
the
services
Hub.
Basically,
plugins
can
offer
services
for
the
editor.
So
this
element
here.
E
It's
a
plugin,
so
we
have
the
editor
here.
This
is
core,
but
this
is
not
core.
Well,
it's
a
Corp
logging,
but
you
can't
disable
and
have
no
outcomplete
in
your
system
or
you
can
replace
it
and
have
a
different
kind
of
autocomplete,
even
with
different
uis
or
basically
whatever
you
want.
I
mean
it
works
like
that,
and
this
plugin
it's
called
out
out
complete
Plus
and
it
defines
a
service
account
out
complete
and
it's
a
consumer
of
the
service.
E
And
what
this
means
is
that
as
soon
as
you
export
complete,
it
will
display
this
UI
element
from
the
editor.
That's
completely
on
the
plugin
side.
There's
nothing!
The
editor
doesn't
even
know
that
this
thing
here
exists,
and
it
also
offers
a
provider
for
this
autocomplete
it
it's
default
provider.
Basically,
they
call
it
subsequent
provider.
It's
something
like
this
end
appears
somewhere
in
the
editor
and
it
will
sort
by
proximity.
E
So
if
the
end
appears
before
the
key,
the
end
is
the
first
element,
but
as
soon
as
you
can,
as
you
have
another
plugin,
that's
for
example,
think
about
chlorine.
It
can
offer
a
different
provider
for
the
outcomplete
and
now
what
complete
Plus
have
two
providers
and
can
ask
for
completes
from
this
one
or
this
one,
and
now
we
have
like
a
more
semantic
thing,
like
ID
clipboard
element
enable
persistence.
E
This
is
where
all
really
elements
of
from
the
JS
atom
and
they
are
all
provided
by
chlorine,
which
means
that
every
plugin
can
offer
a
service
easily
and
other
plugins
can
consume
that
service
and
enrich
the
original
plugin
experience
and
they
are
independent.
Chlorine
doesn't
know
that's
talking
without
a
complete
plus.
It
knows
that
that
is
talking
with
a
service.
So
if
the
outcomplete
plus
doesn't
exist,
it
doesn't
matter,
chlorine
works
the
same,
and
but
again
this
could
probably
be
implemented
in
other
editors.
E
E
These
were
all
internal
firm
clerk,
but
this
need
to
exist
because
the
repo
here
needs
to
somehow
interact
with
the
the
editor
and
the
browser.
So
we
have
a
rebel.
We
have
all
these
things
and
the
repo
it
talks
to
the
server.
Oh
it
it
basically
not
Target
opens
up
a
service
that
opens
up
a
fire
water.
Your
editor
will
connect
to
the
repo
and
the
browser
will
connect
this
server.
And
now
you
only
did
this
because
the
repo
it's
called
it's
talking
in
repo
the
service
is
talking
hcpn
and
web
services.
E
The
file
Watcher
is
talking.
Its
own
protocol
depends
on
operating
system
and
a
browser.
It's
a
different
thing
altogether
that
only
under
the
VPN
websockets.
So
supposing
we
can
make
this
a
single
thing
like
a
poster?
It's
the
editor,
so
poster
is
electron.
So
it's
a
browser.
It
also
is
node.
So
you
don't
need
all
this
interaction.
E
E
Yes,
so
only
if
that's
not
enough,
we
have
an
interesting
like
config
system
like
with
explicit
types
line,
numbers
no
risk
paying,
because
you
don't
have
to
type
shift
and
comments,
and
if
this
sounds
really
weird
that
this
format
sounds
really
weird.
Please
remember
that
today
is
the
April
Fool.
So
it's
it's
not
very
open.
Amazing,
that's
it!
Thank
you.
I
Yeah
I
had
a
quick
question
so
when
or
basically
I'm
just
curious
what
other,
if
any
kind
of
alternatives
to
like
electron
plus
atom
that,
like
I,
think
you
did
mention
some
of
the
other
Alternatives
that
you
or
that
you
were
interested
in
the
plug-in
system
from
Adam
I'm
curious.
What
other
kind
of
alternatives
you.
E
E
I
tried,
I
think
it's
the
RV
I
am
it's
the
only
lpim
for
or
Implement
not
implementation,
but
basically
a
UI
elements
that
have
a
programmable
web
viewer,
but
I
could
not
make
it
work
correctly
and
I
tried
like
vs
code,
but
the
interaction
of
the
editor
and
the
webview.
It's
really
complicated.
You
need
serialization
and,
in
the
end,
I
thought.
Okay,
if
I
need
to
serialize
my
code
to
put
things
in
a
webview.
What
difference
does
it
make
then
just
use
a
browser
and
put
my
stuff
there.
C
E
I
E
I
A
B
You
yeah
to
comment
on
that.
Like
I'm,
one
of
the
the
Culver
crazy
people,
writing
that
and
one
of
the
reasons
I
liked.
The
thing
I'm
gonna
show
later
with
the
notebooks
is
that
vs
code
really
is
in
your
way,
sometimes
so
like
often
where
it's
like
I've
got
a
really
nice
editor
and
now
I
just
want
to
put
inline
values
after
you
evaluate
something
and
like
they
just
don't.
B
Let
me
I
can
put
it
into
like
a
hover,
and
then
you
can't
resize
the
hover
and
so
on,
like
you've
got
these
problems
and
you
want
to
have
like
a
rich
displaying
of
stuff,
but
they
just.
There
are
certain
spots
that
where
you
have
like
a
little
window,
you
can
put
a
rich
stuff
in
there,
but
that
stuff
again
can
interact
with
the
stuff
around
it
like.
When
you
do
a
web
view
in
vs
code,
you've
now
got
like
a
strange
event,
Loop
handling
and
in
there
like
it's,
basically
a
browser.
B
That's
not
really
connected
to
the
editor,
so
I
understand
why
you
would
want
to
have
an
editor
where
it's
like.
It's
not
in
your
way.
It's
that,
like
yeah
sure
you
can
shoot
yourself
in
the
foot
and
like
destroy
it,
the
user's
interaction
with
it,
but
it's
also
like
if
I
know
what
I'm
doing
I
can
like
you
can
run
some
closure
code
and
I
can
give
you
the
actual
value
or
the
stuff
that's
happening
in
the
middle
of
your
code.
B
E
Yeah
poster
is
basically
a
fork
with
the
same
API,
so
you
can
and
that's
something
else
so
that's
interesting,
because
when
we
bump
it
to
electron
the
newest
one,
it
got
faster
because
the
rendering
engine
and
everything
else
got
faster.
So
we
I
think
chlorine
runs
about
50
of
the
speed
in
the
newer
selector,
which
is
a
huge
like
it's
half
the
time
and
I
was
like
what
did
I
do
and
basically
nothing
I,
just
bumper,
the
electron
But.
E
To
answer
the
question
to
to
complement
something
that
looks
said,
Autumn
is
powerful
enough
in
a
way
that
we
are
trying
to
add
some
layer
or
vs
code
plugins,
so
basically
to
one
extent
well
to
the
extent
of
what
we
could
implement.
We
can
display
things
that
are
made
for
vs
code
inside
atom,
because
the
API
or
platform
is
so
powerful
that
you
can
Implement
all
of
yes
code
inside
of
it.
The
opposite's,
not
true,
like
you
cannot
put
all
that
utensil
parts
inside
the
vs
code
as
an
example,
a
thinking
line
in
line
results.
H
So,
let's
see
you
should
be
able
to
see
my
screen
now
right,
yes,
cool!
So
what
I
do
is
I
built?
You
know,
I
was
playing
around
with
chat.
Gbt
I
was
having
an
output
code.
I
was
just
starting
to
do
some
like
web
development,
stuff
I
suck
at
web
development.
I,
don't
really
know
how
to
make
JavaScript
work
very
well,
I'm,
whatever
it's
not
good
at
drawing
svgs,
so
I
was
playing
around
with
strategypt
getting
it
to
Output.
Like
hey
drop
me
an
SVG
of
like
a
down
arrow
to
see.
H
If
you
get
it
to
put
that
in
the
top
of
a
window
and
like
animate
it
so
it
turns
when
I
click
it
whatever
and
I
decided
to
write
a
chrome
plug-in
to
basically
render
the
output
from
chat
GPT
instead
of
an
iframe
to
just
close
the
feedback
loop
a
little
bit
more
so
I'm
not
like
copying
and
pasting
the
code.
So
its
answers
are
a
little
bit
different
every
time,
but
I'm
gonna
put
this
prompting
and
we'll
see
what
it
does
I'm
going
to
ask
it.
H
H
So
you'll
see
it's
writing
some
code
and
then
what
my
plugin
does
is.
It
just
adds
this
little
render
button
so
right
now
it's
only
loaded
to
the
HTML,
because
it's
still
writing
the
CSS.
So
you'll
see
like
the
unstyled
output
here
and
then
when
it
finishes
the
CSS.
We
can
add
that
in
and
we
need
to
finish
this
JavaScript
at
that
point
as
well.
H
I
have
had
some
success,
getting
it
to
draw
charts
as
well,
so
still
pretty
basic,
but
I
had
it
like.
Well,
maybe
we
can
try
this
in
a
second
I.
Had
it
write
some
JavaScript
to
connect
to
an
API,
pull
some
data
from
the
API
and
then
render
it
in
a
chart,
and
it
was
kind
of
like
a
negotiated
process
to
get
it
to
do
this
properly,
but
I
think
it
would
be
really
cool
and
I
think
it
will
be
really
cool.
H
Yeah
there
we
go
okay,
so
it
builds
this
little
window
and
you
can
see
the
source
code
here,
like
all
my
plugin
is
really
doing,
is
creating
an
iframe
instead
of
the
code
block
that
it's
outputting
and
then
it's
allowing
me
to
select
which
of
the
code
blocks
that
it
has
outputted
that
you
want
to
include,
and
then
it
sticks
them
all
together.
Basically,
in
the
order
they
can
tell
it
to,
and
we
get
something
like
this
so
then
we
can
tell
it
like
I,
don't
know.
H
H
H
Okay,
that
was
faster,
I
have
also
played
with
trying
to
get
it
to
Output
closure
scripts
and
then
run
the
closure
script
through
your
compiler
and
so
far.
What
I've
found
is
that
the
JavaScript
that
outputs
is
much
better,
but
if
you
have
an
output
JavaScript
first
and
then
tell
it
to
translate,
to
closure.
Script
comes
out
much
better.
H
So
with
like
a
real
plugin
for
this,
you
could
imagine
doing
these
sorts
of
like
iterated,
prompts
in
the
background
to
make
the
the
ux
a
little
bit
nicer,
but
it's
all
still
so
Patchwork
that
it's
hard
to
know
exactly
how
okay
there
we
go.
Let's
play
that
sine
wave
here
and,
let's
say
another
sine
wave.
Let
me
touch
public
API
apps
rainfall
per
month
in
California.
H
Okay,
let's
see
how
this
one
goes
so
far,
really
in
terms
of
web
development.
Stuff
I've
only
used
this
as
like
a
getting
started
thing
or
to
develop
isolated
elements
like
I
was
saying
svgs
or
like
these
little
window
things,
but
it
has
been
interesting
to
see
how
much
it
can
get
done
on
its
own
and
for
me
personally,
this
has
reduced
the
amount
of
inertia
around
starting
something
new
or
like
like
okay,
I,
don't
really
programming,
JavaScript
or
I.
H
H
This
example
is
too
much
as
you
can
see,
the
complexity
ceiling
is
relatively
low
at
the
moment,
but
hey.
If
anyone
wants
to
try
it
out,
it's
GitHub
here
and
I
did
submit
it
to
the
Chrome
Store
I'm,
not
sure
if
that'll
approve
it
or
not,
I
might
be
breaking
some
policy
or
another
yeah,
but
that's
already.
B
H
Yeah
I
haven't
tried
this
specifically
with
copilot,
just
because
mostly
I
use,
IntelliJ
and
I'm
actually
not
familiar
with
the
plugin
system
at
all.
Here
so
I
haven't
tried
that
I
will
say,
like
I've
I've
been
using
copilot
and
I
found
it's
most
useful
for
like
autocomplete
things
rather
than
co-generation,
like
I've
tried
to
get
it
to
do.
Algorithms
I
think
the
only
thing
I've
really
had
success
with
was
I
had
like
a
random
number
generator
with
uniform
numbers.
I
was
like.
Can
you
write
a
thing
to
make
this
a
normal
distribution
into?
H
Like
you
know
the
Box
roller
transform,
or
whatever
it's
like?
Okay
I
got
that
one,
but
with
other
things,
I
haven't
been
able
to
get
it
to
generate
more
than
like
one
line
of
code
ahead
and
have
it
do
a
very
good
job.
But
it's
been
super
helpful,
like
it
makes
programming
a
little
bit
faster
than
it
would
be.
Otherwise
it
just
takes
the
feedback
loop.
E
So
I
wanted
to
complement
a
little
bit
because
well,
we
were
experimenting
with
some
editors
like
cursor
that
basically
made
some
of
the
stuff
and
I
did
try
to
write
a
plugin
system
for
the
poster
that
uses
chapter
generate
code
and
it's
actually
16
lines
of
code.
So
if
you
want
to
take
a
look,
I
can
guide
you
through.
That
sounds
awesome
because
you
can
basically
again
we
are
inside
the
editor.
You
can
basically
try
to
generate
a
code
and
pick
up
the
result
and
display
another
stpg
and
see
if
it
works.
E
A
Certainly
what
was
difficult
and
what
was
possibly
surprising,
because
right
in
a
way
working
with
GPT
is
maybe
a
little
bit
a
different
mode
of
programming
discovering
what
we
can
receive
and
what
we
cannot
receive
from
it
and
yeah.
Maybe
we
wish
to
comment
about
this
experience
of
working
with
it.
H
Yeah
yeah
I
mean
honestly
I've,
been
I.
I,
see
why
people
are
are
skeptical
about
its
utility,
because
it's
not
like
you
know
you
just
type
in
what
you
want
and
it
will
build
the
whole
thing
for
you,
which,
frankly,
wouldn't
be
any
fun
anyway,
but
I
think
it's
pretty
cool
that
you
can
tell
that,
like
you
know,
I've
never
built
a
Chrome
extension
before
and
Chrome
apis
update
and
break
more
frequently
than
other
things.
H
But
I
don't
know
more
generally.
I'm
just
excited
to
see
what
people
are
building
with
this,
because
I
think
like
it's
interesting
that
the
wow
moment
for
this
GPT
interface
came
when
they
put
this
chat
feature
on
top
of
it
like
to
everyone
not
just
to
people
who
already
liked
working
with
Rebels
this
process
of
like
iterated
conversation
and
resolve,
turned
out
to
be
the
thing
that
made
it
like
a
joy
to
use
so
I
think
we're
gonna
see
a
lot
more
of
that.
H
A
B
Yeah
sure
so,
color
notebooks
have
been
a
thing
for,
like
I,
think
about
four
months
now
we're
using
notebooks
and
vs
code
at
work
to
do
like
displaying
of
our
custom
language
and
I
was
like
while
I
was
building
it.
I
was
like
well,
I
mean
getting
that
into
cover,
doesn't
seem
that
difficult
and
so
like
over
a
weekend.
I
was
able
to
like
get
it
in
there
and
it's
been
a
nice
experience.
B
C
B
B
So
I
was
talking
to
him
how
we
can
get
portal
into
kava
notebooks,
and
it's
been
a
thing
as
well
for
like
three
months
now
whatever,
but
we've
always
had
the
problem
that
basically
in
calvanot
books
your
running
some
code,
then
it
gets
3D
printed.
It
gets
put
into
the
cell
and
then
portal
can
take
over
and
display
that
value
that
works
great
for
kind
of
small
values,
but
once
they
are
big,
you
don't
really
want
to
print
the
whole
thing
or,
if
the,
if
they're,
even
basically
infinite.
B
If
I
do
a
range
from
0
to
infinite,
it
doesn't
work
very
well
to
PT
print
them,
and
we've
now
managed
to
connect
portal
in
a
very
similar
way,
as
it's
usually
connected
where,
instead
of
giving
it
a
whole
Bell
you're
pretty
printed,
it
just
gets
a
way
to
get
at
the
value
and
does
the
connection
itself.
So
it
can
lazy
load
stuff.
B
In
the
background,
the
whole
value
doesn't
have
to
be
pre-compute
it
and
it
doesn't
need
to
like
resent
the
whole
thing
to
cover
or
to
the
browser
or
whatever
I'm
gonna
show
it
up
right
now,
if
I
manage
to
hit
the
correct
button,
we'll
see
there
we
go.
Hopefully
there
you
go
yeah
that
seems
correct.
E
B
Okay,
you
should
be
seeing
like
a
notebook,
CI
namespace,
hopefully
right,
yeah,
okay
cool,
so
this
is
the
the
Calvin
notebooks
just
a
normal
cover
window
and
to
get
here
you're
taking
normal
closure
files
like
this
is
the
closure,
and
this
is
the
portal
code,
but
it
works
in
any
closure
project
and
you
don't
have
to
do
anything
special
to
get
notebooks.
All
you
do
is
right.
Click
open
with
and
choose
closure
notebook.
It's
currently
in
cover
splits
instead
of
call
Buffer,
weird
vs
code,
buggy
reasons,
but
it
still
works.
B
You
just
click
this
and
then
you
get
like
this
thing.
Instead
of
getting
the
same
file
in
a
non
in
a
normal
text,
editor-
and
in
here
you've
got
like
the
normal
notebookie
stuff.
You
can
click
to
execute,
and
then
you
get
the
result
below
it.
I've
already
executed
a
bunch
of
these,
mostly
because
they
take
a
while.
This
is
portals,
see
I
running
thing,
and
it
sounds
pretty
nicely
why
the
new
features
that
works
pretty
well
because
previously,
if
you
run
this,
you
wouldn't
really
like
here,
you
might
have
seen
the
exception.
B
That
was
wrong,
but
in
here
you
would
have
basically
seen
nothing
because
it
actually,
this
code
returns
an
atom
that
gets
or
like
a
promise
that
gets
filled
up
so
usually
you'd
get
the
promise
back
and
then
there's
nothing
in
here.
But
now,
if
I
run
it
I,
it
takes
a
while.
Well
should
have
cleared
this
previously
yeah.
Let
me
clear
the
cell,
while
this
is
still
running-
and
hopefully
it's
going
to
pop
up
right
when
this
is
done
after,
like
10
seconds
or
whatever
yeah.
B
B
I
need
to
press
that
correctly.
Well,
apparently,
I'm
doing
it
wrong
at
the
moment
anyway.
Usually
data,
fireworks,
I
think
I
can
show
it
later
in
the
data
namespace.
The
cool
thing
is
when
I
change
presentation
here,
I'm
going
to
show
it
out
later
as
well.
Is
this
value?
Isn't
anything
like
the
actual
value
isn't
in
here?
B
B
Nice-
and
you
can
see
all
of
these
things
are
just
these
values
that
saying
well
portal
go
grab
that
thing
in
here.
You
can
see
some
well
I
need
to
change.
Oh
actually,
I
wasn't
wanted
to
talk
about
this,
and
one
of
the
cool
things
is.
This
is
not
just
a
portal
thing.
Anybody
can
basically
jump
in
here.
Calva
runs.
These
runs
the
code
for
you,
but
the
display
is
just
normal
text,
as
you
can
see,
and
you
can
write
a
plugin
for
vs
code.
That
just
says
well,
I
understand
this.
B
It's
just
everybody
basically
can
use
this
instead
of
this
being
portal,
and
then
we
can
run
these
things
and
show
them,
and
we've
got
rich
interactions
in
here
and
there's
pictures
and
whatever,
like
all
the
usual
portal
Works
stuff.
Now
previously
it
was
breaking
on
some
stuff
because
it
was
so
larger.
You
can
interact
back
into
the
into
the
jvm
to
get
like
error,
inverse
and
stuff.
G
G
I
can
use
them
real,
quick
and
then
start
clicking
on
some
of
the
keywords.
Oh
so
I
know
in
the
like
data
namespace
and
then,
if
you
scroll
up
to
the
I,
think
it's
like
the
second
or
third
cell.
So
this
is
only
other
thing
to
get.
Is
sorry
go
up
a
little
bit.
It's
like
The,
Hacker,
News,
set
of
keywords,
yeah.
B
G
Stories
news
stories:
I
just
want
yeah
so
before,
because
everything
was
clearly
it
says:
Eden,
you
wouldn't
get
access
to
any
of
the.
Do.
You
define
nav
stuff,
but
so
sorry
go
go
back,
real,
quick
and
then
click
the
metadator.
So,
like
a
part
of
data
find
nav
is
you
can
add
metadata
to
maps?
And
you
can
say:
oh
when
you
nav,
this
data
call
this
function.
So
if
you
just
double
click
one
of
those
keywords,
it
should
in
theory
call
Hacker
News
and
pull
stuff
from
its
API.
G
B
Which
is
really
that,
plus,
you
can
like
all
the
normal
stuff
like
go
get
type
and
whatever
is
suddenly
working
which
wasn't
before
before
you
were
well.
I
mean
it
was
working
on
some
stuff
that
you
didn't
knew
the
data,
but
some
other
stuff,
where
you
just
like
defined
your
own
data
type
right.
That
couldn't
call
back
into
the
jvm
to
ask
for
the
stuff
that
you
needed
and.
G
Not
words
yeah,
if
you,
if
you
click
on
the
whole
set
and
then
there's
like
the
little
thing
that
goes
out,
it's
like
on
the
right,
yeah
click
the
little
external
link
button.
So
what
this
will
do
is
it'll
take
the
value
that
you
have
and
open
it
up
in
a
new
portal
instance,
so
you
can
like
like
kind
of
capture
it,
and
then
this
one
is
still
connected
here.
You
see
how
it
says:
jvm,
so
not
only
did
it
open
it,
it
opened
it
up
connected
to
your
jvm.
B
B
The
thing
that
portal
did
is
just
provide
this
Netbook
renderer
thingy
inside,
like
a
package
Json-
and
this
thing
is
the
the
dxr
extensioning
I
have
here
and
then
it's
giving
you
like
a
domain
J
as
well
I
mean
it
for
portal.
Thankfully,
it's
actually
closure
script,
and
this
thing
basically
just
gets
an
event
with
a
message
that
you
can
get
and
then
you
can
print
whatever
you
want.
It's
not
super
difficult
to.
B
To
say
well,
I,
don't
like
the
way
portal
is
doing
these
things.
I
want
to
put
my
own
viewer
in
here
and
then
you'll.
You
would
be
one
of
these
things
and
you
can
like
say
well,
I,
understand,
Eden
or
playing
no
matter
whatever,
and
the
new
thing
that
we've
got
going
now,
which
is
why
I'm
talking
about
these
notebooks
again,
a
tiny
little
one-line
change,
insert
cover
that
is
basically
saying
to
enrapple.
This
is
not
a
normal
evolve.
B
This
is
a
notebook
evil,
so
anytime
I
press
this
I'm,
sending
like
an
eval
to
to
enrapple
with
this
code
right
and
now
I'm,
providing
it
one
special
extra
bar,
that's
just
saying:
well,
I'm
in
a
notebook,
that's
all
I'm,
saying
like
nothing
super
portal,
specific
or
whatever
I'm
just
saying
well,
this
is
a
notebook
and
no
portal
hooks
into
this.
I've
got
the
code
for
this
here
somewhere.
B
It
has
like
an
an
evil,
middleware
wrapper
for
for
n
Rebel,
and
it
can
grab
this
Evol
and
instead
of
returning
whatever
normal
print
would
return,
is
returning.
This
I
was
displaying
this
before
it's
returning
this
and,
if
you
guys
wanted
to
hook
in
there
as
well,
you
could
do
the
same
thing.
You
would
probably
clobber
yourself
with
the
middleware
of
portal,
but
the
nice
thing
about
the
middleware
is
well,
you
I
mean
it's
middleware
and
you
can
like
reorder
it
or
the
user
can
reorder
it.
B
It's
not
at
a
set
in
stone
and
there's
a
in
the
docs
of
portal.
There's
a
description
how
the
The
Notebook
wrapper
thingy
works,
but
basically
it
puts
like
an
example
in
here:
you're,
basically
just
putting
in
the
middleware
for
portal
and
ripple
red
notebook,
I'm,
also
usually
using
the
red
portal.
But
that's
another
thing,
and
then
you
could
write
the
thing
yourself
and
have.
B
Thing
or
you
could
start
understanding
the
same
structure
that
portal
understands
and
hook
in
there
as
well,
which
is
really
nice,
so
yeah
from
us
from
the
kava
side.
It's
really
cool
that
we
didn't
have
to
like
write
stuff
that
specifically
just
for
one
interaction
with
one
Library.
It
can
like
everybody,
can
hook
in
there
who's
interested
and
say.
Well,
we
kind
of
want
to
provide
our
own
viewers
in
here.
I've
been
talking
with
I
I'm,
really
good
with
names.
B
One
of
the
drug
guys
was
also
interested
in
maybe
putting
the
club
viewers
in
here,
and
they
had.
The
same
problem
was
like
well,
it's
nice
to
show
Eden,
but
we
we
would
have
like
to
have
a
richer
interaction
right
and
if
you
now
put
some
special
ed
I
mean
the
code
is
not
very
much.
Where
is
it
it's
like?
B
Basically
200
lines
of
code
and
half
of
it
is
doing
other
stuff
middleware
in
there,
so
that
clerk
suddenly
sends
the
values
that
it
understands
itself
and
the
viewer
itself
can
do
rich
interactions
back
and
forth.
So
yeah,
that's
really
nice,
we're,
probably
hopefully
gonna
get
kindly
in
there
as
well
at
some
point
right
but
yeah.
That's
it
unless
Chris
wants
to
like
add
this.
This
one
actually
has
basically
been
his
baby.
Mostly
I've
done.
B
F
G
G
G
B
G
G
Lucas
was
demonstrating
so
I'm
gonna
I'm
gonna,
pull
the
same
notebook
that
he
had
and
I'm
going
to
show
a
little
bit
more
that
you
can
do
as
well
with
an
editor
connected
notebook
is
the
like.
First
cool
thing
is
like
normally,
you
have
to
have
like
n
commands
and
you
have
to
know
which
commit
to
call
now.
G
You
can
just
open
up
the
notebook
that
has
all
of
the
code
and
you
could
just
start
like
iterating
on
this
one
specific
build
like
if
your
tests
are
failing
or
something-
and
you
want
to
just
iterate
on
that
one
thing:
instead
of
running
the
whole
build
again
or
knowing
the
command
to
run
that
part
of
the
build
you
just
click
play
on
the
code,
I
need
to.
Let
me
evaluate
the
NS
okay
and
then
I
can
rebuild
it,
and
so
it's
going
to
just
run
that
part
of
the
build.
G
So
I
already
think
that's
like
kind
of
nice
I,
don't
know
if
you
guys
have
that
same
pain
where,
like
I,
don't
want
to
run
our
entire
build,
but
I
want
I,
don't
have
to
have
like
n
little
commands
to
start
this
particle
or
that
part
of
the
build,
and
on
top
of
that
now,
if
you
take
a
look
at
the
output
of
what
it
used
to
look
like
which
is
like
right
here,
it
almost
looks
the
same.
So
it's
like
an
easy
path
to
migrate.
G
It's
like
the
test
output
is
a
normal
closure
test
output
and
then
I
kind
of
do
this
fancy
thing
for
table
formatting,
but
again
this
the
thing
that
sucks
is
this:
this
table
is
like
an
ASCII
table
and
it's
kind
of
it's
gone
now
and
I
can't
do
anything
with
it,
whereas
here
because
I
have
it
as
data
I
can
actually
do
stuff
with
it
like
selects,
columns
or
something
which
that
doesn't
look
like
I.
Think
there's
because
there's
metadata
on
it.
G
But
again,
that's
like
another
thing:
I
can
view
it
as
this
thing
I
can
view
it
as
what
is
it
called
I?
Can
pretty
print
it,
and
that's
that's
literally
underlying
data.
That's
driving
this
table
is
now
well
I.
Think
it's
a
different
table,
but
essentially
it's
like
it
keeps
the
data
intact
as
data
which
is
I,
think
really
cool
and
like
to
play
the
system
to
like
play
this
game,
you're
you're,
or
to
use
these
viewers.
Your
your
data
just
has
to
look
like
this.
G
It's
using
like
prereble
as
the
format.
Just
because
that's
the
thing
I
chose,
but
it's
not
really
important,
like
you,
can
have
your
own
viewers
that
do
other
formats
of
data
and
render
them.
However,
you
want,
but
if
I
go
back
to
the
pure
apple
viewer,
this
is
what
it
looks
like.
The
cool
thing
is
for
the
test.
Output
as
well
is
like
it's.
You
have
access
to
like
more
than.
G
Let
me
show
you
the
whole
thing
that
so
close
your
test
when
it
generates
data,
it
generates
data
that
looks
exactly
like
this
I,
don't
know
if
you
guys
can
see,
but
it's
just
like
a
list
of
these
test
things
which
actually,
if
you
want
to
better
look
at
it
and
the
table
viewer,
it
looks
like
I,
don't
know
if
you
guys
can
see
it.
So
these
are
the
maps
that
are
in
that
Vector
of,
like
all
the
things
that
your
test
outputted.
G
So
you
have
access
to
all
the
data
that
you
test
produced
and
like
and
like
all.
This
works
in
normal,
like
portal
Works
in
here,
because
it's
like
it
doesn't
really
care
about
where
the
data
came
from.
It
just
cares
about
that.
It
is
Data,
because
what
you'll
see
is
this
came
from
like
a
process,
a
closure
CLR
process
got
spawned.
G
G
Oh
I
think
I
went
I,
clicked
a
shortcut
to
go
forward.
I
go
metadata,
yeah,
the
vars
have
metadata
on
them,
which
has
like
file
information.
So
I
can
like
go
through
my
test
and
if
there's
a
failing
test,
I
can
use
my
editor
connected
commands,
which
are
like
go
to
definition,
which
this
should
work.
It
should
open
it
up.
Let's
see
this
one
doesn't
always
like
to
work,
but
in
any
case
I
I
can
take
these
values
and
inspect
them
in
my
runtime
and
do
things
with
them.
G
So
that's
just
that
like
color
I
wanted
to
add
is
to
me.
This
is
really
exciting
because,
like
I
I
want
to
build
programs
that
produce
data
at
every
level,
like
programs
that
I
like
our
servers,
but
also
build
programs
like
build
programs.
In
my
opinion,
you
should
just
produce
data
and
we
should
be
able
to
render
that
data.
However,
we
want
whether
it's
like
this
or
any
you
know
put
some
tables.
G
I
can
copy
it
as
Eden
and
share
it
with
other
people
and
just
keep
the
data
as
data
and
that
and
not
have
to
worry
about,
like
ASCII,
pretty
printing
it,
while
still
supporting
that
for
systems
that
require
that
right,
because
this
build
also
runs
on
GitHub
and
they
don't
have
these
facilities
and
that's
okay.
When
I,
when
I
don't
want
to
have
this
Rich
output,
I
can
just
output
the
old
way
of
doing
things
and
kind
of
do
both.
G
So,
hopefully
that
that,
like
is,
is
cool
I,
don't
know,
I'm
going
to
be
switching
to
notebooks
for
all
my
tests
or
for
all
my
CI
stuff,
just
because
it's
it's
so
convenient
to
just
click
play
and
then,
like
the
the
this
ran
in
a
Bob
ashka
instance.
This
will
run
in
a
closure
script
like
node
process
that
gets
spun
up
and
it's
cool
because
it
all
looks
the
same
too
right.
It
all
has
like
closure.
G
Closure
script
closer
share
a
lot
they're
very
consistent
about
their
like
stuff
that
they
output,
so
I
can
take
advantage
of
that
in
these
viewers
that
are
like
trying
to
pattern
match
that
data
right.
This
kind
of
looks
the
same
but
yeah
that
was
the
like
elaboration
on
that
there's
some
other
stuff
I
can
go
into
with
the
npm
stuff
that
I
think
I
was
going
to
talk
about,
but
I
don't
know
if
you
want
to
say
questions
on
this
first.
A
I
G
The
exact
the
exact
data
that
portal
gets
is
right
here,
which
I
can
view
that
as
a
table,
it
gets
like
a
map
with
these,
like
it
looks
like
P
Ripple
data,
just
because
that's
what
I
I
have,
but
it
has
like
tags
and
then
that
that
data
is
like
errors
and
Taps
errors.
Just
because
it's
like
not
standard
out.
This
is
like
the
tap
format
is
a
maps
that
have
a
tag.
G
The
tag
can
be
error,
tap
out
in
eval,
or
something
or
RIT
for
red
I'm,
not
sure
I
can't
remember,
but
the
values
that
are
tap
are
eaten,
so
I
can
render
this
in
the
Eden
viewer
and
I
can
render
this
in
the
Eden
viewer
as
well.
So
it's
getting
the
data
strings
because
it
knows
that
it's
supposed
to
be
in
in
Eden
value.
I
G
But
not
quite
so,
there
is
a
little
bit
of
instrumentation
that
I
had
to
do
in
my
test
Runner
and
that's
if
I
go
to
like
test
run
or
cl.js,
for
example
right
here
for
emitting
a
table
I
check.
If
the
process
got
passed
like
a
portal
Port.
If
so,
then
I
can
submit
the
data
as
data
as
like
a
tap
output.
G
So
my
sub
process
knows
that
it
can
tap
values
and
that
that
kind
of
makes
the
Dilemma
the
delimiting
of
standard
out
like
right,
because
your
process
normally
has
like
two
output
streams,
standard
out
and
standard
error.
What
if
tap,
was
also
another
Avenue
which
is
kind
of
what
you
get
with
like
prapples.
You
have
out
error,
tap,
eval
and
things
like
that.
G
G
I
G
It
will
send
it
to
the
parent
process
and
then
that
process
will
somehow
make
it
get
to
Portal's
hands
and
in
in
in
in
in
in,
in
this
case,
what's
happening
is
the
sub
process
is
being
like
the
HTTP
server
start,
the
sub
process
spins
up
it
like
sends
all
the
data
via
standard
out
standard
error,
Taps.
It
gets
captured
and
formatted
like
this
right
and
then
that
gets
returned
to
the
like
the
portal
notebook
viewer
which
had
no.
It
has
no
knowledge
of
any
of
that.
I
Does
that
make
sense,
but
it's
it's
eventually
getting
it's
the
the
because
there's
the
the
question
is
just
like:
it
seems
like
portal
is
out
of
process
from
this
sub
process.
Yes,
and
so
you
have
to
like
and
the
mechanism
for
getting
it
from
process
to
processes,
Network
socket
somewhere,
yeah
yeah.
G
I
G
I
G
Yeah
so
there's
a
little
bit
of
instrumentation,
but
this
is
kind
of
like
for
me.
The
ideal
like
workflow
is
just
to
like
get
get
your
build
output
as
data
right,
because
all
the
like
all
the
stuff
with
like
the
keyboard
and
like
viewers
and
then
people
adding
extension
viewers
and
all
that
stuff
like
that,
should
continue
to
work
as
well.
H
I
have
a
question:
that's
more,
maybe
just
about
how
what's
possible
with
portal.
In
the
first
place,
that
I
mean
it
might
be
kind
of
a
category
error.
But
if
you
wanted
to
create
a
viewer
for
something
that's
Dynamic
like
let's
say
you
have
like
a
websocket
connection
and
you
want
to
view
the
messages
as
they're
coming
over
the
connection.
H
G
H
G
And
so
you
actually
don't
even
need
any
of
that
to
use
like
portal,
you
can
just
have
your
own
atom
like
like
this,
and
so
this
is
another
advantage
of
the
process
connected.
Notebook
is
okay,
I
hope
this
works,
don't
make
me,
look
proud
a
conj
pie
right
and
I
just
eval.
This
and
you'll
see
there's
there's
a
kind
of
an
a
right
there,
but
I'm
I'm
mutating
the
output
of
the
previous
cell,
because
the
previous
cell's
value
is
an
atom
right
like
if
I
do
like
nil
here.
G
H
G
Within
the
notebook
context
you
can
delete
the
cell.
I
would
say
that
that
would
probably
be
the
easiest
thing
to
do.
I
don't
know
where
it
is
here,
it
is
there's
a
delete.
I
would
say,
that's
probably
what
you
want
to
do,
and
then
there
are
like
garbage
collection
mechanisms
that
kind
of
are
like
lower
level.
Things
that
are
important,
that'll
make
sure
that
that
value
will
get
cleaned
up,
which
is
what
makes
like
the
notebooks
like
you're,
not
accumulating
all
that
garbage.
G
Hopefully
it
it'll
take
a
little
bit
of
time,
but
I
am
processing
the
stuff
sure,
but
yeah
I
would
delete
stuff
in
like
normal
portal,
we
have
like
a
separate
window.
You
just
have
to
remove
from
the
like
data
structure,
because
at
the
end
of
the
day,
like
portal
is
just
like
give
me
a
data
structure
and
I'll
render
it.
So
if
you
want
stuff,
that's
not
if
you
want
to
remove
that
stuff
from
the
data
structure,
you
can
just
use
your
normal
data
structure,
operations,
cool.
G
G
This
render
output
item
is
a
musical
specific
thing,
but
everything
else
for
the
most
part
like
RPC
connect.
All
this
stuff
is
like
I
guess
this
isn't
obvious
good
specific
thing,
but
all
this
code
exists
in
isolation
and
it's
consuming
the
like
underlying
UI
Library.
That
can
also
be
used
independently,
obvious
code
entirely
right.
G
G
Yeah
because
it
there's
also
like
a
completely
Standalone
mode,
that
requires
no
runtime,
and
it's
just
on
the
internet.
You
can
download
this
or
not
down.
You
can
load
up
the
UI
independent
of
everything
and
it'll
still
pass
Transit
and
Eden
and
all
that
stuff,
because
all
that
speaks
in
a
closer
script
anyway,
yeah
it
should
be
able
to
pretty
easily
go
into
other
editors
like
like
pulsar.
A
A
This
namespace
as
a
notebook
project
which
is
trying
to
to
offer
some
convention
of
how
to
to
to
express
things
in
a
way
that
is,
that
should
work
across
different
tools
and
maybe,
after
this
short
update,
we
could
have
a
discussion
yeah
so
so
that
the
idea
is
that
a
few
of
us
have
been
using.
This
idea
called
your
namespace
as
a
notebook,
which
is
the
general
idea.
A
In
some
way
and
and
then
in
the
cyclos
community.
We
have
been
going
through
tutorials
and
study
groups
and
all
kinds
of
things
and
for
a
while
we
were
using
node
space,
but
then
more
more
elaborate
tools
that
arise
like
Clerk
and
then
we
had
a
question:
should
we
drop
the
old
notebooks?
Could
we
somehow
keep
going
with
the
new
tools
such
as
Clerk
and
Calvin
notebooks?
A
So
a
few
tools
which
are
working
is
Clay,
which
is
the
tool
I'm
using
to
render
these
slides
from
closure.
Namespace
and
Clay
creates
an
HTML
document
and
with
with
some
closure
script
inside
using
the
skittle
interpreter
that
Marcus
was
talking
about,
but
clay
can
also
render
a
kuboto
document
with
some
Skittle
inside.
A
So
this,
these
slides
are
generated
by
this
tool
called
clay
which
is
generating
a
quarter
document
and
has
some
quota
options
to
render
as
slide,
and
it
is
using
the
kindly
convention
to
express
how
things
should
be
rendered,
but
this
document
can
also
be
rendered
as
clear
using
clerk,
so
I
think
yeah.
This
is
a
clerk
document,
rendering
the
same
things,
including
tables
and
and
plots
and
so
on
right.
A
So
it
is
the
same
namespace
rendered
as
Clerk,
alongside
the
option
to
render
it
as
slides,
and
the
idea
is
that
currently
is
this
convention
allowing
to
express
both
both
things.
And
you
know,
we
could
imagine
this
kind
of
specific
use
case,
which
is
not
so
different
from
what
a
few
of
us
are
doing
these
days.
Well,
maybe
let
us
say
two
of
us
are
working
on
a
project
and
we
we
share
the
same
namespace
and
one
of
us
is
using
Clerk
and
another.
A
So
maybe
let
us
just
play
with
it
a
little
bit,
and
so
you
see
we
can
have
this
kind
of
of
we.
Let's
say
we
have
a
data
set
of
the
tablecloth
Library,
so
we
can
render
it
printed
as
a
data
set,
but
we
can
also
have
a
table
view
that
you
know
you
see
we're
saying
this
thing
is
of
Kinds
table.
That
is
the
kindly
notation
so
the
this
way.
A
We
know
how
to
to
render
it
as
using
some
interactive
table
view,
so
we
can
use,
we
can
search
and
sort
and
so
on,
and
if
we
use
clerk
for
the
same
code,
it
would
render
using
the
clerk
table
View
and
when
we
have
portal
support,
it
would
use
the
portal
table
View
and
we
can
can
have
data
visualization.
So
here
we're
using
the
Hanami
library
and
we
are
saying
okay.
The
result
of
this
Hanabi
workflow
is
of
kind
Vega
light,
which
is
this
data
specification
for
plots
so
yeah.
A
A
This
Library
by
by
Sam
Ritchie
I,
mean
the
closure
script
wrapper
of
math
books
that
Sam
Ritchie
has
recently
created,
and
so
we
can
create
things
like
that
and
again
we're
hoping
to
make
everything
compatible
across
tools,
and
so
that
was
a
little
taste
of
how
things
are
looking,
basically
we're
just
specifying
that
certain
things
are
of
certain
kinds
and
another
thing
we've
been
looking
into
is
back-end
computation,
so
we
wish
to
create.
This
is
already
specific
to
Clay.
A
But
portal
also
has
a
really
nice
capabilities
of
having
a
back-end
connected
to
the
browser
view,
as
we
saw
and
and
these
days
I'm
looking
into
how
to
take
something
that
has
some
back-end
computation.
You
see
here,
I'm
simulated,
some
simulating
some
slow
computation
taking
on
the
back
end
and
how
to
embed
it
in
the
different
kinds
of
documents
and
then
how
to
take
that
and
make
it
rendered
as
a
static
document
where
the
back
end
is
not
available
anymore.
So
maybe
I'll
just
to
make
it
more
clear.
A
When
you
render
things
as
a
static
document
and
yeah
and
in
the
near
term,
my
attention
is
going
to
be
a
lot
into
making
things
easy
around
this
kindly
convention,
and
mostly
portal
and
Calvin
notebooks
are
things
that
I'm
looking
to
integrate
with
and
so
that
this.
This
is
what
I'm
studying
these
days
and
yeah.
So
this
was
a
little
update
about
currently
we're
now
around
like
half
an
hour
after
the
official
time
and
maybe
a
bit
later
for
a
few
people.
A
C
A
Yeah,
so
maybe
it
makes
sense
for
those
who
wish
to
stay
a
little
bit
to
have
a
little
break
as
Chris
proposed
and
for
those
who
wish
to
stay
they
could
meet
again
after
five
minutes
or
so
and
maybe
I'll
stop
the
recording.
Now
so
that's
everybody
wish
to
say
anything
before
we
say
goodbye
to
the
recording.
A
Yeah,
though
so,
thank
you
so
much
for
all
the
amazing
presentations,
I
think
all
the
topics
we
saw
today
each
of
them
deserves
a
whole
session.
So
let
us
you
know:
if
anybody
wishes
to
talk
more
about
what
you
were
presenting,
then
let
us
have
just
a
dedicated
session
for
that
and
let's
say
goodbye
to
our
friends,
listening
to
the
recording
and
we'll
keep
chatting
after
stopping
there.
So
goodbye.