►
From YouTube: October 19th, 2020 Jupyter RTC Community Meeting
Description
Recording of the Jupyter Real Time collaboration public meeting.
To attend the next meeting and see a list of all the notes, see this document: https://hackmd.io/UbnBH58hS8itoWgfiWT77A
Notes are archived to a Github issue https://github.com/jupyterlab/rtc/issues/3
A
A
Yeah,
so
this
was
for
the
rtc
talk.
I
have
opened
also
another
an
issue
just
to
track,
and
it's
linked
also
to
the
question,
or
do
we
transfer
the
kernel
messages?
I
think
if
we
have
visuals
to
with,
like
sequence,
diagram
with
actor,
which
is
a
client
server
and
so
on?
A
And
so
it
is
issue
87.
I
didn't
push
yet
a
lot
there,
but
yeah.
I
think
it's.
It
can
be
useful
to
have
a
discussion
around
what
what
we
do.
B
Sounds
good
and
maybe
working
on
those
diagrams,
that's
something!
Maybe
we
could
do
on
a
call
together
this
week,
sometime
eric.
I
think
that
would
be
useful.
B
And
then
some
of
the
demo
I
wanted
to
show
today
kind
of
speaks
to
the
first
question
that
you
had
about
the
kernel
messages
at
least
one
way.
We
could
approach
that
and
then
the
second
one
is
about
yeah,
the
notebook
model
state
and-
and
that's
what
I
had
on
my
docket
for
the
next
couple
weeks,
I
was
exploring
how
to
represent
that
on
the
server.
B
B
So
I
guess,
unless
there's
discussion
on
this
things
that
could
start
could
show
the
demo.
B
B
B
So
this
slash
graphql
this
like
playground,
but
this
is
kind
of
a
cumbersome
to
write
a
bunch
of
queries
and
then
get
the
results
back
and
use
them.
So
I
wanted
to-
and
I
have
some
tests
that
that
test
the
queries,
so
I
thought
it
might
be
nice
to
be
able
to
do
this
in
a
notebook
to
kind
of
explore
some
test
cases.
B
So
this
is
kind
of
cool,
because
it's
actually
using
the
jupiter
server
pi
test
fixtures
and
it's
pulling
those
in
to
start
a
server
here
and
then
once
we
have
a
server
started,
we
can
run
graphql
queries
against
it.
So
in
this
case
it's
running
this
query
or
this
mutation
called
start
kernel
and
it's
grabbing
off
the
kernel
id.
B
B
So
now
we
can
like,
for
example,
get
a
list
of
the
kernels
and
see
their
execution
state.
We
see
we
have
a
kernel,
that's
idle!
B
Another
thing,
that's
kind
of
nice
here
is
we
can
run
subscriptions
which
are
like
over
web
sockets
and
they
get
up
that
you
listen
for
changes
so
here
I
can
listen
for
this
kernel
id
when
the
execution
state
changes
and
then
so
this
is
running
and
then,
if
I
restart
the
kernel,
I
see
that
we
get
these
messages.
It
was
restarting,
it
was
starting,
it
was
busy
and
now
it's
idle
again,
so
this
is
kind
of
a
nice
way
to
like
test
what
we're
doing
and
make
sure
that
it's
reasonable.
B
I
guess
we
see
some
of
the
standard
out
too
gets
fed
in
here,
but
anyway
the
point
was
to
try
to
do
some.
I've
hooked
up
some
of
the
listening
on
some
of
the
channels
so
that
we
can
actually
do
some
code
execution.
So
I'm
gonna
be
executing
this
cell
here,
I'm
grabbing.
I
can
actually
just
grab
less
of
this,
but
anyway,
I'm
executing
so
here
I'm
doing
a
mutation.
B
I'm
x,
I'm
calling
execute
is
the
mutation
and
I'm
passing
in
the
kernel
id
and
my
code,
and
then
all
this
is
just
what
I
want
to
fetch
right
after
I
run
the
mutation,
which
is
the
current
execution
and
all
these
fields
from
it,
so
that
the
idea
is
that
on
the
server
we
have
a
list
of
all
the
executions
that
happen
and
we
save
those
so
that
the
server
is
responsible
for
keeping
those
up
to
date
with
the
drmq
kernel
messages,
not
the
clients.
So
we
can
run
this
execution
and
we
see
starts
out.
B
We
don't
know
the
status,
there's
no
displays,
there's
no
input
request,
we
can
see
the
code
and
the
id
and
then
we
can.
After
a
little
bit,
we
can
run
the
query
to
get
the
execution
passing
an
execution
id
and
we
can
see
we
get
out
display
a
standard
out
display
that
says
two
and
we
get
out
the
data,
which
is
the
mime
type
hello
world.
B
So
I
don't
have
everything
hooked
up
yet,
but
let
me
just
pull
up
the
maybe
I'll.
Do
it
on
github
enthusiast.
B
B
So
this
is
the
the
spec
for
the
execution,
so
we
can
see
all
the
things
that
contains
like
the
status,
the
displays
each
of
the
displays
right
like
whether
it's
data
or
stream,
all
that
kind
of
stuff
yeah.
So
I
wanted
to
just
kind
of
spec
that
out
to
show
how
that
could
work,
and
then
my
next
to
do
would
be
to
add
the
notebook
model
in
memory
as
well.
B
So
then
we
can
say,
like
eric,
was
talking
about
load,
this
notebook
from
disk
make
an
edit
on
this
cell,
execute
that
cell
and
then
save
that
notebook
back
to
disk
and
that
all
the
state
would
be
held
server
side
for
that
notebook
during
the
during
that
process.
B
And
then
I
guess
one
other
thing
I
saw
was
this
interact
kernel
relay
project
which
seemed
pretty
similar
to
what
is
exploring
here
with
this
graphql
endpoint.
That
has
this
cache
of,
like
your
executions
and
such
and
it
communicates
the
kernels
and
talks
to
your
different
apps.
This
isn't
hasn't
had
much
work
on
it.
It
looks
like
and
it's
slightly
different
scope,
but
I
thought
it
was
kind
of
interesting,
but
it
was
a
similar
approach
there
and
I
guess
to
kind
of
zoom
back
out.
B
How
does
this
relate
to
rtc
like
if
you
move
all
of
the
kernel
state
like
executions,
etc?
B
You
move
all
the
notebook
state
to
the
server,
then
rtc
is
doing
a
lot
less
like
it
can
just
be
responsible
for
synchronizing
people's
edits
if
they're
both
editing
the
same
cell,
for
example,
like
making
sure
that
there
aren't
conflicts,
and
so
the
scope
is
much
reduced
for
like,
for
example,
what
what
we
need
yjs
for-
and
it
also
is
a
like
way
to
provide
a
lot
of
the
functionality
of
rtc,
including,
like
multi-user,
editing
and
collaboration
when
you
don't
need.
B
Maybe
the
like
merging
of
people
editing
the
same
line
without
pulling
in
a
large
javascript
library
like
yjs
or
something
so,
it
kind
of
provides
like
a
higher
foundation
to
build
off
of
that's
easy
to
specify
in
a
way
that's
agnostic
to
the
front
end
to
the
back
end.
Since
all
that's
specified
is
the
graphql
schema
like
you
could
reimplement
this
back
end
in
any
language,
or
you
know
with
any
kind
of
technology,
and
as
long
as
it
can
speak
the
same
mutations
and
queries
and
such
then
you
could
communicate
with
it.
B
So
that's
some
of
the
thinking
there
about
why
the
how
this
could
kind
of
help,
like
maybe
a
larger
scale,
providing
like
a
bedrock,
I
guess,
to
build
some
of
the
real-time
features
on
top.
B
C
Is
there
so
I'm
coming
like
really
really
late
to
the
game
here,
so
I'm
gonna
ask
some
stupid
questions
that
I
wish.
I
had
participated
six
months
ago
tasks
because
these
are
things
you've
you've
probably
thought
about
way
way
ahead
of
time,
so
yeah
apologies.
If
you're,
like
I've,
explained
this
six
times
before.
C
That's
is
there.
C
Have
you
have
you
considered
like,
and
I
don't
know
how
hard
this
would
be,
because
I
I
was
trying
to
like
parse
out
all
the
all
the
like
are
there?
Is
there
work
we
can
do
in
parallel
with
the
server
I
mean
with
the
with
the
whole
rtc
idea
like,
because
I
I
think
that
inline
editing
is
like
actually
probably
way
less
useful
than
people
want
to
argue.
C
Is
there
like
so
like
documents
like
quip
or
applications
document
editing
like
clip
they
just
lock,
they
don't
even
they
cheat
by
just
locking
the
line
that
you're
on
so
in
jupiter
world.
C
This
would
be
like
locking
a
cell
and
just
saying,
like
you,
can
edit
other
parts
of
this
document,
but
when
somebody
like
clicks
on
this
cell
or
runs
this
cell,
this
thing
goes:
it's
you
can't
touch
it
until
it's
done
executing
or
they're
done
editing
and
they
exit
that
cell,
which
to
me
probably
has
the
less,
requires
less
work
on
the
server
to
synchronize
anything
and
puts
more
effort
on
the
on
the
actual
front.
End.
C
The
the
hard
part
about
doing
like
this
graphql
stuff
is
you've,
which
I
think
is,
is
something
really
like
we're
going
to
have
to
do
some
major
work
on
the
server,
because
I
agree
like
we
should
offload
some
of
the
the
actual
hard
parts
of
things
like
synchronizing
kernel
messaging,
that's
coming
in,
especially
when
multiple
people
are
trying
to
run
cells
at
the
same
time,
handling
that
on
the
server
is
going
to
be
a
lot
easier,
but
could
we
get
quick
wins
without
putting
ourselves
in
a
hole
by
doing
something
on
the
client?
C
And
maybe
that's,
like
I
said,
locking
some
interactions
for
real
time
just
to
get
the
fact
that
you
just
just
to
get
the
quick
win
that
you
can
open
the
document.
People
can
open
the
same
document
at
the
same
time
and
it
won't
worry
about
like
saving
collisions
and
then
in
parallel.
Do
this
like
graphql
exploration,.
B
B
Well,
I
think
if
you
were
doing
the
locking
thing
that
would
be
totally
independent
right,
because
it
wouldn't
depend
on
this
work
at
all.
It
wouldn't
depend
on
any
of
the
crdt
work
at
all.
It
would,
I
assume,
be
some
separate
service
that
you
would
hit
maybe
and
say:
hey
the
cell
is
locked.
Now
the
cell
isn't
locked
something
like
that.
I
guess
and-
and
I
would
be
aware
of
that.
C
Do
you
do
you
think
we
need
to
like
replace
like?
Are
we,
at
the
end
of
the
day
like
getting
rid
of
in
in
a
perfect
world,
getting
rid
of
jupiter
server
and
replacing
it
with
a
new
server?
Or
do
you
think
we
should
keep
these
as
keep
the
rest
api
and
the
tornado
web
server
around
and
have
graphql
side
of
the
server?
A
extension
of
that.
B
So
I
feel
like
that's
more
of
an
ecosystem
question
of
like
who's,
using
which
parts
and
obviously,
at
this
point
everyone
is
using
rest,
so
it
wouldn't
make
sense
to
get
rid
of
it
like
right.
So
it's
more
of
like
a
I
don't
know,
longer
term
timeline
thing
and
I
think
yeah
it
could
work
either
way.
I
guess
the
nice
part
is
it
gives
us
the
option
to
if
you
know
it
kind
of
like
a
gradual
move.
B
A
From
zach
question
there
may
be
like
already
three
ways
to
implement
rtcs
and
maybe
like
the
lock
unlock,
which
is
a
very
the
base.
A
One
I
mean
then
there
would
be
like
the
graphql
you
you,
you
showed
us,
which
does
not
even
need
crdt,
ygs
and
so
on,
and
then
they
would
be
like
the
third
one,
which
would
be
like
the
one
we've
done
last
year
with
crdt
and
you
can
expand
and
have
combination
of
both
or
of
of
multiple
ones,
and
these
are
probably
all
valid
ways
to
implement
and
to
deliver
something.
All
three
are.
A
Maybe
you
can
sing
more
with
the
fourth
one
and
so
on
yeah,
but
we
have
limited
resource,
so
I
I
just
mean
do
you
want
to?
We
can
think
about
that.
But
do
we
want
to
take
a
decision
on
one
of
them
or
do
we
want
to
continue
exploring
all
of
them.
B
Well,
I
think
we
have
limited
resources,
but
all
our
resources
are
sort
of
independent
somewhat.
So
I
guess
we
can
coordinate,
but
I
guess
we
all
have
different
timelines,
I
think
probably
on
what
we're
delivering
and
for
who.
So
I
think
that
might
impact
what
makes
the
most
sense
for
different
people
to
work
on,
like
I
don't
know
what
your
like
yeah,
what
your
timeline
is
like
or
what?
A
A
I
don't
know,
so
it's
not
only
about
resources.
It's
also
about
the
future.
We
deliver,
but
maybe
we
it's
good
enough
to
just
to
lock,
and
so
it's
already
something
we
we
we
can
at
least
show,
but
I
feel
like
the
the
server
side
is
something
but
implementing
any
of
those
options
on
in
jupiter
lab
is
a
piece
of
work.
It's
not
minor,
even
unlock
and
lock
is
somewhat
objective
that
we
need
to
know.
D
So
I
maybe
I
can
I'm
curious-
maybe
to
go
back
a
little
bit
like
pretty
far
actually
and
like
what
are
some
of
the
info,
like
the
rtc
experiences
that
we're
trying
to
use
as
like
the
state
of
the
art.
When
we're
thinking
about
this
interaction
and
experience
like
heck,
md
or
like
vs
code,
or
something
like
that.
Are
there
any
things
that
we're
kind
of
using
as
like
sort
of
trademark
or
like
representative.
C
It
is
I've
been
trying
to
talk
about
it
when
I
was
talking
like
tim
george,
and
I
have
talked
about
it
over
a
long
period
of
time
and
what
I've
learned
from
tim,
george
among
many
things,
is
that
he
always
thinks
about
it.
In
terms
of
like
specific,
you
know
user
stories
like
how
do
I
like?
What
is
this
thing?
C
What
is
this
pain
point
that
this
person
is
experiencing
and
what
would
be
the
solution
to
that,
and
you
know
like,
for
example,
a
very
simple
one:
is
two
people
are
working
on
a
notebook?
C
They
just
both
want
to
open
the
document,
and
they
know,
like
you,
know
like
something
as
simple
as
opening
a
document
and
maybe
them
wanting
one
person
wanting
to
add
the
cell,
while
the
other
person's
looking
at
it
that
doesn't
require
you
know
like
character
by
character.
Editing,
it's
just
simply.
I
don't
want
to
accidentally
save
the
document
without
another,
while
someone
else
is
changing
it
and
then
override
their
changes
or
whatever.
D
D
Yeah,
I
think
that
that's
like
almost
too
low
level
in
a
sense
right,
like
I'm
curious,
like
maybe
even
just
in
this
room
as
a
small
sample
like
what
are
the
best
experiences
outside
of
google
docs
right
like
google
docs,
is
basically
the
gold
standard
for
this.
But
what
are
some
of
the
tools
in
our
world
right
because,
like
our
company,
a
lot
of
the
developers
aren't
writing
pros
or
code
in
google
docs
they're
doing
it
in
github?
So
what's
the
stuff?
That's
like
closer
to
our
world.
D
That
is
a
good
example
here,
like
personally,
I've
never
had
a
bad
experience
with
hack
md
and
I'm
curious
about
like
how
other
people
might
feel
about
some
of
the
rtc
things
and
I'm
not
personas
are
hard
in
jupiter
because
there's
so
many
different
kinds
of
users,
it's
like
what's
good
already
and
what
are
we
shooting
for.
C
Totally
I
and-
and
I
wasn't
that
wasn't
supposed
to
be
the
one
and
only
user
story-
it
was
like,
let's
start
collecting,
just
these
simple
tasks
and
then
see
like.
Could
we
draw
a
circle
around
you
know
a
majority
or
or
at
least
majority
is
not
even
the
right
approach.
It's
like
what
is
the
I
guess,
most
common
and
maybe
that's
hard
to
even
define
too.
D
Yeah
I
mean
like
so
hackmd
is
open
source.
They
have
an
open
source
server
with
their
crdt
stuff.
There
and,
like
I
know,
we're
thinking
about
notebooks,
but
I'm
like
wondering
hey.
Can
we
just
do
this
in
markdown
to
start
right
like
because
if
I
have
markdown
at
console,
then
I'm
not
having
coding
problems
and
all
I'm
worried
about
is
sort
of
the
editing
story
here
so
like
there
are
a
lot
of
extra
complexities
when
we're
dealing
with
interactive
code.
But
like
can
we
get
to?
D
A
A
Maybe
I
could
have
a
second
look
to
that,
but
there
are
other
open
source
projects
which
we
could
use
just
to
have
that
simple
editor
with
ygs
they
bind
to
to
code
mirror
you
have
code,
mirror
editor
connecting
with
ygs,
so
we
could
start
from
from
those
it's
fully
available.
A
And
maybe
to
to
to
continue
about,
I
think
we
focus
a
lot
on
on
the
editor,
but
to
come
back
to
the
user
stories
and
user
pain
points.
I
see
a
lot
of
issues
to
address
in
terms
of
kernel
sharing,
so
you
you
share
a
document,
but
do
you
share
also
the
states
the
variables
and
so
on
so
jupiter
lab
is
complex
because
you
you
have
that
additional
parameter
or
dimension,
which
is
the
variables
I
have
in
the
the
kernel.
D
There
are
so
many
open-ended
questions
right,
everybody's
going
to
want
to
work
differently,
but,
like
the
complex
state,
is
a
combination
of
a
markdown
editor
or
code
editor
or
code
mirror
editor.
There
are
these
smaller
features,
I'm
kind
of
wondering
like
you
know,
can
we
it's
just
starting
small
and
starting
with
state
of
the
art
and
getting
that
like
closer
to
us
like
what's
the
goal
and
maybe
the
goal?
Maybe
a
short-term
goal
is
to
write
stories
quicker
with
other
people.
D
So
you
know
if
it
was
just
simply
editing
and
then
figure
out.
What
do
people
want
with
the
kernel
story
right
like
if
we
had
a
document
in
markdown,
could
somebody
spawn
a
shared
console
where
both
people
could
be
hacking
on
or
do
people
get
local
consoles?
Are
there
ways
to
do
put
some
trust
elements
in
there,
but
I'm
curious
if
you
can
kind
of
like
deconstruct
this
problem
down
a
little
bit
more
incrementally,
rather
than
dealing
with
all
the
complexity
at
once,.
C
Maybe
work
noting
too
of
prior
art
the
I
learned
this
this
last
week.
I
didn't
even
know
this
steve
told
me
this,
but
the
prior
rtc
experience
that
came
out
in
2016,
I
think
maybe
it
was
it-
was
show
that
jupiter
khan
is
that.
Are
you
one
point?
Would
that
be
pre
1.0?
Basically
1.0
wow?
Okay?
C
So,
but
it
was
you
didn't
share
kernels,
it
was
actually
it
really
was
just
like
real-time
editing
in
the
cells,
and
then
anybody
was
running
on
their
separate
kernels
and
yeah
like
you
definitely
can
get
some
some.
C
You
know
questionable
user
experience
out
the
other
end,
but
at
the
same
time
like
it
was,
I
think
people
liked
it.
You
know
some
some
people
just
wanted
to
edit
a
document
at
the
same
time,
and
so
there's
there
are
weird
like.
Maybe
the
kernel
thing
is
a
later
question,
because
it's
a
it
is
a
harder.
We
don't
know
what
the
solution
is,
and
it
may
be
that
there
has
to
be
a
bunch
of
different
experiences
that
come
out.
The
other
end
on
that
one.
C
But
then
real-time
editing
in
a
cell
is
a
is
a
faster
solution.
We
can
get
to
for
to
address
a
lot
of
needs
too.
D
I
mean
I
think
that
like
zach,
you
and
I
could
probably
collaborate
on
a
document
that
just
used
a
shared
binder
kernel,
for
example
right
like
that
might
be
a
sandboxed
way
to
think
about
this,
originally,
perhaps
so,
maybe
you're
even
switching
out
kernels
at
any.
Given
time
when
you
run
things
like
if
you
were
to
select
some
code
and
hit
shift
enter
and
that
sends
it
over
to
the
console.
It's
like,
oh
what
kind!
What
what
kernel
do
you
want
to
be
on
your
local
one
or
the
shared
one.
B
Can
we
can
we
run
one
jupiter
server
for
many
users
instead
of
doing
this
thing,
where
we
spawn
separate
processes
for
each
user,
and
so
that's,
I
guess-
comes
some
somewhat
to
like
the
identity
work,
that's
being
done
and,
and
things
like
that,
but
that's
for
me,
the
most
exciting
user
experience
kind
of
question
is
like:
how
can
we
really
make
jupiter
the
server
like
more
of
like
a
multi-user
web
application
instead
of
something
you
just
run
locally
for
yourself
and
that
that
would
allow
a
lot
of
interesting
like
ways
to
I
don't
know
just
help
with
the
deployment
story,
a
lot
and
all
that
kind
of
stuff.
B
So
that's,
even
though
this
doesn't
have
anything
specifically
by
identity.
I
guess
that's
the
other
place
that
we
could
work
independently
like.
I
know
that
I
may
be
zach.
Maybe
that
work-
I
don't.
I
haven't
been
following
that
closely,
but
the
permissioning
kind
of
work
that
you
were
doing
on
the
jupiter
server
and
kind
of
even
just
articulating
what
that
vision,
would
look
like
a
little
bit
more.
C
Yeah,
I
don't
think
I've,
I
don't
think
that's
actually
been
like
no
one
spent
time.
Thinking
about
that
on
jupiter
specifically
yet,
like
I
think
I
did
some
initial
scoping
out
of
some
some.
C
You
know
one
one
problem
I
was
trying
to
solve
a
while
ago
and
hasn't,
and
it's
now
been
in
standstill
just
because
it
hasn't
been
prioritized,
but
but
yeah,
that's
absolutely
something
we
and
all
the
all
the
work
that
kevin
bates
has
been
doing
on
on
remote,
kernels
and
thinking
about
kernels
is
having
multiple
users
like
him.
The
server
ain't,
even
the
place
where
he
wants
multiple
users,
kernels,
is
where
he
wants
multiple
users.
C
Now
the
server
is,
you
know,
maybe
how
he's
proxying
those
those
requests,
but
in
some
sense,
like
he's
just
spawning
kernels,
jupiter,
kernels
somewhere
and
connecting
to
them.
However,
he
wants-
and
I
think
eric's
got
the
same.
You
know
interest
too
and
so
trying
to
figure
out
how
we,
how
we
make
those
things
have
you
know
some
some
level
of
or
abstraction
of
multi-tenancy
would
be.
A
Yeah
you
can
have
that
on
the
server
or
rely
on
jupiter
up
and
so
on,
but
I
would
like,
maybe
to
to
lay
here
assault
I
mean
rtc
is
complex.
The
user
experience
must
be
delicious.
We
we
all
want
that,
but
I
I
wonder,
or
it's
a
fear
or
feeling
I
have
we
need
so
many
building
blocks
identity.
We
discuss
that,
but
remote
kernels
and
so
on,
and-
and
I
don't
want
our-
I
hope
we
can
find
a
way
to
to
move
without
having
all
those
building
blocks
at
the
same
time.
A
A
But
I
expect
if
I
continue
thinking
that
way,
I
will
not,
or
we
will
not
move
so
much
because
it's
impossible
to
have
all
the
building
blocks
at
the
same
time.
So
my
question
is:
how
can
we
progress
even
with
the
half
or
not
all?
Well,
we
need
a
minimum,
but
what
is
that
minimum
step?
What
is
the
road
we
need
to
follow
which
building
blocks
we
need
to
have
on
the
table
to
progress?
A
B
One
of
the
things
like
I've
enjoyed
about
the
graphql
work
is
by
specifying
things
explicitly
with
the
types
it
feels
like,
even
if
you're
just
exposing
the
same
things
you're
exposing
a
jupiter
server
like
it.
You
very
cleanly
articulate
what
those
are,
and
you
can
see
how
you
would
then
add
on
other
parts
later.
B
So
there's
like
a
clear
path:
kind
of
forward
for
migration
and
additions
and
movement,
but
it
gives
you
a
space
to
put
those
things
where
different
from
like
the
current
jupiter
server
space,
which
is
harder
to
type
properly.
I
think
and
then
also
just
harder
to
move,
because
it
has
so
much
legacy
usage
already.
F
D
For
my
from
my
user
experience,
why
I
keep
tripping
out
like
well,
I
was
thinking
about.
I
was
talking
steve
messaged
me
on
twitter
and
he's
like.
Oh
man.
We
did
that
atlanta
jupiter
today
thing
it
was
four
years
ago
I've
been
using
jupiter
labs
since
pre
1.0
and
deleted
my
files.
It's
it's
been.
It's
been
a
growth
process,
but
over
the
years
the
one
thing
for
me
that
has
improved
my
ability,
as
a
scientist
and
my
ability
to
communicate,
is
moving
processes.
D
B
D
B
D
Yeah
like
I,
when
I
work
on,
like
blog
posts
and
stuff
with
folks,
I
use
the
live
share
inside
of
vs
code
and
it's
pretty
good
and
I
also
use
the
heck
md
stuff
and
I'm
like
I'm,
like
I'm
just
thinking
like
folks
work
together
on
like
jupiter
con
presentations
for
the
past
couple
weeks,
and
a
lot
of
that
is
about
pros.
You
know
like
if
jupiter
notebooks
are
effective
in
communicating
computational
narratives,
it's
going
to
be
a
lot
of
pros
around
code.
D
If
you
always
just
focus
on
the
prose
part,
will
we
be
able
to
write
better,
more
diverse
stories
if
more
people
can
work
together
just
on
the
prose
part,
because
I
know
the
code
part
in
the
output
part
part
is
really
hard.
But
I
really
like
the
idea
of
folks
telling
stories
together
and
what
happens
in
the
middle
of
all
those.
D
D
D
Kernel
well,
I
love
the
dungeon
master,
colonel
the
jupiter
hub,
colonel
that,
like
can
talk
to
all
the
other
jupiter
hub
kernels,
at
least
that's
what
we
call.
We
call
the
dungeon
master
colonel,
like
the
person
who
gets
to
know
everything
and
like
narrate
the
game,
but
there's
an
interesting
use
case
on
that
one,
as
somebody
like
running
potentially
like
jupiter,
home
or
jupiter
hub
at
home,
and
being
able
to
communicate
with
their
iot
devices
over
like
rtc,
or
something
like
that.
D
So
you
know
maybe
in
some
way
there
might
not
even
be
a
human
on
the
other
side
of
these
things
could
rtc
be
wired
up
to
a
bot.
That's
helping
you
through
your
day
or
something.
B
The
other
thing
I
want
to
mention
before
the
end
of
the
call
was
that
this
will
be
my
last
month
that
at
quansite
and
I'm
going
to
be
taking
at
least
a
few
months
off
and
eric
is
going
to
be
taking
over
these
meetings
and
over
the
the
the
grant
from
cci.
B
So
I
might
be
involved
again
in
january
or
might
not
so
yeah
see.
Things
will
continue
on
since.
B
Yeah,
I
don't
really
have
very
many
plans,
I'm
just
gonna
chill
and
see
what
see
what
seems
like
it's
good
to
focus
on
so.
D
C
A
A
Yeah,
thank
you
for
pushing
this.
Having
pushed
that,
and
maybe
if,
if
you
say,
you're
gonna
join,
maybe
in
two
weeks
we
will
see
you
but
just
add
some
chill,
as
you
said,
enjoy
your.