►
From YouTube: JupyterLab Commenting & JupyterLab Notifications
Description
During the Cal Poly San Luis Obispo (SLO) Project Jupyter Summer Internship, a team of mentors from various partner institutions and companies supported a cohort of 10 students who built three innovative JupyterLab extensions that we’re excited to share with the community!
In this video you will learn more about two extensions:
JupyterLab Commenting built by Cameron Toy, Chloe Frerichs, Rahul Nair, and Srirag Vuppala, mentored by Christopher Brooks, Adam Patterson, and April Wang from University of Michigan.
The JupyterLab Commenting extension lets users comment collaboratively on any file. Interactions are intuitive and make providing feedback or communicating in real-time easy. Comments also support markdown, LaTeX, and more.
https://github.com/jupytercalpoly/jupyterlab-comments.
JupyterLab Notifications and JupyterLab ToDo built by Andrii Ieroshenko, Harshit Mittal, and Marissa Thai, mentored by Afshin Darian from Two Sigma and Cameron Oelsen from Google.
JupyterLab Notifications provides a push notifications system for extension developers and users alike. Notifications API allows extensions to deliver toast notifications to users, while the Notification Center manages their notifications.
https://github.com/jupytercalpoly/jupyterlab-notifications.
JupyterLab's To-Do Lists extension enhances collaboration by allowing users to create checklists, create nested lists, assign tasks to collaborators, and link items to other elements of the JupyterLab ecosystem. Users will be able to create checklist files from the JupyterLab launcher and work with them as standard files.
https://github.com/jupytercalpoly/jupyterlab-todo
View the third extension from this summer, JupyterLab Bifrost: https://youtu.be/HgxsWLKQQHk
A special thank you to Zach Sailer from Apple, Steven Silvester from Apple, and Kevin Jahns from Yjs for supporting and mentoring the entire cohort this summer.
Background on the program:
For more than 15 years undergraduate and graduate student interns have played a critical role in the Jupyter community. Over the years at Cal Poly SLO, 51 engineering and design students have built and helped to build some amazing things: IPython Widgets, nbconvert, JupyterLab, JupyterLab Table of Contents, JupyterLab Git extension, JupyterLab Status Bar, and others. Multiple current and former Jupyter Steering Council members and core developers started out working with us as students.
This program would not be possible without our funders: Leona M and Harry B Helmsley Charitable Trust, Alfred P Sloan Foundation, Schmidt Futures, Gordon and Betty Moore Foundation. Thank you for your continued support and belief in this program.
00:00 Introduction
07:59 JupyterLab Commenting
21:00 Commenting Questions
31:08 JupyterLab To-Do Lists
48:54 To-Do Lists Questions
A
A
The
program
at
california,
polytechnic
state
university
in
san
luis
obispo,
that's
a
really
long
name,
and
so
we
call
it
cal
poly.
For
short,
we're
really
excited
to
be
here
today
and
I'm
thrilled
to
have
the
task
of
introducing
the
phenomenal
work
that
was
undertaken
by
this
summer's
cohort
this
summer,
more
than
ever,
our
program
was
facilitated
and
made
possible
by
a
community
of
mentors
and
collaborators,
but
I
did
want
to
start
by
introducing
the
cal
poly
team,
and
that
is
founder.
A
A
B
The
dream
here
with
this
internship
program,
as
the
slide
says,
is
to
solve
real
world
problems
for
jupiter
users
that
somehow
improves
their
experience
of
using
jupiter
and
the
work
that
they're
doing
with
jupiter
and
the.
How
of
that
is
that
we
combine
software
engineering
and
ux
design
into
a
single
internship
and
with
the
goal
that
each
team
of
developers
and
designers
ships
software
by
the
end
of
the
summer,
you
can
go
to
next
slide
switch.
So
this
internship
is
currently
affiliated
with
cal
poly.
B
It
actually
started
all
the
way
back
in
2005
when
I
was
at
santa
clara
university
and
we've
been
running
it
in
various
forms.
Ever
since
then,
our
first
intern
ever
was
min
reagan
kelly
when
he
was
an
undergrad
at
santa
clara
university
and
he
is
the
lead
and
founder
of
jupiter
hub,
which
many
of
you
are
likely
familiar
with
and
continues
to
work
with
us
today,
as
a
researcher
at
similar
research
labs
in
norway.
B
So
this
has
been
going
on
a
long
time.
We've
learned
a
lot
over
the
years
and
we're
still
learning
a
lot:
the
it's
a
full-time
intern
internship
for
students
over
the
summer.
They
often
stick
with
us
after
the
summer
working
part-time
during
the
academic
year.
The
big
thing
we've
learned
is
how
we've
struck,
how
we
structure
teams,
and
so
the
last
few
years
that
we've
been
running
this.
B
One
thing
that's
new
for
this
year
is
that
we've
leveraged
mentors
from
the
broader
jupiter
community.
Previously
we
had
people
at
cal,
poly,
mentoring,
students
and
this
year
we've
opened
that
up
to
include
a
wider
range
of
people
who
are
are
mentoring,
the
three
teams,
and
with
that,
let
me
thank
and
acknowledge
the
mentors
for
the
two
projects
that
we'll
be
hearing
from
today.
The
first
extension
and
team
is
the
the
commenting
project
and
the
mentors
for
that
are
from
the
university
of
michigan.
B
B
There's
action,
darien
who's,
one
of
the
co-founders
of
jupiter
lab
and
has
been
a
long
time
contributor
and
then
from
google
ux
designer
cameron,
olsen
and
cameras.
Cameron
himself
was
a
former
intern
at
cal
poly
and
did
a
lot
of
the
initial
ux
design
of
jupiter
lab
as
a
student,
and
then
we've
also
had
other
jupiter
contributors
who've
held
office
hours
to
to
answer
additional
questions.
The
students
have
had
zach
saylor,
who
is
currently
a
software
engineer
at
apple
and
also
a
former
intern.
C
A
D
Hello,
everyone
thank
you
for
joining
in
on
our
presentation
today.
Today,
we'll
be
going
over
our
work
on
your
lab
comments.
First,
things.
First
we'll
go
around
and
introduce
ourselves.
That
being
said,
my
name
is
charitable
apollo
and
I'm
a
rising
junior
studying
computer
science
at
cal,
poly
slope
and
I
contribute
as
a
developer
to
the
team.
F
I'm
rahul
nair,
I'm
a
rising
sophomore
at
cal,
poly
slo,
I'm
also
a
computer
science
major,
and
I
was
also
one
of
the
developers.
Chloe
was
one
of
the
designers
of
our
team
she's,
a
rising
senior
at
cal
poly,
so
who's,
unfortunately
unable
to
be
here
so
to
get
a
bit
of
a
background
information
on
our
extension.
We
need
to
talk
a
bit
about
jupiter,
lab's,
new
rtc
or
real-time
collaboration,
features,
which
was
recently
released
in
the
new
jupiter
lab
3.1
update.
D
Why
comments
comments
as
a
medium
for
communication
is
a
staple
across
many
collaborative
applications
like
google,
docs,
sigma
or
microsoft
word
and
with
the
advent
of
rtc
in
jupiter.
Lab
comments
have
been
incredibly
desirable,
ranking
10
out
of
33
from
a
recent
pinpoint
survey
conducted
by
the
core
jupiter
team.
D
This
centralized
medium
allows
for
both
technical
and
non-technical
users
to
collaborate
to
provide
feedback
and
suggestions.
The
defined
structure
of
the
interface
circumvents
the
problem
of
cluttering
the
source
file.
Also,
since
this
is
a
native
jupiter
lab
extension,
the
workflow
has
less
resistance,
since
it's
well
integrated
and
doesn't
require
any
third-party
applications
like
get
or
get
help.
D
Now,
let's
go
ahead
and
start
talking
about
the
core
features
of
our
extension.
A
major
goal
we
achieved
was
creating
a
platform
for
any
file
to
have
commenting
within
jupiter
lab.
While
we
provide
text
file
and
notebook
support
out
of
the
box,
we
also
provide
an
api,
like
interface
for
other
developers,
to
create
custom
implementations
of
commenting
that
is
best
suited
for
them.
D
F
So,
as
you
can
see,
the
design
of
the
comment
is
quite
similar
to
those
of
say
a
google
docs
comments
or
those
in
microsoft
word
or
figma
or
any
other
commenting
application.
We
also
wanted
to
add
a
bit
of
a
unique
twist
to
it.
You
see
chloe
made
those
abstract
moon
icons
which
are
tied
into
the
whole
jupiter
moons
concept,
and
we
have
code
text
akin
to
that
of
a
block
quote
in
html.
E
So
you'll
see
jupiter
lab,
maybe
you
guys
can't
respond,
but
all
right
for
this
demo
we're
gonna
be
working
in
this
data
science
document.
This
is
a
graph
of
the
hodgkin-huxley
equations
which
are
basically
used
to
model
ion
concentrations
and
heart
cells,
and
so
the
first
thing
I
want
to
do
here
is
open
up
the
comments
panel
on
the
right
side,
and
I
can
see
that
chirag
already
has
a
comment
here,
but
the
first
thing
I'm
going
to
do
is
change
my
name
up
here.
E
So
jupiter
lab
assigns
you
an
anonymous
identity
based
on
the
moons
of
jupiter,
I'm
going
to
change
that
to
my
actual
name.
So
it's
a
little
easier
to
follow
along
and
okay.
So
here's
a
comment
here.
He
says
the
graph
seems
to
be
wrong.
Can
you
check
if
everything
is
working?
So,
as
I
click
on
the
comment
here,
it
scrolls
me
to
the
target
of
the
comment
which
in
this
case
is
a
notebook
cell
and
I
can
see
okay.
Yes,
this
looks
a
little
bit
wrong.
E
D
G
E
E
Okay,
so
rahul
agrees
and
that's
how
we
would
address
an
issue
while
collaborating
with
jupiter
comments.
So
I'm
gonna
go
through
a
few
more
features
of
the
commenting
extension
you
can
see
here
when
I
click
on
the
comments.
It
scrolls
me
to
the
target
of
the
comment
text
and
that's
because
the
comments
are
aware
of
where
they
are
in
the
document.
G
E
One
thing
you
also
might
notice
is
that
if
I
make
a
change
to
the
comments
here
like
deleting
this
comment,
the
dirty
status
indicator,
I
can
click
here
showing
that
they're
able
to
change
the
comment
file.
Common
files
are
linked
to
their
source
file.
So
if,
for
example,
I
go
here
and
save
the
original
python
file,
it'll
also
save
the
comments
file
comment.
Files
also
automatically
save
if
you
switch
documents
to
refresh
and
finally.
D
Thanks
for
that
demo
cameron,
if
you'd
like
to
learn
more
or
track
our
progress
feel
free
to
check
out
our
github
also
go
ahead
and
click
on
the
star
or
watch
button
on
our
github
to
receive
more
updates
on
the
project.
Also,
we,
if
you
would
like
to
try
this
extension
out
locally,
you
can
install
pip
release
that
we
have
out.
That
being
said,
we'll
also
add
in
the
binder
link
for
the
demo.
D
F
So,
as
for
our
development,
the
first
few
weeks
was
just
getting
set
up.
We
added
a
few
prototype
setup,
but
mainly
getting
familiarized
with
the
jupyter
lab
api
libraries
code
practices
and
the
sort
such
that
by
week.
Six,
for
example,
we
were
able
to
get
text,
selection,
comments
and
cell
level
comments
for
notebooks.
F
We
revamped
our
ui
just
to
make
it
more
like
what
we
have
it
right
now
and
overall,
we
have
started
adding
some
new
quality
of
life
features.
Like
the
editable
comments
you
saw,
and
the
capacity
average
text
and
now
by
release,
we've
expanded
our
support
for
comments
not
just
from
notebooks,
but
I
see
soft
to
python
files,
text
files,
markdown
files,
you
name
it-
and
this
is
also
where
we
just
started
piling
on
the
features.
There's
the
collapsible
replies.
F
G
E
We
also
used
react
widgets,
wrapped
in
lumino
for
the
ui
and
the
actual
comment
widgets.
So
for
those
of
you
that
don't
know,
lumino
is
the
front
end
library
that
was
designed
by
project
jupiter
for
jupiter
projects
and
using
react
with
lumino.
Let
us
really
quickly
iterate
ui,
while
also
staying
tightly
tied
into
jupiter
lab
files
are
stored
in
json
on
disk
the
stored
server
side
right
now,
they're
stored
in
a
comments
folder
in
the
route
where
you
start
jupiter
lab,
but
we're
looking
into
making
that
user.
E
Configurable
also
comments
are
extensible
and
file
type
agnostic.
So
you
saw
comments
for
markdown
for
use
for
a
python
file
for
our
notebook,
because
we've
used
the
api
that
we
defined
to
create
this
implementation
for
text
files
and
notebook
files.
But
the
api
is
extensible
and
it
gives
you
the
tools
to
implement
comments
for
things
like
csv
files
or
image
files,
and
things
like
that.
It
lets
you.
E
The
first
thing
we
like
is
a
permissions
and
a
user
identity
system,
so
you
saw
that
I
had
to
change
my
name
from
the
anonymous
moon
name
to
my
actual
name.
So
currently,
jupiter
lab
doesn't
implement
a
permissions
or
user
identity
system,
so
we
have
a
little
hacky
stand-in
for
that.
Another
thing
that
you'll
notice,
if
you're
on
the
on
the
binder
right
now,
is
that
you
can
edit
or
delete
anyone's
comment
so
we'd
like
some
sort
of
permission
system
and
once
that's
needed,
we
can
tighten
our
attention.
E
Another
thing
that
we'd
like
to
work
on
is
the
where
the
comments
are
stored,
so
right
now,
they're
stored
in
comments,
json
files
and
there's
some
kind
of
odd
moments
of
friction
that
that
causes
serialization
and
deserialization
finding
the
target
switching
between
documents,
things
like
that,
so
something
like
an
sqlite
server-side
comment
database.
It
really
helps
move
these
interactions
out
and
then
the
last
thing
we
like
to
do
is
integrate
comments
in
a
core
jupiter
lab
we're
looking
into
drafting
an
official
proposal
for
that.
E
So
we
also
like
to
give
a
quick
shout
out
to
the
people
who
helped
us
with
this
extension,
our
mentors
dr
christopher
books
and
adam
harrison
at
university
of
michigan
kevin
yawns
white
with
yjs,
dr
brian
granger,
and
anna
rubel
caba
at
jupiter,
cal,
poly
internship
program
and
then
finally,
the
wider
jupiter
community
as
a
whole.
You
guys
are
all
really
helpful
on
gatorade.
D
All
right,
I
guess
we
can
go
off
addressing
the
questions
in
the
q,
a
I'll
take
the
first
one
by
richard
when
you
export
a
notebook.
Well,
the
comments
come
with
it
right
now.
No,
but
there
is
a
potential
in
the
future
regarding,
because,
like
a
big
question
that
we
had
was
like
the
scope
of
our
extension,
whether
it's
only
going
to
be
a
jupiter
lab
extension
or
like
a
jupiter
notebook
extension.
E
Jonathan
frederick
asks
do
you
write
end-to-end
tests
for
this
feature?
If
so,
how
it
seems
like
right
and
then
test
is
really
complex.
Excuse
me,
multiple
users,
interacting
with
one
notebook.
Yes,
that
is,
is
very
complex.
We
don't
have
end
to
end
tests.
We
don't
have
ui
tests
for
real-time
collaboration
tests,
which
are
things
we'd
actually
like
to
include
before
this
becomes
a
part
of
core.
E
E
Adam
rule
says
really:
gracie
comments
coming
duper
live
and
across
file
types.
Do
you
think
people
will
use
comments
on
markdown
cells
as
well
as
code
sales?
Yes,
I
I
think
there
are
some
uses
for
using
markdown
on
codes
on
comments
on
markdown
cells
as
well
as
code
cells.
You
can
comment
on
markdown
cells.
I
don't
think
we
showed
it
in
the
in
the
demo,
but
you
can
also
comment
on
a
text
selection
in
a
notebook
cell.
We
talked
to
some
people
and
they
really
wanted
to
see
that
so
yeah.
E
When
is
a
comment,
really
discussion,
and
does
this
matter
in
what
we
should
do
in
jupiter
lab
chris
brooks?
When
is
a
comment,
really
a
discussion
and
does
this
matter
and
what
we
should
do
in
jupiter
lab
okay,
so
my
interpretation
of
that
question
is
for
comments
that
are
more
than
just
a
quick
note
or
a
suggestion.
G
Yeah,
so
sometimes
people
have
review
something
and
leave
a
couple
of
comments
and
there's
little
responses,
and
sometimes
it's
like
a
deep
discussion
about
a
design
change.
Think
about
an
issue
in
github
and
how
that
can
lots
of
discussion
can
happen
with
very
minimal
amount
of
code
of
work.
So
how
does
how?
How
should
we
think
about
that
in,
in
the
context
of
something
like
what
you
guys
have
built.
E
I
think
in
a
larger
discussion
you
want
some
idea
of
threading
and
replying
to
a
specific
reply,
so
we
don't
implement
threading,
although
we
are
planning
to
eventually
implement
adding
other
users
or
you
know,
picking
other
users
using
the
notification
system
that
is
in
the
following
presentation,
yeah.
That
is
something
we
thought
about
right
now.
I
feel,
like
the
commenting
extension
best
addresses
the
cases
where
you
have
a
quick
suggestion
or
a
quick
note,
and
you
need
a
little
bit
of
back
and
forth.
E
What
happens
to
comments
in
cells
when
a
cell
is
deleted
or
in
the
content
that
the
comment
is
anchored
to
is
changed?
So
when
the
comment,
when
the
content
is
changed,
you
have
a
text
selection
and
you
change
the
text
before
or
in
the
selection.
It
updates
live
so
text
selections
are
are
flexible
when
you
delete
a
cell
that
a
comment
is
attached
to.
I
believe
it
also
just
disposes
of
the
comment
in
the
json,
but
I
might
be
incorrect.
D
D
D
E
Another
thing
we
considered
was
jupiter
lab
is
inherently
a
multi-document
environment.
You
can
have
two
documents
next
to
each
other,
whereas
something
like
google
drive,
you
have
one
document,
always
in
focus,
so
it's
not
as
problematic.
If
you
have
a
comment
like
popping
over
the
interface
because
it'll
always
you'll
never
intercept
another
another
document,
but
in
jupiter
lab.
We
really
wanted
to
keep
the
comments
in
that
side
panel
in
like
their
own
container,
because
it
can
kind
of
cause
issues
if
there
are
multiple
documents
feel
free
to
leave
any
bugs
you
find
also
on
github.
E
We
know
there's
a
few
bugs
in
there
and
we're
waiting
for
people
to
discover
them
we'll
be
starting
comment:
json
files,
okay,
so
right
now
in
json
files,
it
stores
there's
a
generic
kind
of
comment.
That's
stored
for
every
type
of
comment.
Like
you
have
a
cell
comment
like
a
text
selection
comment
and
for
every
comment:
you
store
the
identity
of
the
user.
E
F
Chris
rhoden
chad,
what
if
jupiter
lab
rtc
had
a
live,
video
and
voice
channel
going
on
at
the
same
time
would
commenting
still
be
useful.
Would
it
need
to
change
to
be
awesome?
I
personally,
I
believe
yes,
commenting,
would
still
be
useful.
There
would
be
different
purposes
for
having
a
comment,
as
opposed
to
say,
a
live
discussion.
F
D
If
you
check
our
issues,
I
believe
we
do
have
in
the
works
like
a
global
comment,
commenting
hub
essentially
in
the
works
where
you
would
be
able
to
like
tag
certain
comments,
so
have
like
adding
cell
tags
to
a
comment
or
making
products
like
a
proper
searching
mechanism
as
well.
So
I
feel
like
that
would
happen
eventually,
but
we
don't
have
it
right
now.
E
Yeah,
that's
that's
so
yeah.
We
had
an
idea
like
a
comment
hub,
which
is
you
could
search
the
comments
on
all
your
documents
and
we
figured
that
things
like
tagging
and
searching
would
be
more
useful
if
you
could
go
through
all
your
documents
and
look
at
all
the
comments
and
that's
another
issue
that,
like
an
sql
database,
would
address
because
you
wouldn't
have
to
parse
all
the
json
files
on
disk.
You
could
just
have
this
one,
that's
fill.
It
did
base
instance.
E
A
A
We
will
now
move
on
to
the
next
team,
though
just
a
quick
reminder
to
that,
you
can
put
questions
in
the
q
a
while
students
are
presenting,
but
they
won't
look
at
them
until
the
end.
In
order
to
answer
them,
you
can
mix
them
into
the
chat
also,
but
it's
a
little
more
confusing
for
us.
So
if
you
can
put
it
into
the
q
a
that
helps
us
manage
all
of
the
questions.
So
without
further
ado
I
will
or
two
do
I'm
not
sure
which
one
of
those
it
is.
H
Hello,
everyone
welcome
to
our
capstone
presentation.
We
are
at
just
your
team
and
today
we
will
be
talking
telling
you
about
two
extensions
that
we
worked
on
over
the
summer
and
please
feel
free
to
post
your
questions
to
q,
a
section
so
we're
a
practic
jupiter
summer,
intern
team
and
it's
our
first
time
contributing
to
open
source.
My
name
is
andrea
and
I'm
a
software
engineering
senior
at
cal,
poly.
H
So
today
we
will
tell
you
about
two
extensions.
We
worked
on
it's
a
to-do
list
extension.
We
will
look
at
the
initial
proposal
for
this
extension
and
our
progress
in
this
extension.
Then
we
will
look
at
the
notifications.
Extension
breadth
of
ux
research
done
for
this
extension
and
we
will
demo
design
prototypes
and
extensions
itself.
I
So,
in
the
beginning
of
our
internship,
I
conducted
user
interviews
with
some
of
our
jupiter
lab
users
and
found
that
if
users
want
to
create
a
to-do
list,
they
would
need
to
use
alternative
options
such
as
the
classic
pen
and
paper
jupyter
text
files
or
third-party
service.
This
does,
however,
force
users
to
jump
between
various
platforms
resulting
in
wasted
time
and
system
resources
just
to
keep
their
work.
I
So,
during
my
interviews,
I
created
some
new
personas,
so
here
is
example
one
I'm
just
going
to
highlight
from
this
slide
the
things
that
we've
learned
most.
So
what
most
users
want
in
a
to-do
list
is
basically
structure.
They
want
to
be
able
to
nest
sub-tasks
and
which
is
why,
in
our
model,
we
followed
a
task
to
sub-task
model.
I
Here
are
some
screens
of
our
earliest
figma
iteration.
As
you
can
tell,
we
do
have
the
nesting
implementation
down,
we
have
the
ability
for
customization
for
color
due
date
time,
as
well
as
the
ability
to
put
in
these
number
tags.
This
basically
is
like
partial
completion.
Just
to
let
users
know
how
far
they
are
through
their
to-do
list
and
then
here's
just
an
example
of
a
screen
of
our
latest
sigma.
I
We
don't
really
have
time
to
go
through
each
prototype,
so
I'm
just
gonna
highlight
what
we
have
done
here,
which
is
basically
moved
our
completed
items
to
the
bottom,
to
keep
it
away
from
the
main
area.
There
is.
We
still
have
implementation
of
subtasks
top
level
tasks.
There
are
due
dates
and
also
the
number
tags
as
well.
H
H
So
this
is
the
latest
version
of
our
extension.
You
can
see
here
that
the
interface
is
updated.
On
the
right
hand,
side
we
see
a
number
of
uncompleted
subtasks
on
each
task.
We
also
can
see
a
completed
section
at
the
bottom
right
hand.
Side
of
the
screen-
and
the
key
difference
here
is
that
we
added
support
of
parsing
of
txt
file
format.
So
currently,
in
the
center
of
the
screen,
the
txt
file
is
opened.
User
can
edit
this
file.
H
So
I'd
like
to
add
that,
at
this
stage
that
we
thought
is
almost
final
stage,
we
understood
that
there
is
a
conundrum
between
to
do
txt
file
format
and
the
url
format
with
nested
subtasks
that
we
want
to
use,
and
it
may
makes
us
either
need
to
change
the
ui
or
to
do
txt
file
format.
So
please
notice.
This
extension
is
still
it's
fairly
alpha
stages,
and
we
need
to
do
this
make
this
decision.
So
if
you
would
want
to
download
this
extension,
you
probably
just
want
to
do
that
in
the
case.
C
So,
as
for
the
potential
next
steps
for
the
to-do
list
extension,
we
want
to
decide
what
paths
we
want
to
go
down
on
and
if
you
want
to
stick
with
the
root
txt
format
or
we
want
to
develop
our
own
parsers.
So
we
can
add,
we
can
add
support
for
nested
lists
instead
of
having
to
make
a
different
file
for
every
list
that
you
want
to
have,
we
want
to
add
the
ability
for
ui
changes
to
reflect
in
the
files
and
vice
versa.
C
So
whenever
a
change
is
made
to
either
the
file
or
the
ui,
it
reflects
in
the
counterpart
as
well.
We
want
to
add
due
dates
and
partial
completion
of
items
to
do
items
and
the
ability
to
assign
items
to
collaborators,
although
that
will
come
as
there
is
a
more
concrete
concept
of
user
identity
in
jupiter
lab.
C
Currently,
the
extension
features
system,
notifications
and
dose
notifications,
and
we
have
a
rest
server
side
architecture
with
a
websocket
feature
and
basically,
what
the
extension
developers
can
use
it
can
do
is
create
notification
objects
using
our
well-defined
api
schema
that
we
publicly
provide
and
use
tokens
to
send
out
notifications
and
retrieve
notifications
from
the
server
side.
That
has
a
sqlite
database
for
storage,
and
we
will
talk
about
that
in
detail
later.
I
So
here's
another
user
persona
just
highlights
from
this
slide.
They
really
want
to
find
notifications
that
are
deemed
really
important
and
top
level
and
be
able
to
have
the
ability
to
customize
their
own
preferences
to
say
if
they
want
to
dis,
dismiss
or
block
certain
notifications
from
constantly
popping
up.
I
I
So
here
are
some
screens
from
the
earliest
iteration
of
our
figma.
Again,
each
notification
has
their
own
notification
cards,
there's
ability
for
users
to
dismiss
or
really
not
to
show
certain
types
of
notifications
like
I've
mentioned
before
these
notifications
are
grouped
based
on
their
origin
and
not
really
subject,
and
we
found
later
on
that
that
was
something
that
users
would
probably
not
like,
and
here
is
our
blocking
panel,
just
basically
to
allow
users
to
customize
preferences.
Like
I
mentioned
before
so
quickly,
I'm
gonna
run
through
the
figma
prototype.
This
is
our
latest
iteration.
I
So
if
I
was
to
restart
it,
supposedly
a
user
would
get
toast
notifications
in
the
top
right.
That's
just
because
it's
relation
to
where
the
center
is.
If
I
open
this
up,
the
it
opens
a
open
drawer
side
panel
here
are
all
of
our
notifications.
They
are
labeled
by
new
and
earlier.
If
I
just
hover
over
this,
I
can
dismiss
it
easily
say
if
I
want
to
open
up
this
group
of
notifications,
these
are
grouped
by
the
notebook
file
itself
and
all
these
notifications
are
related
to
this
notebook
file.
I
I
just
want
to
get
rid
of
it.
I
can,
if
I
hover
here,
you
can
see
that
there's
like
a
cog
icon
that
opens
up
our
blocking
panel
or
the
preference
panel.
Basically,
so
I'm
just
going
to
dismiss
this
close
this
up,
and
we
also
have
the
ability
for
users
to
clear
or
to
like
close
certain
sections,
not
really
to
get
rid
of
all
the
information.
If
the
user
feels
like
there's
so
much
clutter
here,
they
can
just
close
this
section
just
right
here.
I
If
they
want
to
reopen
it,
they
can
or
if
they
really
just
want
to
get
rid
of
all
earlier
notifications.
I
can
just
do
this
right
here.
I'm
just
going
to
quickly
show
you
our
blocked
panel
that
I've
shown
in
our
first
iteration.
This
allows
users
just
to
turn
on
and
off
notifications
that
they
deem
like
too
much
such
as
like
cell
execution,
or
even
commenting
if
they
so
want
to.
C
So
this
is
a
very
early
version
of
the
development
version
of
the
notification
extension.
We
were
kind
of
in
our
exploratory
phase
and,
as
you
can
see,
we
were
tracking
events
inside
jupiter
lab
and
like
a
notebook
that
were
happening
and
populating
the
side
panel
with
cards
according
to
the
action
that
has
just
occurred.
H
C
H
H
Let's
go
to
the
next
slide
to
talk
about
it
in
detail,
so
we
have
defined
our
api
accordingly
to
open
api
specification
and
publish
the
specification
on
github,
so
it's
publicly
available
and
other
extension
developers
can
use
it
and
extend
it.
It
also
allows
it
also
defines
api
and
shapes
of
the
objects
that
api
expects
to
accept
and
it
allows
us
to
auto
generate
server
tests
and
documentation
for
our
api.
C
Yeah,
so
I
can
go
ahead
and
share
my
screen
and
I
have
a
collaborative
jupiter
lab
session
running
on
my
machine,
and
I
have
two
different
browsers
open
to
emulate
two
different
users
that
can
be
connected
to
a
collaborative
user
space
when
a
user
logs
into
a
workspace
for
the
first
time,
they're
prompted
to
enter
a
username.
As
the
previous
comments
team
mentioned,
there
is
no
concept
of
a
user
identity
in
jupiter
lab
as
of
now,
so
this
is
just
a
temporary
placeholder
and
it
stores
a
username
in
local
storage.
C
But
as
there
is
a
more
concept,
more
concrete
concept
of
user
id,
we
would
like
to
move
to
that
system.
But
for
now
I
can
go
ahead
and
enter
my
username
for
this
browser
window
and
do
the
same
for
this
browser
window
and,
as
you
can
see,
whenever
a
user
connects
to
a
workspace.
Every
user
that
is
already
connected
gets
a
notification
that
another
user
has
just
connected
to
your
collaborative
workspace
and
they
also
get
that
notification
in
the
notification
center.
C
Whenever,
when
you
connect
to
a
jubilee
workspace
for
the
first
time,
a
user
also
gets
the
last
20
notifications
that
were
stored
in
the
database
and
that
ensures
that
every
new
user
that
joins
the
workspace
can
feel
like
can
know
what
was
going
on
inside
the
workspace
before
they
were
a
part
of
it
and
talking
about
the
server-side
architecture
and
how
the
notifications
actually
work.
So
so
we
have
a
rest
server
architecture
defined
with
rest
endpoints
that
extension
developers
can
use
to
post
notification
objects
to.
C
Using
the
token
that
we
provide
that,
I
will
that
we
will
discuss
later
and
they
make
a
get
request
and
retrieve
the
last
notification
object
from
the
database
and
that
is
populated
inside
the
ui
and
we're
currently
tracking
cell
executions
and
new
users
joining.
So
if
I
were
to
execute
this
cell,
you
could
see
that,
like
that
event
happened,
and
both
the
users
called
this
notification,
that
the
cell
has
finished
execution
in
the
demo
book
two
dot,
ipv
and
andre
can
talk
more
about
the
token
and
the
ui
elements.
H
So,
for
extension,
authors
to
use
the
identification
api
in
a
familiar
and
comfortable
manner,
we
provide
a
token
which
is
a
pin
wrapper
around
our
end
points,
so
extension
developers
can
import
it
instantiate
it
and
use
methods
on
it.
Pass
notification
objects
to
this
message
instead
of
heating
up
endpoints
directly.
H
So
let's
talk
about
the
user
interface.
Now,
as
you
can
see,
user
interface
is
built
around
interactive
cards
that
are
based
around
the
certain
subject:
the
source
of
notifications
such
as
notebook.
If
more
than
one
notification
comes
from
the
same
source,
they
are
bunched
together
and
a
number
of
notifications
in
bunch
is
displayed.
We
can
click
and
extend
any
bunch.
So
you
can
see
individual
notifications.
H
You
can
see
that
the
cards
itself
are
interactive
and
they
show
creation
time
and
they,
if
you
mouse
overs
over
them,
they
show
interactive
control
elements
x
with
which
you
can
dismiss
this
particular
notification
and
cog
to
open
settings.
So
in
terms
of
settings.
Currently
we
have
ability
to
block
notifications
from
certain
origin
and
when
user,
if
user
does
it,
you
don't
see
notification
from
that
origin.
Harsh
will
demo
it
in
more
detail.
C
Yeah,
so
if
I
choose
to
block
notifications
from
cell
executions,
I
can
go
ahead
and
do
that
and
I
get
a
toast
notification
as
a
warning
prompt
that
tells
me
that
I
will
no
longer
be
notified
for
updates
about
cell
execution.
I
also
have
a
button
for
settings
in
the
post
notifications
that
I
can
use
to
open
the
settings
panel,
and
that
shows
me
what
notification
sources
I
have
currently
blocked.
So
since
this
user
has
blocked
notifications
from
cell
execution
and
for
this
user,
there
is
nothing
in
the
block
notifications
list.
C
If
I
were
to
go
ahead
and
execute
a
cell
on
either
the
notebooks,
this
user
gets
notified
about
that
cell
execution,
but
this
user
doesn't
as
a
user.
They
also
have
the
ability
to
remove
stuff
from
the
block
notifications
list.
So
I
can
go
ahead
and
remove
cell
execution
from
here
and
if
I
were
to
execute
a
cell
now,
both
these
users
will
get
the
notifications
as
usual.
C
C
H
So
we
would
like
to
do
a
special
mention
of
our
mentors.
It's
cameron
olsen
our
exi
mentor
and
f
chanderien,
our
software
development
mentor.
So
you
put
a
lot
of
time
into
our
team
and
into
this
extension
and
help
to
move
it
as
far
as
as
it
would
moved.
Thank
you
very
much
and
thank
you.
Everyone.
Thank
you
for
attending
our
presentation,
we're
opening
four
four
questions.
Now,
let's
look!
What's
up
in
q
and
a
we
will
probably
ask
brian
to
answer
the
first
question.
If
you
would
like
to.
B
Yeah,
so
we
we
go
through
a
process
of
brainstorming,
different
project
possibilities,
and
then
we
score
each
of
those
ideas
based
on
on
a
number
of
different
dimensions,
including
both
impact
on
users,
technical
and
design
complexity,
and
there
we
were
looking
for
projects
that
are
are
not
too
simple,
but
also
not
too
complex
impact
on
the
students
who
will
be
participating
in
and
then
also
interest
from
mentors.
You
know
we
want
want
people
to
mentor
on
projects
that
they're
interested
in
and
so
yeah.
I
It's
this
well.
The
to-do
list
extension
was
more
of
just
a
like
a
native
extension
for
jupiter
to
lab
users
and
to
integrate
well
into
the
ecosystem
of
jupiter
lab.
It's
not
really
meant
to
compete
with
other
third
part.
Well,
there
is
a
little
competition
between
like
other
third-party
platforms,
but
this
was
meant
more
of
for
like
a
native
platform
to
to
do
to
do
extension
for
users,
because
we've
noticed
that
a
lot
of
users
do
use
just
regular
text
files
in
jupiter
lab.
So
we
just
wanted
to
create
an
extension.
H
So
I'd
like
to
add
to
this
that
an
important
thing
for
us,
which
led
for
some
problems
for
us
was
we
wanted
to
use
to
do
txc
a
popular
to-do
list
format,
while
already
widely
adopted
and
used
used
on
the
internet
as
a
backup
file
format
and
have
on-the-go
integration
with
it.
So
yeah
simple,
to-do
list
that
supports
already
existing
open
source
and
coding,
not
necessarily
like
a
competing
thing
with
github
issues.
A
Yeah,
I
think
so
thank
you
team.
I
think
we
will
go
ahead
and
wrap
up.
It
doesn't
look
like
there's
any
more
questions,
so
congratulations
to
marissa
taharsha
to
andre
for
your
summer's
work.
It's
really
excellent
to
see
the
final,
the
final
presentation
and
summary
of
what
you've
been
able
to
do
over
the
past
11
weeks
I
do
the
students
gave
links
to
their
repos.
I
will
also
post
a
link
for
everyone
to
the
jupiter
cal
poly
github,
which
has
everyone's
extensions
or
repos
in
in
that
area.
A
I
also
want
to
give
a
general
project
jupiter
resource
that
I
don't
feel
like.
Everyone
is
aware
of
that's
our
discourse
channel
and
so
lots
of
good
content
and
discussions
happening
within
that
area.
So
I
wanted
to
share
that
today
with
that,
I
think
we
will
go
ahead
and
wrap
up.
I
really
want
to
thank
everyone
for
joining
us.
It's
been
a
joy
to
share
our
work
with
you
from
the
summer
and
we're
looking
forward
to
tomorrow's
presentation
from
our
third
team.
The
jupiter
bicross
team.