►
From YouTube: IPython / Jupyter Lab Meeting, May 13, 2016
Description
Meeting of the IPython/Jupyter development team.
A
B
So
why
don't
we
go
around
first,
just
very
short,
like
10-15
seconds
status,
update
of
what
we've
been
working
on
in
the
last
week
and
maybe
I'll
start
sort
of
Steve
and
I
have
been
working
on
a
lot
on
the
document,
management
infrastructure
and
super
lab.
So
this
is
how
to
have
a
coherent
model
for
documents
and
execution
tied
to
the
documents
and
widgets
that
expose
the
documents
and
we've
been
iterating
a
ton
and
there's
lots
of
discussion
upon
the
pull
request.
B
C
Right
so
basically,
jason
said:
we've
got
a
couple
more
points
of
discussion
for
after
this
meeting
decision
points,
but
I
think
we're
pretty
close
to
at
least
getting
that
merge
and
iterating
from
there,
a
propagating
that
has
changes
to
Jupiter
notebook
and
super
J's,
notebook
and
Jupiter's
plugins
and
finally,
to
the
lab.
B
D
I've
been
working
on
the
tooltip
feature
of
the
console
that
gets
information
from
the
backend
contextually,
based
on
what
you're
typing.
In
the
way
the
QT
council
does
and
I've
had
a
PR
open
since
last
week,
but
I
think
as
of
today,
I
have
it
to
a
point
where
it's
usable
enough
that
I'd
like
to
get
that
merged.
Even
if
we
start
to
change
it,
yeah
there's
some
questions
that
we
need
to
resolve.
Still
that
I
can't
I
can't
do.
D
E
So
I
should
introduce
myself
for
everyone
on
the
call,
I'm,
Alejandra
and
I'm
with
Microsoft,
and
we
were
interested
in
integrating
super
laughs,
more
wit
spike.
That's
our
scenario,
and
so
we
were
meeting
with
brian
to
kind
of
see
if
we
wanted,
if
we
could
create
a
cheaper
lat
plugins
that
would
provide
a
richer
experience
with
the
notebook,
and
so
we
were
thinking
abused.
E
Cases
like
can
I
talk
to
a
colonel
from
a
plug-in
and
configure
with
the
the
colonel
from
within
the
plugin
or
can
I
say,
have
a
valuable
inspector
from
the
plug-in
things
like
that,
and
so
what
Brian
and
I
worked
on?
We
worked
on
a
plug
in
a
couple
of
people
here
and
the
coal
helped
us
on
applying
that
could
figure
out,
which
was
the
last
note
book
that
was
active
and
then
from
there.
That
talking
would
be
able
to
talk
to
the
colonel
by
sending
messages.
So
this
was
a
different
panel.
E
That's
what's
able
to
talk
to
the
led
to
the
last
kernel
and
that
was
active,
and
so
we
got
those
working
I'm
not
too
familiar
with
the
Jupiter
left
code,
but
apparently
I
think
Steven,
Jason,
burstein,
Fred
I,
don't
remember
exactly
who
coded
it
up,
but
kind
of
coded
up,
a
hack
frost,
and
they
had
one
more
that
yeah
I
hack
divorce
yeah
and
they
were
saying
that
that
they
would
probably
like
to
go
and
do
something
like
that,
but
teener
and
so
so
yeah.
E
E
So
things
like,
for
example,
visualisations
automatic
visualisations
wooden
on
spark
like
if
you're
visualizing
a
data,
for
example
like
if
one
of
your
cells
has
the
data
frame,
can
we
automatically
detect
your
data
set
and
visualize
it
for
you
on
a
different
panel,
for
example?
Or
can
we
provide
you
a
video
of
your
cluster
resources
that
you
have
on
your
cluster
configurations
that
you
might
want
to
do
it
to
your
cluster?
B
F
Yeah,
for
some
reason
by
my
headset
microphone
doesn't
play
well
with
the
back,
so
I'm
finishing
up
the
last
few
days
of
the
phosphor,
you
I,
the
repo
squeeze
to
finish
off
menu
and
a
new
bar
earlier
on
of
the
week
working
on
the
command
panel
and
doc
panel
is
the
remaining
thanks
to
be
done.
There
I
use
Jason
you'd
mentioned
earlier
about
wanting
to
start
using
the
stuff
in
phosphor
UI,
as
you
work
on
new
things,
that's
certainly
possible
unless
you're
wanting
to
use
like
Doc
panel
and
command
palette.
F
At
this
point,
all
the
rest
of
the
stuff
is
ready.
I
could
so
I
could
start
punting
out
npm
releases,
you
know
0x
releases
or
whatever.
If
you
wanted
to
start
using
that
stuff.
I
would
caution,
though,
is
that
that
does
have
the
there's
the
potential
there
to
start
mixing
versions
of
like
phosphor
widget,
which
could
lead
to
some
problems.
B
Yes,
but
the
guide
me,
the
thing
is:
we're
essentially
rewriting
the
notebook
code
right
now
to
refactor
it
to
play.
Well
with
this
document
manager,
stuff
and
and
while
we
were
refactoring
everything
and
rewriting
everything
anyway
thought
it
was
a
good
time
to
move
to
the
signals,
the
new
signals
and
stuff
like
that,
okay
yeah.
So
you.
F
F
So
what
I'm,
what
I'm,
trying
to
do
now
with
commit
now
that
menu
and
minibar
is
done,
I'm
working
on
command
palette,
I'm
trying
to
say
see
if
there's
now
that
they're
all
in
the
same
repo
is
if
we
comply
in
some
of
the
ideas
between
man's
and
the
menus
and
the
key
maps
to
make
that
a
bit
more
seamless
and
how
all
of
those
things
talk
together.
So
I'm
working
on
that
problem
right
now,
which
is
a
bit
vexing.
F
So
if
anybody
wants
to
bike
shed,
then
helped
save
my
sanity
welcome
to
have
those
beatings,
and
so
it's
really
getting
over
that
I
think
that's
the
last
hurdle
I
want
to
be
get
over
that
hurdle.
We
can
pull
doc
panel
in
and
since
we
know
doc
panels
really
a
cut-and-paste,
except
if
we
want
to
go
ahead
and
add
the
maximization
feature
as
as
an
initial
thing,
if
we
want
to
do
that
in
the
beginning,
is
going
to
spend
a
bit
of
time
doing
that
or
I
could
just
kick
it
out
immediately.
B
E
F
B
B
B
F
So
while
we
do
have
some
guys
from
Microsoft
on
the
line,
I
would
really
appreciate
feedback
from
you
guys,
as
you
use
the
the
plug-in
API.
If
there
are
features
that
you
want
or
if
you
come
across
any
code
smells
or
you
think
like
something
could
be
done
better,
none
of
that's
written
in
stone.
Yet
so
definitely,
if
you
have
feedback
or
comments
or
concerns
about
any
of
them,
please
let
us
know
right.
E
Right,
I
notin
that,
if
say
I
wanted
to
start
writing
some
plugins
to
get
an
idea
of
where
the
API
saw.
Where
can
I
go
and
looking
like
what
class?
Is
it
the
one
that
implements
most
of
the
api's?
How
can
I
find
the
api's
that
are
available?
Things
like
that.
B
If
you're
just
talking
generic
plugin
api's,
I
think
what's
JSI,
guess
right,
yeah,
I
would
and
phosphide
I
would
be
the
key
name
to
look
for
their
if
you're
talking
about
stuff
that
specifically
interacts
with
Jupiter
lab
I
mean
right
now.
Steve
and
I
are
revamping
how
documents
and
kernels
and
everything
works,
so
everything
sort
of
up
in
the
air
right
now.
B
D
But,
like
jason
said,
if
you
want
to
just
build
a
UI
component
that
sits
inside
the
app,
you
can
look
at
the
way
plugins
are
built
in
the
phosphide
repo
and
use
them
as
your
model
go
orange
uber,
2,
j's
plugins
for.
F
Japan
s,
plugins
good
call,
yeah,
the
the
whole
idea
bind
bind
building
so
basically
Jupiter
lab
instance
of
a
phosphide
application,
and
the
whole
idea
behind
that
is
that
everything
in
a
foster,
I'd
application
is
a
plug-in.
So
there's
nothing,
that's
quote-unquote
special
or
you
know
core
or
has
extra
privileges
that
other
things
don't
and
so,
like
Jupiter
lab
the
literally
the
entire
application.
B
See
how
all
those
are
simple
but
I
think
I
think
maybe
we're
not
really
answering
your
question.
Your
question
was
about
documentation.
What
available
API
is
there
are
not
necessarily
just
examples
and,
and
the
documentation
is
something
that's
on
the
road
map
for
us
to
do
a
sort
of
high-level
narrative
documentation
about
these
things.
But
there
also
is
a
looks
like
alejandro
left.
Oh
so.
B
B
So
so,
essentially,
there's
a
lot
of
examples.
We
don't
have
a
lot
of
narrative
documentation.
It's
on
the
road
map
for
us
to
do
I.
Think
Steve
did
put
together
an
example
plug-in
and
then
some
very
initial
high
level
documentation
about
writing
a
plugin
writing
a
phosphide
plugin
that
might
be
helpful
but
and
there's
there's
API
level
documentation
and
each
of
the
each
of
the
repos
for
the
different
projects.
That
gives
you
sort
of
low-level
reference
documentation.
So.
C
C
B
B
C
One
specific
to
the
dock
manager,
who
want
to
talk
about,
though,
sure
the
first
one
was
what
what
do
we
consider
an
independent
session
on
a
kernel
like
we,
we
can
have
multiple
ways
of
opening
the
same
path
should
and
every
time
you
create
an
instance
of
a
notebook
session.
It
gets
a
unique
client
ID,
which
is
used
to
filter
messages.
C
C
B
Colonel,
let
me
let
me
back
up
just
a
little
bit
and
give
you
know
the
other.
Some
context
says
I
think
it
would
be
really
good,
especially
Darren
you're,
going
to
these
decisions,
impact
you
as
in
how
to
hook
up
kernels
to
consoles
and
how
that
plays
with
the
stuff
that
we're
doing
with
hooking
up
kernels
to
documents.
B
So
we
have
for
every
document
on
disk.
We
have
one
or
more
models
in
the
browser
that
represent
the
content
of
that
document,
and
they
may
represent
the
content
of
that
document
in
multiple
ways.
So
one
model
might
represent
a
notebook
as
a
JSON
data
structure,
with
with
relevant
information
about
the
notebook
like
it
has
cells
and
output
areas,
and
things
like
that,
and
there
might
be
a
separate
model
in
JavaScript
that
represents
the
same
notebooks,
the
same
file
path
name,
but
as
a
text
file.
C
What
yeah,
you
could
even
argue,
maybe
you
want.
We
haven't
base
assumption
that
you
have
one
kernel
or
one
session
for
a
given
path.
Is
that
even
up
for
grabs
or
you
could
have
the
same
file
open
with
two
different
kernels,
an
HEV,
an
independent
session
associated
with
them
like
what
is
I?
Think.
E
This
question
ties
back
to
also
I
back
by
ain't
feature
whenever
we
want
to
implement
something
that
I
collaboration
on
the
same
document
once
a
user
collaboration
on
things
like
online
multi-user
collaboration,
just
like
like
Google
Docs,
or
anything
like
that,
wouldn't
every
when
you
have
to
have
a
back-end
that
understands
each
user
and
he's
able
to
merge
complex
forward
for
each
and
what
Adam?
Wouldn't
that
make
you
or
force
you
to
have
the
same
kernel.
D
D
C
C
B
What
we
have
is
a
document
model
on
the
client
side
is
associated
with
the
session,
and
so,
if
you
had,
for
example,
a
notebook
opened
up
as
a
text
file
and
opened
up
as
a
notebook
data
structure,
there's
two
different
models
for
the
same
path
and
they
would
have
different
sessions.
A
session
is
just
a
mapping
between
filename
and
Colonel.
They
would
have
different
session
data
structures.
No,
they.
Those
special
data
structures
would
point
to
the
same
kernel.
Yes,.
C
They
point
to
the
have
the
same
session:
ID,
even
it
would
just
have
a
different
eternal,
would
have
an
instance
ID
that
gets
attached
to
each
of
the
messages
associated
with
the
colonel.
So
basically
it
be
whether
you
want
to
be
able
to
differentiate
between
all
things
that
are
using
the
arm
that
are
using
that
kernel
or
not,
and
what?
What
is
that
level
of
granular
Oh
to
be
able
to
tell?
In
the
end
the
message
ID?
Who
does
this
belong
to?
What
is
what
is
that
level
of
granularity?
C
B
B
E
D
B
B
B
C
B
E
E
D
B
B
B
So
I
think
the
question
impacts
Darien
in
that,
how
do
we
want
to
handle
consoles?
So
a
console
you
can
think
of
as
a
temporary
connection
to
a
kernel
that
has
no
path
associated
with
it
or
you
could
say
at
the
end
of
your
console
session,
you
might
want
to
save
your
history
and
the
natural
thing
would
be
to
save
it
as
a
notebook
path
or
you
take
a
console
and
you
open
up
a
notebook
path
which
essentially
opens
up
the
history
of
that.
B
Your
opens
up
that
notebook
as
sort
of
the
history
in
your
console
and
then
just
the
console
is
just
append.
Only
at
the
bottom
I
mean
the
real
use
case
for
console
seems
to
be
essentially
temporary
notebooks
that
are
not
saved
that
just
let
you
interact
with
the
colonel
in
a
way
that
doesn't
clutter
up
your
your
hard
disk
yeah.
B
D
D
B
D
B
D
So
you
yeah
for.
B
The
console
you
could
you
could,
for
example,
maintain
internally
the
same
notebook
model,
we're
using
for
the
notebook
but
not
save
the
disk,
and
then,
if
there
was
a
file
save
as
or
some
sort
of
command
to
say
persist.
Whatever's
in
my
console
here
to
disk,
then
you
could
just
make
the
exact
same.
Call
that
we're
making
to
save
a
notebook
model
to
disk.
Well.
B
B
The
document
manager
do
we
just
ad
hoc,
say
here's
a
colonel
you're
welcome
to
share
a
colonel
with
something
that
is
actually
hooked
up
to
the
document
manager,
but
it's
sort
of
outside
the
purview
of
the
document
manager
in
this
plugin
just
just
interacts
with
the
colonel
independently
or
like.
How
do
we
build
that
into
the
design
we.
D
C
D
D
B
This
also
plays
into
Alejandro's
questions
about
wanting
to
have
a
play.
The
interacts
with
the
colonel
and
it
sounds
like
not
associated
at
all
with
the
document.
I
just
want
to
be
able
to
send
a
colonel
commands,
and
things
like
that,
so
I
so
Alejandro's
use
case
would
still
have
a
colonel
with
not
backed
by
a
file,
but.
D
D
Without
having
to
store
it
on
the
client,
because
the
council
doesn't
have
problem,
the
console
can
already
do
that.
It
does
have
it
in
the
client,
but
in
general,
if
everything
is
backed
by
a
file,
the
file
is
not
necessarily
visible.
Unless
you
want
it
to
be
visible,
then
you
have
that
capability,
regardless
of
what
kind
of
client
is
hooked
up
to
the
farm.
D
F
B
F
I
think
in
general,
having
having
everything
backed
by
a
file,
I
think
in
general
is
going
to
be
useful
in
lots
of
cases
like
especially
like
in
cases
where
somebody
spontaneously
disconnects
or
drops
network
connection
or
accidentally
refreshes,
or
something
like
that
will
be
able
to
restore
to
where
they
left
off,
because
we
have
that
persisted
somewhere.
Yeah.
E
Again,
click
note
on
on
a
plug-in
that
is
not
backed
by
a
foul
and
back
into
the
kernel
right
now.
The
that
communication
happens
over
the
execute
code
message
right
and
that's
the
only
way
we're
talking
to
the
Colonel's
today.
But
what?
If?
If
what?
If,
instead
of
saying
execute
code,
you
had
a
way
to
talk
to
the
colonel,
so
you
have
something
like
a
configure
message
so
that
it's
completely
outside
of
the
code
execution
model
that
the
curl
might
have
internally,
and
so
you
could
say
like
ignore
this
for
purposes
of
content.
D
E
C
F
E
Goes
well
I'm,
while
I'm
hearing
the
conversation
I'm
you're
thinking,
are
we
trying
to
put?
Are
we
trying
to
make
the
we're
talking
about
having
plug-in
that
do
not
execute
code,
but
talk
to
the
colonel
I'm,
just
wondering
what
they
are
there?
One
that
I
had
in
mind
was
a
configure
figure
and
getting
full
basically,
and
that
doesn't
seem
to
be.
He
I
mean.
B
There's
art
there's
already
messages
that
talk
to
a
kernel
without
executing
code,
so
like
get
all
the
comm
open,
comm
ports
and
things
like
that,
so
there's
there
are
messages
that
that
talk
to
a
kernel
to
get
information
that
are
not
executing
code
that
are
specific
to
an
agent
right.
These
are
messages
that
are
not
broadcast
to
everybody,
they're,
just
sort
of
a
reply
request
for
a
specific
agent,
but.
B
Okay
and
there's
also
there's
there's
completion
stuff
as
well.
That's
you
know
all
the
completing
stuff
that
Darian's
working
on
right
now,
that's
I,
that's
information,
queries
sent
to
the
colonel
out
of
band
of
executing
code
and
the
result
is
not
broadcast
to
everybody.
It
sent
us
back
to
you
to
do
completions
or
whatever,
so
so,
yeah,
that's
that
stuff
is
certainly
that's.
Class
of
things
is
certainly
around
so
good.
C
B
Right
all
that
mapping
right
so
so
should
a
console
be
outside
the
purview
of
a
document
manager,
or
should
it
be
inside
the
purview
of
a
document
manager
and
do
temporary
files.
So
here's
a
devil's
advocate
type
of
thing
right
now
we
have
just
been
such
a
headache
with
the
IP
ynb
checkpoint
files,
because
they're
in
every
director
you're
ever
dealing
with
and
you
either
have
to
put
them
and
get
ignore.
They
just
clutter
up
all
your
get
listing
the
clutter
up
your
disk
space.
B
So
if
we
don't
make
it
possible
to
have
very
temporary
models,
you
know
sort
of
console
consoles
or
something
like
this
you're
constantly
dealing
with
a
headache
of
temporary
files
that
are
that
are
persisting
on
your
disk.
So
one
thing
I
noticed
about
sage
math
cloud,
because
it
is
also
it
has
this
model
of
every
terminal,
everything
as
a
file,
and
so
you
open
up
a
new
consoles
like
she'll
terminal
and
and
it's
a
file
and
all
your
history
is
stored,
which
is
really
nice,
but
it
launches
a
new
terminal.
B
B
C
B
C
I'm
not
saying
execute
the
files,
I'm
saying
you
could
display,
I
mean
next
to
commands,
but
display
they
come
to
the
history
up
to
a
certain
amount
and
and
then
set
the
current
working
present
working
directory
based
on
the
environment.
Variable
that
was
saved.
The
present
work,
the
PWD
variable
and
make
all
the
variables
very
limited,
very
limited.
B
B
So
what
I've
noticed
with
sage
math
cloud
is
that
I'm
not
opening
up
temporary
shells
all
the
time
instead
I'm
just
opening
up
some
random
file.
That
was
a
temporary
shell
last
time,
so
so
I'm
reusing
terminals
session
files,
rather
than
opening
up
new
new
terminals
and
I,
think
that
would
happen.
It
was
the
same
with
consoles.
B
D
I
mean
I,
don't
I,
don't
do
the
same
things
that
you
do,
but
in
a
normal
terminal
like
a
bash
terminal,
I,
don't
very
often
source
some
shell
script
and
then
begin
I
usually
just
begin
and
that's
sort
of
what
you're
describing
you
describing
source
something
and
then
continue.
There's
certainly
lose
case,
but
it
doesn't
seem
like
the
de
facto
like
that,
the
default
to
me
yeah.
B
B
C
B
Yeah
that
would
be
I,
think
I,
think
it
best.
We'd
probably
put
it
in
the
history,
so
you
could
up
arrow
and
replay
whatever
you
wanted,
but
but
okay
still
on
the
table,
though,
is
how
do
we
deal
with
console
sessions?
Are
they
backed
by
files?
Are
they
just
temporary
connections
to
a
kernel
that
exists
while
they're
connected
to
the
colonel
darienne's
back
all
right?
So
I
think
this
boat
still
open
question
is:
how
do
we
deal
with
consoles?
Are
they
backed
by
a
file?
B
Are
they
backed
by
a
temporary
model
that
is
then
saved
to
a
file?
Are
they
backed
by
a
temporary
file,
that's
hidden
by
default
in
our
UI,
but
still
clutters
up
their
discs?
Are
they
temporary
connections
to
a
kernel
that
only
are
handled
only
show
input,
output,
etcetera,
while
they're
connected
to
that
particular
Colonel.
D
C
D
B
D
Not
sure
what
we
go
if
we
want
to,
because
a
simplified
document
manager,
that's
fine,
because
you
know,
I
think
my
point
earlier
and
I
think
chris
also
seemed
to
like
the
idea
was
that
we
just
have
one
way
of
connecting
and
that
way
is
always
file
based.
It's
just
a
matter
of
what
kind
of
file
it
is,
whether
the
files
visible
or
not
so
so
there
is
some
there's
some
attractiveness
to
that
idea.
What.
C
I
think
of
the
docket
manager
is
something
associated
with
a
file
browser.
Then
I
mean
I'm
not
going
to
open
a
file
and
say
open
this
thing
with
a
console.
I
guess,
unless,
unless
or
a
notebook
file
yeah,
that
could
be
possible
where
you
execute
the
whole
notebook
and
then
create
a
prompt
active
on
well.
D
Or
you
could
just
have,
you
could
have
ok.
So,
let's,
let's
let's
say
we
go
with
the
console,
gives
you
the
ability
to
export
and
save,
and
let's,
let's
call
it-
you
know
dot,
P,
ysh
or
something
like
that.
Just
give
our
you
know
right
so
dot,
pink
balls
and
you
open
those
with
the
console.
You
save
us
from
the
console
so
that
the
document
manager
is
what
used
to
open
those.
B
C
A
blank
a.j.p
SH
file
and
that's
what
you
you
would
you
would
associate
with
your
console
session.
That's.
B
C
B
Does
it
take
that
sage
map
cloud
takes
bosch
kernels
instead
of
ipython
consoles,
but
there's
a
dot
console
file
and
you
create
a
dot
console
file
and
it
basically
persists
your
history
to
disk
and
then,
when
you
open
up
a
new
console
there,
we
go
when
you
open
that
file.
Again,
it
presents
you
with
a
fresh
shell,
but
I
think
it
has
your
old
history.
B
So
you
can
scroll
back
if
you
wanted
to
I'm
daily
nice
thing
about
having
things
persist
to
disk,
which
essentially
means
not
what
persisting
a
disk
is
sort
of
an
implementation
detail.
What
it
really
means
is
we're
persisting
to
the
server
and
and
another
nice
thing
about
persisting
the
server
in
addition
to
what
Chris
was
saying
about
being
able
to
refresh
your
page
and
and
pick
up
where
you
left
off
is
is
the
real
time.
Collaboration
and
things
like
that
become
easy.
B
There's
been
lots
of
times
in
sage
math
cloud,
where
I've
needed
to
show
someone
how
to
do
some
shell
command
or
they
had
some
questions
about
a
shell
command
and
I
just
hopped
into
their
shell,
opened
up
their
cell
and
did
we
had
real
time
collaboration
in
the
shell,
which
was
which
was
really
nice?
Okay,.
D
B
B
B
That
you
have
those
variables
available,
yeah
right,
so
that
might
be
were
too
confusing,
I
agree
or
you
could
do
a
UI
where
you
throw
a
thick
line
saying
you
know
this
was
old
history,
and
this
is
my
freshman.
It
colonel
or
something
I
mean
you
can
try
to
do
that,
but
maybe
it's
too
confusing
and
we
don't
want
to
do
it
anyway.
Well,
I.
B
D
But
Chris
was
talking
about
a
specific
set
of
our
users
who
want
to
work
in
a
console
environment
and
just
don't
care
about
notebooks
at
all.
Are
those
users
going
to
want
to
export
like?
Are
we
basically
who's?
This
feature,
for
if
this
feature
is
for
people
who
already
use
notebooks,
they'll,
probably
just
use
notebooks?
If
this
feature
is
for
a
different
set
of
users,
maybe
they
don't
want
to
save
his
notebooks?
That
I
don't
know,
but
well.
D
C
Are
for
a
notebook
like
if
I
want
to
just
connect
to
the
same
kernel
as
my
notebook
basically
mins
little,
he
has
like
a
scratch.
They'll
add
on
right
now
the
console
could
take
the
place
of
that
yeah.
B
Or
what
I'm
thinking
of
is
the
very
common
workflow
of,
and
maybe
this
addresses
the
persistence
issue
in
the
common
use
case
now
and
that
is
I.
Have
a
file
and
I
have
a
console
and
I
highlight
some
code
in
my
file
and
press
a
button
or
something
rather
and
it
gets
copied
into
the
console,
and
my
persistence
is
my
Python
file
that
I'm
dealing
with
and
I
mean.
B
D
B
That
too,
or
you
could
drag
a
cell
into
your
notebook
or
again
the
the
big
workflow
that
we're
really
missing
now
that
a
lot
of
people
are
used
to
is
having
a
text
file.
So
this
is
a
matlab
workflow
to
our
studio.
Workflow,
you
have
a
text
file
that
has
your
code
in
it.
That's
your
persistence
of
your
code
and
you
have
a
console,
and
you
have
an
easy
way
to
essentially
copy
code
blocks
of
code
from
your
txt
file
to
your
console
and
and
the
console
is
seen
as
a
ephemeral,
temporary
execution
engine
for.
B
D
G
C
I
guess
you
could
say
if
this
Colonel
is
still
alive.
I
can
rebuild
my
console
and
hope
that
the
variables
still
there
and
be
optimistic,
that's
the
best
you
could
do
because
it's
not
like
yeah,
but
he
would
be
missing
snapshot
to
just
ask
the
colonel.
What's
your
current
execution,
not
plan,
but
no.
D
B
C
History,
yeah
right.
B
D
D
B
D
And
I,
actually
it
gives
me
500,
but
it
counts
contiguous
repetitions,
I,
don't
so
I
filter
down
right.
B
Me
it
sounds
like
there's
a
use
case
for
having
plugins
be
able
to
talk
to
a
kernel.
That's
not
five,
not
backed
by
a
file
like
for
a
plug-in
to
be
able
to
just
get
a
handle
on
a
curl
and
and
and
send
code
to
it.
Maybe
maybe
not
the
console,
but
the
other
use
cases
that
Alejandro
was
talking
about
where
it.
B
C
B
Right
so
it
sounds
like
as
an
initial
there.
Ain't
gonnigan
wow
its
network
is
no
I'm
still
here.
Oh
you
just
oh
okay.
It
sounds
like
to
me
an
initial
take
on
the
console
might
be
to
just
treat
it
as
an
ephemeral
thing
and
not
worry
about
it
as
a
document,
because
there's
decisions
still
about
making
it
a
document
aware
thing,
and
so
so
initially
just
treated
as
an
ephemeral
thing
that
can
be
hook
up
to
the
same
kernel
as
a
notebook
or
can
it
or
that
you
can
copy
stuff
into
from
a
text
file.
B
C
Thing
we
store
on
disk
could
be
just
the
fact
that
we
have
a
have
this
console
open
and
here's
the
kernel
for
so
that,
if
you
had
to
recreate,
then
you
just
open
up
the
console
fresh
with
that
Colonel,
and
so
you
wouldn't
have
this
history
shown.
But
at
least
you
have
that
same
session,
open
I
still.
F
F
D
So
what
I
get
from
the
history
request?
Isn't
necessarily
what
you
did,
because
it
might
not
be
from
your
last
session.
It
might
be
from
your
last
20
sessions
plus
if
you
executed
the
same
line
10
times
in
a
row
and
it's
a
an
increment,
for
example.
That
means
the
variable
is
different,
because
I'm
already
I'm,
already
compressing
those
and
yeah
so
I
mean
I,
can
imagine
an
interface
where
you
open
a
console-
and
it
says,
looks
like
your
session
was
interrupted.
D
Gives
you
a
bunch
of
stuff
and
says:
do
you
want
to
execute
this
stuff
or
dismiss
it?
I
can
imagine
a
console
that
does
something
like
that,
but
that's
a
very
different
kind
of
application.
Then
the
consul's
I'm
used
to,
but
then
again
the
council's
I'm
used
to
our
terminals
they're,
not
for
analysis.
So
maybe
we
have,
maybe
literally
you
hit.
You
know
command
are
the
page
refreshes
what
the
council
does
for.
You
is
give
you
a
modal
and
you
have
to
make
a
decision.
D
F
E
F
F
C
Sh
file,
whatever
we
want
to
call
it
consists
of
the
history.
It
starts
out
with
the
history
that
you
grabbed
and
then
that
gets.
We
update
that
with
the
actual
history
as
we're
changing
on
the
client,
which
were
then
having
to
persist
regularly
so
that,
if
a
refresh
happened,
we
can
pick
up
where
we
left
off
with
that
history.
Yeah.
D
D
D
B
B
So
this
means
for
now
refreshing
the
tab
will
essentially
kill
the
Consul.
I
mean
there
there's
a
question
also
of
how
do
we
hook
the
console
back
up
to
the
kernel
or
does
it
just
kill
the
Consul
like
I?
Don't
have
time
to
discuss
it
right
now,
I'm
actually
already
late
for
my
next
meeting,
but
anyway
I'm
glad
we
brought
it
up
and
started
talking
about
it.
A
Okay,
we.