►
Description
AMA doc for questions:
https://docs.google.com/document/d/1NvE6e5e3TveMClgFgj-T8s_A6hWAmGJxzoOpwEXjuec/edit?usp=sharing
A
A
C
B
C
A
C
B
C
B
A
Yeah,
what
are
the
one
of
the
tips
I
can
share
that
as
well
is
and
feel
sorry
for
jumping
in
minute
top
off.
So
with
a
couple
tips.
Is
that
there's
a
there's
a
couple
of
test
projects
that
we
sometimes
use
and
clone
locally,
that
have
like
very
large,
merge
requests
for
you
to
test
locally
with
fifteen
thousand
changes
so
I'm
going
to
link
that
that
project
you
can
import
local
it
into
your
local
environments
to
test
out
those
scenarios
locally,
while
you're
developing
the
features
cuz.
Sometimes
it's
good
enough
to
sketch
oh
crap.
B
Cool
okay,
that
kind
of
goes
hand-in-hand
with
a
the
next
couple
of
questions
I
had,
which
was
any
debugging
tips
or
I'll
skip
ahead
to
the
one
past
that
which
is
any
tips
for
setting
up
local
data
and
developing
against
them.
That's
one
of
the
big
stumbling
blocks
I
often
have
when
I
first
get
an
issue
is
queuing
up
a
project
that
has
the
right
amount
of
stuff
in
it
to
do
whatever
I'm
working
here,
yeah.
C
B
C
I,
don't
really
have
any
tips
on
how
to
set
it
all,
although
really
except
to
the
project
that
Angela
just
said,
don't
tell
nice
on
silicon,
but
even
then
it's
still
nice.
We
should
probably
look
again.
Some
see
dates
and
this
it
can.
We
can
have
quad
stiffs
with
large
discussions,
see
draft
or
working.
B
C
B
A
Okay,
alright,
so
I
just
added
there.
The
link
to
the
project
I
have
I
called
it
from
Lucas
IP
project,
but
apparently
has
cleaned
up
that
project.
So
basically
it
has
a
bunch
of
branches
already
prepared
with
2000
changes
and,
above
so
I
just
have
to
actually
create
the
merge
request
on
your
own,
but
that
would
be
a
tip
is
as
as
you're
preparing
test
data
to
test
your
features
on
a
couple
of
projects.
A
So
so
definitely
it's
good
to
have
some
of
those
things
outside
of
the
local
environment.
So
you
can
just
like
click
quickly,
pull
that
in
or
just
have
snippets
of
rails
consoles
commands.
They
can
whip
up
and
run
those
to
create
generate
those
those
informations
and
just
keep
that
in
your
back
pocket.
So
I'll
go
on
to
Samantha
voice.
Your
question
sure.
C
I'm
just
gonna:
this
is
the
one
thing
I'm
gonna
keep
talking
about.
It's
the
mage,
Christmas,
Orleans
and
I.
Think
people
miss
them
just
doesn't
how
bad
setting
changes
can
actually
make
the
performance
even
just
like
adding
one
extra
property.
It
can
cause
kind
of
big
issues
with
the
rendering
all
right.
We
need
to
be
little
careful
that
likes
a
lot
good.
You
talk
about
as
much
because
performances
get
a
sense
about
the
seemingly
my
main
could
sing.
C
C
Sir
I
guess
probe's
if
we
explain
from
the
start.
So
when
we
request
the
diffs,
we
request
every
single
diff
line
from
the
back
end,
and
we
just
render
a
strand
to
the
page
and
with
you
there
are
some
little
stratagem
there
we're
doing
request
out
a
callback
which
will
wait
until
the
browsers
gives
us
some
free
time
to
render
a
new
file.
C
Set
up
so
cue
now,
I
am
I
this
kid,
sir
I'm
just
reading
as
I
can
see
it's
in
right.
That's
good
great,
essentially
just
sets
up
the
Kim
and
each
ads
in
stay
secure
and
when
the
browser
gives
us
a
bit
of
free
time,
we
can
then
say:
okay,
well,
listen.
The
browser
actually
render
this
and
it
gives
us
a
little
bit
of
performance.
C
D
A
I
think
I
think
I
can
add
some
bit
of
information
there.
I
do
want
I
do
want
Phil
to
cover
one
specific
scenario
who
worked
on
a
feature,
and
he
had
this
performance
concerns
and
I.
Think
they'll
be
easier
for
him
to
explain,
but
since
we're
on
this
subject,
I
and
I
helped
him
with
this.
With
these
particular
improvements,
I'll
give
some
historical
context
and
then
I'll
explain
a
little
bit
further
of
this
code.
A
So
when
we
did
the
merge
request,
refactor
from
Hamel
to
view
we
bumped
into
those
problems
like
the
the
merge
aggressed
that
had
a
hundred
discussions
or
thousands
of
lines
of
changes,
they
would
block
the
browser.
The
browser
was
just
a
hang-up,
and
that
was
because
we
were
relying
on
you
to
just
take
care
of
like
we
just
update
the
state
with
a
thousand
of
stuff
that
came
from
the
server,
and
we
hope
that
view
would
render
it
properly.
A
The
problem
is
that
the
browser
can
only
do
so
much
and
he
was
hanging
because
we're
just
asking
them
to
render
thousands
and
thousands
of
lines.
Each
line
has
a
couple,
a
handful
of
components
on
that
own
line,
so
that
just
added
up
in
terms
of
time
and
just
locked
the
browser
forever.
It's
considerable
considerable
amount
of
time-
and
it
was
these.
This
was
the
approach
that
team
came
up
with,
which
is
kind
of
having
a
queue
of
diffs
to
be
rendered,
and
this
is
kind
of
the
logic
we're
using
the
request.
A
I,
don't
call
back,
which
basically
just
runs
this
whenever
the
browser
is
ready
and
it's
not
like
crying
for
help,
he
will
run
then
to
set
the
discussions.
So
this
this
is
just
right
there,
it's
kind
of
like
a
more
robust
set
timeout
to
release
the
control
of
the
browser
thread,
and
then
you
can
start
setting
the
discussions
on
the
state
and
then,
when
you're
about
to
render
it.
Basically,
all
discussions
have
a
little
flag
like
render
it
here.
That
is
not.
A
That
is
that
is
false
in
the
beginning,
so
you're
going
to
have
to
incrementally
turn
that
flag
on
and
if
it's
on
then
you'll
be
able
to
render
it
there.
How
you
do
that
is,
then
you
will
commit
those
those
mutations
using
a
requestanimationframe,
and
then
you
use
request.
I
will
call
back
to
continue
the
rest
of
the
queue,
so
that's
sort
of
the
explanation
of
the
concern
we
had
for
rendering
large
merge
requests
along
like
the
whole
page
but
Phil.
A
Maybe
maybe
we
can
now
switch
to
talk
about
the
particular
concerns
you
had
when
building
the
feature
we
shot.
That
was
gonna,
be
my
follow-up
question
anyway.
So
I'm
gonna,
I'm
gonna.
Add
that
to
the
document
which
is
recently,
you
worked
on
a
simple,
expand:
full
file
button
in
the
merge
request,
if
stabbed
that's
a
simple
button
that
you
click
and
he
just
expands
the
whole
file.
A
It
looked
like
a
simple
feature
and
and
I
saw
and
I
was
there
in
the
beginning
and
I
saw
how
Phil
was
was
concerned
about
exactly
that
performance
part,
and
he
had
a
very
similar
approach
about
this.
So
Phil.
Do
you
wanna
talk
a
little
bit
about
what
was
the
concerns
that
he
took
around
this
this
part,
especially
to
make
the
the
rendering
of
a
large
file
performant
yeah.
C
C
A
C
Nice
logo,
anything
and,
of
course,
the
full
file
content
straight
in
the
diff,
so
request
a
just
request:
the
actual
content
and
wait
like
a
year,
because
the
team
that
Yama
files
huge
and
then
it
starts
to
run
tweets
the
Lance.
So
you
see
little
low
load
and
spray
at
the
bottom
now
we
could
just
render
this
file
completely,
but
with
this
one,
specifically,
it's
like
10,000
lines.
Whatever
is,
and
you
just
see
the
browser
just
start
to
yeah
die
nice.
C
Let's
see
it
takes
like
maybe
in
this
case
is
probably
like
five
six
seconds
to
actually
render,
and
so
we
did
the
same
sort
of
thing
if
the
request
I'll
call
back.
So
this
is
the
main
actual
UX
action
and
the
date
is
the
days
that
we
get
back
from
the
back
end,
which
just
contains
an
array
of
client,
both
I,
just
an
array
of
antigen.
We
then
compared
here
to
recommit
at
the
highlighted,
if
lands,
which
is
the
inline
diff
view
and
then
parallel
and
then
we
start
to
work.
Oh
okay.
D
Sorry
to
interrupt,
can
you
go
over
the
terminology
a
little
bit
I'm
slowly
getting
it,
but
maybe
you'll
be
helpful
for
someone
else
watching
like?
Can
we
talk
about?
What
are
we
talking
about
in
terms
of
parallel
line?
What
are
we
referring
to
as
two
dips
I
think
these
terminology
will
help
the
next
person,
so
they
don't
have
to
go
through
it.
Like
me,
yeah.
C
Sure
said,
the
code
which
I've
always
found
the
way
is,
we
call
it
highlighted
if
lines
which
actually
equals
in
line
I
would
probably
the
sushi
bar.
We
will
name
it
to
in
line
to
makes
a
little
bit
more
sense
and
then
parallel
defines,
which
is
why
everyone
should,
because
it
just
looks
nice.
It
is
when
you
did
the
split
few,
like
this
mess
side
by
side
and
see
ya
to
a
helical
in
one
individual.
C
D
C
We
wake
up
the
one
that
we're
currently
viewing
in
my
case
would
be
the
parallel
and
the
headphone
being
the
in
line
view
we
can
just
instantly
just
set
the
ones
he's.
Never
gonna
render
them,
so
we
don't
really
care,
and
then
we
get
into
this
logic.
Yeah
we
just
saw
see
ever
more
confusing,
so
we
work
out
okay.
Well,
we
know
we
can
render
maybe
like
500
lines,
I
think
this
equals
yeah
500
lines
and
maybe
like
500
milliseconds,
which
is
it's
not
great,
wait.
Okay
and
we
can
deal
with
it.
C
So
if
it's
more
than
500,
we
learnt
the
incremental
rendon.
If
not,
we
can
just
instantly
just
set
the
lines
and
we
can
wait,
maybe
if
I'm
due
to
similar
seconds
for
the
browser
to
actually
rendering-
and
this
is
where
it
gets
a
little
confusing.
So
we
do
the
old
request.
I'll
call
back
and
that's
just
the
mock
function,
a
mock
damn
after
that
we
can
do
in
the
tests.
We're
just
requests,
I'll
call
back,
and
then
this
is
where
we
do.
The
call
like
so
request
out
a
call
back
in
the
coal.
C
C
We
can
do
some
checks
there,
if
it's
more
than
that,
we
can
just
quit
out
of
it
and
wait
for
an
override
will
call
back
if
we
still
need
to
go
into
lines-
and
you
know
in
this,
while
loop
will
start
to
render
each
time
we'll
have
to
be
aware
until
eventually,
all
the
lines
have
nicely
rendered
and
the
browser
doesn't
freeze,
because
if
there
might
freeze
it
a
little
bit,
cuz
I'm,
pretty
sure
all
the
styles
and
probably
not
the
greatest.
Our
prized
access
to
painting
does
all
that
make
sense.
A
That
that
was
basically
what
I
wanted
you
to
cover
and
then
just
so
that
you
all
understand
like
if
it's
a
small
file
like
you,
won't
even
notice
the
increment
or
entering.
But
if
it's
a
large
file
like
team
llamo,
you
definitely
see
it
and
you
definitely
see
that
it's
progressively
rendering.
So
you
know
what's
happening,
it's
like
you
and
you
were
loading
such
a
large
file,
you're
kind
of
expecting
it
to
like
take
a
long
while,
but
you
can
start
doing
other
stuff
on
the
browser
and
it
will
react.
A
C
D
A
Maybe
if
we
have
a
specific
area
about
what
we
want,
because
we
can
definitely
take
that
like
overall
view,
but
it's
such
a
large
app
that
if
we
have
any
particular
areas
that
we'd
like
to
see
and
again
some
of
those
might
be
just
clarified
by
looking
at
the
at
the
state
or
the
view,
X
one
thing
would,
which
is
sometimes
hard
to
grasp
at
first
sight.
Is
that
we're
getting
a
lot
of
responses
from
the
server
and
you're
just
grabbing
those
and
attaching
to
the
state
and
feel
correct
me
if
I'm
wrong?
A
So
there's
some
times,
you
don't
see
that
in
the
code
itself
that
we're
just
mimicking
the
structure
that
comes
from
the
server
and
then
loading
it
on
the
state.
Sometimes
we're
doing
some
conversions
that
feel
highlighted
there
somewhere
along
the
the
overview.
But
there
are
some
things
that
are
in
the
state
that
can
directly
from
the
server.
C
A
A
So
but
at
the
time
the
the
paranoid
of
us,
the
paranoid
in
us,
we're
always
double
testing
everything
making
sure
that
we
got
regular
like
down
to
the
to
the
performance
analysis
of
the
rendering.
We
do
have
some
work
being
done
by
the
quality
team
that,
in
the
reviews,
app
they're
using
some
models
of
em
ours
to
make
sure
that
performance
don't
regress,
I'm,
not
entirely
sure
of
the
state
of
that,
but
that
has
been
done
by
the
quality.
A
So
there
are
some
only
to
check
that
the
state
of
that,
but
that
was
from
that
work
like
we
started
doing
that
manually.
But
right
now
the
tips
are
be
vigilant
about
perform
and
just
having
those
sort
of
projects
set
up
in
your
local
environment
to
play
around
with
them.
Mr
with
50,000
15,000
lines,
instead
of
just
12,
makes
a
huge
difference
when
you're
developing
these
features,
because
we're
not
gonna
solve
performance
issues
by
accident.
A
There
is
a
deliberate
action
towards
fixing
those
performance
issues,
but
as
long
as
we
don't
make
them
worse,
it's
good
enough
for
the
daily
work
and
we'll
be
scheduling
performance
improvements
as
we
go
along
the
lines
to
make
sure
that
it
just
can
handle
whatever
size.
The
mr
is
oh
yeah,
there's
no
one
specific,
I
agree:
Phil
doesn't
I
think
the
most
important
part
if
I.
A
B
D
C
C
I,
just
literally
just
you
look
at
the
code,
you've
written
a
finger
K.
Well,
how
can
I
test
this
code
make
sure
it's
a
nasty
break
in
the
future,
and
it
didn't
have
to
be
the
test
that
you
miss.
That
is
totally
okay
and
it
just
happens.
You're
not
gonna,
be
on
site
test,
so
every
single
case
possible.
It's
just
whenever
that
case
comes
open.
If
there's
a
regression
or
a
buggy
is
just
to
make
sure
he
does
testicle.
Is
that
book
to
make
sure
doesn't
happen
in
the
future.
A
The
more
time
the
more
tests
you're
right,
the
better
you'll
get
at
that
and
I
think
what
important
part
you
touch.
There
is
exactly
the
point
that
if
you're
fixing
a
bug
right,
something
to
make
sure
that
it
doesn't
come
back
and
we
through
there
you'll
have
the
experience
I
would
I
would
have
put
the
tallest
question
because
it's
been
there
a
while.
C
A
I'll
talk
over
that,
so
the
merge
request-
switcher
was
the
first,
but
at
the
time
it
was
not
as
large
as
it
is
now.
I
think
he
just
grew
up
from
other
stages,
jumping
on
it
and
adding
more
stuff,
but
is
there
anything
particularly
that
you
had
planned
for
the
merge
aggress
widget
to
break
it
down
in
terms
of
architecture
in
terms
of
tricks
to
make
it
a
little
bit
more
manageable
or
just
rewriting
the
whole
thing.
C
C
A
D
A
A
We
moved
it
to
view
for
performance
reasons,
because
we
wanted
to
make
it
more
snappy
to
navigate
through
the
whole
tree
and
the
the
tasks
were
broken
down
and
I'll
I'll
link
to
the
epic
here
in
just
a
second
but
my
question
to
Phil
then,
because
he
was
working
on
that
did
you
did
you
have
any
lessons,
because
it
was
particularly
enough
to
date,
migration
from
Hamel
all
the
way
to
graph
QL.
So
were
there
any
lessons
there
through
that
path?
Anything
you'd
like
to
highlight,
or
was
it
easy?
C
It's
like
the
easiest
entry
factors
you've
ever
done,
because
it's
just
a
sincere
that
doesn't
render
data
there's
no
like
interactive
pots
and
the
biggest
lesson
is
everybody
already
knows.
The
crack
kills
like
the
best
thing
ever
it
mate
is
so
easy
and
the
BAM.
If
you
would
ever
need
side
the
graphical
feature
that
I
would
just
look
at
the
backend
code.
The
backend
code
is
super
simple
to
understand:
there's
not
very
much
complex
in
there
yeah.
If
you
ever
wanted
country
to
crack
down,
please
she's
doing
cuz,
everything
should
be
graph
drop.
C
C
Didn't
really
consider
this
because
it
doesn't
exist
on
my
local,
so
I
wasn't
really
looking
into
it
and
we
have
the
testicle
this
to
the
test.
When
read
when
I
tend
to
feature
flag
on
and
yeah,
we
can
proceed
fairly,
confident
those
tests
for
certain
things,
I'm,
just
I,
haven't
even
checked
yeah,
there's,
probably
something
in
a
dive.
Miss
is
this
yeah.
A
That's
that's
a
good
point
and
yeah.
The
lesson
is
they're.
The
tests
definitely
help
us
in
this
industry
factors
and
and
Thank
You
Phil
for
raising
that
point
of
the
backend,
because
one
of
the
problems
we
had
with
the
modulus
refactor
was
that
we
didn't
do
that
and
at
a
certain
point
we
just
had
to
had
a
sync
up
session
with
tower
where
he
walked
us
through
the
backend
logic
that
it
had
implemented
for
the
Hamel
views
then
was
just
like
it
right.
Do
we
have
this
in
the
front
end?
A
We
have
this
in
the
front.
End
yeah.
We
don't
have
this
in
the
front
that
oh,
we
didn't
have
that
bit
in
the
front
end,
so
we
had
to
rewrite
that.
But
the
back
end
is
a
great
because
if
we
were
writing
something
in
Hamel,
it's
been
sitting
there
for
sometimes
years
and
if
we
haven't
had
problems,
we
definitely
want
to
make
sure
that
the
refactor
will
migrate.
That
and
even
if
you
don't
know
how
to
read
Ruby
either
we
grab
her
back
in
or
it's
usually
in
the
hammer
logic.
A
C
C
Service
happened
so
that
mean
that
I
went
with
you
and
to
get
level
wigs
on
the
issue
date,
I
remember,
making
a
change
on
the
issue
form
with
the
most
cost
form,
and
then
you
I
couldn't
submit
marriage
requests
for
like
a
week
or
two.
We
try
really
deploying
it
and
yeah
there's
nothing
that
I
would
change
in
hindsight.
It's
just
you
just
learn
these
things
over
time.
C
A
Yeah
I
heard
something
yesterday
on
read
something
yesterday
on
Twitter.
It
might
be
useful
for
this
case
where
a
junior
developer
talks
with
senior
developer
and
ask
for
help
and
the
senior
developer
s
answers
the
junior
thinks.
Oh,
my
god
he's
so
smart
in
the
senior
thinks.
Oh
my
god,
I've
made
that
mistake
so
many
times
and
that's
what
Phil
is
saying
that,
like
you
learn
as
you
go,
there
definitely
definitely
true
truth.
There.
C
But
like
it
is
turning
okay
to
make
these
mistakes.
Like
so
I
made
the
mistake,
you're
breaking
the
marriage
press
phone
I
make
you
just
fifty
several
gosh.
What
am
I
done,
I'd
like
it,
it
does
seem
super
bad
all
the
time
for
like
in
a
week,
so
everyone
just
forget
about
it.
Everyone
gets
on
with
the
lives
yeah.
A
I
would
grab
that
particular
example
Phil
to
highlight
one
very
good
characteristic
that
you
have,
which
is
it's
okay,
to
break
those
things,
and
especially
we
have
the
knowledge
of
the
stuff.
You
were
working
on
as
long
as
we
jump
on
it
and
we
put
a
fix
up
and
you
try
to
get
some
some
reaction
to
it
is
is,
is
was
working
amazingly
with
you
and
I,
think
that's
something,
and
that
we
should
definitely
take,
as
example,
because
it
it's
okay
to
break
things
break.
But
we
will
react
quickly.
We
jump
on
it.
A
We
fix
them
right,
a
few
tests
to
make
sure
that
they
don't
come
back
and
send
it
on
its
way.
And
then
it
crisis
is
worded
we're
in
a
far
better
position
now
with
feature
flags
where
we
could
just
turn
off
that
feature
if
it's
just
like
about
just
launched
so
in
a
far
better
position
now
to
just
mitigate
those
risks,
but
I
think
that's
something
that
you
had
as
a
discipline
whenever
something
spun
off
either
yours
or
other
people's
and
the
team
work
a
regression
or
something.
A
You
were
very
quick
to
jump
on
those
because
sometimes
it's
just
a
one.
A
one-line
fix,
if
you
know
about
the
code
and
and
reviewing
code,
is
also
a
good
part
of
being
aware
of
the
code
being
shipped,
and
that
would
be
my
follow-up
question.
You
reviewed
a
lot
of
em
ours
while
it
good
luck,
so
we
have
several
people
on
the
call
and
and
be
more
people
watching
this,
and
some
of
them
are
already
maintained,
errs
others
are
aspiring
to
become
maintainer.
Some
of
them
are
already
trained
imitators.
C
C
So
I
always
like
to
get
the
porn
stars
like
if
it's
not
boring
reviewing
code
isn't
born
it's
enjoyable,
it's
something
different,
but
you
just
want
to
get
our
minds
off
that
and
normally
the
ones
that
don't
just
bark.
So
it's
nice
about
doing
and
yeah
a
lot
of
the
stuff
I've
just
learned
over
time,
things
to
look
out
for
you.
Just
you
get
used
to
things
to
get
always
come
walk!
A
Yeah
I
some
people
have
their
own
habits
and
then
it
changes
from
person
to
person.
But
it's
just
you
supposed
to
hear
what
you
used
to
do
and
like
that
thing
about
having
at
the
start
of
the
day
as
slot,
for
that
just
creates
a
habit
of
always
being
trimming
down
the
pile,
because
if
you
postpone
it
for
later
postponing
for
later,
then
you
could
be
blocking
other
people.
A
B
Follow-Up
that
do
you
have
anything.
This
is
like
a
pattern
or
anything.
You
did
more
I
guess
technically
around
reviewing
like
you
start
with
pulling
down
the
branch
and
running
it
locally.
Do
you
start
with
reading
through
the
issue?
You
start
with
just
skimming
through
the
changes
they
made
anything
on
those
lines
and.
C
Nobody
else
thought
going
through
the
code
and
you
get
like
a
point
in
the
codes
and
you
realize
I
have
no
idea
what
this
speech
is
meant
to
be
doing
at
that
point.
I
go
back
in.
Let
you
look
at
the
issue
which
you
should
probably
do.
First,
but
I
never
do
and
I
always
forget
to
yeah
and
then
eventually
I
just
go
through
the
code
Creole
occurrence
and
then
eventually
all
the
comments
get
resolved
and
you
think
you
are
just
testing
the
loop
I'm.
Not
holding.
My
comments
are
being
resolved
so.
B
C
C
A
yes,
it
depends
on
the
feature.
Yes,
there's
some
features
we
should
assign
to
UX
to
review
it.
So
I
like
to
think
that
they've
reviewed
it
in
the
browser
quite
well
and
know
how
it
works
and
call
it
books
that
way,
yeah,
so
I,
probably
don't
want
it
in
the
browser's
much.
This
should
proficient
with
this
I
guess
it's
okay,.
D
C
C
D
C
And
best
advice
that
I
can
give
yourself
is.
It
was
what
I
was
given
way
back
when
I
started.
It
was
to
always
review
code
yourself
first
and
trying
to
find
any
issues
that
you
find
eventually
every
time
you're
against
the
same
mindset
of
how
the
maintainers
think
you
know
start
to
catch
on
to
them,
because
I
mean
over
time
you
just
generally
naturally
just
learn:
I
kill
all
the
meteors.
Don't
we
pick
up
on
this
point
I'll
just
do
it
differently?
Next
time,
yeah
always
review
the
code
yourself.
First.
C
Yeah
I,
don't
know
just
yeah,
there's
nothing
I
would
say
avoid
you
just
you
just
write
the
codes.
You
do
and
then
I
mean
maintainer
of
your
comments
on
it
and
if,
like
the
code
that
you
wrote
and
you
feel
like
it's
the
best
way
to
write
the
code
feel
free
to
like
disappear
view
review
or
a
maintainer,
you
should
totally
do
like.
C
A
Yeah,
that's
yeah
and
I
really
enjoyed
it
at
this
point
Phil
because
sometimes
people
take
the
the
feedback
that
they
got
from
the
merge
request
as
mandatory
and
sometimes
there's
something
we
miss
as
we
review
code,
and
sometimes
it's
not
obvious,
exactly
the
side
effects
and
with
front-end.
We
know
that
there's
a
few
things
that
CSS
or
not
CSS,
that
will
make
a
big
change
in
the
in
the
end
result
or
just
cross
browser
compatibility.
That
is
not
obvious.
A
So
if
you're
absolutely
sure
that
this
is
the
right
approach
and
you
feel
like
the
maintainer
is
missing,
something
speak
up
and
in
in
get
lab,
like
will
always
assume
good
intention.
So
keeping
an
open
communication
is
useful.
It
is
critical
to
to
get
that
discussion
in
the
healthy
state
that
you're
just
making
sure
that
this
was
considered.
We
I
was
doing
this
because
of
that
she
still
lies
dude.
You
think
I
still
need
to
change
and
then
that
discussion
will
just
solve
itself
on
its
own,
but
yeah.
A
D
C
My
color
mister,
to
call
in
mistake
my
I
go
to
comma
semicolon
mistake
and
you'll
see
how
it
Steven
Michael
mistake
is
the
common
mistake
is
probably
not
so
bad
now
that
we
have
listed
in
place
while
ago,
when
Lou
honey,
translate
you'd
always
find
strings.
Would
not
you
have
the
translation
methods
I
like
I
would
always
forget
them,
and
Filippo
would
always
tell
me
to
add
them,
and
I
would
never
remember
for
the
next
Miyagi
Chris,
but
the
Karem
ethic
that
I
always
add,
and
it's
much
too
possessive
thing.
A
C
A
Cool,
so
I
still
have
a
bit
of
time.
I
was
gonna.
Ask
you
remember
what
would
you
say
was
the
most
complex
feature
you
worked
on
under
the
source
code
and
the
Sasuke
yeah
I
know
that
you
worked
on
a
bunch
of
domain,
so
everybody
eat
other
stuff
but
source
code.
What
can
you
think
of
one
particular
feature
that
he
thought
alright?
This
took
a
while.
C
The
very
first
ever
be
feature
we
added
is
the
resolving
disscussion
two
different
comments,
but
because
you
sort
of
like
admin
view
into
Jake
Korea,
which
was
rendering
an
ajax
call,
it
was
like
creating
some
super
hacky.
The
UK
like
you
just
don't
even
want
to
look
at
now,
and
so
that
was
kind
of
complex
he's,
always
after
clank
hats,
these
edge
cases
being
didn't
even
think
about,
and
that
was
I
worked
at
our
on
that
one
and
it's
always
finished
for
the
day
and
be
like
yeah
fixed
everything.
C
A
C
C
A
Famous
last
words,
so
that
segues
a
little
bit
to
my
next
question
and
I,
know
that
so
you
work
anywhere,
you
give
very
helpful
hands
on
the
batch
comments
on
merge,
request,
reviews
I
was
doing
you're
working
when
that
feature
and
you
you
came
along
and
you
helped
structure
along
the
split
of
the
code
uni
and
see,
and
he
was
amazing
by
the
way.
Thank
you.
A
But
that
leads
me
to
my
question,
which
is
what
what
would
be
the
the
features
you
would
give
us
a
heads
up
to
about
the
the
things
that
are
available
in
C
e.
That
are
not
sorry
that
are
available
on
EE.
They
are
not
available
on
C
e
because
sometimes-
and
we've
been
bidding
about
it
about
this
in
recent
past,
where
we
work
on
a
feature
on
C,
it's
working
great.
But
then
we
forget
that
there's
something
touching
this
code
base
or
happening
on
the
especially,
for
example,
the
batch
comments.
A
It
is
more
prominent
now
on
the
source
code.
Is
there
any
other?
Apart
from
the
batch
comments,
that
only
exists
that
you
think
about
on
the
source
code?
We
need
to
look
out
for
that.
Even
going
back
into
the
old
code,
even
going
back
to
ham
will
use
stuff
that
is
good
creep
are
upon
you
and
you're,
not
unexpected.
On
the
seaside.
Maybe.
C
I
guess
the
other
thing
that
could
figure
out
that
being
on
the
source
code
will
be
I'll,
lock
and
folder
locks.
You
can
lock
specific
files
and
folders
from
being
edited
I
guess
she
doesn't
become
a
big
issue
anymore.
When
we
have
the
single
codebase,
some
theory,
the
tester
Cassie's.
If
you
saw
it,
marries
into.
A
A
C
A
A
Did
you
see
any
activity
in
image
requests
regarding
other
groups
working
with
compare
views
because
we're
you
know
when
you're
putting
any
more
any
more
requests
down
below
there's
a
compare
view
of
the
two
branches
and
that's
still
not
refactoring,
to
view
yeah.
So
is
there
anything
like
that
that
you've
seen
like
old
code
being
touched
recently
that
falls
under
this
kind
of
fantastical.
A
C
C
A
C
D
C
C
A
D
C
C
D
D
D
A
So
I'll
just
ask
out
of
the
out
of
all
the
new
stuff
coming
into
the
browser
as
a
whole.
Is
there
any
particular
feature,
any
particular
spec
that
you
wish
we
could
have
used
in
not
just
source
code,
but
a
good
lab
that
we
didn't
get
to
use,
or
you
feel
like
it's
an
emergent
thing
and
we
need
to
think
about
it.
I
know
that
you
already
talked,
on
the
other
hand,
a
way
of
making
the
web
ID
work
offline.
C
A
He's
giving
a
presentation
today
to
London
about
that
yeah
we
had
one
service
worker
in
the
web,
ID
right,
we
removed
it,
no
snappy
a
web
worker,
then
oh,
oh
yeah,
it's
true
great,
was
a
woodworker
yeah,
interesting,
all
right,
so
I'll
anything
else
that
you've
been
feeling.
This
is
cool.
I
want
to
play
with
this.
No.
C
C
A
A
A
Okay,
so
I
guess
I'll
end
here
and
if
you
have
more
questions,
fuels
gonna
stay
for
a
couple
more
days,
so
definitely
reach
out
to
him.
Ask
ask
questions
if
not
reach
out
to
me
and
you
can
find
somewhere
to
answer
this
and
Phil.
Thank
you
very
much
for
for
enduring
our
onslaught
of
questions.
It's
always
fun
to
learn
how
you
think
and
how
you've
been
working.
So
with
that.
Thank
you.
Everyone
I'll
see
you
in
another
call
and
have
a
great
day
all
right,
bye.