►
From YouTube: How CODEOWNERS functionally works today
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
A
I,
just
kind
of
wanted
to
talk
through
code
owners
a
little
bit
about
how
how
the
code
works
and
how
the
feet,
where
the
feature
sort
of
sits
right
now
in
terms
of
like
what
it
does
and
where
it's
doing
it
and
you
answer
any
questions
that
people
have
confusions
concerns
comments,
ideas
for
the
future,
all
that
sort
of
stuff,
I
scheduled
half
an
hour,
I'm
totally
happy
to
go
longer.
It's
the
end
of
my
day,
but
I
don't
mind
going
longer.
I
think
we
did
a
little
over
an
hour
this
morning.
A
We
don't
want
to
lower
the
bus
number,
but
the
more
that
we
can
do
that
like
this,
the
easier
it's
going
to
be
for
all
of
us
as
a
team
and
also
as
individuals
if
we
have
to
support
these
sorts
of
things.
So
if
I
go
off
on
my
another
wild
trip
up
to
Alaska
and
I'm
gone
for
three
weeks
and
the
problems
start
rolling
in
someone
else
can
can
dive
in
hopefully
so.
A
A
I
mean
it
especially
when
we're
working
hand
in
hand
with
you,
I
think
the
better
we're
gonna
be
so
the
corners
as
originally
conceived
was
meant
to
be
a
way
to
suggest
reviewers
for
a
given
path
right.
So
it
was
never
really
meant
to
be
sort
of
like
access
control,
but
as
we
rolled
it
out
and
we
brought
in
approval
rules,
more
and
more
more
more
users
were
depending
upon
it,
as
is
really
highly
flexible
access
control
for
controlling
during
change
management.
How
changes
were
coming
to
their
could
their
their
code
base?
A
That's
led
to
some
interesting
problems
as
we
try
to
apply
things
so
one
of
the
things
I
did
last
summer
was
we.
We
moved
code
owners
to
be
enabled
on
individual
protected
branches.
So
actually,
in
the
in
the
repository
configuration
section
you
can
go
in
you.
Can
you
can
individually
enable
like
whether
or
not
co-owners
are
applied
to
a
specific
protected
branch,
so
you'll
see
sometimes
in
the
code
or
add
we're
saying
like
hey,
is
this?
This
branch
is
this:
should
we
be
checking
code
owners
on
this
particular
branch
or
not?
A
And
that's
that's
where
that
goes
feeds
back
into
that
future
from
the
UI
it
was.
We
launched
that
originally
only
for
command-line
actions,
which
are
almost
entirely
push.
Events
right
like
get
push
to
a
certain
branch
up
on
the
service
and
one
of
the
validations
that
is
run
at
that
time.
Is
this
diff
check,
clasp.
A
Is
this
validate
code
owners
Shh?
Where
am
I
here
it's
right
here.
It
just
creates
this
new
validator
object,
which
is
a
recent
thing
that
I
added
in
this
last
week
and
then
runs
it.
There's
only
really
three
things
that
we
need
to
know
in
order
to
run
code
owner
checks,
we
need
to
know
the
project
and
the
target
branch,
and
then
the
paths
that
we
want
to
check
against
the
co-owners
file
code
owners
are
always
run.
A
We
always
use
the
version
of
the
code
owners
file
that
is
found
on
the
target
branch,
the
branch
that
were
attempting
any
changes
into.
Otherwise
somebody
could
could
including
a
changed
code
owners
file
in
their
their
commit,
and
then
that
would
be
I
mean
that's
ridiculous,
because
then
they
can
think
it's
set
that
to
be
whatever
they
want
to
do.
B
A
We
go
in
many
ways
and
all
that
it
really
does
helper
methods
and
loaders
aside.
Is
it
fires
up
Chris
and
activates
a
loader
object
and
then
what
the
loader
object
does?
Is
it
pulls
in
the
file
every
time
that
we
need
to
parse
code
or
rules,
we're
actually
opening
the
file
and
reading
it
into
memory?
A
That's
found
in
that's
kind
of
a
new
thing:
that's
going
to
come
out
in
3
1
if
or
3
2.
If
everything
goes
well
with
development,
the
sectional
piece,
but
that's
that's
all
that
really
happens
so
in
the
validator.
All
we
have
to
do
is
we
have
to
say:
do
we
have
any
entries?
What
entries
is
entries
are
any
did
any
entries
or
scuse
me
lines
or
definite
of
definition
in
that
cleaners
file
match
against
paths
that
we
we
sent
in
here?
A
A
A
Leggett
lab
code
owners
has
all
of
the
files
that
are
related
to
to
code
owners
processing,
which
is
really
really
handy,
because
you
know
anything,
you
have
everything
like
nice
and
tightly.
Control
like
that
is
really
great.
Also,
the
code
is
very
functional
and
stateless
in
this
way
that
it
always
loads
up
the
the
coders
file
andrey
parses
it
every
time
you
ask
you,
try
to
to
validate
a
set
of
paths
and
it
doesn't
make
any
sort
of
statements
or
shouldn't
make
any
sorts
of
statements
about
whether
it's
a
valid
action
or
not
it.
A
A
Take
a
look
at
the
loader
real,
quick
there's,
a
lot
of
like
little
tiny
convenience
methods
in
here.
It's
very
abstracted
and
simplified.
So
there's
a
lot
of
simple
complexity.
That's
going
on
in
here,
the
user,
loader
and
the
group's
loader
are
probably
the
most
interesting
parts.
Oh,
this
is
the
main
entries
method
just
step
through
it
fairly
quickly.
A
We
then
user,
loaders
and
group
loaders
will
loop
over
those
and
pull
out
the
exact
matches
and
the
exact
users
and
try
to
populate
those
entry
objects
to
fill
out.
Who
are
the
actual
owners,
not
just
a
user's
email
address
or
the
name
of
a
group.
But
who
is
behind
that?
What
gitlab
account
should
we
should
we
reference
as
an
owner
in
that
situation?
A
You
can
look
up,
users
can
be
referred
to
in
the
coders
file
by
their
user,
their
gitlab
username
or
their
email
address,
and
there's
a
tool
see
the
reference
extractor,
which
knows
about
how
to
parse
email
addresses
out
to
to
get
at
a
possible
username,
and
this
and
look
up
stuff
as
well.
Here
groups
are
a
little
more
complicated
because
groups
have
members-
and
this
is
where
we
got
into
some
issues
in
the
incident
from
last
month
and
I
think
mark
we've-
we've
had
a
little
bit
of
back-and-forth
of
this
as
well
of
like
what.
A
How
the
groups
work
is
we
look
at?
We
had
originally
only
created
this
list
of
groups
that
had
been
invited
to
the
project,
so,
if
you
specified
at
gitlab,
you
would
have
to
have
invited
that
group
a
tacit
lab
to
the
project
in
order
to
some
match,
because
what
the
group
loader
does
is
it
creates
this
list
of
groups
that
are
eligible
to
be
expanded
into
ownership.
A
A
Without
explicitly
having
invited
them
to
the
repository,
we
want
to
think
if
I'm
looking
back
and
reading
the
history
of
how
that
came
together,
there
was
a
desire
to
have
that
be
a
very
deliberative
act.
You
are
you're
actually
like
going
and
making
that
choice
to
invite
that
group
and
having
to
go
through
that
process
in
order
to
give
them
that
sort
of
ownership
and
control.
So
it's
a
two-step
process
on
that
we've
recently
added
I
think
something
you've
probably
seen
my
code.
My
frantic
trying
to
get
this
to
work.
A
A
Yeah
so
I
mean
that's,
that's
basically
it
it
takes
this
file.
It
pulls
out
the
paths
and
a
bunch
of
like
potentially
your
semi
random
identifiers
and
make
some
choices.
Who
are
the
identities
behind
these
people,
who
are
owners
and
associates
them
inside
of
these
entry
objects?
And
then
we
go
through
when
we
do
matches.
We
say
like
okay
for
each
path
that
I've
been
given.
Does
it
match
one
of
these
entry
objects
if
no
great,
no
violations?
If,
yes,
we
have
the
violation,
return
this,
this
error
message
string.
A
B
B
A
B
A
Needed
most
people
are
thankful
when
I,
muted,
I
think
that's
going
to
be.
That's
really
comes
down
into
the
the
group.
Loader
is
where
that
that's
going
to
happen,
but
it's
also
where
it
comes
down
to
group
membership.
The
user
has
the
membership
in
a
group,
isn't
transitive,
there's
no
inheritance
between
a
group,
a
subgroup
and
a
sub
sub
group
in
terms
of
who
we
expect
to
be
members
of
either.
So
if
we
have
three
groups,
we
have
a
route
group
of
a
a
sub
group
of
B
and
then
a
sub
sub
group
of
C.
A
You
can
be
a
member
of
any
one
of
those
three
without
being
a
member
of
anything
higher
in
that
chain.
Necessarily
so,
if
we
specify
that
group
B,
for
example,
owns
this
particular
code,
remember
users,
who
are
not
members
of
that
group
explicitly
members
of
that
group
will
not
be
matched
as
potential
Co
donor
approvers.
A
A
A
So
really
I'm
not
seeing
it
right
here
in
the
code
right
now,
but
what
we,
basically,
whatever
the
group
responds
to
when
you
ask
inquire
of
that
group,
object
dot
users,
who
are
your
users,
who
are
you
related
to
in
the
database?
Those
are
the
users
that
we
consider.
We
don't.
We
don't
then
like
walk
that
tree
up
or
down
to
try
to
pick
up
other
users
and
fan
out
across
the
hierarchy.
B
A
B
Alrighty,
hey
I
have
just
one
more
question:
I'm,
not
that
familiar
with.
You
know
how
the
group
meant
to
work
in
get
land,
but
if
they
are
not
like
inheritance
and
what
are
we
using
them
for,
like
organizing
in
our
groups
like
in
sub
groups
and
stuff,
like
that,
so
what's
the
benefit
of
having
that?
If
ye
are
not,
you
know
in
everything
anything
from
it.
A
A
But
if
you
think
about
it
in
terms
of
each
each
sub
group
should
be
a
subdivision
or
a
more
specific
subset
of
the
route
group.
So
the
route
group
is
get
left
out
of
work
or
get
a
lot
work
right,
and
so
each
subgroup
is
a
more
specialized
group.
So
get
lab
award,
slash,
finance,
slash
engineers,
then
we
might
have
slash
engineer's,
slash
source
code
right.
A
That
would
be
us,
so
it's
each
one
is
a
little
bit
more
specialized,
so
hierarchically
they
live
under
they
have
they
have
some
relationships,
I'm,
not
sure
entirely
what
benefit
that
has
in
terms
of
the
feature,
but
for
us
that
that
membership
isn't
necessarily
transitive
down
down
that
sub
tree.
It
might
certainly
be
up
the
tree,
but
it
doesn't
have
to
be
from
what
I've
seen
like
you
could
be
a
member
of.
A
A
A
Wrong
I
haven't
looked
at
it
entirely
deeply
again,
because
the
food
code
owners
is
really
kind
of
where
I've
been
interacting
with
groups
in
depth
for
the
first
time
and
I'm
really
I'm.
Only
caring
about
like
I've,
only
really
cared
about
like
who
are
the
members
of
these
groups
and
then
understanding
that
the
way
that
the
way
that
our
users
are
interacting
with
groups
is
to
think
about
them
in
that
sort
of
subdivision
level,
like
a
military.
B
A
B
Guess,
like
I,
understand
that
if
you
are
a
member
of
B,
that's
more
specific
to
a
so
I
guess
that
pod
makes
sense.
But
if
you
are
a
member
of
like
B,
when
you
specify
the
code
of
the
role
for
a
then
you
don't
get
to
be
included
in
that
list.
That
sounds
with
it.
You
know
it's
strange,
but
I
guess
they
must
reasons.
Oh.
A
Yeah
I
mean
it's,
it's
really
like
it
might
be
something
we
we
want
to.
We
want
to
dress
in
and
again,
I
might
be
entirely
wrong
and,
as
I'm
saying
it,
I'm
like
this
doesn't
sound
right.
Carrie
you've
got
to
be
wrong
because
it
doesn't
make
any
sense
to
me
so
I
take
that
take
what
I
just
said
with
a
grain
of
salt
around
membership.
Why
not
I
just
want
to
draw
your
attention
briefly
to
this
here
when
we're
looking
at
like
members
or
an
entry.
So
this
is
the
entry
model.
A
A
A
I,
it's
confused
me
and
like
every
single
person,
who's
worked
on
this
in
the
last
few
weeks,
as
we've
tried
to
work
on
these
problems,
we
all
get
to
a
point
where
you
just
like
wait,
a
minute
hang
on.
How
does
this
work?
What
is
the
relationship
here
between
these
different,
these
different
concepts
and
objects?
A
It
doesn't
doesn't
rely
on
them
already
understanding
these
these
concepts
right
so
like
how
does
co2
there's
work?
How
can
you
use
it
for
access
control
and
effective
way?
How
does
it
relate
to
path
locking
like
when
what
situations
would
you
want
to
use
one
or
the
other,
and
and
the
more
that
we
can
understand
that
story
and
how
that
story
of
the
feature
merges
with
what
our
users
want
to
do?
A
B
Okay,
question
I'm,
not
sure
if
you're
going
to
show
it
to
us,
English
class
smells
like
what
are
other.
What
are
the
other
like
entry
points
to
close
owners,
I
mean
you
mentioned
earlier
that
we've
gotta
decode
owners
by
live
check.
So
what
what
are
other
enterprise
Nick
I
know?
We
use
code
owners
for
approval
rules,
but,
aside
minute,
what
are?
What
are
the
other
things.
A
A
A
The
trigger
diff
tech
there's
really
only
one
one
of
that,
and
that
is
when
the
git
server
receives
a
get
receive
pack
event
and
then
that's
whenever
you're
doing
basically
a
push
or
a
merge,
I
think
there's
some
other
there.
Some
other
get
events,
but
those
are
the
main
two.
Ninety-Nine
percent
of
get
actions
funnel
through
that
this
this
particular
set
of
checks
that
works
fine
for
the
command
line
when
people
are
just
doing
get
push
because
you
never
do
a
git
merge
from
the
command
line
that
almost
never
happens.
A
A
I,
don't
I,
don't
know,
that's
a
good
question
for
me
to
find
out.
That's
not
that's,
not
a
piece
of
gate.
I've
ever
tried
to
do
I've
done
some
weird
things,
but
not
that
one
so
so
that
works
that
works
great
for
this.
Some
of
the
problems
we
had
recently
where
we
tried
to
enable
this
for
for
web
events-
and
you
can
actually
see
here
in
diff
tech
on
line
23.
A
We
do
a
check
here
for
to
update
your
firmware
because
we
don't
want
web
events
to
be
funneling
through
this
code,
because
web
events
are
not
just
pushes
to
branches,
but
it's
also
merge
events,
because
the
server's
receiving
this
pack
of
new
data
that
it's
gonna
try
to
write.
We
don't
want
that
running
through
here,
because
there's
a
lot
of
automated
processes
and
there's
no
reason
to
to
stop
an
action,
that's
happening
when
it's
already
been
approved.
A
A
A
Just
search
for
code
I
just
act
for
code
owners
like
oh
yeah.
That's
that
file
I'll!
Remember
it
this
time.
For
sure
this
is
a
little
service
class
and
what
it
does
is
when
something
changes
about
that
about
the
merge
request,
I
think
every
single
time
it
goes
in
and
it
deletes
all
of
the
existing
code
owner
rules
or
all
the
existing
approval
rules
and
sets
up
new
ones.
B
Karen,
do
you
know
if
we've
covered
the
known
cases
where
the
coder
and
his
file
wasn't
dated,
or
at
least
wasn't
read
again
in
the
context
of
an
mr,
and
so
you
could,
for
example,
change
a
rule
in
the
target
branch
in
an
NR,
that's
already
open
and
it
wouldn't
apply
that
rule.
When
you
tried
to
merge,
and
so
you
could
merge,
NMR
that
isn't
consistent
with
an
updated
rule
that.
A
B
A
A
Do
know
that
that
when
we,
if
you
go
into
the
repository
settings
and
you
disable
and
then
re-enable
code
owner
code
under
rules
on
that
protected
branch,
it
will
recreate
them
at
that
time.
So
I
mean
you
could
I
mean
I
I
know
that
there's
we
manually
do
it
there,
but
I
honestly,
don't
know
what
happens.
I,
don't
know
if
we're
tracking,
if
we
spot
a
chain
change,
that's
coming
in
to
the
code
owners.
If
we
then
go
and
we
create
all
the
rules
for
all
of
the
open,
em
ours
or
not.
B
B
A
A
Just
an
idea,
and
then
we
can
write
it
down
or
not.
I
don't
know
we
might.
We
might
want
to
be
able
to
want
to
capture
the
SHA
of
the
the
applicable
version
of
the
code
owners
when
we
create
the
rule
and
then
just
do
a
quick
comparison
before
merge
to
sort
of
say,
hey
the
approval
rules.
Look
or
like
is
everything
up
to
date.
Has
this
changed
since
we
had
approval
the
same
way
that
when
you
change
in
mr
it
will
you
can
set
it
so
that
it
will?
B
A
Because,
like
the
change
might
not,
the
change
might
not
affect
your
mr
right,
like
if
I
changed
a
typo
in
my
name,
but
it
was
for
a
rule
for
a
completely
different
part
of
the
codebase.
There's
no
reason
to
go
regenerate
those
rules
for
everything
it
should
only
apply
to
the
ones
that
you
know
are
open.
So
just
do
it.
I,
don't
know
like
we
could
throw
up
a
little
a
little
button
or
something
that
says
hey.
You
know
we
have
to
or
I
don't
know.
A
B
A
A
A
lot
of
them
there
is
a
lot
of
them,
I
mean
beef
and-
and
that
gets
back
to
that
history,
that
I
mentioned
up
front
and
I
don't
mean
to
apologize
for
it.
I
would
never
apologize
for
it
right
buddy,
but
it
was
intended
as
code
reviewer
suggestion
and
so
I
think
that's
kind
of
in
the
back
of
our
mind,
it's
kind
of
been
that
way
as
a
very
lightweight
access
control
that
people
are
actually
relying
on
it
and
they're
doing
some
really
intricate
things
with
it.
A
Yeah
says
that
that
evolutionary
complexity
has
bit
us,
and
so
there's
gonna
be
there's
going
to
be
some
stuff
and
we're
going
to
somewhere
still
gonna
see
stuff
moving
into
the
future.
I
think
it
will
never
be
perfect.
At
the
same
time,
Wow
people
actually
use
this
feature
right,
like
how
cool
is
it?
How
cool
is
it
to
work
on
something
that
when
you
break
it,
people
actually
care
like
that?
That's
kinda,
that's
kind
of
a
good
feeling,
I
mean
not
to
not
to
get
to
Pollyanna,
sure
or
silver
lining
about
it.
Then
yeah.
A
All
right:
well,
we
are
just
a
little
bit
over
time,
but
if
you
have
any
other
questions
or
thoughts,
concerns
ideas
feel
free
I
mean
to
to
drop
them
an
issue
or
at
me
or
at
the
group
and,
of
course,
there's
an
epic
for
improving
code
runners
that
has
a
whole
bunch
of
different
ideas
in
it.
I
haven't
looked
at
it
in
a
little
while
I
really
look
at
it
when
somebody
put
something
new
in
it,
but
I'll
try
to
find
it
and
drop
it
into
the
sock
channel
next
couple
days.