►
From YouTube: WG Component Standard Meeting 20190212
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
B
C
C
A
C
A
2788
3
I
need
to
get
back
at
this,
but
it's
it
for
the
basic
and
what
it
does
creates
the
otherwise
a
package
for
all
component
configs.
So
we
can
have
this
one
way
of
saying:
I
want
to
be
coded
config
and
that's
using
the
the
things
we
want,
like
strict
sterilizer,
using
a
strict,
I'm,
Marshall,
ER
and
stuff
like
that,
and
eventually
it
also
can
handle
multiple
kinds
in
the
same
file
or
in
different
files.
A
B
A
D
A
Okay
by
me,
but
anyway,
this
moves
the
existing
flag
thing
we
have
inter
component
base
and
that's
the
first
step.
Basically,
we
need
to
take
so
this
dream
and
or
the
third
with
his
7277
8
is
also
my
table,
which
is
basically
adding
testing
some
of
the
components
configs.
So
this
this
is
dependent
on
the
first
arrow
as
a
package,
so
I'll
try
to
get
done
first,
the
coming
week.
B
The
the
motivation
for
this
is
that,
in
order
to
adopt
component
config,
what
you
typically
have
to
do
is
maintain
a
mapping
of
your
legacy
flags
that
people
were
using
to
configure
your
runtime
onto
that
configuration
so
that
you
don't
break
backwards
compatibility
and,
as
part
of
this,
you
also
have
to
ensure
that
flags
take
precedence
over
any
config
loaded
from
file
so
that
you
do
not
again
break
compatibility.
So
we
did
this
in
the
cubelet
and
there
are
all
kinds
of
sort
of
tricky
edge
cases.
B
We
ran
into
implementing
this
kind
of
thing,
and
that's
all
linked
in
that
version.
Component
configuration
file
stock,
which
is
linked
at
the
top
of
the
cap,
and
so
this
cap
kind
of
has
two
goals.
One
is
to
make
it
much
easier
to
implement
that
flag,
precedence
handling
the
other
one.
Is
that
there's
another
common
flag
related
case,
which
is
that
lots
of
third-party
libraries
also
register
flags?
They
tend
to
register
them
globally,
which
means
they
link
in
to
your
command
line
API,
whether
you
want
them
or
not.
B
B
B
B
B
B
D
B
A
D
E
A
A
Yeah,
so
with
regards
to
and
I'm
not
ago
that
ties
into
this
is
like
now
we
have
this
separate
global
flag.
We
have
flag
packages,
we
have
whatever
like
with
cave-like.
We
could
actually
wrap
them
all
into
one
package,
so
we
don't
have
to
have
like
I,
don't
know.
We
have
some
string
string,
Maps
and
customs
I.
B
B
D
A
C
A
A
A
A
A
A
A
A
B
One
one
thing
that
came
up
a
few
weeks
ago
was
the
question
of
how
will
eventually
make
these
configurations
sort
of
composable
and
I
think
the
main
question
there
was
like
we're,
combining
all
these
controllers
into
one
binary
like
do
you
really
want
to
type
out
the
client
information
for
every
single
you
want
to
enable
it's
not
versus
being
able
to
provide
it
once
so?
There's
there's
probably
an
in-between
step
here
after,
like
splitting
these
all
out
where
we
want
to
like
come
up
with
some
common
schema.
E
E
E
B
E
E
Yeah
and
then
that
gets
deserialized
separately
kind
of
behind
the
scenes,
and
then
all
the
other
controllers
that
are
currently
being
managed
by
this
controller
manager
also
get
to
register
their
own
specific
config
and
when
they,
when
they
do
that,
they
can
pull
back.
They
can
also
pull
back
the
common
config
and.
E
Well,
I
mean
that's
that's
kind
of
the
approach
we
take
in
controller
run
time
and
queue
builder.
We
have
this
idea
of
a
of,
like
every
controller
is
managed
by
a
controller
manager.
You
can
have
multiple
controllers
running
under
the
single
encounter.
A
controller
manage
was
the
thing
that's
responsible
for
doing
all
this
stuff,
like
setting
up
shared
informers,
setting
up
clients,
populating
discovery,
information
stuff
like
that,
and
then.
D
E
A
Yeah,
so
basically,
what
I
think
it
practically
would
look
like
the
sterilized
types
would
be
that
we
have
cube
controller
or
manager
configuration
which
has
this,
like,
whatever
generic
things
like
where,
where
to
serve
and
like
what
controllers
to
run
and
all
rest
config,
the
generic
one.
So
that's
one
kind,
and
then
we
have
one
kind
per
controller
in
the
external
types
and
in
the
internal
types
it
looks.
It
looks
exactly
the
same,
but
the
main.
A
E
A
E
A
C
A
A
That
will
be
built
into
the
serialize,
a
package
that
I'm
that
I'm
writing.
So
you
just
do
like
I.
Have
this
string
source,
let's
string
source
then
determines?
Is
this
like
comma
separated
list
of
files,
or
is
it
one
file
or
is
it
a
directory,
then
reads
the
stuff?
Then
when
reads
it,
it
splits
iam
documents
and
that's
all
this.