►
Description
In this session we discuss implementation plans for the requirements in scope with this upcoming Remote Development Iteration.
https://gitlab.com/gitlab-org/gitlab/-/issues/381485
A
Okay?
So
we
have
these
tasks
and
scope
and
we
want
to
flesh
out
a
plan
implementation
plan
with
lines
of
code,
all
that
stuff
related
to
these
tasks.
So
I
have
our
like
agenda
thing
here:
I'm
going
to
kind
of
just
copy
this
into
the
agenda
and
then
we'll
throw
some
notes
in
there
and
then
after
we
draft
some
notes.
I
might
put
it
just
in
the
description
here
itself
or
I
might
add
a
new
comment
to
it.
So
you
can
throw.
A
B
A
So
some
things
that
are
done
so,
let
me,
let
me
add
some
historical
context
here
and
that's
good
mentioning
that
I'm
going
to
add
links
to
historical
context,
which
would
be
really
good
so
going
into
the
code.
This
is
part
of
the
source
control
stuff
commit
flow.
All
of
this
is
ex
vs
code.
Extension
is
the
only
thing
that
has
access
to
management
stuff,
so
I'm
going
to
go
to
our
extension,
the
main
file
where
we
set
things
up
and
boom.
Here
we
go.
B
A
This
is
important.
Yeah,
so,
and
I
could
also
jump
into
the
architecture
document,
but
this
is
the
package
that
compiles
the
extension
runtime.
So
when
we
bootstrap
everything,
we
use
this
built-in
extension
to
build
the
file
system
and
all
sorts
of
other
stuff,
the
file
search
provider
and
other
things
like
that.
So
we
had
a
whole
implementation
for
Source
control
related
to
the
spike,
and
this
this
worked.
A
A
B
And
the
reason
we
switched
away
from
the
get
implementation
because
I
worked
with
you
on
this
was
because,
like
it
basically
relies,
let
me
get
cloned,
which
is
unacceptably
slow
for
large
repos.
You
know
it's
even
looking
at
other
implementations
of
vs
code,
including
me
aspro.dev.
There
was
no
way
around
that
performance
Blocker
of
like
how
do
you
initially
clone
the
code,
and
you
can't
do
at
least
with
that
version.
You
know
partial
clones.
B
A
Yeah,
so
small
clarification
to
what
you
said
is
the
didn't
depend
on
git.
It
implemented
a
git
based
algorithm
which
had
some
issues
with
it,
and
but
it
was
very
abstract
dealing
with
like
get
objects
and
stuff,
and
it
did
have
issues
because
it
was
dealing
with
objects.
We
wanted
to
get
the
original
object
references
because
these
are
rated
to
hashes
of
the
files.
So
we
could
have
gone
down
that
path
and
but
we
identified
there's
some
complexities
here
and
at
that
moment
we
evaluated.
Could
we
use
a
in
browser-based
git?
A
Well,
if
we
did
that
that
required
actually
using
git
clone
of
stuff,
which
was
going
to
be
so
unperforming
and
stuff,
and
then
you
brought
up,
do
we
really
need
gits
and
when
we
dove
into
the
file
system,
we
built
this
overlay
file
system.
We
can
actually
get
what
has
changed.
What
has
been
touched
in
real
time
and
compiled
a
commit
based
off
of
that.
So
that's
the
new
approach
which
I.
B
C
A
C
A
A
A
C
B
A
A
C
A
Object
that
we
get
overlay
FS
keeps
track
of
files
that
have
been
touched
in
a
way
that
we
can
read
here
and
there's
some
unit
tests
that
are
also
kind
of
confirming
this,
so
I
think
so.
I
think
there's
also
yeah
this.
This
Mr
will
probably
get
more
context
as
well
from
like
the
overlay
FS
stuff,
but
this
is
tracking
changes
so.
D
B
C
D
B
Little
bit
yeah,
could
we
start
from
the
other
direction
and
talk
about
like
okay
from
the
looking
in
the
the
API
to
create
merge
requests
and
make
commits
like
calling
to
get
lab
API?
For
that?
Where
would
that
go?
Yeah,
yeah
and
those
things
happen
to
me
in
the
middle
we
just
talked
about
here
and
that
and
make
every
every
all
of
the
requirements
before
the
API
be
fulfilled.
A
C
A
B
A
A
B
D
A
Yeah
so
like
they
have
a
whole
git
extension,
which
is
pretty
good
at
seeing
how
we
can
Implement,
with
this
thing
so
like
if
I'm
using
vs
code
and
I
see
this
kind
of
stuff.
I
could
do
a
search
for
almost
some
of
these
texts
and
see
where
it
shows
up
in
the
vs
code
project,
which
give
me
a
good
indication
for
like
okay.
How
do
we
create
this
button?
And
things
like
that.
A
A
B
A
A
B
C
A
A
C
C
C
D
C
A
D
A
A
A
A
Those
vs
code
give
us
the
ability
to
so.
This
is
another
really
good
thing
to
note
about
vs
codes
API,
so
here's
like
when
you're
in
extension,
land
you
have
access
to
this
entire
API
there's
also
a
proposed
API,
which
you
won't
see
here,
but
you
can
see
the
proposed
API
you
can
see
if
I
in
our
projects,
if
I
go
to
proposed.
A
A
Yeah,
okay,
here's
there's
an
interesting
thing
like
they
have
fine
text
and
files
and
like
so
they
have
actually
a
pose
API
for
handling
this
in
the
more
fancy
way.
But,
like
the
main
thing,
that's
in
scope
is:
how
do
we
want
to
alert
users
about
the
limitation
and
I?
Don't
know
what
what
we
can
change
here,
we
can
add,
like
we
can
definitely
hook
into
that
like
give
us
the
ability
to
add
something.
B
A
C
A
This
this
is
something
I'm
pushing
forward.
So,
okay,
yeah,
those
are
those-
are
our
scope.
Things
in
addition
to
this,
like
there's
a
whole
bunch
of
other
lovability
things
we
can
add
like
branding
stuff
like
for
me,
I,
don't
think
this
is
encompasses
everything
in
scope.
I,
think
this
is
the
must-haves
there's
a
lot
of
nice
to
haves.
A
Some
of
these
issues
already
open
of
so
like
in
the
boards
here.
I
have
one
for
a
development
Board
of
like
bugs
and
features
and
maintenance
stuff,
but
it
looks
like
we're
kind
of
just
focusing
on
the
bugs
and
features
right
now,
there's
some
like
noisy
console
era
stuff,
which
could
be
indicative
of
actual
problems.
That
would
be
nice
to
take
care
of
there's,
there's
branding
stuff
but
I
think
also
just
while
we're
having
to
work
on
this
critical
path.