►
From YouTube: 2023-01-25 Code Review Weekly
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Hello,
everyone
Welcome
to
the
voter
view
weekly,
which
is
okrs.
They
are
due
by
the
end
of
the
week.
So
if
we
can
get
some
ideas
and
then
try
and
refine
those
over
the
next
day
and
a
half
that
would
be,
that
would
be
good.
So
we
can
also
discuss
like
if
you
have
questions
about
it,.
B
A
That
would
work
too,
but
otherwise
yeah
either
way
works.
For
me.
B
Okay,
I,
don't
I,
don't
have
any
specific
thing
to
add
to
what
I
added
in
the
comments.
So
let's
just
go
through
the
threads
and
then
synchronously
speaks
happy
to
nothing
is
said
in
stone.
So.
A
Yeah
and
I
have
not
I
didn't
I
intentionally
sort
of
like
didn't
propose
any
of
this
time,
so
probably
more
more
pressure.
This
way,
but
I'm
trying
to
see
where
we
come
back
on
things.
So
I
will
look
at
all
the
feedback
that
has
happened
since
I
sent
this
message.
B
I
have
one
question,
though,
popped
up
in
my
mind
right
now:
where
are
we
with
the
restructuring
Mr
effort?
Are
we
close
to
being
ready
pick
it
up
or
how's
that
looking.
A
It
is
still
in
research
as
far
as
I
know,
it
is
in
like
a
next
round
of
user
testing
and
then
there's
some
shifts
in
people
working
on
it.
So
Pedro's
back
he's
going
to
be
picking
up
more
work
on
that
Annabelle
will
be
picking
up
work
again
on
like
the
review
rounds
concept
and
so
I'd
expect,
like
neither
of
those
are
in
an
engineering
State
during
the
quarter.
B
So
let
me
move
on
to
my
next
point.
Okay,
all
right.
Nobody
has
any
thoughts,
then
I'll
move.
So
this
is
more
of
a
heads
up,
so
essentially
just
something
that
might
affect
our
capacity
going
forward,
but
even
though
it
still
related
works,
so
status
lab
has
been
probe
and
asked
to
join
working
group.
That
is
information.
It's
a
related
topic.
So
it's
the
moving
our
code
based
to
view
three
we've
talked
about
this
in
the
past,
we've
talked
about
it
in
the
round
tables
as
well.
B
This
will
eventually
benefit
our
code
review
efforts
of
performance
since
view
3
opens
up
a
bunch
of
opportunities
and
tooling
that
we
can
use
to
that's
not
at
our
disposal
with
V2
So.
B
In
theory,
we
can
have
much
more
performant
code
using
view
three
mechanisms,
but
for
us
to
get
there,
there's
still
a
bit
of
a
rocky
road,
so
Tim
and
Ilya
have
sort
of
banded
together
and
to
make
this
effort
a
little
bit
more
active
and
consistent
they're
forming
a
working
group
around
the
effort
and
Status
lab,
because
he's
also
close
to
the
project-
and
he
has
a
couple
of
relevant
expertise-
will
be
a
key
asset
to
that
effort.
B
So
what
this
means
to
us
is
that
we
are
looking
into
the
specific
proportion
of
capacity
we'll
dedicate
to
this
effort.
We
are
looking
at
a
a
major
part
of
this
capacity,
just
not
sure
exactly
what
for
for
rough
measure.
What
we've
been
talking
about
in
the
context
of
working,
which
is
something
between
60
to
80
percent
of
the
of
the
capacity
not
too
keen
on
dedicating
80
of
status.
B
Labs
capacity
about
60
seems
doable
around
50
halves
would
be
something
that
we
can
accommodate
in
the
context
that
the
work
is
doing
as
as
well,
but
leaving
a
bit
of
the
proportion
for
us
to
get
the
benefits
of
his
expertise.
For
the
performance
work,
but
it
will
undoubtedly
have
some
impact
on
the
capacity.
So
I
want
to
hear
your
thoughts.
If
you
feel
like
this
is
a
good
investment
or
not
what
yeah
open
to
feedback
I
am
supportive.
A
I
think
it
also
makes
sense,
it'd
be
good
to
know
what
the
work
ends
up.
Looking
like
I
think
I
know,
there's
a
lot
of
stuff
that
we've
talked
about,
that
is
view3
related,
and
this
has
always
seemed
like
a
blocker,
so
I'm
I'm
excited
to
see
that
it's
being
driven,
it
could
potentially
be
useful
to
like
I'm
boxes
like
the
working
group
looks
like
it's.
Gonna
exist
for
basically
the
year,
which
I
don't
know
if
that's
like
reasonable
or
not
like
I,
wonder.
B
That's
a
fair
concern:
what
I'll?
What
I'll
do
is
I'll
say
on
top
of
things.
So
what
I've
already
talked
with
status
live
is
there's
a
couple
of
things
he
already
seen
that
he
can
help
with
I'm
thinking
of
doing
sort
of
a
buffer,
each
Milestone
or
allocating
X
points
for
that
and
whatever
he
ends
up.
B
He
and
the
work
group
starts
out
for
being
picked
up,
will
fit
into
that
perfect,
but
we
still
have
the
rest
of
the
capacity
containers
left,
whatever
proportion
that
is,
if
he
has
like
two
weeks
vacation
then
ends
up
not
having
that
much
capacity.
Working
with
so
yes,
I'll
stay
on
top
of
things,
make
sure
that
it's
they're
relevant
and
they're
valuable
to
us.
B
It's
a
good,
but
all
in
all,
it
seems
like
status
letter
is
a
reasonable
engineer,
so
it
will
definitely
help
taking
the
right
work
and
thinking
well,
the
work
and
not
just
be
sacrificing
capacity,
so
I
feel
like
it's
going
to
be
safe,
but
I'll
stay
on
top
of
it
and
I'll.
Let
you
know
if
something's
changed,
we
can
always
raise
the
flag
later.
B
Okay,
thanks
guys,
yeah
thanks
for
putting
that
in
writing
the
next
one
okay.
B
So
this
is
sort
of
a
sharing
for
the
group's
awareness,
so
you've
all
probably
seen
the
Epic
that
Thomas
has
created
from
micro
code
review.
This
is
in
our
context
of
pursuing
crazy
ideas
and
trying
to
learn
from
them
and
the
ideas
that
maybe
we
can
extract
some
bits
of
this
experimentations
that
can
fit
are
hunt
for
performance
improvements
in
in
the
context
of
the
round
tables,
but
Thomas
has
ship
proof
of
concept
earlier
than
we
expected.
So
thanks,
Thomas,
oh
you're,
in
the
car
hi.
B
So
it's
already
you
can
already
play
around
with
it.
It's
definitely
restricted
it's
based
just
rendering
divs
of
the
of
the
apis
right.
Now
it
doesn't
have
comments.
It
doesn't
have
all
the
feature
Parry
that
we
need,
but
it
is
a
start
at
this
point
that
we
want
to
see
how
each
feels
and
essentially
it's
loading,
plug
the
data
from
the
end
from
the
public
API
to
indexeddb
and
then
rendering
it
off
there.
First
prioritizing
rendering
of
inboxdb
the
point
inside
cache
on
the
browser
so
yeah.
B
It's
definitely
there's
a
video
that
you
that
he
did
with
an
overview
of
the
architecture
how
it
works.
There's
a
little
bit
of
there's
a
snippet
document
about
the
caveats
right
now,
the
POC
there's
the
application
that
you
can
play
around
with,
but
just
I'll
walk
your
your
account
and
then
there's
a
code
and
the
feedback
issue.
So
the
ask
here
is
we're
going
to
be
discussing
this
on
the
round
table
we're
going
to
be
discussing
this
over
the
next
couple
of
days
to
brainstorm.
B
How
can
we
extract
value
out
of
this
into
our
code
base?
But
yes,
and
then
we're
going
to
have
a
probably
a
call
next
week
to
kind
of
like
actually
have
a
call
together
to
like
to
brainstorm
around
this.
This
thing
after
people
have
investigated,
so
they
ask
especially
For
Engineers,
is
to
take
a
look
at
the
code.
Take
a
look
at
the
feature
of
the
approach
and
just
share
your
thoughts
on
how
we
can
make
this
work
for
for
us
and
extract
the
value
out
of
this
okay
I'll.
B
Stop
there
any
questions
that
I
could
help
with
Thomas,
also
on
the
call
so.
A
Is
the
like
the
the
main
thing
in
here?
That's.
B
Also
the
lack
of
view,
so
basically,
this
is
not
a
view
app.
This
is
using
native
elements,
web
components
essentially
to
render
things
right
away
without
the
need
to
ramp
up
and
bootstrap
a
whole
library
to
get
things
on
the
page,
which
kind
of
aligns
with
the
expectations
that
status
lab
has
been
doing
for,
like
partial
server-side,
rendering
of
the
static
stuff
and
then
later
attacking
on
the
interactive
stuff
at
a
later
stage.
B
So
the
difference
here
is
instead
of
doing
server
side,
rendering
of
the
initial
part
we're
still
doing
it
on
the
front
end
not
effective
stuff
on
the
back
end
for
this,
but
it
is
essentially
a
different
implementation,
a
different
code,
though
so
it's
not
reusing
stuff
in
view
which
allows
us
to
be
much
faster,
putting
things
on
the
page
and
then
reusing
things
now,
of
course,
this
is
on
the
on
a
vanilla
page,
it's
the
empty
page
right
one.
Another
interesting
exercise
would
be.
B
How
would
this
look
inside
gitlab
right
with
all
the
the
Chrome
around
the
diffs
How?
Would
how
fast
would
this
be,
but
then
that's
also
relevant.
Then
we
can.
We
can
still
use
some
some
of
this
approach
to
like
kick
start
the
rendering.
B
As
long
as
then,
we
can
move
over
to
a
more
interactive
state
of
the
page
without
the
heavy
part
of
first
render
me
super
heavy,
as
it
is
right
now,
so
the
problem
we
have
identified
already
is
that
everything
in
the
page
is
reactive
and
it
doesn't
need
to
be
that's
where
standards,
love
and
Thomas's
research
aligns.
B
B
Yes,
so
this
is
the
stage
that
we're
in,
but
we
don't
know
exactly
how
this
is
going
to
take
shape
into
our
code
base
I've,
actually
theorized,
something
that
could
be
meaningful
to
you
by
the
one
way
that
we
can
take
a
value
out
of
this
experiment
is
to
bring
it
over
to
our
current
main
divs
app,
but
there's
also
possibility
of
us
building
something
on
the
side
as
a
light
version
of
code.
B
Reviewing
which
would
be
sort
of
a
sidekick
thing
like
more
simplified
version
of
merge
request,
but
I,
don't
know
if
that
makes
sense
from
a
perspective
of
products
like.
Would
that
even
be
something
that
we
would
ship
would
be
something
that
we
shipped
as
a
separate
project
like?
How
does
that
work?
B
So,
right
now
everything
is
pretty
pretty
early.
We
don't
have
any
implementation
of
this
sort
of
thing
on
gitlab
with
web
components,
so
that
would
still
be
for
debate
up
for
discussion
code,
but
we
need
to
find
the
value
of
this
approach
so
that
we
can
measure
these
things
and
extract
what
makes
sense
and
what
doesn't
make
sense.
B
So
that's
kind
of
where
we
are
right
now
we're
brainstorming
at
this
stage,
but
it
is
something
that
we
can
see
now
play
around
with
and
we
have
a
bunch
of
limitations
so
that
the
lines
are
not
given
line
by
line
in
this
implementation
they're
just
given
the
content
of
the
file
of
the
diff,
and
then
he
dumps
on
the
page
and
does
the
best
effort
of
highlighting
it
with
highlight.js,
which
is
definitely
not
production
ready.
B
However,
it's
an
interesting
flip
on
how
we
treat
the
diffs
at
this
point,
how
we
go
from
here
to
leaving
comments
online
questions,
something
that
we
have
to
start
off
but
yeah.
So
this
is
sort
of
like
a
very
early
on
stage
feedback
request,
because
this
might
Sparkle
other
conversations
that
could
be
useful
but
yeah.
A
A
This
after
we
just
talked
about
committing
50-ish
percent
of
someone's
time
to
view
three
like
how
are
you
rationalizing?
Those
two
two
things
I
think
is
an
interesting
like
sure
point
because,
like
if
you're
saying
like
oh
well,
we
built
this
thing
and
it
doesn't
use
View
and
then
you're
telling
me
like
I'm
gonna,
go,
send
an
engineer
to
spend
50
of
their
time
on
view.
Three
like
those
are.
Those
are
worth
like.
A
Like
how
the
thinking
around
that
works,
I
think
the
other
thing
that
you
mentioned,
which
I'm
do
you
want?
I,
don't
know
that
we
need
to
talk
about
that.
One
now,
like
I,
think
just
think
about
that
one,
because
I
think
that's
that's
an
interesting
conundrum
like
the
technology,
one,
that's
sort
of
interesting
to
me
that
was
you
mentioned.
You
mentioned
that
this
is
now
using
highlight
JS,
which
is
different
than
how
we
do,
which
is
the
same,
highlighting
that
we're
using
in
like
source
code
no
and.
A
That
feels
like
an
interesting
like
red
to
pull.
I
don't
have
like
more
thought.
It
feels
like
an
interesting
thread
because
I
know
we
saw
sort
of
like
substantial
performance
games
or
I
think
fairly
good
performance
gains
on
the
source
code
side
for
that
change,
and
so
I
think,
like
that's
an
interesting
one
to
think
about
here,
because
I'm,
pretty
sure
that
is
one
of
the
longest
lead
times
in
drift
generation
is
actually
like
going
back
to
do
the
highlighting
and
so
I'm
I'm
sort
of
curious
about
that
one.
That
feels
like
an
interesting.
B
About
this,
so
I
can
open.
I
can
open
take
that
one
first,
so
the
highlight.js
feels
good
in
the
high
on
the
proof
of
concept
level,
we've
seen
limitations
of
language
support,
but
also
highlighting
chunks
of
files
breaks
down
really
fast,
because,
if
you're,
if
your
chunk
is
in
the
middle
of
a
function
and
the
highlighter
is
not
able
to
capture
the
grammar
is
not
able
to
capture
that
it's
a
part
of
a
function.
B
You
can
start
to
break
down
the
highlight
and
we've
seen
that
with
python
files,
so
much
so
that
we
a
lot
of
language
files
on
the
blob
view,
is
being
Fallen
back
to
Rouge.
So
we
still
have
these
two
approaches
on
the
blog
page,
where
we
some
things
we
render
on
the
highlight.js
some
things
we
render
with
Rouge.
So
it's
not
fully
ready
for
something
like
replacing
the
diffs
that
we
have
right
now
or
sorry
see.
That's
highlighting
that
we
have
right
now
on
the
dips.
B
Which
is
also
so
one
of
the
things
that
we
can
that
we
have
to
talk
about.
If
we
push
this
forward
to
production
level
is
right.
We
have
the
blog
raw
file,
we'll
probably
need
a
way
to
get
the
additator
the
highlighted
blog
content,
but
also
per
line.
The
way
that
it's
performed,
which
goes
back
to
batch
diffs,
is
not
available
on
the
on
the
public
API,
for
example.
B
This
is
all
used
in
the
public
APK
endpoints,
it's
a
conversation
for
the
back
end,
but
we
might
need
to
tweet
some
endpoints
together
or
improve
the
ones
we
have
right
now,
or
maybe
it's
an
opportunity
to
introduce
graphql.
A
B
A
A
The
highlighting
matches
like
identical
the
whole
way
down
across
Ruby
graphql,
some
CSS
handle
like
everything
like
it,
feels
good
for
this,
and
so
like
I,
wonder
if,
like
I
know,
you
said,
there's
limitations
and
we're
falling
back,
but
like
maybe
this
is
one
of
those
like
80
20
things
where
like
in
most
cases
most
of
our
customers
actually
are
a
good
number
of
customers
are
covered
by
like
highlight
JS
and
would
see
significant
performance
benefits
and
then
like
in
cases
where
we
have
to
fall
back
like
those
discs
are
like
on
a
second
round
trip
or
something
right,
like
maybe
there's
a
path
there
that
like
that,
is
actually
worth
pursuing,
because
if
there
is
a
performance
benefit
to
that
like,
maybe
we
get
diffs
up
faster,
highlighting
pops
in
and
then
like
that.
A
That
feels
a
little
better
I
there
is.
There
is
differences
in
the
highlighting
like
the
it
is
not
as
complete
like
we
have
character,
highlighting
in
in
merge
request,
diffs,
and
these
are
like
whole
line
highlights
like
they.
Don't
do
just
the
thing
on
the
line
that
changed,
but
but
in
general
it
feels
good.
So
it'd
be
it
would
be
interesting
to
like
I,
don't
know,
keep
thinking
about
it
without,
like
like
fallbacks,
are
not
bad
like
if
we
cover
80
or
something
like
that's,
not
it's
not
unreasonable,
but
it's
something
to
like.
B
Sure
look
at
more
yeah
we'll
keep
that
in
mind.
So
going
back
to
your
other
question,
so
I'm
trying
to
find
the
agenda
and
then
have
it.
I
move
have
too
many
tabs
up,
but
right
found
it
yeah.
How
do
we
equate
betting
on
view
three
investment
and
then
talking
about
something
that
doesn't
use
view
at
all?
We
do
so
one
of
the
conversations
I
had
with
Thomas
yesterday
when
he
showed
me.
This
is
so
the
value
that
this
brings
is
a
very
quick
bootstrap
from
the
Native
level.
B
However,
I
don't
see
a
reality
that
we
can
give
away
View
support
So
at
a
certain
point
in
this
app.
You
will
have
to
inject
view
so
that
we
can
be
using
say,
suggestions
component,
the
markdown
components,
all
of
those,
so
the
the
code
quality
components
that
so
there
will
be
some
point
in
the
life
cycle
of
this
page
that
will
have
to
inject
View
at
a
certain
point.
It
just
won't
be
to
the
whole
page.
If
we
can
that's
where
view
3
and
view
two
make
a
difference.
B
For
my
conversations
with
stanislav
there's
a
couple
of
things,
we
cannot
do
in
view
two
especially
around
hydration,
that
we
can
do
with
u3
and
it
opens
up
I,
don't
know,
I,
don't
have
the
specifics
here
right
on
top
of
my
mind,
but
that's
where
it
still
makes
sense.
I,
don't
see
a
reality
where
gitlab
has
a
full
web
components,
diffs
app,
because
there's
so
many
things
around
it.
B
So
it
doesn't
really
make
sense
to
ideate
something
exclusively
without
view,
however,
something
hybrid
where
we
can
still
take
the
benefits
of
you.
Take
the
benefits
of
web
components,
get
them
together
and
and
build
something
really
performant.
That's
how
I
see
both
Investments
making
sense.
Does
that
clarify
that,
for
you,
okay,.
A
Yeah
I
think
it
makes
sense.
I
think
you
know
our
team
is
three,
so
we
should
just
be
mindful
of
how
how
spread
we
are
in
Technologies
and
asks
for
implementation
to
make
sure
we're
not
like
10
of
the
way
down
a
bunch
of
different
things.
That's
not
sure.
B
That's
a
fair
ask
one
of
the
things
we
also
talked
about
is
we
can't
just
introduce
something
into
the
code
base
without
scrutiny
from
outside
groups,
and
there
was
also
there
would
also
be
an
approach
of
like
evangelizing,
the
rest
of
the
company
to
like
hey.
This
is
a
great
way
to
leverage
this
technology
together
with
you,
and
how
can
we
make
the
current
code
based
marry
this
new
approach?
So
there's
still
a
bit
uphill
battle
for
this
in
in
something
like
this.
B
B
Like
I
said
at
this
point,
we're
just
wildly
exploring
and
we'll
see
what
we
can
extract
the
value
out
of
this
and
we're
prepared
if
nothing
makes
sense.
At
least
we
know
that
this
route
has
these
hurdles.
So
again,
it's
not.
The
only
thread
we're
exploring
status
live
is
exploring
partial
server-side,
rendering
streaming
on
the
blame
page
who
can
benefit?
So
that's
why
this
last
quarter
was
about
exploration
and
as
we
go
into
the
new
quarter,
we
want
to
start
shipping
the
improvements
out
of
this
explanation.
So
that's
part
of
my
API
comment.
B
B
Thanks
for
the
questions
guys,
that's
it
I,
don't
have
anything
else.
Thomas.
Do
you
want
to
add
anything
not
that
you're
at
the
computer.