►
From YouTube: GitHub Quick Reviews
Description
Issues Discussed:
* dotnet/winforms 5069: Introduce ApplyApplicationDefaults Event to the Application Framework
https://github.com/dotnet/winforms/issues/5069
* dotnet/runtime 31274: We should be able serialize and deserialize from DOM
https://github.com/dotnet/runtime/issues/31274
* dotnet/runtime 48615: Add blittable Color to System.Numerics
https://github.com/dotnet/runtime/issues/48615
Chapters:
0:00:00 Introduce ApplyApplicationDefaults Event to the Application Framework
0:28:29 We should be able serialize and deserialize from DOM
0:41:34 Add blittable Color to System.Numerics
A
B
B
C
C
C
E
C
The
default
font
has
changed
from
that
framework
to
the
core,
and
now
it's
going
to
change
again
since
windows,
11
isn't
introducing
a
new
system-wide
default
font
and
the
problem
is
that
user
controls
and
forms
that
have
been
or
that
are
migrated
from
classic
framework,
often
have
designed
pixel
perfect
and
in
migration
scenarios.
Customers
have
already
complained
that
they
don't
have
the
time
to
read
out
redo
layouts
of
forms
at
once.
C
C
We
want
to
do
that
in
the
same
matter
as
visual
basic
did
that
already
like
with
so
with
application
events.
We
already
have
a
couple
software
of
a
couple
of
them
like
startups
startup
next
instance,
network
availability,
change
and
stuff
like
that,
and-
and
that
is
the
reason
we
wanted
to
to
introduce
a
new
event
where
we
can
set
all
those
things
and
all
the
things
that
will
most
probably
come
in
the
future
in
that
in
that
style.
If
you
will
that's
the
that's
the
a
bigger
picture
of
that.
C
Yes,
yeah,
that's
inherited,
but
it's
it's
done
in
in
kind
of
a
black
box,
visual
basic
six
style.
Synth
is
still
so.
You
don't
really
see
the
generated
code
until
you
explicitly
set
that
up
in
the
solution
explorer
and
that's
also
the
reason
we're
good
yeah.
We
basically
want
to
hide
a
couple
of
things
like
it's,
something
that
that
I
think
is
not
reflected
yet
in
the
in
the
change
I
need
to.
C
I
need
to
amend
that
is
the
high
dpi
mode,
for
example,
that
that's
going
to
be
generated
by
the
project
system
will
have
the
editor.
What
is
it
visibility
network
or
something
as
an
attribute
on
it,
because
we
don't
want
to?
We
actually
don't
want
the
user
to
to
set
those
things
in
the
base.
Class
windows
forms
application
based
directly.
C
Those
things
should
exclusively
be
set
with
the
application
events,
so
part
of
those
things
are
infrastructure
that
we
need
so
that
project
system
can
actually
generate
the
code
that
we
want
to.
You
know
expose
in
the
ui
in
long
term
by
the
way
we
want
to
change
that
application
framework
stuff
completely
and
go
in
parity
with
c-sharp.
But
for
the
time
being,
we
cannot
do
that.
You
know
as
quickly
as
in
c-sharp,
because
there
for
visual
basic.
C
C
Yeah,
so
so,
basically,
the
application
framework
has
a
couple
of
settings
that
we
need
to
extend.
These
are
those,
and
those
settings
are,
are
then
going
into
something
that's
hidden
in
the
solution
solution
x
pro
by
default.
If
you
do
show
files,
then
you
will
see
there
is
there's
a
file
called
application.myapp
where
all
these
things
are,
you
know,
got
collected
from
the
ui,
and
this
is
the
base
for
actually
generating
code.
C
So
if
you
see
here,
there's
a
custom,
my
application
code
generated
behind
that
which
actually
generates
that
code
and
then
that
results
in
an
application.designer.pb
and
this
one
is
actually
the
thing.
It's
only
a
partial,
defined
class
at
this
point,
because
the
compiler
does
some
magic
in
the
background.
Also,
in
addition
so-
and
and
this
is
basically
the
my
application
is
the
is
the
is-
the
inherited
class
of
windows
forms
application
base
and
then
those
things
get
collected.
C
C
We
want
to
do
in
the
future,
and
it
will
just
be
that
thing.
That's
going
to
be
extended,
and
this
is
this
is
the
style
visual
basic
has
done.
Setting
those
you
know
startup
behaviors
from
from
day
one
yeah,
and
this
is
why
we
picked
up
that
thing.
So
there
is
no,
there
is
no.
In
the
whole,
you
know
basic
application.
There
is
no
program.vb
where
you
could
do
that
stuff
and
so.
D
C
D
D
D
C
Yeah,
okay:
this
is
something
that
actually
is
set
because
it's
it's
in
the
in
the
generated
code.
It's
used.
It's
got
to
be
set,
so
a
single
instance
is
said.
Enable
visual
styles
is
set,
but
this
is
nothing
that
that
is
that
is
supposed
to
get
exposed
directly
and
well.
To
be
honest,
I
I
would
like
certain
things
to
be
differently
now
already,
but
we
were,
depending
on
project
system,
to
provide
the
ui
for
the
settings
we
need,
like
you
know,
setting
the
fonts
or
setting
the
high
dpi
mode.
D
So
basically,
what
you're
saying
is
that
things
that
are
get
set
are
logically
things
that
are
recorded
in
this
myapp.xml
file,
that
the
designer
effectively
writes
down
and
then
the
generated
code.
Does
it,
but
there's
no
expectation
that
the
user
does
it
effectively.
So
for
things
that
the
user
is
supposed
to
write
in
code,
the
pattern
is
there's
an
event.
There's
event
arcs
and
you
set
those.
C
Even
you
know
take
more
of
those
those
properties
that
have
been
set
by
the
compiler
generated
code
and
move
them
more
into
the
application
events
to
expose
them
there
and
then,
at
the
same
time
go
with
a
different
application
framework
ui.
If
you
will
so,
we
can
have
parity
to
c-sharp.
At
one
point,
that's
the
plan.
D
C
I
would,
I
would
say
it's
just
not,
you
know
it's
it's
just
me.
It
doesn't
do
any
harm
if
it
is,
if
it
is
shown,
so
the
event
wins,
because
that's
the
thing
that
is
that
is
processed
last.
If
you
will,
even
if
you
set
the
high
dpi
mode,
it
wouldn't
do
any
harm,
it's
just
that
it
would
not
be
clear
what
wins.
C
So
if
you
do
both,
if
you
derive,
I
mean
you're
ready
to
derive
my
winforms
application
base,
but
if
you
would
overwrite
on
initialize
and
then
set
the
high
dpi
mode
there
and
then
do
other
settings
even
if
they
don't
pop
up
in
intellisense,
then
it
would
work
and
then,
if
you
then
handled
the
event
in
addition,
well,
then
those
different
settings
would
just
win
and
get
applied
in
time.
It
wouldn't
do
any
harm.
C
D
D
C
B
C
D
C
D
C
D
A
C
Just
to
be
consistent,
and
also
I
have
one
yeah,
one
thing
I
also
want
to
address
is
the
is
the
you
know,
using
the
delegate
with
a
generic.
We
had
problems
in
the
past
with
the
editor
if
we
had
and
if
we
had
event
error,
arcs
based
on
based
on
a
delegate
that
used
generics
like
event,
args
off
and
then
the
certain
type,
because
then
it
got
inserted
in
the
wrong
format
and
it
was
screwed
up.
C
D
D
To
declare
delegates
every
single
time,
we
need
some
new
event
arcs,
but
given
that
this
is
what
vb
has
already
done
in
that
namespace
and
if
you
look
at
the
namespace
there's
already
a
ton
of
those
guys
in,
I
personally
don't
care
like
I
I'm
I'm
fine
with
saying
it
just
follows
the
existing
pattern.
There's
one
more
delegate
handler
in
there
and
it's
yeah.
C
D
B
I
mean
I
I
feel
like,
so
we
don't
do
events
anymore.
This
is
you
know
the
first
event
that
we've
added
okay,
it's
one
of
at
most
10
events,
we've
added
in
the
last
like
three
years,
but
I
certainly
would
have
thought
that
the
generic
event
handler
would
have
been
tested
with
you
know
like
the
the
vb
nc
sharp.
D
C
C
It's
probably
not
something
that
my
point
is
that
I
assume
that
it's
gonna
work,
but
I
remember
that
I
had
cases
and
I
have
no
idea
when
that
was
where
it
was
not
working,
I'm
just
remembering
them.
I
cannot
put
them
really
in
a
time
frame.
My
concern
is
sure
that
the
lack
of
time
to
thoroughly
test
it.
C
I
would
rather
you
know,
refactor
the
whole
thing
and
be
up
to
date
with
it,
but
then
I
really
need
to
have
the
time
to
test
that
and
we
don't
have
so
much
resources
for
visual
basic
anymore,
but
this
is
really
important
to
get
in.
I
mean
still
like
so
many
percent
of
our
customers
are
vb
and
it's
really
important
for
open
forums.
B
Right
so
I
think
the
the
request
would
be
just
so
that
we
can
make
sure
that
we're
doing
the
same
thing
everywhere,
going
forward
that
someone
somewhere
pretends
to
commit
to
testing
using
a
generic
with
this
kind
of
thing.
Not
for
this
feature.
But
you
know
between
now
and
when
the
next
one
comes
along
and
hopefully
the
next
one
doesn't
come
along.
C
Days
before
I
would
actually,
I
would
actually
be
volunteering
to
test
that,
and
but
at
the
point
where
I
have
a
little
bit
of
time
to
do
that
and
then
I
would
also
consider
you
know
see
what
we
can
refactor
and
when
we,
when
we
get
to
a
point
where
we
can
introduce
the
feature
that
the
vba
framework
becomes,
you
know
parity
with
c-sharp,
then
I
think
we
have.
We
really
would
have
the
chance
to
do
that,
and
it's
not
that
much
of
an
effort.
It's
just
you
know
it's.
B
C
But
this
is
this
is
important
because,
as
I
said,
the
font
setting
is
really
what
what
what
customers
need.
Also,
because
that
now
windows
11,
is
really
changing
the
font
and
it
screws
up.
So
many
things
in
the
in
the
layouts
of
wind
farms
and
and
so
we
need
a
yeah
short-term
solution.
Without
really,
you
know
having
a
a
block
then
down
the
road.
D
C
Well,
yes,
I
mean
so
you
used
to.
I
mean
the
document.
The
the
docu
says
that
you
used
to
had
to
override
uninitialized
and
then
you
would
be
able
to
set
the
minimal
splash
screen
display
time,
and
this
is
just
terrible
for
for
vb,
and
that
was
that
was
an
integer
already,
but
I
I
don't
see
any
any
reason.
You
should
do
that.
C
D
Yeah,
I
honestly
think
it's
easier
to
explain
if
you
just
say
this
is
just
mirroring
the
existing
property
on
the
type,
so
it
has
the
same
name
and
same
type,
so
I
would
just
go
with
an
end
at
that
point,
because
yeah
I
mean
it's
just
easier
to
explain
to
people.
I
think,
like
I,
I
mean
in
general,
every
introduce
new
apis.
C
D
C
D
B
D
C
F
B
B
E
D
E
D
E
E
D
D
D
E
E
D
D
E
No,
we
haven't,
I
think
I
mean
the
advantage
of
doing
it.
This
way
is
that
you
can
use
either
syntax,
so
it's
discoverable
from
either
json
sterilizer
or
from
the
instance.
If
we
want
to
force
people
down
a
particular
path,
then
we
would
probably
just
move
these
on
to
the
corresponding
type
and
make
them
you
know
static.
E
E
D
Yeah,
I
am
basically
just
copied
with
the
customer
role
like
I
did
not
design
anything
like
the
the
sample
code
that
was
in
my
proposal
was
just
taken
straight
from
the
customer
and
I
think
they
did
it
as
extension
methods,
but
that
doesn't
necessarily
mean
that
we
should.
I
mean
I
mean
I
don't
have
strong
feelings.
It's
just
looking
on
the
other
methods.
We
don't
really
have
anything
today
over
the
dom
right.
D
D
I
don't
have
strong
feelings
here
I
mean
I
can
see
the
video
on
them
being
extension
methods,
because
I
think
once
you're
on
a
dom,
it's
not
insane
to
assume
that
they're
extension
methods
there
or
you
know
at
least
that
you
can
dot
into
them,
because
the
whole
dom
is
basically
dottable
right.
But
I
also
have
no
objections
saying:
let's
make
them
statics
and
everything
that
does
serialization
starts
with
json
seal
as
a
dot.
B
Yeah,
I
have
so
you
know
in
the
in
my
feelings.
It's
I
have.
No,
I
think
it's
good
that
they're
just
overloads
to
deserialize,
so
it's
the
existing
methods
following
the
existing
patterns,
the
the
this
attribute,
I
think
it's
mildly
unpleasant,
but
I
understand
that
there
are
some
people
who
would
like
it
and
since.
G
G
E
E
F
G
B
B
H
So
the
initial
motivator
for
this
was
the
reason
I
opened
this
to
begin
with.
Was
you
know,
there's
you
know,
system
drawing
color
is
not
an
exchange
type
or
like
it's,
not
the
it.
It
contains
the
raw
data
that
windows
uses
for
color,
but
it
has
additional
stuff
on
it,
which
is
explained
up
there
that
you
can't
really
use
an
array
of
colors
to
represent.
H
Drawing
color
to
convert
to
that,
and
the
idea
here
would
be
that
we
would
build
off
of
these
based
on
customer
needs
and
hopefully,
over
time
we
can
kind
of
move
people
out
of
the
system,
drawing
space
which
we've
already
had
that
other
proposal
coming
up
to
to
sort
of
depreciate
the
unix
support
for
the
non-basic
stuff
right.
So
it
ends
up
being
one
of
the
reasons
that
people
pull
in
system
drawing
at
all
was
just
to
get
the
color
type,
but
point
and
point
and
rector,
the
other
things
too.
H
I
I
was
going
to
say
the
the
original
concern
was
that
we
were
going
to
be
adding
new
types
to
system.drawing
and
system,
drawing
wouldn't
be
the
thing
moving
forward,
and
so,
if
we
ever
decided
to
add
proper
color
types
in
the
future,
you'd
have
people
being
like.
Do
I
use
system
drawing
colors,
or
do
I
use
this
other
colors?
This
resolves
the
problem
by
saying
system.
D
I
guess
I
still
don't
understand
how
this
prevents
the
bifurcation,
because
I
mean
you
can
say
that
yeah
there's
a
new
type
and
it's
the
thing
moving
forward.
But
everything
we
have
in
wind
forms
in
wpf
doesn't
deal
with
any
of
those
types
and
we
can't
change
what
they
are
having
right,
because
there
will
be
a
massive
breaking
change
in
both
wind
forms
and
wpa.
H
That
we
have
that
are
coming
in
for
performance
reasons
which
talks
about
some
of
these
things.
Some
of
these
are
like
we
do
take
arrays
of
colors
in
a
few
places
could
be.
We
could
take
spans
of
this
stuff.
That's
just
the
what
we
need
the
data
for,
and
you
know
we
don't
burn
things
over.
We
can
get
things
back
for
new
apis
and
because
it'll
implicitly
convert
to
color.
Then
you
can
use
it
and
you'll
be
fine
with
it.
J
J
H
The
other
purpose
of
this
thing
is
also
to
do
for
our
own
internal
purposes
and
other
people's
purposes.
To
like
do,
you
know
for
for
me,
specifically
with
the
forms
that's
doing
interop,
it's
it's
easy
to
mess
this
up,
because
everybody
has.
You
have
to
define
this
thing
yourself
and
just
you
can
make
them.
You
can
make
a
mess
and
not
realize
it.
You
know
and
like
controlling.
This
is
a
little
bit.
D
Is
that
like
if
we
have
sufficient
api
service
that
would
deal
with
that
type
right
and
so
like
lacking
that
I
don't
think
the
type
is
useful
enough
as
a
as
a
as
an
interrupt
mechanism
at
that
point,
I'd
rather
have
it
private
in
with
forms
or
wherever
we
need
it
right.
If
we
like,
I
mean
once
we
once
we
actually
have
api
service,
that
motivates
this
thing
being
an
exchange
type.
D
I
D
I
So
image
sharp
wouldn't
benefit
from
this
type
and
the
reason
that
james
downvoted
it
to
my
understanding
is
because
the
color
and
the
color
space
stuff
is
hard,
and
so
the
general
thing
of
having.net
expose
all
trying
to
expose
something
like
wick,
where
it
supports
all
these
image
formats
and
everything
else
it.
It
basically
would
invalidate
image
sharp
existing
existing
because
then
you
have
everything
built
in
and
and
that's
not
something
that
that's
the
goal
of
this.
Instead,
you
should
think
of
these
color
types
as
primitives.
I
They
are
specifically
not
what
wpf
or
winforms
use,
because
what
wpf
and
winforms
use
is
a
primitive
plus
a
ton
of
other
metadata
that
they
use
to
interrupt
with
the
brushes
and
the
resource
systems
and
everything
else
that
they
have,
and
so
these
are
functionally
like
in
32.
They
are
the
color
primitive
types
on
which
you
can
build
the
other
types,
and
in
this
initial
proposal
they
are
basically
literally
just
wrapper
types
around
the
raw
data.
B
B
H
Yeah,
like
you
can
use,
like
other
you
know,
vector
stuff,
to
do
the
to
to
exchange
the
data
around
the
problem
is
getting
the
you
know
like
having
having
the
each
of
your
fields.
Be
specifically.
Typed
is
super
important
for
this
because,
as
you
can
see,
the
order
is
different,
depending
on
what
you're
getting
the
color
data
in
and
out
of
you
know,
the
argb
is
what
windows
has
been
using
for
its
stuff
in
the
historically
in
what,
when
forms
is
you
know,
gdi,
plus
and
gdi?
D
I
mean
I
don't
know
like
to
me
it's
hard
to
motivate
new
api
servers
for
gdi
hdi
plus,
I
think
if
this
type
would
be
useful
for
let's
say
maui
or
something
else
we're
doing.
I
think
that
would
warrant
the
public
type
much
more.
Otherwise,
it
would
just
say
yeah
define
a
private
type
inside
of
those
assemblies
right.
That's
the.
C
I
Any
graphics,
libraries
out
there
they
could,
if
they
want
to
and
deem
it
useful
use
this
as
the
primitive
building
block
and
know
that
it
has
before
that
it
is
performance
oriented
in
that
it
is
not
opinionated
in
its
design.
It's
basically,
if
you
want
a
rgb,
you
get
literally
a
rgb
where
every
field
is
a
t
and
it
performs
the
basic
operations
for
you
accelerated
if
possible.
D
I
understand
that
you
could
I
mean,
but
what
I'm
trying
to
say
is
like,
unless
there
is
a
plan
that
it
does,
I
don't
think
the
type
pays
for
itself,
because
basically
you
have
a
type
now
that
somebody
could
be
using,
but
nobody
is
using
right.
So
that's
the
like
to
me
the
only
value
of
adding
this
type
is
if
it
does
become
an
exchange
type.
If
it's
not
an
exchange
type.
It's
just
yet
another
thing
that
you
can
do
throughout
the
interval
player.
D
D
You
have
to
reach
out
to
them
and
make
sure
that
people
buy
into
this
design.
Right
to
me,
the
validation
of
this
thing
is
like
is
the
is
the
shape
that
the
libraries
have
sufficient
right
and,
like
the
one
library
that
does
image
processing
that
is
really
you
know,
advanced,
doesn't
think
this
type
is
useful,
and
I
understand
what
tenor
was.
I
I
think,
regardless
of
that,
it
fits
well
within
the
realm
of
what
the
student
numerix
exposes
it
and
it
fits
in
with
how
the
other
types
like
vector,
2,
3
and
4,
get
used
vector,
2,
3
and
4
are
interchange
types
and
they
get,
but
most
libraries
don't
use
them
directly.
They
use
them
internally,
sometimes
wrapping
their
as
the
as
the
backing
field
for
their
own
types
and
they'll
convert
between
them
for
performance
reasons,
but
they
don't
expose
it
to
the
users,
and
so
it
ultimately
becomes
a
libraries
aren't
going
to
use
this
type
directly.
I
Not
quite
because
it
so
yes
and
no
it's
it's
similar
to
vector
four
in
the
same
way
that
a
quaternion
is
also
a
vector
four,
like
ninety
percent
of
the
code
between
a
quaternion
and
a
vector.
Four
is
the
same
for
for
the
primitive
operations,
but
then
there's
some
additional
operations
that
are
different
and
you
actually
want
that
strong
typing
to
differentiate.
I
You
actually
want
to
know
this
is
a
rgb
and
not
potentially
bgra
or
rgba
or
hslv,
or
some
other
format.
You
want
that
strong
typing
to
know
this
is
specifically
this
layout
of
color
information
and
as
it
is,
it
exposes
the
two
common
color
formats
that
basically
every
library
supports
and
gives
us
room
to
expose
others.
If
users
request
that
in
the
future.
D
Yeah
I
mean
like,
as
I
said
like
I'm,
not
opposed
to
that,
but
but
I
guess
my
question
is
like
who's
asking
for
this.
Besides
us
like
is
there
customer
evidence
that
suggests
that
if
we
expose
this
type,
it
would
become
an
exchange
type?
Was
it
just
something
that
we
find
useful
and
we
could
imagine
it
becomes
an
experiment.
B
H
B
Would
it
alleviate
your
concerns
if
we
say
that
you
know
when
we're
done
with
this,
if
we're
happy,
with
the
shape
that
it's
approved,
provided
we
find
some
use
for
it
before
we
ship
like
this
is
marked
for
seven.
So
we
have,
you
know
a
year
to
figure
out
now
that
we
have
the
thing.
Where
would
we
want
to
use
it?
B
I'm
like.
I
feel
that
previously
I
felt
like
there
was
a
justified
need
for
it
and
that
I've,
so
I've
just
carried
the
feeling
into
us
looking
at
it
again,
so
I
feel
like
once
we
have
it
that
there
are
things
that
you
know.
Tanner
alluded
to
issues
that
have
been
punted
on,
because
there
wasn't
a
good
way
to
solve
them,
and
but
I
don't
think
we
want
to
look
at
like
an
entire.
B
B
D
Yes
and
the
other
it's
kind
of
like
the
the
problem
is
the
inverse
right.
Like
you
like
on
the
one
inside,
you
can
just
look
at
these
types
and
say:
do
they
have
the
right
shape
but,
like
the
validation,
isn't
the
things
that
it
interoperates
with
right
like?
Does
it
have
the
right
shape?
Does
it
have
the
right
naming
that's
hard
to
judge?
If
the
only
thing
I
have
is
this
right
right.
I
I
D
I
D
D
D
D
So
like
by
the
way,
I'm
not
saying
absolutely
not
right,
all
I'm
saying
is.
I
think
I
want
to
just
see
more
evidence
that
if
we
do
this
stuff
is
happening
right,
and
so
that's
why
I'm
saying
I
mean
before
we
before
I'm,
I
guess
I'm
willing
to
approve
it.
I
would
say:
have
we
reached
out
to
people?
Have
we
have
we
circulated
this?
Have
we
socialized
this?
Do
we
think
there's
enough
meat
behind
that
to
make
that.
H
They
have
reached
out
to
us
basically
and
they've
been
doing
it
for
the
past
several
years
I
mean
literally,
I
mean
there's
just
if
you
follow
the
links
through
on
these
things.
There's
you
know
one
of
the
issues
that
was
broken
out
from
another
one
was
opened
by
kendra
back
in
2015,
so
I
mean
it's
it's
it's
a
repeated
thing
and
people
have
actually
been
asking
for
this
explicitly.
H
It's
it
goes
to
32
418,
and
then
you
know
that
one
goes
back
to
14
825
and
there
are
other
ones.
I
didn't
hunt
them
all
down,
but
this
keeps
coming
up
over
and
over
again
when
I
was
in
the
library's
team,
it
was
like
hitting
these
things
too
and
there's
there's
lots
and
lots
of
details,
and
this
basically
takes
everybody's
feedback
from
all
these
different
issues
and
gives
them
basically
what
they
wanted.
H
I
mean
minus
some
additional
like
exposure,
you
know
expanding
out
on
things.
You
know
where
people
wanted,
you
know
want
the
color,
you
know
the
predefined
colors
and
things
like
that
and
those
things
we
can
cover
earlier
time.
But
you
know
the
fundamental
thing
is
like
it
is
usable,
even
if
people
don't
use
it
as
an
exchange
type.
The
expectation
is
is
that
they
prob
they
will,
but
they
won't
like
it's
it's
a
chicken
and
egg
thing.
They
won't
do
it.
H
D
Have
to
be
depending
on
no,
I
understand
like,
but
the
the
problem
is.
It
cuts
both
ways
right
so
like
if
we
ship
something
in
order
to
unblock
that
tie,
and
then
people
start
first
looking
at
it,
and
then
we
get
feedback
like
oh.
What
you
now
have
is
not
quite
what
I
needed,
so
I
still
can't
use
it.
Then
we
just
have.
H
Another
type
there's
no
thing
it's
like
for
the
raw
data
like
for
this
specific
scenario
it
matches
what
the
raw
data
is.
So
there's
not
like
you
may
not
like
the
name.
Fine,
you
know
it
might
not
have
an
extra
piece
of
like
additional
functionality
now,
like
the
hsl
converters
or
whatever,
but
there's
no,
like
the
data
is
the
data.
It's
like
a
rgb
all
in
order
and
the
other
way
around
that
will
never
change
it's.
It's
just
gonna
be
like
naming
related
things
that
people
will
be
complaining
about.
H
H
The
more
contentious
things
about
what
what
like
what
we
should
do
for
predefined
colors
and
things
like
that.
You
know
we
really
want
some
more
feedback
about
what
goes
into
that
sort
of
thing
that
that
has
opinions
that
can
be
like
influencing
the
way
we
go
one
way
or
the
other,
but,
like
you,
know,
the
raw
data
itself.
This
is
just
what
it
is.
I
Right
this,
this
isn't
like
jason,
where
we're
exposing
classes
or
anything.
This
is
literally
primitive,
struct
types
there
is
no
shape
that
isn't
this.
This
is
the
raw
minimal
shape
for
these
types,
and
there
is
no
other
shape
that
works,
because
it's
a
primitive
struct,
and
so
it
has
to
be
exactly
four
fields
that
are
of
the
component
names
and
then
the
the
constructor,
the
converters
that
we
have
on
the
other
types,
and
I
equatable
that
is
the
minimal
surface
area.
G
I
That
prevents
it
from
working
with
vb
that
may
prevent
it
from
working
with
f-sharp.
If
it's
going
to
be
used
from
wind
forms,
then
it
can't,
because
it's
going
to
be
need
to
need
to
be
usable
from
vb,
but
also
none
of
the
other
numeric
types
are
likewise
constrained,
so
we'll
likely
use
whatever
pattern.
We
come
with.
G
B
G
G
D
Just
not
be
reusable
necessarily
in
a
generic
context
right,
but
if
somebody
takes
an
argb
or
float
right,
vb
will
be
able
to
handle
that
just
fine,
because
it's
just
an
instantiated
generic
at
that
point
right.
The
problem
is
you
can't
write
generic
code
that
you
know
works
within
with
a
t
that
is
constrained
to
some
numeric
interface,
but
that
seems
fine.
I
mean
right.
I
So
so
you
so
there
are
ways
to
work
around
not
having
the
constraints
such
as
creating
another
helper
type
to
do
it,
which
is
what
we're
going
to
have
to
do
on
vector,
2,
3,
4
anyways,
as
well
as
vector,
128,
vector,
256,
vector
64
and
the
rest
of
the
ecosystem.
That's
been
created
around
generics
for
the
past
20
years,
but.
G
D
Well,
but
it
I
mean,
I
mean
I
guess
the
details
matter
here
like
I,
don't
understand,
necessarily
what
you
mean
by
the
helper
type,
but
also
I
mean
do
you
really
expect?
I
mean
I
understand
the
general
argument
with
generics
where
you
already
are
in
the
generic
context,
but
you're
unconstrained
now
using
generic
types
that
are
constrained
is
not
possible
because
you
can't
know,
because
you
know
you
have
to
annotate
yourself.
So
it's
a
breaking
change
and
it's
viral
right,
but
right
like
I
would
assume
that
most
graphics,
libraries
aren't
generic
right.
E
D
I
G
G
I
I
I
G
I
D
D
Right
so
I
mean,
I
guess,
that's
why
I
said
like
to
me
details
matter
right
so
so
the
question
is,
I
understand
what
tenor
is
saying,
but
it's
I
think
it's
a
bit.
I
mean
I
would
almost
say,
defeatist
if
we
say,
oh
because
there's
one
particular
thing
that
we
can't
do
with
us,
we
can't
use
it
anywhere.
That
seems
a
bit
over
the
top.
Like
I
I
would
say.
Yes,
when
you
introduce
a
new
feature,
we
have
to
think
about
how
it
interoperates,
but
I
think
there
are
ways
we
can
make
this
work
right.
D
So,
for
example,
we
could
say
yeah,
you
can't
cost,
but
there
is
a
method
you
can
call
that.
Does
it
right
and
that
might
be
good
enough
right.
So
I
think
the
question
is,
you
know
to
steven's
point:
are
we
doing
ourselves
a
disservice
by
kind
of
dumbing
down
feature
areas,
so
we
can't
take
advantage
of
them
just
because
somebody
needs
an
exchange
in
in
a
in
a
corner
case,
part
of
their
library.
D
Or
could
we
just
say
sorry,
those
are
the
things
that
we
expect
the
ecosystem
to
either
break
or
absorb
or
work
around
right,
and
I
think
that's
there
must
be
some
sweet
spot.
That
is
not
zero
right
like
there
must
be
some
sweets
where
we
can
say.
Oh,
we
can
use
these
features
in
these
areas
and
in
these
areas
well,
it
would
not
be
great
to
do
it
right
and
I
think
the
numeric
interfaces
as
far
as
I
understand
them,
offer
a
whole
bunch
of
value.
D
Add
versus
some
of
the
other
ones
we
have
like
you
know
unmanaged
or
you
know,
are
somewhat
less
interesting
constraints.
So
that's
why
we
very
often
go
with
one
constraint
there,
because
you
know
you
can't
do
much
more
with
them.
So
that's
why
I
think
it.
You
know
it
depends
on
where
the
you
know
where
the
line
falls,
kind
of
thing
right
and
it's
we
need.
G
B
B
B
D
Well,
I
mean,
I
would
say
if
it's
an
exchange
type.
Yes,
if
it's,
if
it's
an
interrupt
mechanism
where
one
converts
to
the
other,
who
cares
that
the
thing
in
the
middle
is
is
a
generic
type
like
vector4
that
takes
four
floats
or
a
vector
four
that
takes
four
bytes,
because
you
just
use
it
as
a
transport
at
that
point
right.
D
So
that's
why
I'm
saying
if,
if
this
type
like,
if
the
fact
that
we
give
it
a
name,
is
useful
that,
then
I
think
it's
only
useful
if,
if
the
exchange
pays
for
itself,
as
in
like
oh
there's,
no
libraries
that
take
it
or
produce
it,
there's
methods
that
operate
over
them.
That
is
distinctively
different
from
you
know,
a
tuple
of
four
bytes
right
and
that's
kind
of
the
thing
that
this
probably
here,
yeah
there's
some
methods
here
that
do
that.
D
But
quite
frankly,
you
know
we
could
have
a
type
called
a
rgb
that
you
know
create
little
engine
of
you
in
color.
That
gives
you
back
a
you
know,
vector
four
of
byte,
or
you
know
literally
a
couple
of
four
bytes
right
I
mean
we
could
like
nothing
in
here
says
we
need
to
have
those
types,
I'm
not
saying
we
shouldn't.
D
All
I'm
saying
is
that
every
time
we
introduce
an
exchange
type
like
this,
I
think
there
is
some
heavy-handedness
that
comes
with
that
it
needs
to
pay
for
itself,
and
so,
unless
there's
some
libraries
out
there
by
some
I
mean,
like
I
don't
know,
four,
five,
six
or
whatever
that
are
saying
yep
I
will.
I
will
take
this
type
and
I
validate
that
the
design
of
the
type
works
for
me.
D
If
you
will
right
and
and
every
time
we
design
a
type
where
we
use
it
ourselves
in
some,
you
know
corner
where
it's
nifty,
that's
not
enough
right.
So
that's
why
I'm
saying
if
we
have
a
hero
scenario
like
oh,
he
has
two
or
three
for
our
libraries
that
use
it
now
and
now,
as
a
user.
I
can
use
these
four
libraries
and
pass
values
around
that's
a
useful
scenario.
D
D
J
D
Right
it
just
gave
you
one
example
right
I
mean
it's
okay
to
say
like
oh,
it's
not
wpf,
that's
using
it
but
like
asp.net
is
using
it
or
I
don't
know
like
these
image
processing
libraries
that
are
very
popular
using
it
right
or
want
to
use
it
right.
That's
fine!
That's
that's
customer
evidence
right!
That's
that's
evidence
for
once
you
have
that
type,
it's
being
useful.
D
H
Wire,
I
can't
I
can't
build
it's,
not
just
interop,
it's
the
other
things
that
I'm
saying
like.
I
need
to
be
able
to
build
upon
this
for
like
system
drawing
and
other
wind
forms
related
like
image,
manipulation
or
color,
like
color
color
array,
manipulation
things
where
I
cannot
expose
things
in
a
way.
That's
that's
performant
right!
You
know
I
can't
take
raw
data
without
you
know
I
can
say
all
right
well,
I
can
try
to
build
these
apis
off
of
off
of
vector
four
or
eight
or
whatever,
but
it's
yeah.
D
Mean
that's
that's
what
I'm
saying
I'm
not
I'm
not
saying
that
you're
wrong!
All
I'm
saying
is
that
you
know
the
apis
you're
you're
talking
about.
They
aren't
part
of
this
proposal
right.
So
that's
why
I'm
saying
to
me
it's
a
bit
hard
to
say,
oh
because
I
could
imagine
a
world
where
these
things
are
usable
or
valuable
or
useful.
D
I
think
for
for
an
exchange
type
like
this.
I
don't
think
it's
enough
like
because
I
mean
every
time
we
do
these
things
we
like
it.
So
let
me
step
back
for
a
second
right.
It's
not
that
I'm
saying!
Oh
because
you
don't
have
enough
evidence.
Let's
not
do
this
right!
That's
not
how
most
api
proposals
go
right.
Most
of
the
time
we
are
saying.
Oh,
this
method
looks
useful
enough.
D
Here's
how
we
would
interoperate
with
system
drawing
color,
here's
the
algorithms
that
we
can
now
build
at
a
high
performance
in
aggregate
now
the
package
has
value
right
right,
but
if
the
only
thing
we're
reviewing
here
is
kind
of
basically
a
struct
before
fields.
I
understand
that
that
makes
the
proposal
neat,
but
I
I
don't
feel
like
I'm.
If
I'm
I'm,
I'm
in
the
position.
H
D
H
If
you
want
to
exchange
stuff
with
a
you
know
between
libraries,
there's
no
way
for
them
to
do
that
in
a
way
that's
expressible
unless
they
take,
if
they
want
to,
if
they
want
to
pipe
it
through
the
framework
right.
There's
no
way
to
do
that
outside
of
outside
of,
like
an
untyped
type
that
we
have
right,
which
is
risky
and
difficult
to
use
or
system
color,
which
has
no
performance,
raises
return.
Color.
D
I
D
Not
what
I'm
saying?
That's
not
what
I'm
saying,
I'm
not
saying
you
know,
dump
in
more
apis.
What
I'm
saying
is
provide
evidence
right.
The
evidence
could
be
four
paragraphs
of
text
that
says
here's
the
kind
of
algorithms
we
we
want
to
do.
There's
a
proposal
link
if
you
want
to
look
at
them.
Here
are
the
four
libraries
that
have
asked
for
this:
they
they
have
looked
at
this
proposal.
They
think
it's
viable.
This
is
how
they
will
exchange
it
like
that.
That
to
me
would
be
would
be
completely
fine.
D
I
mean
you
know
we
don't
have
to
design
the
entire
thing
right.
All
I'm
saying
is
that,
right
now
it
seems
just
you
know,
unrealized
potential
right,
and
so
nothing
you
said
is
wrong.
All
I'm
saying
is
that
there
is
a
lot
of
like
ifs,
that
needs
to
happen,
and
if
they
don't
happen,
the
type
isn't
that
negative.
H
This
is
taking
six
years
of
feedback
into
account
right,
plus
all
the.
What,
in
addition
to
what
tanner
is
already
saying,
it's
not
that
people
aren't
asking
for
this,
they've
been
asking
for
forever
and
one
of
the
things
that
we
haven't
like
one
of
the
reasons
we've
like
not
gotten
anywhere
with
it
is
because
they've
tried
to
like
build
a
bigger
system
and
throw
the
whole
thing
at
once
right,
but
they
all
boil
down
to
this
sort
of
basic
thing
right
is
that
they
need
this
sort
of
thing
as
the
building
block
right.
I
What
users
have
been
asking
for
from
kendra
to
four
three,
two
one,
eight
that
was
that
you
looked
at
earlier,
taking
it
all
and
boiling
it
down
to
what's
something
that
actually
fits
that
and
works
for
winforms
as
their
interchange,
type
between
performance
and
color.
That's
taking
all
of
this,
and
then
it's
simplifying
it
down
to
what
was
something
that
we
could
actually
get
in
to
start
this
off
without
reviewing
literally
you
know,
100
plus
apis,
all
at
once
and
getting
into
some
of
the
more
complex
discussions
of.
D
And
the
answer
to
that
is
clearly
no
and
that's
fine.
I
think
that
I
think
I'm
not
actually
demanding
that.
I'm
just
saying
to
me
the
problem
with
exchange
tab
is
doing
them
incrementally
in
small
increments
might
be
detrimental
because
you
don't
get
enough
leeway
like
you,
don't
get
enough
mileage
out
of
them
right.
So
that's
why,
to
me
kind
of
I
don't
know
like
maybe
the
maybe
the
fact
that
it's
an.
D
Problematic,
I
mean,
if
you
write
an
actual
proposal
that
says:
yes,
here's
the
shape
of
the
type
here's,
what
we
envisioned
to
happen
in
the
long
run,
and
we
make
it
the
design
and
we
share
it
more
widely
with
people
and
see
what
the
reaction
to
that
is.
That
would
be
a
fine
next
step
in
my
opinion,
but,
like
I
am
hesitant
to
just
say,
api
approved,
because
it's
the
only
way
this
layout
has
to
happen
on
the
wire
like
that.
That
seems
from
in
my.
I
I
H
D
As
it's
suggested
right
and
then
we
ship
it
in
seven
and
then
a
bunch
of
libraries
look
into
that
and
saying
sorry.
I
can't
use
it
for
various
reasons
right
either,
because
I
already
have
types
I
there's
not
enough
value
in
exchanging
those,
and
then
we
have
a
type
that
nobody
is
using,
and
I
mean
we
have
seen
this
in
the
past.
So
this
is
not.
This
is
not
something
that
I'm
that
I'm
making
up.
D
Had
types
that
people
have
asked
for,
we
built
them
and
then
nobody's
using
them.
So
it's
not
like
the
first
time
this
happens,
but
my
bigger
concern
is
that
there
is
already
this
problem
that
we
have
a
bunch
of
graphics.
Libraries,
people
already
upset
with
us
that
we
build
things
like
you
know,
part
of
maui
is
this
drawing
stack
that
we
have
right
for
controls,
and
so
this
is
just
another
thing
where
people
say
like
oh
great
you're,
competing
with
us
again
and-
and
so
my
question
is:
how
do
we?
H
That's
true,
I
just
like.
I
think
that
there's
like
there
is
an
answer
here
that,
like
people,
need
a
color
and
they
do
use,
I
mean
from
the
framework
and
they
do
use
system
drawing
color,
and
that
is
just
not
good
enough
right
and
it's
it's
weird
to
ask
people
to
expose.
That
thing
is
like
how
do
I
give
you
a
color
that
you
can
use
or
make
people
do
their
own
manual
transformation
between
that.
H
D
So,
to
be
very
clear
right,
I'm
not
saying
you
don't
have
good
reasons,
I'm
not
saying
the
design
of
the
type
is
wrong.
What
I'm
saying
is
that
the
proposal
as
it's
written
here,
doesn't
make
that
obvious.
So
to
me
it's
lack
of
like,
like
all
the
things
you
just
said.
I
believe
you
they're
true
it's
just
that
they're,
not
part
of
this
proposal
right.
D
So
that's
why
I'm
saying
if
you
had
a
design
that
is
a
bit
more
detailed
and
a
bit
more
here's
what
we
would
envision
happens
over
the
next
two
years
and
we
share
that
more
widely
and
get
more
eyeballs
on
it.
Because
again,
this
proposal
has
six
upvotes
and
you
know
18
comments
right,
which
basically
means
it
as
it
stands
here.
It
seems
to
have
been
not
seen
by
a
lot
of
people,
and
that's
my
only
concern
like
my
concern
is
not
that
you
know
I
see
something
that
is
obviously
wrong.
I
This
is
literally
not
exposing
the
types
you're
basically
saying:
do
we
get
evidence
to
expose
them
and
when
forms
is
sol
or
do
we
not
expose
them
at
all,
because
winforms
fundamentally
needs
types,
we've
said
system
drawing
is
no
longer
supported
on
unix.
So
now
everyone
that's
been
using
color
on
unix
can
no
longer
use
it,
so
they
have
no
alternative,
and
so
it
comes
down
to.
We
either
expose
a
type.
D
Just
don't
make
clear
like
if
we
talk
about
the
same
thing,
there's
a
difference
between
an
api
proposal
which
yes
should
be
targeted
and
a
vision
for
a
feature
which
should
be
a
bit
broader
than
the
increments
right,
because
the
thing
is
it's
hard
to
judge,
especially
exchange
type.
If
the
only
thing
you
look
at
is
this
very
narrow
slice
right?
So
that's
that
that's
why
I'm
saying
for
the
api
proposal?
What
you
have
is
perfect
in
size
right.
I'm
just
saying
to
me
the
proposal
here
or
the
the
the
approval
isn't.
D
Do
I
like
this
api
shape
right?
The
approval
here
would
mean
we
are
capable
of
introducing
this
new
concept
into
the
platform
and
we
are
confident
that
it
will
be
used
and
we
are
confident
that
it
pays
for
itself,
and
all
I'm
saying
is
that
in
this
api
proposal,
I
don't
see
enough
evidence
for
that.
To
be
true,
I'm
not
saying
you
know,
I'm
not
saying
you're
wrong,
I'm
not
saying
here's
evidence
that
I
have
that
suggest.
H
Like
oh,
it's
a
lot
of
people
again
you're
just
you're
you're,
taking
out
six
years
worth
of
stuff.
By
just
pointing
to
this
one
issue
I
mean
I
could
have
like
iterated
on
my
very
first
branching
out
from
issue
to
issue
to
issue
and
like
people
have
been
asking
for
this
forever,
and
this
is
like
taking
in
precisely
what
they've
been
asking
for.
I
mean
I
I
can.
I
can
go
and
expand
this
thing
and
flesh
out
what
you
know.
H
D
D
I'm
not
saying
that
at
all,
I'm
not
saying
it's
less
important.
All
I'm
saying
is
that
I
want
to
make
sure
when
we
say
this
is
the
thing
we
ship
that
people
are
buying
into
that.
I
just
want
to
I
want
to.
I
want
to
make
sure
that
enough
people
have
seen
this
before
we
we
we're
taking
this
to
an
approval.
That's
all
I'm
saying
and.
I
I
think
the
thing
that's
being
overlooked
is
that
there
is
literally
no
other
surface
area
that
could
be
exposed
here.
It's
either
we
expose
this
and
we
eventually
expand
it
with
the
with
the
core
methods
that
other
graphical
numeric
math
libraries
expose
like
directx,
math
and
glm,
or
we
do
not
expose
it,
and
we
go
back
to
the
original
proposal
which
is
winforms
exposes
this.
Basically,
as
is
in
their
own
surface
area,
and
we
never
expanded
any
further
in
the
future.
H
We
work
with
system
drawing
right,
that's
just
what
it
is
and
like
those
we
work
with
bitmap
and
other
image
types
that
come
from
that
and
sometimes
we're
manipulating
the
pieces
that
are
in
there
and
there's
no
way
to
get
to
the
data.
You
know
in
a
public
way
at
the
moment
right,
so
you
know
either.
I
continue
because
this
is
an
iterative
thing.
H
You
know,
we've
introduced
the
the
dependency
on
system
numerics
for
for
for
the
for
the
matrix
stuff
right
primarily
around
this
sort
of
thing,
too,
is
what
we're
going
through
and
unraveling
these
pieces.
Now.
I
know
one
of
the
other
places
where
we're
suffering
in
our
performance
is
specifically
around
image
manipulation.
H
You
know
for
like
icons
and
things
like
that,
where
we're
fiddling
with
stuff
I'm
like
I
either,
I
have
to
have
something
where
I
can
get
the
raw
data
out
right
and
right,
like
so
like
the
ultimate
thing
is
going
like
from
system
drawing
which
is
not
under
you
know,
it's
not
an
internal
thing
to
win
forms,
and
you
know
something
has
to
be
there.
I
mean
we
can
make
it
an
untyped
one
of
these,
which
I
guess
is
possible
or
we
could
do
with
my
original
proposal,
which
had
its
definite
downsides.
H
The
reason
I
went
that
way
is
because
I
knew
this
conversation
hadn't
gone
on
for
seven
years.
It's
like
difficult
to
to
get
to
get
to
an
end
point
on
it,
so
I
thought
well.
Maybe
I
can
avoid
that,
and
you
know
deal
with
the
immediate
scenario
which
is
like
you
need
need
something
like
that,
but
you
know
I
do
agree
that
it's
better
to
have
something
an
exchange
thing
just
like
we
do
with
the
matrix
thing.
That's
just
totally
agnostic
to
to
to.
You
know.
I
System
drawing
right,
and
so
it
basically
comes
down
to
a
question
of-
is
this
going
in
sister
numerix
colors,
or
is
it
going
in
system
drawing
and
the
the
view
based
on
the
past
six
years
worth
of
data
and
industry
experience
and
prior
art?
Is
that
having
these
in
system
numerix,
colors
and
extending
them
with
additional
methods
in
the
future,
so
that
core
operations,
like
addition,
blending,
interpolation
etc
exist,
like
other
core
math
and
color
related
libraries?
Do
was
the
right
approach,
especially.
H
And
the
manipulation
in
particular
is
something
that
I
want
to
take
advantage
of,
and
I
want
it
to
be
done
in
held
inside
of
system
numerics,
because
we
do
that
in
wind
forms
right.
We
we
manipulate
the
the
we
manipulate
the
brightness
of
things
and
stuff
like
that,
we're
converting
to
hsl
and
back
and
forth-
and,
like
you
know,
that's
that's
the
iterative.
H
Well,
you
know
we
want
to
do
our
design
this
way
too,
and
it's
like
well.
You
know
we
do
have
some
of
those
color
some
of
those
things
inside
of
our
api,
but
I'd
rather
not
be
like
continually
expanding
the
the
winforms
api
for
things
that
are
kind
of
more
generic
in
nature
right,
because
we
do
have
some
of
that
for
building
your
ui
right,
where
we
have
the
little
helper
classes
that
like
allow
you
to
manipulate
things,
to
build
your
ui
in
some
sort
of
consistent
way
right,
but.
H
I
I'm
definitely
not
saying
we
shouldn't
do
the
additional
work
of
like
let's
write
out
a
proper
design,
doc
showing
how
this
will
extend
in
the
future,
but
I
do
think
it
comes
down
to
basically
is
this
going
under
system
drawing
or
system
numerics
colors?
No
matter
what?
Because
if
we
say
we're,
never
extending
this
in
the
future,
because
we
don't
think
other
libraries
will
use
it.
I
B
We
just
want
you
to
find
someone
in
some
library
I
looked
at
sharp
dx,
but
unfortunately
they've
gone
out
of
business,
someone
in
some
library
that
goes.
Oh
my
god.
Thank
you
so
much
and
then
they
say,
I'm
totally
ready
to
use
this
and
then
we
come
back
and
say
great
if
filled
someone's
scenario,
let's
ship
it.
But
so
let's
not
talk
about
whether
or
not
there's
a
customer.
Let's
pretend
there's
a
customer
talk
about
what
we
like
and
don't
like
about
the
type
and
then.
B
B
H
I
I
They're
primitive,
math
types
like
cosine,
there's,
not
exactly
other
signatures.
You
can
have
for
them.
These
are
this,
isn't
some
you
know
edge
case
library
where
there's
a
lot
of
opinions,
there's
a
effectively
industry
standard
for
the
names
and
for
the
terminology
here
and
for
the
operators
that
get
exposed
on
it
and
there's
not
really
a
difference.
It's
like
vector
four
there's,
not
opinions
on
vector
four
there's
a
correct
way
to
do
it
and
not
exposing
it.
B
Right,
except
there
is
no
to
hsl
here
and
then
there's
the
if
you
do
expose
to
hsl
what
like
are
we
doing
that,
or
is
somebody
else
doing
that
if
we're
doing
that?
What
are
we
doing
the
return
type
as
because
now,
once
you
go
hsl
you're
back
in
the
you
have
a
tuple
that
the
order
matters,
and
now
you
don't
have
a
name
so
do
we
also
need
an
hsl
type
in
order
to
go
with
that,
like
that's
where
some
of
these,
we
need
to
see
that
somebody
says
yes,
this
is
great.
B
I
B
B
But
I
think
we
have
spent
a
lot
of
time
talking
about
whether
or
not
we
think
we
want
it.
I
think
the
answer
is
we
don't
know
you
guys
know,
I
kind
of
believe
you
emo's
not
sure,
but
let's
table
that
in
the
american
sense
and
let's
table
the
actual
shape
and
the
british
sense
and
let's
talk
about
what
you
have
on
or
what's
on
screen
right
now
and
then
let's
try
to
make
some
progress
with
this
meeting
so
argb.
B
This
is
famously
called
out
by
brad
abrams
in
the
original
version
of
framework
design
guidelines,
as
one
of
the
names
that
we
wish,
we
had
never
named,
in
particular
color
from
argb.
Everyone
read
it
as
color
from
arc
b
because
they
understand
what
args
are
and
that's
just
the
way
that
human
brains
parse.
Do.
We
believe
that
the
people
who
would
use
this
are
in
this
space
enough.
That
argb
is
the
right
name
or
should
it
be
what
brad
says
we
retroactively
wish?
B
I
B
I
The
the
simplest
example
would
be
you're
in
a
game.
You
have
a
debug
display,
that's
displaying
positions
or
in
this
case
colors,
and
you
want
it
formatted
in
a
particular
way
such
as
you
want.
If
you're
in
you
know
a
culture
that
uses
commas
instead
of
periods,
then
you
want
to
use
the
comma
there,
and
so
you
want
culture,
aware
formatting.
B
I
It
would
likely
be
explicitly
the
the
iscaler
concept
which
hasn't
been
reviewed
yet,
but
you
specifically
need
a
concept
of
scalars
and
correspondence
to
vectors,
and
so
it
wouldn't
be.
I
number
itself
fair
enough,
although
scalar
might
be
a
number
there's,
there's
some
wonkiness
there
that
I
still
have
to
finish
flushing
up
for
seven.
I
I
Yes
and
there's
lots
of
cases
where
you
may
not
be
able
to
parse
something
that
gets
output
depending
on
factors,
but
basically
four
vector
components.
We
never
decided
and
we
never
even
finalized
what
the
what
that
format
was,
and
if
there's
alternatives
that
are
accepted
as
well,
and
so
these
likely
should
be
partial.
I've
just
never
sat
down
and
considered
what
that
final
spec
would
be
and
and
proposed
it
for
reviewing
a
google
okay.
They.
B
B
I
B
B
The
so
the
I
can
I
can
get
the
explicit
here.
We
do
have
the
problem
that
I
don't
know
that
all
languages
are
good
with
calling
the
conversion
operators.
So
we
generally
suggest
that
you
have
a
named
version
of
it
and
then
I
question
personally
whether
or
not
the
implicit
from
just
an
rgba
to
a
color
is
right.
Like
don't
the
colors
have
names,
or
do
we
have
one
that
just
creates
it
from
the
four
numbers.
I
B
I
I
H
B
So
my
recommendation
is
to
never
add
explicit
conversion
operators
or
never
add
conversion
operators
it's.
This
is
a
to
me.
It
starts
at
minus
a
million,
not
minus
a
thousand,
so
you
need
to
really
really
really
really
really
have
a
good
reason
why
it
feels
like
a
natural
thing
to
use
the
parenthesis
syntax
or
to
use
a
implicit
assignment.
H
I
mean
I
I
I
personally
like
it
when
it's
like
this,
like
I,
I
totally
get
having
the
from
and
the
two
ones
as
as
well,
but
you
know
I
just
because
we
have
a
2a,
rgb
and
we'd
just
be
doing
the
the
same
overload
for
that
right
I
mean
the
in
color
already
there
is
from
a
rgb,
and
there
is
from.
There
is
two
a
rgb.
B
H
B
H
H
H
B
H
B
B
H
H
D
D
B
B
D
H
D
Yeah,
the
only
thing
you
want
to
be
careful
with
is
constructors.
Are
that
only
works
when
the
type
is
different
right?
The
nice
thing
with
like
from
methods
is,
you
can
have
the
same
type
but
different
named
methods
right,
and
so,
if
that,
for
example,
if
four
bytes
could
either
mean
a
rgb
or
rgba,
then
having
a
constructor
that
takes
four
bytes
is
not
super
useful
right,
because
you
don't
know
which
one
it
is.
B
B
B
B
D
B
B
B
H
I
I
I
If
you
have
a
mod
rec
anywhere,
that's
not
cls
compliant.
If
you
add
a
mod
opt
anywhere
that
is
not
cls
compliant
in
the
compiler
will
not
correctly
detect
and
flag
those
and
so
cls
compliance.
Just
sit
in
modern.net
does
not
exist
because
it
is
not
correctly
tracked
by
any
any
compiler
that
people
actually
use.
D
B
I
D
D
B
H
D
D
H
I
D
D
H
D
It
it
would
it.
It
just
means
that
when
you
so
the
so
the
downside
is
still
when
you
see
the
list
they're
still
further
away
right.
So
until
somebody
starts
typing
argb,
you
may
not
realize
that
there
is
like
two
of
them
right,
because
one
of
them
is
happens
to
be
off
the
screen
when
you
look
at
it
right.
D
D
E
D
H
H
D
Yeah,
as
I
said
to
me,
it's
less
about
the
you
know
more
links
or
more.
You
know
more
proposals,
it's
more
about
getting
more
eyeballs
from
the
community
on
it
and
making
sure
that
that's
the
thing
that
we
collectively
think
is
the
right
design.
That's
all,
and
I
mean
there
is
this
thing
of
like
yeah.
You
know
who's
actually
using
this
type
right.
If
no,
if
nobody
is
exchanging
this
type,
it's
not
paying
for
itself
right
but
like
to
me
that's
kind
of
the.
D
B
Yeah
and
I
think
an
easy
potential
answer-
I
don't
know
if
it'll
actually
solve
emo's
concern,
but
is
I
know
jeremy?
You
want
it
in
win
forms
if
maui
has
a
place
that
they
would
use
it
in
maui.
That's
now
two
libraries
in
parallel
workloads
and
now
we've
defined
like
yeah.
We
have
an
exchange
type.
This
is
how
you
can
talk
about
a
color
in
a
way
that
you
didn't
care
what
your
rendering
tech
was.
B
So
it's
just
we
kind
of
want
to
see.
What's
the
second
place
that
it's
going
to
get
used
and
that
somebody
says
oh
yeah,
I'll,
like
it's
usable
for
me,
I'll
use
it
and
I'm
I'm
happy-
and
I
don't
want
to
see
these
extra
19
things
bolted
on
before
I
would
use
it
like
or
if
they
do,
then
we
also
talk
about
those
19
things.
I
B
B
H
Something
like
using
this
in
my
own
things
and
like
I
I
just
can't
imagine
I
sure
I
can
imagine
that
some
library
folks
would
just
not
want
to
use
it
sure,
but
I
I
I
know
that
people
will
want
to
be
using
this
thing.
I
would
be
using
it
because,
like
it
feels
really
awkward
to
like
have
to
define
well
define
your
own
basic
type
for
this
thing
and
or
go
worse,
go
to
system
drawing
color
to
be
the
interrupt
thing
that
you're
using
so
right.
This.
I
Is
just
it's
just
a
I
was
saying
it's
just
a
core
type:
that's
exposed
by
every
other,
major
numerix,
graphics,
library
out
there
alongside
vector,
2,
3,
4
and
matrix
plain
quaternion,
and
so
we're
just
we're
building
parity
with
directx,
math
and
glm
by
exposing
this
here,
because
this
is
realistically
the
only
type
from
the
xna
days.
Slash
directx,
math
glm
that
we're
not
exposing
is
the
color
interchange,
operations
and
types.
H
So
yeah
I
I
have.
I
have
extremely
high
confidence
that
it's
like
we're
just
pulling
a
a
common
view
in
that's
what
people
already
mean.
It
is
what
it
is.
It's
I
just
I'll
use
it.
Winforms
will
want
to
use
it
want
to
do
something
in
system
drying
to
be
utilizing.
This
too,
we
already
defined
this
internally.
I
mean
I
have
an
argb
defined
everywhere,
but,
like
don't
want
to
do
that
anymore,.
I
D
B
H
I
totally
get
his
presidency
and
I
don't,
but
you
know
I
I
just
don't
I
understand
where
you're
coming
for
a
memo.
I
just
don't.
I
I
have
enough
confidence
that
this
is
going
to
be
used,
that
it
doesn't
that
I'm
not.
As
that.
My
my
worries
on
that
front.
I'm
not.
I
don't
have
the
same
level
of
concern.
B
Issue
so
I
will
say:
there's
there's
one
thing
that
could
be
the
concern
right
is
we're.
We
talked
about
this
and
we
said
you
know
it's
net
seven,
but
if
everybody
says
everybody
who
would
be
interested
in
using
it,
that's
not
winforms
said
maui
is
building
net
standard.
Then
then,
now
we
need
a
different
story
for
this
and
they've
said:
oh
well,
if
it's
not
net
standard,
I
can't
use
it.
B
B
I
think
the
one
thing
that
we
really
want
to
get
you
know
two
or
three
people
to
buy
off
on
again
be
great
if
image,
sharp
or
if
sharp
dx
still
existed
or
whatever.
If
they
said,
like.
Oh
yeah,
no,
we'll
totally
build
a
converter
for
this.
We
have
our
own
type
because
of
historical
reasons,
but
yeah
we
get
it.
It's
it's
great.
We're
gonna
interrupt
with
this
thing,
and
now
now
people
can
interoperate
sideways
and
fine
you're,
not
taking
over
our
jpeg
processing.
We
don't
care
and,
like
that's.