►
From YouTube: JupyterLab Dev Meeting, October 14, 2016
Description
Meeting of the IPython/Jupyter development team, October 14, 2016
Meeting Notes: https://jupyter.hackpad.com/JupyterLab-Weekly-Meetings-UUJ3gIQ3iBS
A
Labeling
systems,
what
I'm
typing
war
in
the
ACT
pad
and
part
of
what
we
did
was
start
to
create
some
visualizations
of
our
open
github
issues
for
the
Jupiter
lab
repo,
and
we
did
that
with
all
tear
which
sort
of
forced
us
to
think
about
our
data
model.
That's
implicit
in
the
label
naming
scheme
and
taxonomy,
and
probably
the
first
thing
I'm
going
to
show
is
the
visualizations
that
are
in
the
hack
pad,
and
so
this
is
a
count
of
the
number
of
open
issues
by
the
first
grouped
by
the
labels.
B
A
C
A
A
Yeah
good,
so
so
again,
within
each
sub
sub
plot
or
facet,
the
components
are
listed
here.
Each
particular
facet
is
a
milestone,
so
first
209,
then
10,
then
the
back,
walk
and
then
the
colors
are
the
type
labels
of
none
maintenance,
enhancement
or
bug
one
to
make
this
plot
it
didn't
require
us
to
it.
We
found
that
in
almost
all
cases
we
were
only
assigning
a
single
type
do
an
issue.
There
was
a
couple
exceptions
with
that
on
maybe
one
or
two
issues
we
were
doing
both
bug
and
enhancement.
A
Then
we
decided
that
let's
actually
just
decide
on
those
at
the
core
enhancement
and
then
the
other
was
feature
parity
which
for
us
felt
a
little
bit
inaudible
to
the
type
we
tended
to
apply
feature
parity
with
other
things.
We
converted
feature
parity
to
a
category
or
cap
colon
labeled,
so
that
enable
doesn't
have
a
really
clean,
a
sort
of
single
value
type
we've
started
to
go
through
and
make
sure
that
issues
do
have
a
type
you
can
see
here.
We're
not
done
doing
that.
A
A
A
The
next
is
an
hour
wanting
to
distinguish
between
issues
that
are
ready
to
be
acted
upon
and
implemented
versus
issues
that
need
discussion.
We
have
a
needs,
discussion,
label
and
we'd
like
to
continue
to
use
that
the
difference,
those
that
we'd
like
to
start
having
some
dedicated
meetings
to
have
discussions
and
make
decisions
on
those
issues
to
try
to
keep
things
in
the
basically.
A
We
have
a
lot
of
stalled
discussions
that
are
just
sort
of
sitting
there
that
we'd
like
to
either
close
or
move
to
implementation
points,
and
then
we've
also
gone
through
and
come
up
with
a
more
uniform
labeling
color
scheme
and
I'll
just
show
that
here
in
the
issues
page
there
we
just
took
a
guess
on
how
to
assign
colors
I
know
Jamie.
You
have
thought
about
taking
a
pass
at
that.
What
we've
done
ish
alee
is
a
unique
color
or
in
each
of
our
issue
prefixes.
So
cat
colon
is
purple
component
component.
Colon
is
blue.
A
A
A
I'm
going
to
continue
to
push
on
the
visualization
to
come
up
with
some
sort
of
standard
visualizations
that
we
might
want
to
have
available.
Another
one
is
to
start
to
separate
design
related
issues
from
non
design
related
issues.
We
felt
like
that's
another
big
category
in
terms
of
who's,
working
on
what.
C
A
Number
by
I
Steve
replied
to
my
my
issue
and
I
think
or
my
question
and
I
think
it
makes
sense.
But
right
now
we
do
have
some
subversion
conflicts,
potentially
with
Jupiter
jf
services
in
Jupiter
lab.
But
it
looks
like
we'll
resolve
those
as
we
move
to
the
new
Jupiter
or
and
in
p.m.
vinny's
and
I'll.
Let
Steve
talk
about
all
that
stuff.
D
D
Why
we're
doing
that,
the
ramifications
were
to
update
rubies
to
point
to
the
new
locations
like
we
can't
use
the
Jupiter
org
address
anymore,
because
that
remaps
to
the
old
repose,
the
old
github
organization,
so
either
we
need
a
new
domain
for
Jupiter
lab
or
we
just
keep
using
the
github
dot,
IO
link,
which
is
fine
for
now
and
then
I
pulp.
We
did
publish
the
Jupiter
lab
extension
builder
as
a
namespace
package,
so
that
is
done.
D
We
still
got
some
work
in
progress
on
services
before
we're
able
to
release
that
under
the
new
mpm
organization,
as
just
one
outstanding
PR
that
we're
working
on
update
the
Taipings
for
the
typescript
2
point,
0,
semantics
and
other
than
that
in
Jupiter,
lab
itself,
I've
been
working
on
updating
interfaces
to
use
the
uniformly
use
phosphorus
iterable
and
adding
tests
where
we
didn't.
We
weren't
writing
them
before
because
now
we're
actually
testing
against
the
Jupiter
notebook
server.
So
we
have
a
live,
live
sessions
that
we
can
interact
with.
D
D
D
So
the
UI
collection,
for
example,
and
then
porting
that
same
method
over
to
Jupiter
lab
so
when
you'll
have
a
Jupiter
lab,
so
the
at
Jupiter
lab
/
notebook,
for
example,
will
be
a
separately
installable
entry
point
and
you
wouldn't
you
wouldn't
require
paths
within
that
that
would
be
the
atomic
package
level
of
of
import.
So
this
is
a
lot
of
work
to
be
done
to
get
there,
but
I
think
once
we're
at
that
point
between
having
getting
rid
of
this.
D
This
bringing
pieces
of
packages
with
you
to
4d
duping
and,
in
addition,
having
some
logic
on
the
server
and
or
the
client
side
to
detect,
where
there's
an
incompatibility
before
even
trying
to
load
it
and
then
finally,
as
a
stopgap,
allowing
a
package
to
fail
to
load
a
plug
in
the
fill
to
load
with
the
warning
and
the
console,
so
that,
if
you
have
one
package
that,
for
some
reason,
couldn't
be
rectified,
it
doesn't
bring
the
whole
application.
Now
you
can
still
sort
of
limp
along
lots
of
work
to
do
on
that
frame.
Right.
C
D
So
the
intent
was
to
copy
the
the
the
methods
used
by
the
angular
package
where
it
has
sub
packages
and
they
each
had
their
own
version
and,
and
it
uses
some
internal
scripts,
do
some
rectification
amongst
the
euro
version
versus
that
was
published
on
NPM.
So
trying
that
out
on
foster
first
I
think
makes
sense
before
we
do
that
in
in
juban,
lamb,
yeah
and
there's
going
to
be
probably
sums
as.
B
I
say,
ultimately,
it
doesn't
really
matter
the
number
of
packages
that
that
Foster
has,
because
the
one
solution
will
scale
to
n
number
of
packages.
The
thing
that
really
makes
this
possible
is
the
typescript
do
dodo
support
for
remapping
imports
at
compile
time,
which
is
what
we
were
missing
before,
and
so
we
can
basically
point
the
typescript
compiler
zaz
hey.
B
If
you
have
anything
that
looks
like
this,
here's
where
you
actually
find
the
sources
for
that,
even
though
they
might
be
in
a
separate
package
that
lives
alongside
somewhere
else
or
directory,
and
that's
completely
independent
of
how
web
packer
note
or
anything
is
going
to
actually
find
the
modules
at
at
quote.
Unquote.
Runtime.
D
D
C
C
I
think
I'm
next
worked
with
Ryan
a
lot
on
issued
triage
and
various
issues
worked
on
typing
issues.
Steve
I
was
going
to
hold
off
on
trying
to
get
make
sure
Jupiter
ji
services
is
working
well
with
Jupiter
Rob
and
I
pi,
which
it's
working
well
with
Jupiter
lab
and
I
pie,
widgets,
there's
a
lot
of
crust,
still
a
knife,
I
widgets
from
the
conversion
over
the
typescript.
We
just
did
a
basic
conversion
typescript,
but
there's
still
a
lot
of
crust
there
and
so
I
think
that's
a
bigger
project.
C
D
C
D
C
D
C
D
C
Okay
and
I
also
gave
a
talk
at
PI
data
DC
on
Jupiter,
lab
I
think
it
was
pretty
well
received.
A
lot
of
people
came
up
afterwards
and
said
it.
Super
lab
is
really
cool.
One
thing
that
I
didn't
expect
was
that
only
a
handful
out
of
probably
50
to
70
people,
there,
only
a
handful
had
heard
the
syfy
talk.
So
so,
while
a
lot
of
people
has
seen
the
syfy
talk,
I
think
there
still
is
a
lot
of
value
and
giving
introductions
to
Jupiter
lab
at
various
conferences
and
when
we
see
people.
C
D
C
E
Hi
so
last
week,
I
did
some
work
on
trying
to
make
the
inspector
just
a
little
more
resilient,
a
rock
solid
so
because
it
now
no
longer
resides
statically
right
hand
size
because.
E
D
E
I
could
have
just
not
existed
all
along,
so
I
wrote
a
manager
sweet
and
there
was
an
outstanding
bug
in
it
that
I
didn't
realize
until
this
week,
and
that
was
that
suppose
you
open
up
a
console
in
a
notebook
and
then
later
you
open
an
inspector
I
need
to
cash.
Basically,
the
last
source,
that's
available,
so
that
if
you
open
up
an
inspector
after
the
fact
that
still
works,
it's
stupidly,
I
had
only
been
testing
it
by
opening
an
inspector
and
then
opening
stuff
set
in
I
didn't
catch
that.
E
But
but
another
thing
that
was
wrong
and
it's
a
much
more
fundamental
thing,
which
is
what
I
wrote
in
a
hack
pad
is
across
the
board.
All
of
our
plugins
have
basically
been
instantiating.
Their
own
focused,
tracker
and
they've
been
using
that
as
their
own
little
pool
of
instances
of
of
whatever
plug-in
type
they
are
so
markdown
widgets
have
their
own
little
tracker
and
consoles
have
their
own
and
notebooks
have
their
own.
But
that's
actually
I,
think
I'm.
Misunderstanding
of
what
focus
tracking
is
for.
E
We
really
only
need
one
focus
tracker
for
the
entire
application
and
it's
already
part
of
the
main
application
stock
panel,
because
that
already
adds
Dom
listeners
for
focus
events
and
that
already
emits
a
bunch
of
signals
for
what
the
current
widget
is.
So
all
these
other
focus
trackers
were
adding
extra
Dom
listeners
that
were
superfluous
and
actually
we're
not
giving
you
the
information
you
needed,
because
when
the
main
application,
when
you
switch
from
a
console
to
a
notebook,
for
example,
the
console
focus
tracker
doesn't
get
a
change
event.
E
So
it
doesn't
know
that
it's
no
longer
current
and
the
notebook
one
doesn't
either,
but
rather
the
normal
one
does.
But,
but
there
are
cases
where
you
just
fall.
You
have
incorrect
states,
so
you
can't
tell
the
inspector
which
one
to
actually
be
connected
to,
because,
if
you
have
say
four
different
tab
panels
open
instead
of
one
main
panel,
your
doc
panels
for
tab
panels
and
all
four
of
them
are
full.
Two
of
them
are
notebooks
and
two
of
them
are
consoles
and
you
click
between
them.
E
Now,
if
you
click
from
a
console
back
to
the
notebook
back
to
a
notebook
that
was
not
the
last
currently
focused
notebook,
then
actually
the
wrong
thing
is
connected
to
the
inspector,
and
there
are
other
ways
where
you
could
actually
end
up
with
none
of
them
being
connected
to
the
inspector.
So
the
solution
is
we
just
merged
it
in
today,
there's
a
new
class
in
common,
it's
called
instance
tracker
and
what
an
instance
tracker
does.
Is
it
just
keeps
track
of
your
specific
plug-in
type
that
you
care
about?
So
there's
a
notebook
instance
tracker.
E
There's
a
console
instance
tracker,
there's
a
markdown,
which
instance
tracker
and
all
of
them
are
connected
now.
The
application
she'll
also
has
two
events
now
for
a
one
event
for
current
change,
and
it
also
has
a
current
widget
attribute.
So
all
of
them
now
connect
to
the
application.
She'll
focus
tracker
that
tells
them
hey.
The
current
widget
has
changed
and
they
have
a
sync
method
where
they
check
to
c
0
is
the
thing
that
it
changed
to
one
of
mine
do
I
care
about
this,
and
if
they
do
care
about
it,
they
can
do
something.
E
They
can
say.
Okay
hook
me
up
to
the
inspector,
and
if
they
don't
care
about
it,
they
don't
care
about.
It
doesn't
matter.
So
it's
like
a
one-liner
thing.
You
put
inside
your
plug-in
and
it
kind
of
just
takes
care
of
itself
and
for
notebook
in
particular,
that
instance,
tracker
has
been
a
subclass
so
that
it
can
emit
extra
signals
for
the
current
cell,
because
you
might
care
about
what
cell
it
is
and
because
it
has
handles
to
every
single
note
book
there
is.
E
It
can
basically
be
a
proxy
for
all
of
those
notebooks
and
whichever
one
of
those
has
a
cell
change
event,
it'll
it'll
send
that
to
whoever's
listening
and
that
way
you
don't
need
to
care
about
how
many
notebooks
there
are
whatever
the
tracker,
which
is
what
the
plug-in
provides.
You
is
going
to
inform
you
of
that.
So
it's
kind
of
a
it's
kind
of
a
big
change,
because
it
touched
all
the
plugins
that
we're
tracking,
but
the
upshot
is
that
it's
simpler
to
conceptualize
and
it
adds
fewer
Dom
listeners.
E
So
performance
is
slightly
going
to
be
improved,
at
least
at
least
the
there's
fewer
things
that
are
going
to
happen
on
folks
events
and
I.
Think
conceptually
it's
easier
to
explain
to
somebody
be
that
oh,
the
application
will
tell
you.
What
has
the
focus?
You
don't
need
to
worry
about
that.
You
just
need
to
worry
about
what
things
your
plug-in
cares
about.
The
pool
of
instances.
You're
plugging,
cares
about
and
do
whatever
you
want
when
that
changes,
so
yeah
I
mean
I,
encourage
you
to
take
a
look
at
it.
E
If
you
care
about
this
sort
of
thing,
I
will
link
to
the
in
the
heck
pad
I'll
link
to
the
actual
pull
request
that
had
this
in
it
there
you
go
and
yeah
I
mean
that
that's
the
run-through,
if
anything,
is
not
clear,
I'd
be
happy
to
answer
questions
about
it.
I.
F
So
there's
there's
two
sort
of
related
user
experience,
things
that
I
wanted
to
bring
up
and
sort
of
pull
the
room
for
ideas,
and
both
have
to
do
with
the
use
case
for
sharing
a
document
where
say
I'm
working
on
a
document
and
I
want
to
bring
Jason
on
board.
So
I
set
up
the
permissions
and
send
you
some
variety
of
link.
F
F
So
this
is
related
to
initially
that
Brian
opened
I
think
a
couple
days
ago,
which
and
has
been
sort
of
knocking
around
for
a
while,
which
is,
did
we
encode
some
sort
of
way,
perhaps
in
the
URL
of
specifying
some
sort
of
state
saying
I
want
to
open
this
type
of
document
or
I
want
to
there
any
of
a
number
of
things,
but
it
could
be
something
like
the
layout
or
what
type
of
document
you
want
to
open.
Ryan.
F
A
F
C
A
C
A
C
F
A
Think
the
URLs
of
Jupiter
hub
are
going
to
be
used
for
other
purposes
such
as
stations,
and
so
but
my
I
guess
the
way
that
I
had
thought
about
this
was
that
you
send
someone
the
code
or
something
that
they
put
into
the
real-time
collaboration
UI,
and
that
code
is
not
for
a
document
it's
actually
for
session
and
that
session
itself
is
a
real-time
object.
That
has
a
list
of
all
the
documents
that
have
been
shared
in
that
session
that
that's
so
like
you
can
imagine
you
know.
Here's
no
and
here's
the
real
time
session.
A
It's
ABC
123,
you
copy
it
from
me.
Tell
you
paste
it
into
your
Jupiter,
lab,
real-time
color
and
then
instantly.
You
see
all
the
documents
that
have
been
shared
in
that
session
and
so
the
bat
itself.
Maybe
you
know
some
opaque
ID
within
the
Google,
real-time
API,
that
has
a
base
set
of
objects
that
know
about
the
documents
that
we've
added
to
that
mm-hmm.
I.
Think,
of
course,.
C
For
collaborating
I
think
one
thing
would
be:
we
insist
that
work.
If
the
collaboration
involves
a
colonel,
then
I
think
we
should
insist
on
collaborating
on
a
single
server
that
we
shouldn't
try
to
handle
the
use
case
of
two
separate
notebook
servers,
because
then
you
have
to
separate
kernels
to
separate
contacts.
A
That
that's
a
pretty
important
usage
case
be
different
yeah,
and
the
semantics
in
that
case
would
be
that
only
one
user
and
run
code,
the
other
user,
could
clone
that
notebook
on
to
their
local
system.
So.
A
B
F
A
A
C
If
you're
going
to
collaborate
on
two
different
notebook
servers
than
you,
the
dinner
I
mean
there
needs
to
be
some
shared,
something
and
so
you're
sharing
the
real
time.
Collaboration
service,
like
it's,
a
google
api
through
a
google
account
or
some
other
service
that
you're
set
up
that
provides
real-time
collaboration,
attention
others,
but
at
the
moment,
google,
in
real
time,
and
only
one
person
is
able
to
execute
because
they're,
the
only
one
that
have
access
to
a
kernel
right
and
the
others.
Can
others
see
the
document
feed
and
essentially
have
it
as
a
viewer.
C
F
F
C
A
C
That
it
has
a
share
as
a
menu
option
or
drop
down,
or
something
like
that.
That
gives
you
some
identifiers
to
the
third
party
service
and
then
there's
an
open
and
the
corresponding
other
person
sing,
and
it
opens
whatever
I
mean
Adam.
Why
depends
on
the
third
party
service?
You
just
need
to
give
it
some
identifiers,
flustered
service,
and
then
there's
I
mean
each
of
them
have
a
plug-in
for
the
third
party
service
that
know
how
to
get
and
fetch
information
from
the
third
party
source
and
then
and
then.
F
A
C
C
A
C
C
A
Quite
in
the
sense
that
google
drive
allows
sharing
the
folders
with
the
same
permissions
and
be
what
part
of
the
challenge
here
is
that
were
explicitly
not
using
google
drive
to
store
these
files,
and
so
we
have
to
have
our
own
abstraction
for
representing
groups
of
files
and
that
that's
what
sort
of
what
I
mean
by
a
session,
and
it's
a
completely
transient
thing.
These
these
documents
would
not
actually
be
stored
persistently
on
Google
Drive,
like
they're.
Just
on
your
file
system,.
C
A
There's
going
to
have
to
be
some
sort
of
you
I
associated
with
this
plug-in
that
manages
permissions
that
manages
documents
that
manages
all
all
that
I
mean
that
that's
I
mean
you
know.
Hot
you'll
have
to
be
able
to
control
who
has
access?
Is
it
read
or
write
permissions?
What
documents
are
scoped
by
that
access
like
I,
think?
That's
it.
C
Sounds
like
the
primary
thing
that
you're
trying
to
get
over
just
single,
so
single
files,
I
think,
is
by
far
the
easiest
and
most
understandable
way
to
have
this
sharing.
But
it
sounds
like
you're
trying
to
address
use
cases
where
you're
actually
sharing
multiple
files
and
money
easily
share
multiple
files
without
sending
three
different
links
that
they
open.
C
That
or
it
might
be
easy
I
mean
instead
of
adding
files
to
a
shared
real
time
thing.
It
might
be
that
we
make
the
URI
that
you
send
can
have
multiple
files,
so
it
could
be
Google,
Drive,
colon,
slash,
slash
a
file
?
and
then
a
comma
delimited
list
of
files
that
you
want.
The
final
IDs
that
you're
sharing,
so
you
don't
have
to
embody
this
concept
of
a
session
in
order
to
share
multiple
documents.
C
C
F
C
Me
to
me
the
simplest
cases
is
sharing
a
single
file
and
that's
what
we
should
tackle
first
and
trying
to
introduce
you
I
or
concepts
of
groups
of
files
that
need
a
you
I
to
understand
that
these
files
are
grouped
together
or
to
share
a
folder
of
these
files
or
something
I.
Think
there's
a
lot
of
you.
I
questions
person
I
think
we
should
tackle
just
share
a
single
file
first
and
but
you
think,
is
kept
here.
Multiple
right.
F
A
I
think
yeah
I
agree
with
Jason
that,
starting
with
a
single
file
in
tackling
the
UI,
for
that,
you
will
have
to
do
that,
no
matter
what
yeah
and
I
sell
for
that
having
a
left
panel
that
allows
people
to
commence
sharing
on
a
document
and
get
the
ID
for
it
and
then
another.
It
would
be
that
you
can
paste
in
ids
there
for
documents
that
have
been
shared
with
you.
B
A
A
A
Where
is
it
so
like
it?
What
if
you
if
in
dropbox
a
directory,
is
a
sharepoint
and
everything
below
it
is
within
that
sharepoint
and
there's
no
other
share
points
in
that
can
be
correlated
with
that
or
its
children
in
goop.
You
can
share
our
betray
mixtures
of
directories.
Sub
directories,
files
with
different
groups
of
people
in
different
ways,
and
it's
something
that,
like
we
use,
both
dropbox
and
google
drive
ourselves
for
different
purposes,
and
we
we
find
ourselves
not
able
to
use
dropbox
because
of
its
limited
sharing.
C
Also
anything
else
in
that
was
the
main
thing:
okay
will
do
in
granite,
Brian
and
I
were
looking
at.
Is
there
anything
else
from
anybody
else?
Yeah.
A
I,
actually
so,
Jason
and
I
talked
in
the
elevator
about
this
briefly
and
all
open
an
issue
but
wanted
to
at
least
bring
it
up,
and
that
is
we
have
this
I
rendered
her
pattern
that
that
came
from
phosphor
and
in
phosphor
an
I
render
or
something
that
is
responsible
for
returning
Dom
nodes
to
render
certain
parts
of
a
associated
wit.
What.
A
B
General
than
that,
that's
where
it's
used
a
lot,
but
in
general
the
renderer
is:
if
there's
something
that
a
widget
wants
to
allow
external
users
to
customize
based
on
what
is
rendered,
then
then
it
provided
then
do
you
provide
it
as
an
I
renderer.
So,
for
example,
the
doc
panel
that
I'm
working
on
now
also
has
a
renderer,
but
that
thing
produces
tap
Lars.
B
A
Okay,
and
so
it's
not
well
I-
think
what's
a
little
difficult
when
that
language
gets
over,
the
Jupiter
lab
is
that
renderer
has
we
use,
render
or
something
completely
unrelated
to
that,
but
that's
just
use
it
for
rendering
mine
bundles
to
output
in
notebooks
and
consoles
by
the
I.
Think
the
bigger
question
is
in
at
least
a
Jupiter
Dobb.
A
It
just
feels
like
too
much
complexity
for
a
flexibility
that
we're
not
using
in
any
way
and
I,
don't
foresee
us
needing
to
use,
and
a
great
example
is
the
the
editor
abstraction
so
where
there's
a
PR
open
to
generalize
code
mirror
to
an
editor,
and
this
is
exactly,
I
think,
what
we
had
in
mind.
The
issue,
though,
is
for
this
to
be
useful
across
all
other
plugins.
A
This
is
becoming
a
plugin
that
provides
some
sort
of
I
added
or
instances,
and,
and
so,
but
the
pattern
ends
up
being
way
different
than
the
I
renderer
pattern
and
so
I.
My
proposal
is
that
at
least
in
Jupiter
lab
and
in
particular,
deep
inside
the
notebook
everywhere
that
we
we
just
stop
doing
that
and
make
make
the
message
that
render
that
view
methods
of
the
widget
that
is
responsible.
For
that
view,.
B
I'm
not
close
enough
to
the
classes
that
you're
talking
about
to
give
a
confident
opinion,
but
another
another
facet
of
this
is
that
by
separating
out
the
rendering
from
the
widget
itself,
you're
drawing
a
separation
between
the
behavior
of
the
widget
and
the
visual
display
of
the
widget
and
so
conceptually
for
somebody
reading
the
code,
it
might
be
easier
to
reason
about
what's
actually
happening
because
you're
not
you're
not
having
to
visually.
Admittedly,
Parsa
like
okay.
This
is
completely
independent.
B
A
E
One
of
the
things
that
we
have
tried
to
do
is
to
make
the
renderers
we
used
to
just
have
them
return,
HTML
element,
but
now
we
specifically
say
look
return
an
li
element.
We
need
that.
That
way,
you
can
do
whatever
you
want
inside
it.
But
if
you
return
in
li,
that's
what
the
actual
code
structure
is
going
to
need
for
the
rest
to
work.
So
if
we
make
the
return
type
of
the
different
renderers
be
be
basically
such
that
the
logic
of
the
widget
can't
fail.
E
B
Yeah-
and
that
becomes
more
of
a
problem
too,
when
your
renders
start
returning
virtual
Dom
nodes
like
we're
doing
right
now
in
the
tab
bar
tab,
like
your
tab,
should
be
Li
elements,
but
there's
nothing
in
the
virtual
Dom
system
that
encodes
the
type
of
the
virtual
Dom
node
that
you're
returning
so
right.
Now
the
tab
bar
just
assuming
yeah
you're,
going
to
give
me
Li
elements.
I
could
make
those
board
type
safe,
but
that's
a
lot
of
work
and
I.
Don't
know
whether
that
were
the
weather,
we
would
get
benefit
from
doing
that
and.
A
There's
another
place
that
the
abstraction
leaks
and
that's
in
the
application
and
usage
of
CSS
classes
that,
like
if
you're
returning,
Dom
node.
It's
pretty
likely
that
you're
going
to
have
to
have
labeled
those
with
all
the
needed.
Css
classes,
and
that
has
in
some
ways
is
likely
to
leak
across
to
the
widget
itself.
And.
B
Well,
if
you
look
at,
if
you
look
at
what
I
do
in
in
tab
bar
there's
actually
a
good
solution
for
this,
so
in
town
bar
when
it
tells
you
to
render
the
node
for
a
particular
tab
like
it
gives
you
all
the
information
about
that
tab,
that
you
need
to
set
your
CSS
classes,
and
so
you
can
send
those
CSS
classes
to
whatever
you
want
now
by
default.
It
you
know
by
default.
A
C
Are
you
caring
to
take
on
looking
at
this,
or
are
you
just
okay
I'm
willing
to
do
that?
Great?
Please,
open
an
issue
of
course,
and
so,
as
as
one
last
item
of
business,
we
wanted
to
try
to
start
tackling
some
of
these
needs
discussion,
issues
they're
starting
to
pile
up,
and
these
meetings
are
a
good
place
to
either
want
to
decide
or
board.
C
They
need
more
discussion
and
carried
out
with
the
kick
start.
The
discussion
there's
only
one
issue
that
it's
number
447.
That
is
an
milestone.
Oh
point:
nine
needs
discussion,
issues
an
issue
I'll
place.
The
link
in
the
chat
here
447
deals
with
a
command
pilot
interaction.
I
think
I
can
even
share
my
screen.