►
From YouTube: Editor Group - VSCode Spike Demo & Discussion
Description
In this meeting we discuss the results of a research spike involved with replacing the Web IDE with a VSCode web build and custom VSCode extension.
POC MR: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/79096
A
A
So
I
have
some
diagrams
and
stuff
to
talk
about
there
and
then
I
was
going
to
demo
it
and
then
we
can
get
into
all
the
pros
cons,
what-ifs
discussion,
which
I've
added
some
initial
thoughts
here
at
the
end,
probably
is
good
for
us
to
use
the
agenda
like
if
we're
gonna,
maybe
add
things
so
I'm
just
gonna
go
forward.
I'm
fine!
A
There
is
the
get
lab
vs
code
package
which
we're
going
to
dive
into
what
that
is
in
a
little
bit
and
then
there's
just
the
mr
for
hooking
it
into
where
the
web
id
is
currently
loading.
We
load
this
package
and
then
this
is
a
very
helpful
reference
to
the
official
vs
code
extension
api,
all
the
things
that
are
possible
from
there.
A
You
see
interesting
name,
spaces
like
terminal
and
custom
web
views,
so
there's
there's
a
whole
lot
of
possibilities
that
hasn't
been
touched
in
this
effort,
but
are
quite
possible
looking
at
what
other
extensions
can
do
yeah.
So
I
want
to
dive
into
the
architecture
and
then
we're
going
to
go
to
the
demo.
A
So
the
main
thing
that
we're
adding
in
this
effort
is
a
package
which
I'm
just
calling
gitlab
vs
code
and
there's
two
things
going
on
with
this
package:
there's
modules
that
you
import
for
it
to
bootstrap
everything
onto
an
element,
but
then
there's
assets.
It
needs
to
host.
So
it
hosts
a
web
build
of
vs
code
and
we
just
get
this
from
the
web-
it's
completely
untouched,
but
then
it
also
needs
to
host
a
place
for
our
custom
extension
to
live.
A
So
we
have
other
node
modules
that
we
actually
host
assets
from.
So
we
kind
of
just
copied
what
we
were
doing
from
source
graph
over
to
this
similar
package,
where
we
have
a
module
that
we
can
import
that
gets
bundled
into
our
gitlab.
Frontend
is
very,
very
small,
but
most
of
it
just
creates
an
iframe
which
then
loads
these
self-hosted
files.
A
But
there
is
the
runtime
environment
that
we're
in
when
we
start
up
the
page
and
we
have
access
to
all
the
dom
features
and
all
of
our
gitlab
contacts
and
that's
what
this
index.js
gets:
access
to,
the
main
runtime
environment,
extensions,
get
access
to
very
specific
extension,
runtime
environment,
and
so
the
main
contacts
initializes
just
the
main
vs
code
modules
and
there's
some
customization.
We
can
actually
do
there
like
turning
off
features
by
just
replacing
what
modules
that
get
dependency
injected,
because
they
use
a
special
loader
that
lets
us
do
that.
A
A
So
here
this
is
like
the
main
entry
point
method
to
this
package.
Where
we
create
this
iframe
and
from
the
iframe,
we
actually
can
inject
we're
actually
going
to
inject
the
configure
information
we
were
started
with,
which
contains
like
what
project
we're
loading,
what
ref
we're
loading
and
things
like
that
when
I
said
we
can
actually
do
a
level
of
customization
here,
vs
code
uses
amd
to
load
their
modules,
which
means
that
we
can
kind
of
actually
redefine
modules.
A
They
have
a
very
they
have
great
architecture
which
anything
that's
going
to
be
contributing
to.
The
main
engine
are
in
these
contribution
modules,
so
I've
done
something
where
I'm
actually
just
completely
disabling
this
kind
of
feature
by
looping
through
these
modules
and
just
saying
that
these
are
no
op
modules,
they're
not
going
to
actually
do
anything,
so
this
actually
changes
the
behavior
of
it
rather
than
starting
up.
All
of
this
welcome
to
vs
code
content,
which
isn't
really
appropriate
for
gitlab.
We
can
kind
of
just
turn
that
off
this
isn't.
A
This
is
a
last
resort.
If
there's
certain
behaviors,
we
want
to
customize,
because
all
of
this
is
really
tying
into
implementation.
Details
of
the
vs
code
package,
not
necessarily
their
official
extension
api,
but
it
is
still
very
possible
to
make
some
customizations
like
this.
I
wanted
to
show
that,
and
I
wanted
to
show
what
the
extension
runtime
looks.
Like
extension,
runtime
looks
like
a
module
that
exports
this
activate
function
and
you
have
access
to
this
glorious
vs
code
object
where
you
can
execute
commands
and
do
stuff
like
that.
A
A
Yeah,
so
this
is
just
diving
into
what
the
extension
api
looks
like.
So,
if
you're
going
to
mess
with
the
very
first
thing
that
happens
with
an
extension,
is
vas
code,
runtime
will
actually
read
the
package
json
for
what
is
this
extension
contributing
to
the
whole
workbench,
and
that
includes
things
like
commands,
special
views
and
all
of
it
is
actually
is
just
declared
in
this
json
and
you
may
actually
fill
in
the
details
in
the
activation
method
of
your
extension.
A
A
Yeah,
so
here's
the
really
here
is
one
of
the
biggest
challenges
I
ran
into
this
and
was
super
stoked
to
find
the
fix
for
it,
which
is
actually
really
simple.
I
was
really
concerned,
there's
going
to
be
a
very
complicated
fix,
but
it's
actually
a
sample,
so
the
extensions
are
in
a
severe
sandbox
like
they
run
in
a
web
worker
with
global
functions.
A
Rewritten
extensions
have
a
really
hard
time
reaching
outside
themselves,
which
is
a
good
thing,
but
in
our
situation
we
want
to
register
a
file
system
provider
with
the
actual
files
of
whatever
project
they've
loaded,
so
that
that
information
is
coming
from
the
get
lab
front
end.
How
do
we
get
that
information
into
the
extension,
runtime
environment
and
most
extensions?
Don't
do
this
where
they're
trying
to
read
from
outside
their
environment,
most
extensions
need
their
own
setup
like
our
gitlab,
our
official
vs
code
extension.
Does
this
we're
like
the
official
gitlab
extension
for
vs
code?
A
A
We're
able
to
do
that
from
when
we
bootstrap
vs
code
and
then
the
extension
is
able
to
use
those
commands
when
it
executes
the
command.
It's
sending
that
to
the
main
vs
code
runtime,
because
code
goes
back
to
our
main
context,
we're
make
from
our
main
context.
We
can
actually
reach
out
to
the
backend
and
all
of
that
information
gets
passed
back
down
to
the
extension.
A
A
Yep
thanks
for
thanks
for
asking
that
question,
so
I've
tried
to
highlight
in
here
blue
are
things
that
we
actually
are.
Developing
white
is
something
so
in
this
case.
This
is
just
the
vs
code
built
of
that
we're
packaging,
but
we're
not
necessarily
touching
so
the
pack,
the
actual
npm
package,
looks
like
this.
A
It
looks
like
this
where
we
have
the
package.json.
Our
main
is
the
start
module,
but
then
these
are
the
hosted
files
which
contain
the
vs
code,
build
that
we
don't
need
that
we
don't
need
to
touch
but
contains
the
extension
which
we
do
end
up.
We
we
do
create
and
then
just
the
main
method
for
the
iframe
to
load
and
stuff.
Does
that
answer
your
question.
A
Okay,
cool
yeah,
so
last
last
little
thing
I
want
to
show
is
like
I'm
going
to
demo,
and
this
is
just
what
I've
done
with
this
demo
is-
is
mostly
take
the
file
system
and
get
implementations
that
was
done
for
the
web
id
poc
and
glue
that
into
the
vs
code
api.
So,
what's
really
exciting
about
the
extension
architecture,
is
we
have
a
whole
like
in-memory
file
system?
A
A
D
D
A
D
A
Just
like
the
state
redesign
is,
and
so
the
the
source
control
and
like
the
what
git
does
as
an
algorithm.
It's
not
a
lot,
it's
just
really
elegant,
and
so
this
is
just
an
implementation
of
how
git
manages
source
control
and
rather
than
keeping
track
of
it.
It
calculates
it
based
on
get
object,
hashes
and
this
merkle
tree
and
stuff
and.
A
D
D
A
A
great
idea,
and
that's
a
great
that's,
a
great
question
we
totally
could
and
because,
at
the
end
of
the
day
it
is
just
what's
called
just
get
objects.
It
is
just
these
hashes
that
have
their
own
kind
of
content.
The
types
look
like
this:
where
objects
is
either
a
tree
or
a
blob,
and
the
data
is
if
it's
a
tree,
it
has
children.
A
Okay,
so
here
I
am
in
gitlab,
I
got
gitlab
running.
Let's
hope
this
doesn't
break
I'm
just
going
to
open
up
the
web
id,
which
we
all
know
and
love,
and
this
thing
is
loading
and
oh,
my
gosh,
it's
so
different.
Now,
so
I
loaded
the
main
gitlab
project
really
fast
compared
to
with
the
web
id
with
the
current
web
id.
A
I'm
gonna,
do
it
again
in
case
you
missed
it,
this
loads
really
fast
all
of
the
file
and
I'm
ready
to
go,
and
I
can
search
through
everything
and
make
whatever
changes
I
want
to.
We
could
dive
into
later
on.
We
could
talk
about
the
performance,
one
of
the
things
that
makes
this
a
lot
faster,
even
though
there's
a
lot
more
going
on
is
that
it's
not
using
view
view.
Reactivity
is
actually
a
really
huge
burden
on
the
current
web
ide,
so
we're
able
to
load
the
entire
file
tree,
create
this
structure.
A
A
A
That's
kind
of
lame
for
from
bs
code,
but
it's
kind
of
nice
that
there's
community
efforts
to
make
the
subsidiary
systems
more
open
source
friendly,
so
we're
able
to
override
what
extension
gallery
we
use,
and
so,
rather
than
pulling
from
the
main
vs
code
marketplace,
this
pulls
from
openvsx,
which
I
guess
is
like
a
somehow
like
a
clone
of
it.
That's
what
getpod
uses,
but
let's
install
them
because
that's
why
we're
all
here
and
now
them
is
installed
so
now,
yeah
we're
ready.
Okay,
I'm
just
gonna
make
some
changes,
okay,
cool!
A
A
I
can
also
you
know,
make
split
tabs
all
of
this
lovable
editing
experience
that
we
take
for
granted
and
our
local
environments
is
just
out
of
the
box
with
using
vs
code,
I'm
going
to
go
ahead
and
undo
the
changes
and
let's
double
check
that
the
source
control
does
its
thing
and
it
did
its
thing.
So
now
there's
no
changes.
A
A
We
have
some
ideas
for
how
we
could
make
users
that
aren't
familiar
with
this
ui
have
a
more
of
a
call
to
action.
There's
actually
a
proposed
api
to
just
create
a
call
to
action
button
button
here
that
we
could
probably
take
advantage
of
we're
already
using
one
of
the
proposed
apis,
which
is
working
nicely.
A
I
don't
have
the
commit
implemented,
but
probably
where
how
we
would
implement
like
picking
a
branch
and
whether
we
want
to
open
mr
is
through
vs
code
has
like
a
quick.
They
call
it
quick
pick,
I
haven't
implemented
it,
but
it
basically
lets
you
create
yeah.
You
can
like
open
a
dialogue
and
you
can
create
like
a
little
form
that
the
user
has
to
go
through
to
finish
some
sort
of
command.
So
we
could
do
something
similar.
A
A
Yeah,
so
I
haven't
implemented
that,
but
there's
nothing
that
would
stop
it
from
working,
because
this
data
of
the
diff
data
is
all
there
and
the
get
there's
still
some
to
do's
to
wrap
up
here.
But
I
was
mainly
wanting
to
see.
Are
there
any
blockers?
That's
gonna
prevent
this
from
working,
and
the
answer
is
no
there's
still
some
things
we
need
to
do,
but
yeah
committing
would
work
totally.
Fine.
A
The
the
user
flow
would
look
different
than
how
it
currently
does,
because
there
is
not
right
now,
a
very
clear
call
to
action
button.
I
think
there's
a
way
we
could
add
it.
That's
something
that
we
can
investigate,
I'm
pretty
sure
because
there's,
I
think,
I've
even
included
a
link
to
it.
There's
a
proposed
api
for
that,
but
then
also
like
picking
the
branch
and
seeing
if
you
want
to
do
an
mr
those
those
will
have
to
be
like
native
vs
code
dialogues.
A
E
A
Are
there
any
so?
This
is
a
really
good
question.
So
out
of
the
box,
this
works
just
with
the
files
you've
opened.
You
can
register
a
file
content
search
provider,
but
that
would
require
more
of
an
infrastructure
than
we
have
so.
If
I
now,
let
me
see
if
I
can
front
end
yeah
so
now,
when
I
search
for
front
end,
I'm
going
to
get
things
for
only
the
files
I've
opened.
E
A
Yeah,
that's
a
really
great
question.
So
right
now
it's
just
blank
and
I
think
you
can
create
like
a
welcome
view
for
this
saying,
like
this
doesn't
work.
This
is
also
something
we
can
look
into
to
see.
Are
we
able
to
like
from
the
dependency
injection
side
like
just
totally
turn
this
kind
of
thing
off
some
of
the
things
that
you
would
think
you
could
do
that
for
you
can't?
A
C
C
A
Hype,
this
yeah,
I
really
wanted
to
figure
out
how
to
hide
this.
I
was
able
to
for
some
other
ones
and
for
some
of
these
was
a
little
bit
more
hidden
than
I
could
figure
out
how
to
but
there's
the
capabilities
there,
because
I
can.
I
can
functionally
do
this.
So
it's
a
matter
of
kind
of
figuring
out.
How
is
vs
code
doing
this
internally?
Do
they
expose
something
publicly?
We
could
do
that,
there's
a
little
bit
of
spelunking
in
their
code.
That's
a
it
is
a
good
question.
A
C
So
how
likely
he
said
that
if
we
actually
need
this
sort
of
customization,
we're
gonna
have
to
fork
vs
code.
This
is
something
that
that
that
we
talked
about
last
week
as
well,
but
it's
like
now
that
you
have
like
more
experience
trying
to
to
customize
the
workbench
in
this
way.
Have
your
opinion
change
about
having
to
fork
vs
code.
A
I
think
that
we
can
use.
I
think
that
we
can
use.
We
can
use
their
dependency
injection
through
their
modules
to
change
their
contributions.
I
think
that
will
be
pretty
good.
There's
some
projects.
I've
seen
that
straight
up,
don't
necessarily
fork
it,
but
are
basically
like
a
patch
file
for
how
we
patch
vs
code
to
do
things
we
wanted
to
do
I
mean
that
would
be
ultimate
last
resort.
I
don't
see
it
being
necessary
when
I
look
at
things
in
the
wild
like
gitpod
and
vsco.dev.
A
F
A
A
A
The
fact
that
I
can
install
them
extension
this
means
I'm
really
happy
as
a
user
from
a
maintainability
perspective
like
this,
isn't
a
lot
of
code
just
to
get
this
our
part
running
so
there's
a
whole
lot,
we're
doing
the
web
ide
to
kind
of
recreate
the
wheel
which
vs
code
already
has
so
like
this
current
package.
It
doesn't
have
any
tests,
but
it's
like
3
000,
ish
lines
of
code
where
our
web
id
directory
is
like
16
000
lines
of
code
and
it's
possible.
A
We
can
actually
do
more
with
with
the
vs
code
package
than
we
could
with
the
current
web
id
because
of
how
tightly
coupled
things
are
in
the
web
id,
and
that
goes
into
also
just
a
lot
of
the
api
is
just
they're,
really
great
abstractions
for
how
we
can
extend
parts
of
the
view
and
in
a
reliable
way,
very
huge
features
super
excited
about.
If
we
do
this,
we
can
even
look
at
beefing
up
the
gitlab
workflow,
the
official
vs
code
extension
to
run
natively
alongside
this
to
completely
change.
A
What
does
it
mean
to
open
up
the
web
iv
in
an
mr?
So
we
can
actually
add
comments
from
within
that
editing
experience.
It
could
be
really
exciting
and
so
tomas
who
have
paired
with
me,
enriquez
paired
with
me
on
this
a
bit,
but
tomas
who's
contributed
a
lot
to
this
poc
already.
He
already
created
a
web
build
of
this
extension,
but
it
still
has
to
go
through
the
workflow
of
like
registering
a
token
and
things
like
that.
A
So
there's
work
to
be
done
if
we
wanted
to
make
that
be
able
to
live
alongside
this
native
experience,
but
it's
very
doable
there's
a
huge
performance
when,
as
we've
seen
just
with
me,
editing
this
that
this
is
a
lot
faster
than
the
web
id
some
cons
is.
The
ui
is
very
restricted
to
what
they
let
us
do.
A
Those
are
those
are
concerns
and
then
also
from
a
usability
perspective
like
the
web
id
and
having
less
features
means
that
you
know
users
don't
necessarily
run
into
you
shooting
themselves
in
the
foot
by
configuring
and
extending
things
in
a
bad
way.
So
the
fact
that
things
are
so
customizable
in
this
environment
from
the
user
perspective,
it's
it's
possible
that
for
for
users,
looking
for
just
a
simple
interface
that
that
could
be
lost
and
we
could
try
to
see
what
things
we
can
do
to
improve
that.
A
F
I'm
gonna
voice
over
michael.
I
captured
a
couple
of
the
comments
on
marcel's
enrique's
questions
in
the
agenda,
but
if
you
want
to
go
back
through
and
fill
out,
any
more
detail
feel
free.
We
have
the
recording
too,
so
you
don't
have
to
michael,
had
a
comment
I
believe
in
the
issue
about
customizing
the
ui.
This
is.
C
F
Hot
topic
and
like
four
of
my
other
questions,
are
gonna
be
related
to
this.
But
to
what
extent
is
it
possible
to
get
the
get
lab
look
and
feel
and
marcel?
You
can
talk
to
this
a
little
more
in
the
question
here,
but
how
themeable
can
we
have
a
default
theme
for
git
lab?
Can
we
change
the
icons
to
get
labs,
ui
icons,
things
like
that
would
go
a
long
way
to
making
people
feel
comfortable
while
we
maintain
the
workflow
of
vs
code
and
the
get
the
power
of
vs
code.
E
Yeah,
definitely
it's
a
great
topic
and
I'm
not
I'm
still
not
100
sure
how
much
users
will
expect
more
of
a
gitlab
experience
and
more
of
a
vs
code
experience.
I'm
really
really
unsure
about
these
things.
I
I
think
it
could
go
either
way
and
it's
a
very
interesting
piece
to
tackle.
So
my
my
question
is
more
like
how
much
flexibility
do
we
have
and
because
you
put
customizability
at
the
con,
I
want
to
also
have
a
question:
do
you
mean
customizability
from
the
user
side?
E
A
A
E
A
A
F
A
E
F
B
No,
I
was
just
like
one
of
the
points
I'd
heard
is
like
the
concern
about
users,
overly
customizing
it
and
like
especially
for
ideas.
That's
not
a
concern
at
all,
and
the
the
length
that
I
put
is
like
dhh
stance
on
rails
from
2012,
which
seems
to
have
worked
out,
which
is
like
here's.
What
you
get
out
of
the
box,
we're
very
opinionated
about
that.
You
can
do
other
stuff.
F
F
We're
going
to
end
up
having
to
duplicate
that
effort,
and
we
may,
we
may
never
be
able
to
achieve
parity
or
consistency
in
a
way
that
feels
like
it's
all
gay
lab
right.
So
I'm
that's
one
of
my
big
concerns.
I
don't
know
if
there's
an
answer
to
that
other
than
what
you've
already
talked
about,
but
maybe
I.
A
There's
nothing
that
prevent
us
from
patching
packaging
that
separately,
reusing
that
in
snippets
or
something
like
that,
and
I
think
the
content
editor
would
be
very
similar
and
because
vs
code
has
to
be
so
flexible
and
so
they
they
they
quote,
use
cases
like
one.
You
know
having
a
3d
model
editor
and
things
like
that
like
because
it
has
to
be
so
flexible.
You
know
we'd
be
able
to
just
completely
reuse
the
content
editor,
but
it
does
bring
up
questions
from
like
a
packaging
perspective.
Right
now
we
have
everything
living
in
the
gitlab
project.
A
If
I
need
to
reuse
something
in
this,
get
lab
vs
code
package
like
that's,
going
to
have
to
kind
of
be
in
its
own
package
and,
like
so
from
a
packaging
perspective,
it
brings
up
those
challenges,
but
there's
nothing
that
stops
us
from
from
having
our
core
functionality.
Shared
and
vs
code
is
just
glue
code.
F
I
think
you
know,
as
we
move
forward
on
this,
I
should
preface
it
I'll
go
back
and
and
talk
high
level,
but
as
we
move
forward,
I
think
that'll
be
one
of
the
other.
The
next
steps
for
like
architecture
and
proof
of
concepts,
maybe
giving
some
very
specific
examples
of
things
we
want
to
accomplish
over
the
next
couple
years
with
the
web
editor.
F
F
A
couple
months
ago,
when
we
started
talking
about
when
marcel,
had
an
issue
that
was
like,
we
should
maybe
think
about
getpod's
new
openvs
code
server
project.
I
was
a
little,
maybe
overly
skeptical,
not
because
I
think
it's
a
bad
idea,
but
I'm
nervous
about
the
implications
and
I'm
especially
nervous
about
that
project
in
the
infrastructure,
our
ability
to
support
the
infrastructure.
F
What
you've
done
here
is
shown
that
it's
possible
to
do
that
without
messing
up
our
infrastructure,
so
I
think
that's,
first
of
all,
very
impressive
and
I'm
very
appreciative
of
your
your
diligence
there
and
your
recommendation
to
even
look
into
this.
So
I'm
putting
a
bunch
of
things
that
sound
skeptical,
I'm
actually
very
very
encouraged
by
this.
So
I
don't
want
you
to
think
I'm
I'm
raking
you
over
the
coals
for
it
or,
if
I'm
falling
on
one
side
of
the
fence
or
not
that
that
being
prefaced,
consistency
is
a
big
concern.
F
We've
talked
about
that.
The
loading
which
I
think
dennis
has
a
similar
question
here.
So
loading
was
fast.
That
alone
almost
sold
me
on
the
whole
thing,
and
I
want
to
just
have
it
now:
I'd
love
to
see
it
quantified
on
larger.
Mrs
because
I
know
that's
a
big
challenge
we
have
with
the
web
ide
today
and
with
loading
mrs
to
begin
with,
so
something
that
I
can
point
to
and
say
like
web
id
opens
this
large,
mr
in
7.8
seconds
and
vs
code
opens
it
in
1.3
or
something
like
that.
A
A
The,
but
then
view
is,
is
not
view.
Reactivity
does
not
work
well
for
large
amounts
of
data
and
the
way
that
our
current
state
works.
The
way
that
this
state
works
is
every
single
file
object.
Whether
it's
a
tree
or
file
gets
is
an
object
and
our
current
web
id
it's
a
humongous
object.
So
we
take
up
like
a
gig
of
memory
when
we
open
up
the
gitlab
project
in
the
web
id
because
vue
has
to
create
so
many
frequent
functions
about
it.
A
F
Appreciate
that
last
bit
before
I
let
dennis
run
through,
I
just
wanted
to
ask
about
extensions,
because
that's
the
other
part
that
makes
me
nervous,
not
just
overextending
the
experience
and
making
it
feel
disjointed,
but
literally
managing
extensions
and
having
an
extension
manager
in
there.
It's,
I
think,
there's
even
a
product
principle
somewhere
that,
like
we,
don't
want
plugins
and
stuff
like
that
in
our
product.
So
we
would
need
to
be
really
intentional
about
that
experience.
Can
we
even
do
anything
about
that
experience?
F
A
I
think
so,
if
I
can
replace
the
extent
yes,
I'm
sure
we
can,
if
I
can
replace
the
extension
gallery,
I'm
sure
we
can
also
just
empty
out
the
extension
gallery.
I
would
be
really
surprised
if
he
couldn't
yeah.
That's
a
really
good
question.
It's
a
good
point
and
maybe
that's
you
know
one
of
the
safest
things
we
can
do.
F
I'm
not
saying
we
should,
or
it's
just
nice
to
know
that
we
can.
All
this
is
going
to
require
some
validation.
I'll
just
cut
to
my
next
step
is
going
to
be
probably
taking
this
with
michael
and
getting
some
user
feedback
user
validation.
I
expect
a
lot
of
these
similar
things
to
come
up,
but
we
got
12
minutes
give
or
take
I'll.
Let
dennis
run
through
his
questions
too.
B
I
mean
that's
a
really
good
point:
do
do
we
want
people
to
be
able
to
customize
it
or
not,
and
I
I
think
that's
like
the
giant
elephant
in
the
room
from
a
product
perspective
and
to
me
it's
like:
do
we
want
this
to
be
a
real
idea,
or
do
we
just
want
it
to
be
a
file
editor?
And
you
know
if
we're
going
to
have
to
let
people
extend
and
customize
it
the
way
they
want?
F
I
mean
honestly,
I
would
I
would
say
my
take
on
this
is
not
just
just
to
address
it.
My
take
right
now
my
gut
says
not
to
limit
the
types
of
extensions
that
can
be
installed,
but
that
installing
them
within
the
context
of
the
ide
is
not
the
best
place
to
do
it,
and
if
anything
I
would
advocate
for
some
centralized
or
project
level
group
level.
Extension
management
view
for
the
ide
and
we
kind
of
just
like
bring
that
registry
in
to
our
ui.
F
D
D
That's
super
impressive!
That's
that's
mind-blowing!
The
point
is
that
we
are
like
vs
code
is
super
cool
super
nice.
The
problem
is,
there
are
two
problems.
First
of
all,
not
everybody
is
the
developer,
meaning
vs
code
interface
won't
tell
them
anything.
It
will
be
just
perceived
as
completely
new
interface
for
those
users
and
the
second
one.
Even
among
the
developers.
Not
everybody
is
the
vs
code
user,
like
I'm
jetbrains
user.
D
If
we
try
to
customize
like
not
allow
users
to
customize,
but
I
mean
our
own
customizations
of
the
ui
elements,
if
we
do
it
too
hard,
then
we
will
create
completely
new
interface.
That
is
not
familiar
to
anybody
and
it
will
be
the
new
experience
for
everybody.
So
we
will.
We
have
to
be
careful
with
that.
I
think
it's.
It's
just
just
a
comment,
not
a
question,
but
just
wanted
to
to
to
to
mention
that.
A
A
Online,
so
the
vas
code
modules-
I
haven't,
tried
it
without
an
iframe,
but
all
of
their
all
of
their
examples
and
internal
things.
They're
loading
vs
code
has
control
of
the
whole
document
and
so
that
we
can
keep
our
gitlab
nav
bar
and
our
main
outside
context.
From
getting
touched.
We
create
a
dynamic
iframe
with
basically
bootstraps
the
web
view
yeah,
and
I
was
concerned
about
running
into
resizing
issues,
but
those
seems
seems
to
be
actually
okay.
D
A
D
D
Well,
lucky
you,
okay!
So
thanks
for
replying
to
this
one,
but
the
third
one
goes
back
to
the
discussion
of
the
of
the
web
id
whether
we
are
able
to
achieve
the
same
like
or
we
won't
get
the
same
speed
but
at
least
comparable
speed
to
or
you
know,
wait
wait.
A
second
I've
skipped
so
the
this
this
next
one
was
about
using
the
same
memory
version
control
for
the
current
gravity
so
and
yeah
paul.
Do
you
want
to
just.
A
The
same
memory
version
control
yeah,
the
main
block
with
all
this
is
the
state
redesign
and
because,
in
fact,
the
file
system
and
memory
version
control
that
I've
used
for
this
spike
is
like
80
the
same
as
the
original
state
redesign
poc.
But
now
it's
just
has
a
glue
code
to
vs
code
and
I
added
type
stuff,
because
I'm
now,
when
I
write
typescript,
I
feel
like
I
have
that
typed
everywhere.
So.
A
A
Well,
the
it's
easy
to
plug
this
into
vs
code,
because
vs
code
has
good
state
abstractions.
We
can't
plug
this
into
the
web
ide
because
there's
so
much
coupling
and
duplication
of
our
state.
We
can't
we're
not
even
a
place
where
we're
calculating
diffs.
So
that's
the
state
redesign
is
two
parts.
One
is
creating
the
end
memory
file
system
and
source
control,
which
is
kind
of
already
there,
but
then
also
the
state
redesign
is
all
about
refactoring
web
of
any
states.
A
D
D
D
A
Do
you
know
what
I
mean?
So
I
it's
a
definitely
a
legal
question
that
it's
possible
they
wouldn't
have
to.
They
wouldn't
have
to
go
through
every
extension,
because
the
nature
of
how
extensions
are
run
just
like
the
nature
of
how
we
like
run
pipelines
and
stuff.
But
I
don't
really
know
it's
a
good.
It's
a
great
question.
D
D
But
for
those
hardcore
developers
we
we
just
provide
the
separate
domain
and
they
just
go
there
and
do
whatever
they
want.
The
main.
The
main
question
is
only
how
to
connect
that
to
their
repositories,
to
allow
them
to
to
access
their
repositories,
but
that's
again
just
connecting
the
api
endpoints
and
be
done
with
that.
A
Yeah
and
that's
that's,
doable
and
that's
a
great
question,
and
I
I
mean
we
talked
about
we've.
We've
talked
about
having
like
ide.getlab.com
to
like
open
up
the
web
id
before,
and
so
we
could
do
something
really
similar
for
this.
I
think
the
biggest
concern
is.
Do
we
want
to
maintain
then
do
we
do
we
want
to
maintain
this?
The
web
id
and
like
do
we?
A
D
For
I
like
for
for
some
period
of
time,
we
would
still
have
like,
if
you
mean
by
the
trade-off,
you
mean
we
would
still,
we
would
need
to
support
like
three
four
different
editors.
That
would
still
be
the
case
if,
even
if
we
replace-
because
it's
not
gonna
happen
over
time-
that
we
replace
everything
with
just
vs
code
right,
so
it
will
still
happen.
D
The
the
point
is
that,
if
it
is
the
separate
thing,
it's
much
more
maintainable
than
like
doing
this
and
getting
into
all
sorts
of
regressions
as
we
go,
so
that's
that's
just
and
once
we
prove
that
things
work
fine
on
the
separate
domain
and
people
do
like
this,
and
people
do
want
to
use
this.
That's
when
we
might
make
the
decision
to
replace
the
existing
thing.
It's
just
you
know
to
give
to
to
to
allow
some
iteration
into
the
process.
A
A
A
F
F
D
F
Was
just
gonna
say
you
you
all
can
say
I
want
to
be
respectful
of
people's
time.
Let's
stop
the
recording.
We
can
answer
these
in
async
manner
or
whoever
wants
to
stay
on
can
keep
chatting
if
that's
okay,
with
paul
I'm
gonna
step
out,
but
again,
thank
you.
Paul
thanks
everybody
for
your
great
questions
and
input,
we'll
figure
out
next
steps
and
and
document
them
in
issues
and
try
and
post
this
video
as
soon
as
it's
available,
rendering
and
stuff
like
that.