►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
A
Email's
not
here,
so
I
have
to
pretend
to
be
german.
It
goes
well
with
my
learning
to
speak
german.
Today
we
are
focusing
on
analyzers
and
one
blocking
issue,
which
happens
to
be
an
analyzer
which
makes
that
statement
redundant.
But
that's
what
we're
doing
so
yeah
a
lot
of
talking
about
things
that
talk
about
things
very
meta.
A
All
right,
the
one
blocking
issue:
finalize
logging
analyzers,
three,
six:
zero:
six,
four.
B
So
for
this
one
there's
five
different
diagnostics
that
aim
to
so
yeah.
I
kind
of
summarize
the
whole
thing
in
the
table
and
I
have
sample
usages
lower
down.
B
Like
as
an
example,
the
first
example,
as
you
see,
the
first
two
are
disabled
by
default,
as
the
explanation
in
the
message
purpose
says:
like
first
one
just
checks
the
message
template,
that's
provided.
If
it's
not,
if
the
arguments
in
the
template
are
not
camel,
are
not
a
pascal
case,
it
would
give
that
kind
of
diagnostic
out
when
enabled
and
then
the
second
one
basically
hints
to
using
more
performance
apis
so
like
it
discourages
usage
of
block,
trace
log
debug
and
all
that
then
yeah.
B
So
you
would
see
in
the
example
first
example
self-explanatory.
The
second
one
using
log
trace
the
resolution,
and
none
of
these
have
fixers
by
the
way,
and
so
basically
the
comment
to
that
portion
explains
what
would
remove
the
message
diagnostic
and
then
the
third
one
you'd
see.
The
argument
is
preferred
to
be
string,
not
numeric
and
the
fourth
diagnostic,
the
the
last
three
are
usage
type
category.
B
So
diagnostic
number,
three
is
the
numerics
issue.
Four
says:
logging
format
string
should
not
be
dynamically
generated,
so
basically
it's
just
it
might
so
like.
I
have
two
examples
to
show
basically
having
having
met
in
the
message
template
dynamically
generated
string
is
just
not
the
purpose
of
using
these
to
find
apis.
These
are
just
pre-compiled
actions
to
use.
B
Later
last,
one
is
the
one:
that's
the
only
one
that's
of
severity
warning
and
if
someone
uses
it
so
the
reason
this
warning
is
because
if
someone
today
uses
this
sample
they
would
get
a
runtime
exception
and
the
runtime
exception
is
also
showed.
B
B
B
C
D
C
B
C
C
B
C
D
I
think
the
constant
in
that
example
is
a
better
example.
Imagine
you
are
appending
a
an
actual
thing.
You
want
to
log
you're
appending
exception
dot
to
stream,
and
I
want
you
to
put
that
into
a
named
argument.
So
you
get
all
the
benefits
obstruction
login.
Instead
of
appending
it
to
form
a
string
every
time
and
you
can
have
issues
with
parsing,
because
we
try
to
parse
the
format
string
and
if
you
happen
to
have
curly
brace
something
in
there.
It'll
still
be
a
problem.
A
Defined
you're
finished,
it
is
what
it
is
and
if
you
built
it
with,
you
have
a
constant
string
that
you're
pre-pending
or
appending
to
everything,
then
that
then
that's
fine.
You
could
even
have
that
be
built
off
of
string
interpolation
because
of
a
bunch
of
things
that
you're
gluing
together.
But
good
luck
with
the
syntax
merging.
I
missed.
D
F
Yeah
this
is
this,
is
the
exact
same
and
you
know
for
people
who
are
used
to
to
see
you
know
passing
arbitrary
stuff
into
printf.
They
think
jeremy.
You
gave
the
string
format
example
earlier,
yeah
bad
things
will
happen.
G
G
F
F
D
D
D
I
think
the
log
trace
and
other
simple
overlaws
are
for
kind
of
like
hello
world.
You
get
into
login
scenarios
when
you
get
to
localized
login,
I
think
you're
an
advanced.
A
Would
be
extraordinarily
difficult
because
you
don't
get
to
indicate
which
order
things
came
in
like
string
format,
you
have
the
numbers
and
that
that's
why
they're
numbers
they
can
float
around
the
these
it's
like
well,
the
first
thing
is
going
to
be
called
message,
so
hopefully
your
language
supports
that.
B
F
B
About
the
diagnosis,
the
force
diagnostic,
the
second
example,
the
person
who
wrote
it
down
might
assume
that
they're
gonna
have
like
an
empty
string,
but
when
they
use
the
returning
action,
whatever
value
they
provide.
B
As
the
argument
integer,
let's
say
they
feel
like
one,
it's
gonna
print
out,
one
or
11
or
whatever,
but
it's
kind
of
like
confusing
for
the
very
least
like
the
second
usage
example
for
diagnostic
for
kind
of
shows
where,
if
someone
provides
string
empty
for
example,
as
the
argument
tablet,
they
minus
that
they're
gonna
get
string
empty,
but
they
won't.
G
B
I
mentioned
that
because
I
think
I
heard
you
guys
say
we
want
to
keep
that
for
only
like
apis
like
like
block
tracing
and
stuff,
but
not
defined,
but
kind
of.
A
Right
I
mean
this
is
totally
fine.
First
of
all,
there's
no
dollar
sign
here,
so
it's
not
actually
turning
into
the
empty
string.
This
is
going
to
log
with
a
tag
name
of
string.empty
yeah
and
that's
either
fine
and
don't
say
anything
or
it's
a
bad
name,
because
you're
not
allowed
dots
and
then
that's
a
naming
violation
which
is
more
like
diagnostic
one,
but
it's
not
dynamically
generated
like
it's.
It's
definitely
not
the
same
thing
as
what
the
the
title
of
diagnostic
four
says.
G
C
D
D
We
want
customers
to
do
structured
logging
and,
when
you're,
appending,
dynamic
values
to
a
format
string
in
your
log
calls.
By
definition,
those
values
won't
become
part
of
some
named
output
in
the
end,
because
they're
gonna
in
for
mastering
they
wouldn't
have
accompanying
key,
and
we
want
all
kind
of
dynamic
values
to
be
key
value.
Players
that
you
can
filter
by
or
consume
and
structured.
G
G
So
it
is
so
you
said
that
there
aren't
going
to
be
any
fixes
for
these
diagnostics.
Some
of
them,
I
would
say,
like
diag
tube,
like
I
understand
what
that
message
means,
because
you.
E
G
I
know
about
logger
message:
dot
defined,
but
if
someone
hasn't
seen
it
before
like
is
that
enough
of
a
message?
Is
there
gonna
be
like
a
link
or
one
of
these
examples
in
it
or
something.
D
D
I
don't
know
what
the
reason
is
for
absence
of
fixes.
It
might
be
just
the
lack
of
resources
to
implement
them,
but
a
lot
of
these
can
conceivably
have
a
reasonable
code
fix
like
the
first
one,
obviously
just
uppercase
the
first
character.
Second,
one
is
a
great
example:
getting
a
lock
message
defined
to
work
is
hard
and
I
think
we're
doing
the
strongly
typed
plugin
thing
that
can
also
benefit
from
cod
fix
kind
of
creating
a
strongly
typed
vlogger
type.
B
Sure
yeah,
it's
just
it
wasn't
yeah
I
mean
I
I
thought
about
it
too.
The
first
two
would
make
sense
to
have
fixers,
but
I
kind
of
because
it
wasn't
going
to
make
it
for
60.
I
kind
of
didn't
put
it
in,
but
we
could
have
like
if
we
wanted
to
review
having
a
fixer
and
then
do
it
later.
That's
fine
for
the
first
two
makes
sense
to
have
third
one.
A
Does
the
I
mean,
I
guess
in
the
general
case,
where
it's
not
already
violating
diagnostic
four
and
gluing
things
together?
You
know
that
you
can
turn
the
literal
and
then
turn
that
into
a
field,
because,
presumably
you
want
a
field
and
not
a
local
here.
A
D
A
A
A
Is
there
a
reason
so
for
the
second
diagnostic
is
the
reason
we
want
off
instead
of
ide
hint
or
whatever,
because
the
thing
that's
there's
like
information
actually
seems
fine.
Maybe
I
guess
I
don't
know
what
we've
done
with
the
rest
of
the
performance
once.
A
A
For
small
performance
things,
do
you
remember
what
what
the
severity
we've
been
using
is?
Have
we
been
using
off
and
you
have
to
turn
on
the
category
or
we've
been
using
the
the
like.
H
A
But
we've
been
doing
so
hidden
is
the
like:
the
dot
dot
dot
under
the
variable
that
doesn't
show
up
anywhere
else
exactly
right,
yeah.
So
I
think
we
could
promote
diagnostic
two
to
hidden
I'll
trust.
You
guys
on
whether
or
not
number
one,
maybe
a
breaking
change.
Maybe
that's
why
you
want
it
off,
but
it
seems
like
if
you're
going
to
write
it,
you
want
it.
You
probably
want
it
on.
I
B
B
A
Right,
so
that's
where
the
the
hidden
level
of
you're
on
the
line
you're
looking
at
the
line
and
there's
a
you
know
little
fuzzy
on
the
ide.
That
tells
you
there's
a
thing
here
that
you
may
not
know
about,
and
then
you
look
at
it
and
it's
like
oh,
I
should
start
moving
us
to
loggermessage.define
because
parsing
strings
over
and
over
and
over
again
sucks.
A
I
So
I
don't
have
a
strong
opinion
on
this,
but
we
have
for
pretty
much
all
the
new
rules
we've
written.
I
don't
think
we've
shipped
any
of
them
as
disabled
entirely
like
off.
I
think
they've
pretty
much
all
been.
I
A
All
yeah
you're,
at
least
I'm
hearing
you
in
bursts
steve,
but
I
think
I
got
the
gist,
which
is
oh.
D
I
I
A
A
I
We've
shipped
a
whole
bunch
of
legacy:
fx
cop
rules,
ported
to
c
c-sharp,
reported
to
roslyn
analyzers
as
disabled
by
default
or
off
by
default,
but
any
of
the.
B
A
All
right
so
diagnostic
four
that
log
trace
should
not
use
a
dynamic
message.
You
think
that
one
is
info.
A
F
Yeah
this
this
seems
reasonable,
if,
if
you
have
high
confidence
in
your
ability
to
track
at
least
a
subset
of
them,
like
absolutely
worn
on
that
subset,
right.
F
F
A
D
C
A
And
then
the
the
the
pre-compiled
ones
that
one
actually
locks
in
that's
the
purpose
of
the
generic
because
it
locks
in
the
parameter
count.
So
people
know
what
to
do
so.
We
don't
actually
have
the
across
assembly
boundary.
So
this
is
everything
except
a
dynamically
generated
message:
okay,
that's
nice!
A
A
suggestion,
but
it
I
agree
with-
or
I
instinctively
agree
with,
the
gist
of
what
steve
was
saying
of.
Why
are
we
writing
the
analyzer?
If
we
don't
think
we're
going
to
turn
it
on.
A
B
Yeah,
so
the
example
for
the
diagnostic
speed
would
be
updated.
No
would
with
the
er,
because
steven
said
might
want
to
change
the
messaging
to
be
clearer,
or,
I
guess
explain.
I
don't
know.
A
Yeah,
I
assume
that'll
come
up
in
the
code
review.
I
was
really
only
thinking
or
concerned
with
the
logical
flow.
A
G
H
F
A
F
A
I
F
Oh
yeah,
no
you're,
absolutely
right.
This
is
so
the
the
analyzer
is
proposing
call
has
value
if
it
returns.
True
call
get
value
or
default.
Yeah
like
the
just
suggest.
Legit
should
make
that
work
better.
F
A
H
I
A
F
Like
in
in
in
sharp
lab,
at
least,
which
is
what
dotnet
five,
there
is
a
redundant
code
gen,
but
we
could.
We
could
fix
that
ourselves
within
the
runtime.
F
I
wonder
if
we
could
actually
we
we
might
want
to
as
an
internal
experiment,
write
this
analyzer
anyway,
run
it
over
our
own
internal
code
and
then
use
that
as
data
for
whether
this
is
a
significant
problem
that
actually
does
need
to
be
addressed
in
the
chuck
like
we
could
say:
hey,
it
saves
you
know
x,
number
of
kilobytes
of
code,
john.
I
don't
expect
it's
going
to
be
in
the
kilobyte
range,
but
whatever.
F
A
F
A
A
F
G
D
G
A
F
I
mean
it
is:
it
is
somewhat
common
to
call
methods
like
stringbuilder.append
within
a
loop
or
a
pen
format,
and
this
would
trigger
put
this
trigger
on
that.
No
because
you're
passing
different
data
every
single
time.
F
A
All
right
well,
because
the
the
purpose
or
the
intent
is
yeah.
That's
exactly
this
came
from
you
can't
capture
it
because
it
modified
in
the
loop
and
honestly,
I
think
any
expression
we're
not
going
to
know
enough
to
know
if
it
changed
in
the
loop
or
not,
unless
it's
a
literal.
So
if
all
we're
doing
is
floating
out
literals,
then
there's
no
point
to
this.
A
F
Maybe
it
would
make
sense
to
flip
this
and
say
instead
of
having
a
disallow
list
like
we,
we
simply
special
case
methods
that
we
know
tend
to
be
egregious
offenders,
that
people
often
call
inside
of
a
loop,
and
then
we
we
just
try
to
make
those
scenarios
a
little
bit
easier.
G
A
A
Right
because
if
if
the
thing
that
we
want
to
say
is
hey
you're
calling
console.writeline
in
a
loop,
it
turns
out,
this
is
actually
a
bad
example,
because
we
have
up
through
four
arguments
already
as
a
special
case
version
of
console.writeline.
A
So
this
isn't
actually
params,
but
the
if
the
thing
that
we
want
to
to
say
we're
avoiding
is
just
creating
an
array
of
four
over
and
over
and
over
again,
then
that
makes
a
little
bit
of
sense
to
me
that
we
create
an
array
outside
and
rewrite
the
code
to
just
update
the
members
in
that
array.
So
you're
just
saying
here's
an
array
of
four
things,
read
it
and
then,
like
come
back
to
me.
A
So
I
think
my
feeling
on
this
is
no.
We
should
just
get
pram
spam
right
that
there's
nothing
good.
We
can
do
in
the
meantime,
because
none
of
these
are
useful.
A
G
A
A
Relevant
but
and
if
you're,
if
you're
looking
at
you
know
every
allocation
matters
level
of
performance
because
you
know
gen
zero
is
almost
but
not
entirely
free,
then
yeah.
You
would
probably
be
willing
to
have
the
unnatural
looking
you
created
the
array
and
what
you're
doing
here
is
saying.
You
know
right
or
you
know,
temp
sub
zero,
equal.
I
console.writeline
this
string,
comma
temp
and,
like
sure.
G
I
F
F
A
Yeah,
so
it's
the
you
know
things
like
console.writeline.
We
have
the
four
argument.
Specialty
thing
just
you
know
to
avoid
the
pramsiness
and
how
many
people
are
doing
five
and
like
there's
a
reason
we
stopped
at
four.
We,
as
we
didn't
feel
five
was
as
useful
as
it
was
worth
its
cost
in
il
right
like.
E
A
A
Ugly
and
depending
on
what
you're
doing
like,
if
it's
I
didn't
look
at
string
builder,
append
format,
but
it
may
be,
one
fix,
maybe
switch
to
the
new
interpolated
versions.
One
fix-
maybe
oh,
if
I
do
this
as
two
calls
to
append,
then
it
doesn't
allocate
the
array
I'll
just
do
that
like
there's
a
there
are
things
that
can
make
your
code
look
clean.
That
still
accomplish
your
task
without
creating
the
the
manually
updated
array
which,
again,
like
I've,
done
the
manually
updated
already
it
it
solves
a
functional
problem.
A
A
G
The
other
thing
that
I
wonder
about
this
is
like
how
good
of
a
heuristic
is
that
it's
in
this
method
body
in
a
loop
right
because,
like
you
could
still
have
like
you
know
if
you
extracted
the
method
body
to
or
the
loop
body
to
a
method,
the
same
issue,
but
it
wouldn't
be
flagged
like
sure
it's
like
do
you
just
do
you
just
highlight
like
every
single
time
params
is
used
and
like
let
the
developer,
decide
if
it's
hot
enough
to
do
anything,
I
I
I
don't
know.
A
Not
wanting
to
highlight
too
much
so
maybe
that's
reasonable,
so
it
wouldn't
be
every
call
to
a
params
method.
It
and
again
this
wouldn't
trip
at
all,
because
this
is
not
params.
This
is
a
call
to
console.writeline
string,
comma
arg0
through
three
or
one
throughput.
A
I
I
F
I
C
F
I
B
F
F
Yes,
33797,
the
one
that's
linked
is
in
fact
what
you
just
asked
about
steve.
F
F
I
Does
this
show
up
meaningfully
enough
to
have
have
an
analyze
report.
A
F
I
For
that
example,
if
we
had
like
these
rules
can
compose
right,
if
you,
if
we
had
a
rule
that
was
index
or
after
it
contains
key
rule,
offers
to
fix
that
for
you
and
then
once
it
does,
you
get
another
rule
that
fires
saying
hey:
you've
got
to
remove
immediately
after
try
get
value
that
can
be
removed
with
an
out
or
something.
F
I
That's
what
I
mean,
but
but
it
ends
up
being
offered
as
a
sequence
of
analyzers
and
fixes
right.
You
start
with.
What's
on
the
screen,
it
offers
to
change
it
to
try
to
get
value
followed
by
remove,
and
then
you
get
another
fixer
immediately
that
says.
Actually
you
could
go
from.
Try
get
value
to
just
remove
if
you
wanted
to
yeah
or.
D
A
A
But
if
you
do
anything
else,
then
I
don't
think
we
should
even
we
definitely
shouldn't
fix
it,
and
I
don't
know
if
we
should
warn
it.
Sorry
if
we
should
squiggle.
I
A
Here,
that's
fair,
evo.
F
If
we
had,
if
we
have
an
analyzer
that
is,
contains
key,
followed
and
and
then
within
that
block
a
call
to
the
indexer
itself,
which
I
believe
we
have
that
analyzer.
If
that
and
absolutely
nothing
else,
triggers
an
ide
squiggle,
then
yeah,
then
we
don't
need
an
ide
squiggle
for
this,
like
we,
we
just
say,
like
some,
some
rule
has
already
told
you
there's
a
problem
here.
F
So
that's
kind
of
I
guess,
a
a
less
aggressive
version
of
what
you
had
proposed,
originally
steve,
where
we
don't
try
to
chain
fixers,
one
off
of
each
other.
We
just
say:
there's
an
analyzer
that
tells
you
something
something
there
there's
a
contains
key
inside
of
a
loop
if
statement
like
and
then
there's
an
access
into
the
dictionary
itself
anywhere
within
that
loop
like
it.
At
that
point,
we
just
kind
of
squiggle
the
whole
block
and
say
like
something
weird
is
going
on
going
on
here.
A
Yeah,
what's
interesting
about
this
last,
you
know
we
should
also
consider
is
that's,
definitely
not
safe.
A
G
F
Yeah-
and
there
are,
there
are
certain
assumptions
we
can
make
too
like
for,
for
example
like
we
can
we
well,
we
can't
assume,
like
you
know,
on
our
lives
that
say
the
equality
comparer
itself
won't
mutate.
The
dictionary
but
like
as
far
as
an
analyzer
goes
like.
We
don't
have
to
care
about
really
weird
esoteric
edge
cases
like
that.
F
A
A
F
A
A
G
A
G
F
F
I
mean
I
I
know
I
mentioned
earlier
like
we.
We
should
try
to
follow
the
spirit
of
what
the
language
team
does
and
not
make
analyze,
not
make
fixers
that
that
would
incur
behavioral
changes,
but
I
think
we
have
a
little
bit
more
leeway
than
they
do
honestly.
As
long
as
we
are
not
ourselves
too
agree
just
about
it.
I
I
don't
know
I
I
complain
to
folks
in
roslyn
enough
anytime,
a
fixer
comes
anywhere
close
to
making
a
semantic
change.
I'm
not
sure
I'd
see
a
difference
between
those
and
these
fair,
especially
like
this
comes
up
for
me
most
when
I'm,
you
know,
I
have
a
few
minutes
and
I'm
trying
to
roll
some
additional
like.
I
F
In
in
these
cases,
are
we
talking
about
like
realistic
edge
cases
that
the
analyzer
might
be
triggering
or
are
we
talking
like
someone
wrote
something
just
weird
and
contorted?
Oh.
I
E
I
mean
there's
a
trade-off
right
like
I
think,
if
you,
if
you
go
too
far
on
the
you
know,
not
making
any
mistakes
ever,
then
you
can
basically
never
offer
code
fixers.
So
I
think
I'd
rather
be
in
the
camp
of
we
offer
a
code
fixer,
but
we
disable
bulk
because
I
feel,
like
the
the
benefit
of
fixers
very
often
is
telling
people
like
okay.
What
what
should
you
do
instead?
E
F
And
I
I
think
we
can.
We
can
probably
make
some
safer
assumptions
like
we
would
never
expect,
contains
key
to
fail,
for
instance
like
ever,
and
our
fixers
can
probably
make
that
same
assumption,
even
though
someone
could
very
easily
say
throw
from
within
their
implementation.
A
F
The
the
linked
issue,
the
one
where
we
have
contains
key
followed
by
remove,
is
still
marked
as
open,
meaning
that
analyzer
has
not
been
created
yet,
even
though
I
believe
it
was
approved.
I
would
be
curious
to
see
if
people
report
problems
with
that
once
it's
checked
in.
C
A
A
A
Like
that's
where
it
gets
weird
like
we
could
highlight
this,
but
not
offer
a
fixer,
because
there's
a
method
invocation
expression
between
them.
F
You
would
you
would
also
have
to
change
that
to
an
if
statement,
which
means
that
we're
we're
now
altering
the
flow
graph
of
the
person's
method.
A
E
I
mean
I
think
this
goes
back
to,
like
you
know,
you're
flagging
code
right
so,
like
I
think
in
this
case,
I
think
it's
fine
to
say:
do
we
really
want
to
encourage
people
to
have
semantics
like
that?
Where
you
say,
oh,
if
you
throw,
then
the
remove
doesn't
do
anything
or
do
you
want
to
say
don't
write
code
like
that
right?
Do
they
you
know
you're
doing
you.
I
think
it's
fair
to
say.
90
of
people
would
assume
that
this
thing
doesn't
throw
right.
A
A
If
this
is
some
sort
of
you
know,
work
tracker,
this
is
do
work
on
this
key.
I
was
given
that
succeeded
now
clear
the
work
like
that's
that's
different,
so
like
that's
it
it's
an
entirely
possible
flow.
It
may
be
less
than
10,
but
it's
totally
entirely
possible
that
this
code
on
the
screen
would
be
do
some
work.
Great.
The
work
is
done.
Remove
the
thing
we
don't
need
to
do,
processing
on
it
anymore.
F
E
I
mean
so,
if
you
painted
from
that
point
of
view
right,
then
you
would
say
well
if,
if
the
goal
of
this
whole
rule
is
perf
right,
then
the
semantics
of
bar
is
throwing,
and
then
you
don't
do.
The
remove
seems
weird
at
that
kinds.
You
probably
want
to
say
well
bash
your
body
return
a
bull,
and
then
you
should
have
that
thing
unconditionally
under
that.
F
E
F
C
E
A
Yes,
especially
if
you
trim
it
a
lot
dot
dot,
dot
exceptions
are
better
performance
than
ifs.
A
E
F
A
There
was
a
method
call
in
between
and
this
may
be
the
same
in
all
of
your
code,
but
we
don't
want
to
offer
a
fixer
here
because
there's
a
method
involved,
I
don't
know
if
we
even
wanna,
I
don't
know
if
we
wanna
highlight
that
or
if
we
just
want
to
say
this
is
obvious.
We
will
highlight
it,
we
will
fix
it.
A
A
A
Right,
if
you
have
a,
if
you
have
a
custom
comparer
that
counts
the
number
of
times
you've
called
it
and
gives
different
answers,
then
I
don't
care
about
you.
No,
that.
F
Would
be
the
only
code
that
would
be
broken
here?
It's
not
that
it's
like
the
the
only
time
I
ever
expect
someone
to
be
cognizant
enough
to
actually
store
the
value
into
a
local
before
calling
remove
is
for
someone
who's,
already
kind
of
an
expert
in
using
dictionaries,
and
those
people
are
already
using
try,
get
value
and
remove
and
other
advanced
apis.
F
A
F
I
mean
yeah,
yes,
I'm
I'm
having
trouble
imagining
that
the
number
of
people
who
would
benefit
from
an
analyzer
is
worth
the
cost
to
us
to
implement
it.
But
if
we
want
to
go
for
it,
then
let's
go
for.
H
A
Remove
with
an
out
assuming
emo's
table
is
right.
Here
is
we
added
that
is
not.net.
F
E
F
A
That's
true
programming
is
hard.
Programming
is
hard
so
who
wanted
to
say
if
it's
a
call
to
try
to
get
value.
F
This
is
why
I
actually
think
steve
was
kind
of
on
the
right
track
earlier.
Where
contains
key
and
then
indexer
is
try,
get
value
and
then
try
get
value
and
then
remove
is
more
different
to
remove
overload
just
start
chaining
them,
and
if
you
have
a
call
to
an
indexer
followed
by
remove
well,
it
could
throw
in
so
many
different
places.
We
just
don't
touch.
F
F
F
I
A
F
I
A
F
It's
fine.
If
the
answer
is
no,
I'm
just
curious
as
to
what
you
know.
A
Again,
it's
it's
when
things
get
weird
in
multi-targeting
scenarios
right
like
okay,
the
the
the
case
of
remove
here
is
probably
not
better
enough
that
you
would
pound
if
all
of
the
cases
that
you
ran
across
it.
If
your
net
standard
2o
and
a
net
core
specific,
like
you
just
turn
the
rule
off,
but
you
would
still
want
the
other
rule
to
run
so.
A
F
Yeah,
the
the
being
able
to
turn
one
of
them
off
independently
is
a
good
reason.
I
just
I
wasn't
aware
of
a
case
where
a
person
might
want
to
do
that,
but
sure
yeah.
A
F
E
I
think
that's
a
broader
discussion.
I
mean
there
was
a
recent
comment
that
tanner
made
about
how
c
sharp
doesn't
actually
enforce
cls
compliance
anymore.
I
didn't
quite
understand
what
he
meant
by
that
I
mean
we,
so
the
problem
was
here:
that's
compliance.
Is
we
care
about
the
spirit?
I
don't
think
we
care
about
the
particular
mechanics
that
we
currently
have,
because
they
they
have
not
aged
very
well
right.
E
So
the
problem
that
we
effectively
have
now
is
that
the
things
that
are
actually
causing
us
trouble
with
language
interop
are
not
actually
caught
by
cls
compliance
anymore
right.
So
because
now
the
challenge
that
we
have
is
that
it's
not
apis.
It's
really
type
system
features
that
the
thing
doesn't
really
track.
So
this
is
a
refs.
You
know
struct,
for
example,
versus
this
is
a
dim
versus
this
is
a
you
know.
E
I
don't
know
certain
interface
constraints
that
we
now
add,
and
so
I
think
it
would
be
nice
to
have
an
analyzer
similar
to
cds
compliance.
That
would
tell
us
hey,
you're,
exposing
an
api
that
is
no
longer
across
language.
Are
you
sure-
and
I
think
the
spirit
that
we
want
to
have
is
that
there
is
another
way
of
doing
it
and
the
way
it
can
be
slower
or
you
know
more
involved
or
whatever,
but
it
should
generally
be
possible
to
use
the
platform
right,
and
so
I
think
that
makes
sense.
E
I'm
not
sure
that
cls
compliance,
true
false,
is
the
way
to
do
that,
though
that's
kind
of
the
problem,
so
I
don't
know
quite
what
to
do
with
it.
To
be
frank,.
F
E
Right,
I
think
the
trouble
effectively
is
that
the
way
cds
compliance
was
meant
to
work
is
basically
you,
you
bubble
it
up
right
and
then
it's
a
very
similar
to
security
transparency
where
it's
a
similar,
but
it's
a
very
simple
thing
to
understand
right,
and
so
you,
what's
nice
with
that
model,
is
that
it
converges
and
that
it
you
know
you
only
have
to
look
at
a
given
api
and
to
know
what's
this
apis,
that's
compliant
or
not,
versus
with
the
analyzer,
it
would
be
a
bit
harder
to
bubble
that
up
in
api
reviews
right
because
well,
how
do
we
know
that
something
is
not
cls
compliant
in
that
sense,
right.
E
E
Yes,
and
so
I
think
the
the
and
across
is
also
not
really
a
a
well-defined
term
either
right,
because
it's
not
like
you
know,
there's
super
subjective
relationship
with
every
language,
but
there
is
a
an
overlapping
venn
diagram
and
we
can
totally
say
that
we
think
of
class
compliance
as
literally
the
innermost
circle
right,
the
lowest
common
denominator,
but
that's
that
might
not
be
usual.
E
You
know
what
we
actually
want,
because
there
are
certain
languages
like
you
know,
cobol.net,
which,
quite
frankly,
I
don't
care
whether
I
can't
use
certain
features
right,
I'm
not
going
to
dumb
down
the
platform
because
they
stopped
evolving
right.
But
if
you
look
at
the
actual
languages
that
are
still
kept
up
to
date,
specifically
c
sharp
and
f
sharp,
then
also
there's
a
different
bar
between
c
sharp
and
f
sharp
versus
v
b
right,
because
v
b
basis
said
we
don't
want
to
evolve.
E
F
G
E
Yeah
and
so
that's,
I
think
why
I
think
it's
a
bit
more
on
on
kathleen
and
and
whoever
the
new
f
sharp
pm
is
and
mads
to,
I
think,
come
up
with
like
okay,
here's
how
we
should
think
about
that,
and
then
we
can
probably
find
a
way
to
automate
that
because
I
feel
like
if
we
don't
automate
it
we're
going
to
miss
things
right,
and
maybe
that's
okay,
because
I
mean
you
can
always
say.
E
Maybe
we
just
have
to
add
you
know,
string
based
methods
later
or
something
right
like
what
we
did
with
span,
which
is
also
fine
but
like
I
I'd
rather
have
these
things
bubble
up
doing
design,
because
then
we
can
still
influence
the
design
right.
We
don't
have
to
try
to
find
you
know
a
way
to
make
the
square
hole
fit
the
round
pole
or
whatever
the
saying
is
right
so
yeah.
I
think
that
is
something
we
should
think
about
how
we
do
cls
compliance,
but
I
don't
have
a
good
answer
for
that
today.
E
F
E
I,
yes,
I
think,
that's
fair.
I
think
this
needs
to
design,
I
think
more
than
anything
and
then
you
know
I
have
a
slightly.
I
would
be
biased
to
what's
saying,
could
we
fix
the
class
compliance
mechanics
that
we
have
today?
Maybe
the
answer
is
yes.
Maybe
the
answer
is
no
right,
so
yeah,
but
it
will
be.
E
E
Some
of
the
limitations
we
have,
but
I
feel
like
it's
very
easy
to
to
make
mistakes,
because
these
things
are
nuanced
right
and.
F
E
Well,
like
worst
case,
like
two
years
after
we
shipped
right-
I
mean
yes,
I
mean
that's.
The
other
reality
is
that
you
know
the
language
ecosystems
also
move
for
different
cadences
right,
vb
is
definitely
trailing
behind.
F
sharp
is
is
moving
as
fast
as
c
sharp
but
like
they
don't
use
the
same
sort
of
libraries
right.
E
So
if
you're
building
a
website
with
the
f-sharp
you're
not
very
likely
to
use
asp.net
right
so
like
there
is
a
there,
certainly
is
a
bias
towards
well
certain
things
may
never
materialize
in
the
next
two
years
right
so
the
so.
If
we
don't
consider
that
we
may
be
too
late
right,
so
that's
the
other
side
of
it
all
right.
I
think
we
discussed
this
to
death,
so
I
think
it's
something
we
need
to
put
on
hold.
E
A
A
E
E
I'm
okay
with
doing
that,
because
that's
kind
of
like
not
changing
anything
it
just
I
mean
this
is
these:
are
old
fx,
cop
analyzers?
That
reported
right,
so
they
I'm
fine
with
saying
you
know,
we
can
definitely
change
defaults
right
that
doesn't
make
any
sort
of
drastic
changes
to
the
infrastructure.
E
A
E
E
E
E
E
F
47927
yeah
so
in
in
a
nutshell,
the
the
very
first
line.
Oh
sorry,
there
there
are
overloads
of
string,
dot,
split
which
will
take
you.
You
see
you,
you
see
that
string,
dot
split.
It
takes
a
char
separator
than
the
int
count
than
the
string
split
options.
There
are
scenarios
in
which,
if
you're
passing
a
literal
char
to
as
a
string,
dot
split
parameter
that
char
might
actually
match
the
into
count
parameter
rather
than
the
separator
parameter.
F
There's
there's,
if
you
scroll
down
like
there's,
actually
a
proposal
for
that
as
a
more
general
rule,
you're
right,
not
just
for
string
split
there.
A
I
I
F
F
In
in
the
related
issue
46103,
I
had
also
potentially
proposed
that
we
special
case
parameter
names
to
say:
if
it's
capacity
or
count,
then
we
trigger
the
analyzer.
Otherwise,
maybe
we
don't
but
triggering
on
parameter
names
rather
than
just
api
shapes
seems
a
bit
weird
to
me.
I
I
D
F
Think
the
proposal
had
it
only
for
cons,
but
I
mean
we
absolutely
could.
If
we
felt
like
that
was
the
the
more
common
case
I
mean
it
would
certainly
fulfill
string.splits
requirements.
A
Yeah
I
mean
granted.
If
you
had
an
array
called,
you
know,
match
chars
and
you
passed
match
charge
sub-zero
on
match,
charge
sub
one.
You
could
have
just
passed
the
array,
but.
A
E
F
I
I
I
do
struggle
with
this
because
at
that
point
we're
basically
implementing
a
arguably
it's
a
style
rule
and
I
don't
think
we
should
really
be
in
the
business
of
style
rules.
At
the
same
time,
we're
trying
to
flag
actual
mistakes
in
people's
code,
but
we're
basically
writing
a
rule
that
says
you
have
to
use
explicit,
casts.
E
Well,
I
wouldn't
go
that
far.
I
would
just
say
like
this.
Particular
conversion
is,
like
you
know,
make
up
some
percentage
indication
of
an
accident
right.
So
that's
why
it's
good
to
have
an
explicit
cast.
For
that
I
mean,
arguably
I
would
say
c
sharp
messed
up
in
department,
but
like
that,
that's
maybe
a
different
thing,
but
like
most
implicit
costs,
are
fine
right,
like
that's
yeah
like.
A
Implicit
bite
to
int
implicit
in
to
long
those
make
sense,
but
I
feel
like
I
guess
I
don't
know
what
we
take
in
split.
I
assume
it's
char
array
and
not
interval
of
char.
A
Yes,
so
if
you
had
a
string
that
was,
you
know,
string
and
you
pass
split
string,
sub
zero
split
string
sub
one,
because
I
don't
know
you're
weird
like
saying
that
you
want
that
you're
passing
an
index
or
expression
on
a
string
into
a
thing
that
takes
ends
that
feels
like
you're,
probably
not
calling
what
you
think
you
are
calling,
which
is
why,
for
me,
it's
yeah
that
maybe
we're
being
a
bit
opinionated,
but
I
feel
that
the
implicit
conversion
from
char
to
anything
is
wrong.
F
What
we
might
be
able
to
do
so
that
this
problem
also
affects
string
builder,
which
is
the
related
issue,
that's
linked
from
here
it
because
it's
sometimes
people
will
try
to
pass
a
char
to
the
string,
builder
constructor
and
lo
and
behold,
it
gets
implicitly
turned
into
an
int
and
now
you've
specified
the
capacity
rather
than
an
initial
value
for
the
string
builder.
F
So
maybe
what
we
can
do
is
find
all
the
apis
across
the
bcl
that
take
char
as
parameters.
I
don't
think
there
are
a
whole
lot
of
them.
I
really
don't
think
it's
common
to
pass
that
across
an
abi
and
then
we
can
see
just
how
bad
this
problem
really
is.
Aside
from
these
two
apis.
I've
really
not
heard
of
this
being
an
issue.
F
Which
which
we
could
yeah,
but
we
would,
we
would
want
the
evidence
first,
that
that
these
are
really
the
only
two
things
that
are
a
problem
which,
like.
I
A
F
Now
we
would
have
found
them
yeah,
no
you're,
absolutely
right
steve.
My
heuristic
for
looking
for
stuff
would
not
have
worked.
F
No,
I
guess
what
you
would
want
is
you
would
want
to
look
at
apis
which
which
take
ins
and
also
have
overloads
that
take
chars
or
strings,
because
then
that
that
could
be
an
indication
that
there's
a
char
being
widened
here.
I.
F
A
A
A
A
You
went
from
character
data
into
number
data,
and
maybe
you
didn't
mean
to
do
that.
So
what
are
we
thinking?
We
should
do.
F
So
special
casing,
the
two
apis
I
think,
gets
this
immediate
benefit
the
I
I
think
there
is
an
argument
to
be
made
for
doing
a
wider
investigation,
but
as
far
as
I'm
aware,
no
one
has
time
to
commit
to
it
in
the
foreseeable
future.
E
E
E
F
Both
fine
steve
would
that
also
alleviate
your
concerns
too,
where,
if
we
narrow
it
just
to
these
two
apis,
we're
very
unlikely
to
find
false
positives.
H
F
And
if
you
really
intended
to
do
it,
like
you
said,
I
think
emo
just
do
the
explicit
cast
and
column
day
and
the.
C
D
D
A
F
I
I
say
start
with
warning
and
then
we'll
do
our
normal
thing
of
running
it
over.
You
know
various
code
bases
and
it
shouldn't
find
anything.
If
it
does,
we
should
reconsider
well
either
it
finds
things
and
they're
all
you
know
true,
and
we
need
to
fix
them
or
it
finds
things
that
we
reconsider
if
they
were
false
positives
for
some
reason,.
F
F
Yeah,
okay
yeah.
I
I
didn't
know
if
reliability
was
like
like
instability
versus
like
just
hey,
you're,
doing
something
wrong.
E
E
E
E
A
That
for
a
local
variable,
specifically
not
a
parameter
so
for
a
local
variable
or
a
non
public
field
or
non-protected
field,
make
sure
that
the
field
is
assigned
to
the
strongest
or
declared
as
the
strongest
type.
It
can't
be.
A
E
I
I
We
could
of
course
choose
to
not
offer
a
fixer
if
we
were
really
concerned
or
we
could
do
something
else,
but
I
think
the
case
is
where
this
will
go
wrong
or
few
and
far
between.
I
F
By
the
way,
this
analyzer,
if
it
already
existed
in
dot
net
6,
would
have
found
bugs
before
we
checked
them
in
or
it
would.
It
would
have
found
regressions
sorry
before
we
checked
them
in
one
of
the
things
I'm
thinking
of
right
now
is
where
we
made
a
change
to
system
text
json
and
regressed
the
size
of
the
binary
by
like
10k
in
wasm
scenarios,
and
that
was
largely
due
to
the
fact
that
we
had
a
private
field
as
an
interface
rather
than
the
concrete
type
that
we
knew
the
interface
to
be.
This.
I
E
I
mean
what's
funny,
though,
is
that
this
is
the
opposite
of
what
resharper
recommends
and
also
the
opposite
of
what
people
in
the
java
ecosystem
are
usually
doing
like
they
had
this
guideline.
A
Yeah
I
mean
it
does
move
into
cases
where
you
know
the
the
more
specific
you're
writing
your
declarations,
the
it
does,
make
it
a
little
harder
to
refactor
some
things
later,
but
I
don't
know
too
many
people
who,
if
they
had
a
a
local
that
was
a
list
that
are
really
going
to
want
to
change
it
to
ilist
or
innumerable
later.
I.
I
A
I
There's
value
in
both,
but
the
real
value
comes
from
going
to
as
well
there's
absolutely
value
in
going
to
a
class
instead
of
an
interface
and
there's
absolutely
value
in
going
to
a
sealed
class
instead
of
an
interface,
and
there
is
minimal
value
in
going
to
a
more
derived
more
to
whatever.
You
want
to
call
it
interface,
but
not
much.
I
E
A
A
list
in
one
case-
and
I
don't
know
something
else-
that's
an
eye
list
and
another
an
array
and
another-
and
it's
like
you
could
have
made
this
eye
list
like
you're
gonna,
make.
I
G
Obviously,
the
like
dictionary
thing
that
steve
brought
up
in
the
comet
for
locals
one
of
the
few
times
I
don't
use
far
because
I'm
on
asp.net
is
when
I
want
an
interface,
because
the
class
I'm
calling
you
know
has
only
like
an
explicit
interface
implementation
for
the
thing
that
I'm
doing
and
then
that
probably
won't
compile
if
it
switched
to
the
concrete
type
I
mean
you
could
obviously
cast,
but
that's
why
I'm
declaring
it
well.
I
I
mean
I
think
anyway,
we
would
need
the
rule
to
flag
those
things,
so
the
rule
would
also
need
to
look
at
usage
sites
and
we
need
to
decide
whether
we
we
wanted
to
use.
You
know
explicit,
cast
at
each
call
site
or
just
not
worn
in
that
case.
G
Yeah
yeah,
I
guess
if
you
could
evaluate
whether
it
break
compilation,
then
that
would
solve
most
of
it.
Well,.
A
Yeah,
I
guess
I
don't
know
which
way
the
linker
would
go,
but
presumably
as
long
as
it's
not
a
value
type,
the
the
interface
cast
is
freeish
and
so
having
it
at
the
call
site
instead
of
at
the
variable
site
or
variable
declaration,
means
that
the
linker
should
know
that
it
gets
to
still
throw
a
bunch
of
stuff
away.
F
Yeah,
you
could
you
could
even
imagine
the
compiler
doing
that
on
our
behalf.
If
we
knew
certain
things
ahead
of
time
like
that,
the
class
was
sealed,
blah
blah
like
we
could.
We
could
literally
just
change
the
il
that's
actually
emitted
to
be
more
efficient
other
like
we
could
also
change
the
jit
to
kind
of
be
a
little
more
optimized
here.
There
are
weird
edge
cases.
F
F
Whatever
and
I
imagine
the
scenarios
that,
like
stephen,
was
talking
about
that's
what
you're
not
enumerating
over
those
interfaces
right,
they're,
just
calling
methods
on
them.
G
I
I
Compilation
because
of
you
know
explicitly
implemented.
I
We
could
have
to
fix
or
automatically
fix
the
call
sites
and
someone
could
choose
to
apply
the
rule
if
they
wanted
to
or
not.
They
argued
to
that
particular
instance.
It's
just.
I
A
Because,
again,
with
a
sealed
type,
we
know
everything.
But
if
you
go
from
you
know
I
enumerable
to
I
list:
no,
okay,
that's
a
bad
one.
If
you
go
to
a
non-sealed
type
from
an
interface,
a
more
derived
type
could
have
explicitly
implemented
the
interface
and
you
could
now
you're
now
changing
your
call
flow.
A
F
E
A
A
F
Would
it
be
possible
to
simplify
this
by
by
trapping
only
the
example
that
was
given
here,
where
you
have
an
inline
assignment
as
part
of
the
field
declaration.
F
F
A
constructor
parameter,
and
then
you
assigned
it
to
a
field
of
an
interface
or
a
base,
type
like
traffic.
E
F
Okay
well
ignore
read-only.
Then
right
say
that
say
that
the
field
is
assigned
from
only
one
place
and
it's
assigned
from
a
new
statement.
E
F
E
But
that's
what
I'm
trying
to
say
is
like.
If
I
let's
say
I
derive
from
list
of
t
and
I
re-implement
I
I
list
of
you
know
of
t
right
and
now
I
assign
it
to
an
I
list
of
t
rather
than
my
derived
type
of
list
of
t
right
then,
even
if
it's
only
assigned
once
that
that
changes
behavior,
and
so,
if
we
give
up
on
that,
then
I
don't
know
why
we
would
limit
it
to
just
one
assignment.
F
I
guess
I
I
thought
we
were
saying
that
we
wanted
to
support
that,
that
someone
could
have
subclassed
list
of
t
and
then
and
then
we
we
didn't
want
to
start
calling
like
intermediate
methods
without
going
through
the
the
most
derived
implementation.
Did
I
misunderstand
that.
E
Well,
yeah,
I
guess
I'm
saying
like
we
should
make
a
decision
whether
we
care
about
people
doing
these
kind
of
things,
because
it
will
be
very
hard
to
track
and
I
think
like
I
would
just
have
a
rule
that
is
easy
to
explain
and
I
think
it
seems
easy
to
explain
to
say:
hey
across
all
your
assignments.
We
notice
the
common
type
is
full,
but
you
declared
you
know
an
even
more
base
type.
Maybe
you
should
use
foo
instead
right.
F
E
And
that's
the
thing
I
don't
have
a
good
handle
on
like
to
me.
These
all
seem
like
almost
unintentional
corner
cases,
rather
than
intentional
behaviors.
F
E
F
Sure
I
I
guess
I
was
saying
that
a
a
a
potential
equivalent
rule
could
be
like
we
assigned
and
the
assignments
were
the
result
of
a
new,
which
means
we
actually
know
the
honest-to-god
concrete
type
going
in
there
like
we
didn't
take
it.
We
didn't
just
fetch
it
as
a
return
value
for
a
method
somewhere,
and
in
that
case
we
know
that
we're
not
going
to
bring
into
these
holes.
E
A
Yeah,
so
you
know
just
a
quick
example
here
of
what
we
would
break
and
that's
this
will
no
longer
call
ilist
ad,
it
will
call
list.ad,
and
so
it
would
bypass
the
side
effect
of
calling
out
here
right
well
in
in
your
case,
we.
F
E
I
mean
I
think
it's
reasonable
to
do
these
gymnastics,
but
then
I
think
you
really
want
to
redefine
new
as
well
like
you
really
want
a
public
new
ad
to
to
make
things
sensible
right.
Otherwise,.
A
A
Yeah-
and
I
don't
think,
there's
any
problem
with
going
to
a
more
specific
interface,
because
usually
the
more
specific
interface
is
not
going
to
redefine
like
they're,
not
going
to
have
used
new,
so
you're
not
going
to
change
what
you're
calling
there.
So
the
the
interface
one
is
actually
a
safer
substitution.
F
Right
but
the
if
the
point
of
this
is
for
performance,
then
staying
within
an
interface
isn't
really
going
to
help
you
at
all
anyway.
A
Right
so,
but
I
think
emo
had
the
suggestion
of.
If
the,
if
the
most
common
type
is
an
interface,
then
don't
bother
firing
the
thing
it's
we've
already
done
the
work
assuming
assuming
that
that
is
an
easy
enough.
Like
the
compiler,
you
can
throw
three
types
at
it
and
ask:
what's
the
most
common
base
type
or
even
you
just
throw
two
at
it.
Then
then
great,
we
we
have
an
answer.
A
And
that's
the
the
cases
that
I
can
come
up
with
are
our
x509
certificates.
Has
you
know
we
have
like
the
I
export
pal
well
in
each
of
our
individual
os's,
there's
only
one
instantiation
of
that
interface
and
it's
explicitly
assigned
in
a
thing,
but
if
you
look
across
the
way
that
it
gets
declared
in
the
way
that
it
gets
utilized
like
the
reason
we
have,
the
interface
is
because
having
the
interface
means,
we
get
a
better
answer
than
I
can't
find
this
method.
F
A
F
F
If,
if
the
type
itself
is
marked
with
serializable
or
the
field
is
marked
with
data
member
or
the
type
is
marked
with
data
contract,
I
believe
we
should
suppress
this
rule
because
at
that
point,
like
we're
changing
how
the
serializers
behave
and
there
may
have-
there
might
have
been
a
very
good
reason
that
they
wrote
the
type
that
way
they
did
and
we
might
actually
break
their
code.
But
it
can.
E
E
I
feel
like
once
you
once
you
say
that,
like
what
does
it
mean
any
attribute
of
the
json
one,
any
attributes
of
the
data
contract
once.
E
G
A
E
I
would
probably
start
with
info
and
see
what
people
are
getting.
As
I
said,
there
will
be,
some
people
will
absolutely
hate
it,
but
given
that
it's
a
pro
optimization,
I
don't
see
a
reason
why
we
would
turn
it
on
by
default.
A
E
Yeah
I
mean
it
is
debatable.
I
think
moving
forward
like
I
think,
there's
this
question
now.
You
know
if
somebody
writes
a
library,
do
we
want
this
library
to
be
great
for
linking
by
default?
If
the
answer
is
yes,
then
all
the
rules
that
are
off
by
default
that
would
take
away
from
that
might
be
problematic
right.
So
we
might
boost
it
later,
but
I
think
starting
with
info
is
probably
the
right
call.
F
Yeah,
oh
and
internal,
also
not
just
public
and
protected.
E
A
Well
because,
but
you
know
during
the
the
compilation
phase,
whether
or
not
you
have
the
ivt
like
it's,
it's
part
of
the
compilation
or
not.
The
analyzer
runs
basically
as
part
of
a
compilation
unit
or
runs
as
part
of
a
compilation
so
effectively
the
so
you
would
know
if
it's
there
now.
Yes,
you
could
be
in
the
state
where
your
inmate
make
file
adds
an
internals
visible
to
and
your
cs.
Proj
doesn't
have
it,
but
I'm
sorry,
windows
in
office
get
on
a
unified,
build
system.
A
Yep,
so
I
guess
now
I
get
to
eat
a
very
rushed
lunch,
but
I
observe
that
we
are
beyond
time
and
we
actually
got
through
everything
we
wanted
to
get
through.
I
think
so
yeah
I
don't
see
analyzer
on
here
at
all,
and
our
list
is
getting
nice
and
small,
so
I
don't
know,
propose
new
api
and
with
that
I
declare
the
meeting
adjourned
have
a
nice
day.