►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
Know
something
in
his
setup
is
broken.
Oh
apparently,
because
I
forgot
to
change
back.
We're
live
already.
Oh
awesome.
As
a
few
seconds
ago,
yeah
emo
has
had
some
technical
difficulties
with
hosting
so
until
he
gets
them
worked
out,
I'm
being
the
driver.
Okay,
so
hello,
everyone
welcome
to
thursday
edition.
As
you
can
see,
people
like
painting
things
red,
so
we
didn't
quite
get
to
the
no
red
state
that
we
wanted
to.
A
So
we
will
kick
off
with
apparently
a
complicated
one.
A
low
level
aci
api
support
for
objective
c
scenarios.
Four
four:
six:
five
niner
aaron
talk
to
me.
B
Okay,
this
is
not
gonna,
be
fun,
so
just
just
set
the
set
the
tone
here.
Basically,
this
is
around
trying
to
get
close
to
how
we
do
interop
in
the
comm
world,
but
apply
it
to
objective
c.
B
That
was
the
real
goal
like,
let's
just
make
it
as
simple
as
possible
and
symmetrical,
and
there
were
issues
there
are
issues
there,
particularly
around
existing
scenarios,
that
we
don't
necessarily
want
to
break
because
of
the
existing
pattern
in
xamarin.
B
B
So
that's
that's
kind
of
the
scope.
An
example
of
this
is
if
we
like,
for
example,
if
we
were
to
say
if
we
were
to
own
the
entire
interop
hierarchy,
we
could
say
well,
the
base
type
is
x,
so
we
know
exactly
what
to
do
with
it.
We
know
it's
a
part
of
the
objective
c
interop
layer,
but
because
of
impacting
this
type
hierarchy
is
a
non-trivial
exercise,
particularly
from
a
compatibility
standpoint.
B
We've
added
an
attribute,
and
on
typeload
we
look
at
the
type
that's
loaded.
We
see
this
attribute
and
we
set
a
bit
and
so
we've
we've
circumvented
changing
the
type
system
by
adding
an
action.
So
that's
what
that
first
attribute.
Does
it
tells
us
that
this
type
is
involved
in
the
objective-c
interop
layer.
A
A
You
know,
objective
c
object
like
we
could
insert
that
in
the
net
six
definition,
even
if
it
wasn't
there
and
then
at
five
definition
and
as
long
as
you
end
up
unified
to
the
net
six
or
seven
or
whatever
we're
talking
about
for
this
universe.
You
would
see
that
it's
an
objective
c
based
thing
because
paint
whether
it's
painting
an
attribute
or
adding
a
base
type.
It
still
won't
work
for
older
types.
Unless
we
have
an
injection
system.
B
Yeah
they
were
considered.
This
is
the
other
factor.
Here
is
the
existing
code
generation
logic
that
exists
for
xamarin.
Okay,
you
know
adding
that
type
into
that
hierarchy
was
considered
too
much
of
an
impacting
change.
So,
yes,
your
point
is
fair.
I
think
yan
brought
that
up
as
well.
It's
like
we
could
put
this
in
the
base
and
it
will
just
inherit-
and
it's
not
going
to
hurt
anything.
It's
not
going
to
be
a
breaking
change
for
existing
binaries,
but
the
impact
to
the
system
was
deemed
too
expensive.
C
To
be
fair,
like
you
know,
the
design
of
this
api
is
kind
of
you
know,
based
on
kind
of
you
know
these
negotiations
and
compromises
right.
I
I
think
you
know,
for
the
code
generation,
like
all
the
objective
c
types
really
inherit
from
some
base
type
right
so
to
mark
the
base.
C
Types
with
this
attribute
is
about
as
impactful
co-generation
change,
as
you
know,
changing
the
base
type
to
something
else,
but
you
know
it's
kind
of
negotiated
to
end
up
with
attributes,
so
we
can
certainly
put
it
into
nodes
that
you
know.
Maybe
the
base
type
would
be
better
and
you
know
do
we
really
understand
that
it
attribute
makes
the
code
generation
that
simple,
yeah.
A
Okay,
I
was
just
making
sure
we
didn't
end
up
with
something
complicated
because
of
the
of
out
of
ignorance.
I
guess
of
making
sure
like.
Oh
the
types
already
exist
and
we
can't
add
base
types
it's
like
well,
we
can,
we
just
have
to
do
it
right
and
john's
one
of
the
people
who
knows
how
to
tell
us
how
to
do
it
right
so.
C
Yeah
and-
and
you
know
like
having
the
base
type,
would
make
the
rest
of
the
api
is
kind
of
cleaner,
because
it's
like
that.
One
of
the
apis
that
we
look
later
at
takes
basically
object
as
an
argument,
but
it
basically
requires
that
object
to
be
marked
with
this
attribute
right.
So
if
we
instead
have
that
api,
taking
the
the
strongly
strongly
type
type
base
type,
it
would
be
cleaner.
C
B
B
B
A
C
B
C
Is
you
know
just
some
points
about
the
naming
guy
like
one
question,
is
whether
it's
really
worth
having
a
new
name
space
for
this,
because
there
will
be
like
one
or
two
types
in
it
ever
right,
whether
it
should
just
make
it.
You
know,
objective
c:
support
in
the
system:
runtime
interrupt
services,
marshall
system,
runtime,
internet
services,
name
space
right,
that's
a
point
to
consider.
C
C
It's
basically
the
point
of
this
api.
You
know
it's
like
it's.
It's
not
kind
of
the
the
the
primary
point
of
the
design
was
to
make
something
that
allows
the
existing
xamarin
interrupt
to
work
without
breaks
right,
so
the
design
is.
That
was
like
number
one
goal
for
the
design
right.
You
know
the
the
existing
xamarin
interop
is
based
on
the
mono
embedding
api.
So
it's
reaching
out
to
the
guts
of
the
mono
run
time
to
do
what
it
needs.
C
We
wanted
to
kind
of
have
something:
that's
you
know
smaller
surface
and
then
we
can
kind
of
declare
hey.
This
is
the
this.
Is
the
api
to
for
the
objective
c
interrupt
support
to
work
with,
so
this
was
kind
of
the
minimum
set.
We
came
up
with
that
manage
the
constraints
right.
B
It
really,
it
really
is
very
targeted
at
the
xamarin
like
honestly.
If
we
wanted
to,
we
could
literally
call
this
xamarin
bridge
interrupt
like
that's
it
is
that
tailored
you
could
you
could
absolutely
use
this
api
and
you
know,
replicate
the
xamarin
bridge
as
it
exists,
but
you
would
basically
need
to
follow
its
design,
which
may
or
may
not
be
the
best
design,
but
that
is,
it
is
literally
enabling
a
very
specific,
targeted
scenario.
B
So,
to
that
end,
the
name
of
the
class
aside,
the
the
first
function
we
have
is
the
callbacks,
and
this
is
very
much
related
to
what
jan
is
referring
to
as
the
trying
to
project
or
the
the
trying
to
project
what
the
mono
embedding
api
delivers
in
a
managed
api
service
and
it's
the
minimum
set
to
need
that
that
is
needed.
That
just
doesn't
exist
in
any
other
way,
and
this
one
is
about
specific
callbacks
during
garbage
collection
that
are
needed
to
track.
B
These
interop
objects
across
the
boundary
and
it's
it
they're
they're
global.
They
are
specific
for
the
xamarin
bridge
because
of
how
it
was
designed,
but
this
is
largely
correct
if
we
could
have
changed
a
lot
more,
this
would
have
been
all
internal
implementation
detail
if
we
had
like
our
base
type
and
all
these
other
things.
B
Have
actually
done
this
onto
the
covers
initialize
the
reference
tracking
begin
and
end
when
that
reference
tracking
occurs.
These
are
just
callbacks
is
reference
callback
if
we
are,
if
anybody's
familiar
with
the
ref
counted
gc
handles
that
we
use
in
com
interrupt.
That
is
the
callback
for
every
object
and
the
tracked
object
has
entered
the
finalizer
or
finalization
queue.
B
A
I
mean
I'm
just
curious,
it
doesn't
really
matter
or
impact
the
api,
but
I
assume
that
tracked
object
entered
finalization
is
before
you
return.
The
callback.
The
native
side
should
be
done
with
it,
because
we're
about
to
consider
everything
dead
or
does
it
just
say
like
this
now
begins
when
the
managed
code
no
longer
cares
about
this
object
and
native
can
do
whatever
it
wants.
A
So
if
it
was
an
on
because
we
don't,
if
we're
not
enforcing
a
base
class,
then
there's
not
an
enforcement
of
a
finalizer
or
at
least
a
custom
finalizer.
So
is
this
yeah
just
you're
in
that
late
stage
of
garbage
collection
and
the
managed
code
is
about
to
not
care
so
be
aware.
The
manage
code
is
about
to
not
care.
B
That
this
case
so
to
answer
your
first
question.
Yes,
all
types
in
this
system
because
of
how
xamarin
was
designed
the
xamarin
interop
was
designed,
will
have
a
finalizer
okay,
that
is
true,
but
by
design
there
is
nothing
enforcing
that
as
you
as
you
point
out
right,
we
can't
enforce
that,
but
that
is
how
it
is
designed.
F
So
one
question
I
have
is
so
who,
like
what
kind
of
infrastructure
is
calling
these
apis
is
this
kind
of,
like
a
kind
of
a
managed
wrapper
around
some
objective
c
apis?
That
basically
deals
with
the
you
know
interrupt
to
objective
c.
Is
that
kind
of
because
I
mean
they
seem
like
very
runtime
specific
api.
So
why
is
it
why,
basically,
why
are
these
public
against
my
question?.
F
So
like
they
seem,
like
you
know
as
janus
counted
earlier,
they're
kind
of,
like
you
know,
into
the
guts
api,
so
why
do
they
have
to
be
public?
Is
that
because
the
there's,
like
some
sort
of
managed,
wrapper
around
objective
c
apis
as
everyone
provides
that
has
to
call
them
similar
to
com
interrupt
or
win32
wrappers?
Is
that
kind
of
the
the
the
question.
B
F
B
Yes,
this
is
a
this
is
code
gen
in
the
in
the
z,
amaron
layer,
which
is
not
part
of
the.net
system
right.
It's
that
it's
it's
a
completely
different
live.
I
don't
know,
I
don't
know
if
framework
is
the
right
way
to
put
this,
but
it's
at
a
different
layer.
It's
not
built
into
the
system
so
providing
a
public
api
is
the
only
real
way
to
do
that
and
they
use
a
ton
of
code
gen
that
will
consume
these
apis.
B
F
B
Exactly
it's
almost
identical
to
that,
the
the
down
the
one
caveat
to
that
is
it's
it's!
Exposing
a
bunch
of
low-level
constructs
that
we
did.
We
didn't
have
to
expose
in
winrt
because
of
we
could
expose
com
rappers,
and
it
has
that
whole
hierarchy
and
base
that
we
are
allowed
to
control.
In
this
case,
we
that
wasn't
possible
for
the
previous
constraints
discussed,
and
so
we
had
to
expose
some
of
these
low-level.
B
F
C
B
It's
one:
it's
it's
one
person,
it
is
the
xamarin
and
you
could
absolutely
I
mean
yes,
how
xamarin
is
constructed.
Is
they
have
a
base
library
that
abstracts
it
all
away,
but
the
only
only
thing
that
is
calling
whether
directly
or
indirectly
is
the
pre-generated
code.
That's
kind
of
like
the
point
out.
C
Okay,
we,
you
know
this
look
like
in
theory.
We
can
make
it
some
sort
of
internal
api,
but
then
we
have
challenges.
You
know
how
they
would
kind
of
get
to
it,
because
you
know
like
it's.
It's
kind
of
for
the
same
reason
that
asp.net
targets-
you
know
our
public
surface,
even
though
we
have
apis
and
that
that
are
really
only
useful
for
asp.net
right.
F
Right,
no
yeah,
I
mean
I'm
just
wondering
like
how
much
scrutiny
do
we
have
to
apply
here,
because
I
mean
I
mean
I
guess,
based
on
how
you
describe
it.
It
sounds
like
these
e
apis
are
probably
longer
lived
than
we
want,
but
there
is
a
chance
that
some
stuff
will
change,
because
we
changed
the
way
interrupt
works
over
time.
Right
would
be
my
guess.
F
B
So
we
so
the
previous
callbacks
we've
initialized
the
system.
In
this
case
we
are
the
create
reference
tracking
handle
is
more
or
less.
What
is
what
is
involved
is
the
gc
handle
that
comes
out
of
that
create
reference
tracking
handle
is
more
or
less
what
is
involved
and
represents
those
ap.
Those
callbacks
that
are
above
the
native
side
through
directly
indirectly
calls
create
reference
tracking
handle
with
an
object
you
could
cons.
B
In
this
case,
the
need
was
two
pointers
worth
was
enough
for,
for
what
was
needed.
We
originally
had
one.
There
was
some
there
was.
There
was
additional
memory
that
was
needed,
so
we
made
it
two
pointers
that
memory.
B
That
memory
that
is
returned
is
what
is
passed
through
to
the
is
reference
callback
and
the
tracked
object
enter
finalization
callbacks.
As
you
see
they,
they
both
take
in
pointers
and
and
return
something
or
nothing,
but
the
input
to
the
is
referenced
callback
and
the
tracked
object
entered
finalization.
B
Is
that
scratch
memory
and
the
reason
we
do
that
is
because
these
are
unmanaged
call.
These
are
like
native
callbacks,
so
we
can't
pass
a
pointer
to
an
object,
a
managed
object,
so
we
need
something
that
is
stable,
and
that
is
what
that
scratch
memory
is,
and
so
that's
what
and
so
that's
why
it's
scratched
they
can
put
whatever
they
want
in
there
and
it,
and
it
is
the
bonus,
is
on
them
to
say
I
can
identify
this
object
through
this
scratch
memory.
However,
it
is,
and
that
is
non-movable
member
okay,.
A
B
B
So,
okay,
they
will
get
that
pointer.
That's
the
contract
like
here
is
the
gc
handle,
so
you
have
the
gc
handle
and
it's
obviously
indirect,
and
that
allows
you
to
hold
on
to
it
and
extend
it
and
play
with
it.
However,
you
wish
and
there's
also
this
other
native
memory
that
is
also
associated
with
that
that
that
is
what
we
will
use
to
pass
to
your
reference
tracking
callback
and
your
tracked
object
entered
finalization
so
that
that's
how
you
know
how
to
track
it.
Okay,
I'm
gonna.
B
B
A
Okay,
so
the
one
thing
that
I
worry
about
here,
aside
from
the
fact
that
we
just
last
week
had
the
first
thing
that
wanted
to
use
the
word
scratch,
and
then
we
decided,
since
it
was
a
word
that
had
not
been
used
in
api,
we
were
going
to
replace
it
so
we'll
come
back
to.
That
is
if
this
started
off
as
needing
one
pointer's
worth
of
memory,
and
now
it
needs
two
pointers
worth
of
memory.
G
F
A
Eight
would
just
be
writing
three,
but
it
only
owned
two
of
them,
so
something
needs
to
communicate.
That.
B
Okay,
that's
that's
fair
part
of
the
part
of
the
reason
that
we
this
was
done
with
two
is
because
one
pointer
was
one
pointer
is
absolutely
needed
because
of
how
that's
like
that's
the
minimum
right.
The
second
pointer
was,
if
you
need
more
we're
allowing
the
the
caller
to
allocate
extra
if
they
want,
they
have
a
place
for
it.
So
with
that
extra
pointer
location,
they
can
allocate
whatever
they
wish
sure.
So
that
was
the
that
was
kind
of
the
two
is
enough
because
it
will
scale.
A
C
B
B
A
No,
so
I
think
we
can
communicate
that
and
have
a
little
bit
of
future
proofing
here
of
just
if
we
out
span
of
int
pitter,
then
it
tells
you
straight
up:
here's
where
it
lives,
because
you
can
ask
for
the
pointer
or
the
ref
or
whatever
you
want
from
the
span
and
here's
how
many
I
gave
you
and
we've
just
communicated
in
the
capi.
It
happens
to
always
be
linked
to,
but
like
it's.
A
It's
here
you
go
here
are
your
two
bytes.
It
is
a
pointer
and
a
bounds,
so
I
think
we
would
just
change
it
to
outspan
span
event
pitter,
because
it's
really.
C
B
B
B
F
Yeah
to
me,
the
the
the
problem
with
the
design
is
not
two
pointers
or
three
pointers.
It's
more
as
jeremy
said
like
what
happens
if
we
change
our
mind
right
and
we've
eventually
reached
a
point
where
we
say:
oh,
everybody
needs
three
pointers
and
we
don't
want
to
pay
for
the
intervention
for
every
single
object.
You
know.
Maybe
we
now
have
three
pointers
somewhere,
then
that
would
be
unfortunate
and
that's
what
I
meant
by
famous
last
words.
B
A
Fair,
I
mean
that
makes
perfect
sense,
yeah
and
having
it
just
as
the
this
is
what
the
runtime
gives
you
when
you
have
to
deal
with.
It
seems
nicer
with
regards
to
this
paragraph,
because
otherwise,
you'd
have
the
great
you
called
me
before
with
two
and
now
you
called
me
with
three,
and
I
can't
give
you
the
same
right
thing
all
right.
A
F
A
F
B
I
don't
yes,
it
is
because
xamarin
has
the
concept
of
if
they
determine
that
sorry
xamarin
has
the
concept
of
we
don't
care.
If
we
have
to
create
a
new
rapper,
we're
absolutely
fine
with
it,
then
we'll
get
rid
of
rappers
immediately
and
just
create
a
new
one
right
now
if
they
want-
and
so
they
just
will
literally
call
this
again
if
they
think
if
they
believe
that
they
need
one.
A
Right,
and
so
with
the
it's,
I
guess
it
really
yeah
covered
it
here
with
the
paragraph
of
you'll,
know,
you've
received
a
second
one
if
your
span
is
not
zero
filled,
basically
yeah
because
you're
promising
it's
zero.
If
this
is
the
first
time
it
was
called,
and
it's
whatever
the
last
caller
did.
B
If
it's
not
that's
and
that
gets
back
to
the
very
ugly,
I
think
this
is
a
global
thing
like
there's
just
literally
one
api
that
does
all
of
this,
and
so,
if
you
have
initialized
you're,
clearly
owning
the
entire
interop
story
here.
So
the
only
person,
the
only
yeah
person
that
has
touched
that
scratch
memory,
which,
whatever
memory
that
extra
memory
is.
B
A
Decide
and
I'll
check
the
emails
again
well,
the
other
one
was
initial
buffer
because
it
was
it
represented
the
starting
memory
for
a
growable
thing.
Yeah
I
mean
that
really.
It
seems
like
this
is
the
indirection
buffer.
A
F
A
A
A
That
we
are
reviewing
what
is
intended
and
it
wasn't
some
copy-paste
errors
nope.
I.
B
A
A
F
A
Well,
but
right
now-
and
I
have
a
note
that
we
can
circle
back
to
it
right
now-
it's
in
a
tiny
little
namespace
with
these
two
types
and
but
we'll
come
back
to
that
yeah.
Okay,
so
I
followed
this
link.
A
A
B
This
is
okay.
We're
gonna
have
a
great
great
lesson
in
how
objective
c
works.
It's
a
message,
passing
logic,
which
basically
means
in
instead
of
having
a
v
table.
B
So
this
object
is
specifically.
This
function
is
a
standalone
c
file.
This
is
just
basically
a
standalone
c
function
and
you
pass
in
an
object,
identity
and
you
pass
in
the
name
of
the
function
that
you're
interested
in
in
this
case.
It's
really
what
it's
really
a
message
and
the
message
is
the
function
name,
the
name
that
that
is
what,
and
so
what
happens
is
I
have
my
object
and
I
say
foo,
and
it's
literally
does
this
object,
respond
to
message
named
foo.
B
Does
that
make
it's
it's
the
it's
the
way
of
making
it's
basically
duct
typing.
Do
you
respond
to
foo?
You
respond
to
foo
great.
I
love
it
here
you
go
so
there's
the
strong
typing
doesn't
necessarily
exist
if
you
have
a
type
that
has
two
messages,
and
you
have
another
instance
that
implements
one
of
those
messages.
B
It
will
respond
to
it
there
so
that
that
that
type
enforcement
is
handled
at
the
at
the
compiler
level,
not
necessarily
at
the
runtime
level.
If
that
makes
sense,
and
so
this
allows
for
a
lot
of
flexibility
with
c
interop
at
the
from
objective-c
standpoint.
So
what
this
basically
says
is
I
would
like
to
this.
This
function
is
documented
as
taking
void
and
returning
void,
but
that's
really
not
its
signature,
because
it's
just
a
trampoline.
B
B
A
B
B
B
And
and
the
compiler
knows
all
this-
this
is
like
the
objective
c
compiler
chain.
You
know
figures
this
out
and
does
all
this.
If
you
wanted
to
do
this
yourself
from
c,
and
you
wanted
to
interact
with
objective
c,
you
you
call,
you
have
to,
you,
have
to
know
to
call
the
appropriate
message
send,
because
in
objective
c
nobody
explicitly
calls
message,
send
they
have
their
own
syntax
s,
t
rhett,
you're,
returning
a
structure.
B
C
A
It's
I
mean
like
really
it's.
You
know
just
of
the
of
the
little
bit
that
we
want
to
talk
about
right.
It's
like
the
I
saw,
there's
a
link.
I
went
to
the
link,
it
says
it's
void,
void
and
I'm
like
I
don't
know
what
to
do
with
this
and
then
like
so
is
prett
and
stret,
and
super
stret,
like
are
those
good
names,
but
really
looking
at
it.
It's
just
you
took
their
underscores
with
camel
cases
and
you
passed
gal
cased
and
got
rid
of
the
underscores.
B
B
So
I
guess
john's
point:
why
do
these
exist?
These
exist
because.
C
C
They
actually
hijacked
this
interrupt
these
dll
import
apis
to
do
special
things
for
these.
They
routed
it
to
some
their
own
implementation.
That
grabs
the
actual
call
with
something
else
right.
So,
but
you
like,
when
you
do
dla
import
of
the
objective
c
c
message
sent
method
in
the
objective
c
runtime.
It
doesn't
actually-
and
you
are
in
the
marine
application-
it's
not
going
to
call
actually
that
that
entry
point
it's
going
to
call
something
else
right.
C
So
it's
basically
this-
and
this
is
this.
Behavior-
is
used
both
by
the
auto
generated
code
gen,
but
it's
it's
even
documented
in
kind
of
the
xamarin
documentation
where
it
says.
If
you
do
dll
import
for
this
thing,
it
doesn't
actually
do
do
what
it
says.
It
does
something
else
right.
C
So
what
this
api
is
for
is
basically,
like
you
know,
allow
the
xamarin
support
library
to
communicate
to
the
to
the
runtime
hey.
You
know,
if
you
see
these,
these
dla
imports
here
is
what
to
replace
them
with
that.
That's
the
whole
point
of
this
okay.
A
C
A
C
So
not
all
these
are
valid
on
all
platforms,
for
example
the
send
fb
red
one,
it's
actually
only
applicable
on
x86.
I
think-
and
you
know
there
is
a
chance
that
if
there
is
a
new
platform
added,
you
know,
maybe
we
we
end
up
with
objective
c
message:
sense,
sd-2
or
sdi-x.
C
A
C
Inconsistency
between
the
the
enum
name
and
the
api
name
right,
the
enum
name
says
msg
and
the
api
names
spells
it
in
full,
like
message
right.
Should
that
be?
Should
it
be
in
sync.
B
A
That
no
one
other
than
xamarin
is
going
to
call
this,
and
so
no
one
like
probably
this
could
be
named
qwerty
and
it
would
be
fine,
but
I'm
fine,
I'm
personally
fine
with
msg
and
the
enum
name
and
message
spelled
out
nicely
in
the
static.
Does
anyone
else
want
to.
A
B
Okay,
so
what
this
is,
this
is
when
objective
c.
This
is
when
you're
in
a
native
code,
particularly
objective
c
or
c.
I
guess,
but
it's
on
an
objective
c
scenario
and
you
catch
an
exception
from
except
objective
c
or
you
have
some.
You
would
like
to
propagate
an
error.
Think
of
it,
you
can
think
of
it
as
h,
results
concepts
from
com.
A
Okay,
and
so
this
says
for
thread,
does
it
mean
thread,
thread
or
async
local
capture
state
and
does
the
one
person
who
needs
to
call
it
know
what
it
means
and
how
to
use
it?
A
A
If
I'm
wrong,
that's
fine,
but
it
this,
because
this
is
a
managed
method.
It
seems
like
you've,
done
a
double
hop
here
before
you
call
this.
Otherwise
you
would
just
throw
because
you're
back
in
managed.
B
I
see
got
it
yes,
I
I
see
what
I
see
the
what
you're,
what
you're
getting
at
there.
A
B
A
B
This
one,
this
one
is
this
one
is
the
worst
this
one
I
hate
this.
I
had
to
learn
way
more
things
than
I
wanted
to
learn
with
this
problem,
so.
B
B
In
this
case,
we
want
the
same
type
of
system
or
sorry
yeah.
We
want
this
basically
the
same
type
of
system,
but
on
objectives,
and
that's
because
I've
thrown
a
managed
exception.
It
is
going,
it
is
going.
It
has
hit
something,
and
I
expect
because
of
existing
behavior,
that
the
mono
embedding
api
enables.
B
I
expect
that
exception,
to
have
the
opportunity
to
be
converted
to
css
yeah
or
a
cpus
exception.
That's
what
I
want,
and
this
provides
a
handler
for
it
and
that
yeah
it
provides
a
handler
series
of
handlers
and
you
can
propagate
it.
However,
you
wish,
if
you
return
a
handler
and
there's
a
big
bunch
of
comments
there.
B
A
B
So
that
syntax,
that
was,
that
was
a
bit
of
a
mind,
bend
right
there.
So
it
basically
says
this
is
a
delegate.
Unhandled
exception.
Propagation
handler
is
a
defined
delegate.
This
delegate
is
called
because
it
is
asking
the
supplier
to
say
I
have
an
exception
it
it
has.
We
have,
it
is
about
to
cross
into
the
native
back
into
a
native
boundary,
I'm
giving
you
the
exception,
I'm
giving
you
a
runtime
handle
to
the
last
method.
B
You
have
an
option
here,
you
can
give
me
a
you,
can
give
me
a
function
pointer,
it
has
to
be
unmanaged
and
the
context
that
I
will
pass
to
it.
You
can
put
whatever
you
want
in
there.
Whatever
details,
you
need
to
construct
your
objective
c
exception,
and
I
will
call
that
in
the
appropriate
context
and
from
that
from
that
function
pointer,
you
need
to
either
throw
a
ma
a
native
exception
that
will
propagate
properly
into
the
into
the
native
environment,
or
you
need
to
record
it
log.
A
Okay
and
I'm
so
just
trying
to
understand
how
it
works
if,
if
you've
handled
it
and
you've
called
you
know,
objective
c
dispatch
exception.
However,
that
works
from
the
callback
or
sorry
you
did
that
in
the
function
that
the
callback
returned.
The
delegate
to
how
does
like
is
the
you
did
that
simply
that
now
you've
returned
and
that,
like
the
managed
code,
just
assumes
that
you
did
that
and
goes
on
a
happy
day
or
is
it
already?
You
know
like,
and
I've
rethrown
and
torn
down
the
state
or.
B
B
We
will
set
it
up,
just
as
if
you
had
called
this
native
function,
this
native
callback,
that
we'll
throw
so
we
said
we
reset
the
state
of
the
stack
so
that
the
callback,
the
unmanaged
function
pointer
that
you
called
can
safely
throw
an
exception
or
fail
fast.
We're
not
required
there,
but
that's
it!
That's
why
it
honestly,
if
we
could
this
this
deli,
this
unmanaged
that
takes
an
endpoint
or
returns
a
void.
If
we
had
an
attribute
that
said
no
return,
that
would
be
appropriate
there.
B
J
J
J
You
know
it
gets
encapsulated
in
some
sort
of
objective
c
exception
and
then
the
objective
c,
throw
mechanism
will
unwind
its
code
and
at
some
point
you
hit
another
boundary,
possibly
where
you
go
from
objective
c,
back
into
managed.
J
Previous
api,
would
you
know
unbundle
the
objective
c
exception
extract
the
managed
exception
and
possibly
let
it
rethrow.
So
the
idea
is
that
the
two
runs,
the
objective
c
runtime
and
core
clr
are
cooperating
to
unwind
this
thing
past
a
mixed
stack
of
managed
and
unmanaged
methods.
Does
that
make
sense.
A
Okay,
so
I
think
I
think
the
problem
that
I
was
having
is-
I
was
thinking
too
globally
of
the
managed
code
calls
native
code,
which
calls
managed
code
which
throws
and
then
hits
this
unwind,
and
I'm
wondering
how
the
runtime
resumes
and
the
answer
is.
However,
the
native
code
said
to
do
so
so
that
basically
the
handler
said
I'm
I
was
called
from
an
objective
c
context.
I
throw
an
objective
c
exception.
I
hit
an
objective
c
catch
that
says,
keep
going,
I
hit
rhett.
A
A
Okay,
so
I
guess
I
I
was
just
confused.
I
think
I
got
confused
by
the
you
must
fail
fast
door,
throw
of
I'm
like,
but
if
it
throws
the
we're
gonna
pop
back
into
managed
code
and
do
something
what's
gonna
happen,
and
the
answer
is
no.
A
A
B
Delegate
I
had
originally
had
this
as
a
set.
It
looked
kind
of
weird.
You
couldn't
call
it
multiple
times
a
bunch
of
things.
So
I
because
it
is
because
again
it's
a
global
thing.
I
can
imagine
having
a
sequence
of
I
guess,
a
couple
handlers,
because
you
can
filter
based
on
what
you
see,
because
those
right
and
as
long
as
you
return
a
null
move
on
so.
B
G
C
But
I
would
expect
the
xamarin
will
only
ever
register
just
one
right.
The
thing
about
this
api
we
were
like
you
are
throwing
the
idea
of
hey.
This
is
like
relational
purpose
thing:
it's
not
really
tied
to
objective
c
much.
You
know.
Should
it
be
a
general
purpose:
api
on,
say,
system,
dot,
runtime
interrupt
service
is
marshall,
but
you
know
it's
like
it
doesn't
feel
quite
right.
So
so
we
are
basically
like.
C
A
A
I
don't
remember
if
they're
a
list
or
a
queue.
Sorry
that's
the
same
thing.
I
don't
remember
if
they're
a
stack
or
a
queue,
so
I
don't
know
if
the
last
one
to
register
thinks
that
they
get
the
most
control
or
if
the
first
one
to
register,
wins
it.
A
If
we
really
feel
like
it's
only
going
to
be
one
then
and
they're
never
going
to
unregister
it
effectively
again,
my
suggestion
would
be
that
we
move
it
as
a
parameter
in
initialize
of
it's
a
it's
a
thing
you're
only
supposed
to
call
once
we
expect
you're
always
going
to
do
it.
Let's
just
make
it
a
parameter
there,
and
if
we
come
up
with
a
different
kind
of
exception
handler,
then
we
make
another
api
like
we
just
overload.
Initialize
with.
I
have
a
different
notion
of
a
handler
now.
A
B
A
B
I
have
no
grip
with
putting
passing
this
into
the
initialized
function.
I
think
that's
reasonable.
I
will
say
that
yeah,
I
don't
see
why.
A
That
would
be
a
problem
right,
because
the
set
for
set
pending
exception
for
thread
is
that
one
is
you're
supposed
to
call
it
multiple
times
of.
Oh
go
register
a
thing
or
clear
a
thing,
or
you
know,
and
it's
thread
local
instead
of
global
and
so
like
that
makes
sense
to
be
a
function.
But
the
other
half
here
of,
like
hey
I'm
taking
over
interop
with
in
this
case,
objective
c
here-
is
how
I
handle
things
seems
like
it's
all
that
you're
saying,
and
so
I
think
it's
part
of.
A
Yeah
so
now
now
we
only
have
two
things
left,
so
emo
you
pay
attention
to
user
experience
way
more
than
I
do
if
we're
searching
if
intellisense
is
back
to
defaulting
to
search
across
all
namespaces
is
bridge
to
generic
a
word
and
if
we're
not
doing
that,
do
we
is
bridge
still
may
be
too
generic
a
word.
F
F
If
we
leave
it
in
the
objective
c
namespace,
then
I
mean
so
to
be
clear,
like
intellisense
no
longer
defaults
to
searching
across
all
namespaces,
they
removed
that
because
it
created
too
much
noise,
but
but
what
you
basically
can
now
do
is,
if
you
do,
you
know,
there's
control
space
which
is
autocomplete
and
then
there's
ctrl
j,
which
is
basically,
you
know,
show
the
autocomplete
window,
and
if
you
hit
control
or
j
again,
basically,
then
it
searches
across
all
namespaces.
F
That,
basically
does
that,
so
it
it
shouldn't,
be
surprising
for
people,
but
I
think
our
general
guidance
is.
We
try
to
avoid
single
term
names,
especially
when
they
have
generic
names,
because
they
have
a
high
chance
of
colliding,
and
I
would
argue
the
noun
bridge
is
not
specific
enough.
Like
I
mean
somebody
will
have
a
bridge
that
has
nothing
to
do
with
objective
c
right:
okay,.
A
A
I
guess
I
don't
know
what
the
shape
of
things
in
interrupt
services
look
like,
but
I
assume
that
they're
amongst
the
least
netty
names
that
we
have
so
I'm
fine
with
your
suggestion
of
take
the
objective
c
sub
name
space
and
turn
it
into
obj
or
big,
o
little
b,
little
j,
big
c
prefix
on
these
two
types.
F
B
A
F
A
F
F
K
F
Windows,
runtime
namespace,
for
example,
so
having
an
objective
c
namespace,
wouldn't
be
a
terrible
idea
in
my
opinion.
Now,
if
there's
only
ever
going
to
be
two
types
in
it,
then
yeah
it
is
a
bit
wasteful
to
to
to
put
it
there.
On
the
other
hand,
interrupt
namespaces
is
like
it's
super
large
namespace.
So
everything
you
add
there
is
just
you
put
it
on
the
pile
basically
right,
so
it
makes
it
somewhat
harder
for
you
to
find
stuff,
but
maybe
that's
okay.
I
mean
the
the
general
rationale.
F
F
So,
for
example,
if
you
do
interrupt
you're
very
likely
to
be
using
for
interrupt
name
spaces,
you
know
there's
probably
more
than
one
and
and
now
you
may
have
to
deal
with
the
fact
that
you
know
names
that
may
sound
reasonable
when
you're
aware
which
nation
they're
in
no
longer
look
reasonable,
because
you'd
have
no
idea
which
name
spaces
they're
coming
from
they
just
pop
up
in
intellisense.
Now,
as
as
top
level
items
right,
and
so
that's
why
you
know,
you
should
have
names
that
by
themselves
make
sense,
because
I.
F
Right
you're,
looking
at
a
code
review,
somebody
takes
a
method
that
takes
a
bridge,
for
example,
okay,
bad
example,
because
it's
a
static
type,
but
you
know
you
could
imagine.
When
you
look
at
the
method
signature
you
have
no
idea
which
namespace
that
type
came
from
right,
and
so
you
still
want
names
that
make
sense,
and
so
that's
why
you
know
we
we
generally
avoid
like
single
noun
type
names.
For
that
reason,
because
the
nouns
are
usually
too
you
know
unspecific,
like
you
know,
think
note
or
tree
or
item
they
almost
are.
F
You
know,
doomed
to
have
collisions
right
and
that's
why
you
usually
want
to
add
something
else
to
it,
and
then
you
have
like
you
know
two
nouns,
you
already
usually
sufficiently.
You
know,
disambiguated.
The
only
exception
to
the
rule
is
like
core
platform
concepts.
Like
array
span
index
range,
that's
where
we
take
single
known
words,
because
we
also
usually
expect
people
will
build
higher
level
concepts
that
have
to
also
include
that
name
somewhere.
A
As
a
similar,
we
have
a
namespace,
I
mean
so
yeah
xmlnode
is
in
an
xml
namespace,
where
it
it
got.
The
repeat
in
asn
tag
is
the
name
of
a
type
in
system
formats,
asn
1,
and
it
has
the
prefix
just
because
yeah
again
you,
if
you're
using
it
you'll,
have
you
know
the
six
usings
at
the
top
of
your
file
and
then
it's
tag
well.
Was
that
a
collision
across
any
of
your
other
five
name
spaces,
maybe
so
yeah?
B
Can
can
I
let
me
let
me
challenge
that
only
because
I
hear
what
I
absolutely
get,
what
you're
saying,
but
here's
where
I
would
say
this
is
perhaps
different,
because
whatever
file
you
have
you
are
likely.
This
is
because
this
is
a
building
block.
You
are
likely
building
up
a
system,
so
you're
not
going
to
have
system
runtime
interrupt
services.objectivec.
B
And
if
I
am
in
objective
c
world,
I
just
want
to
use
the
bridge
because
that's
what
I'm
focusing
on,
if
I
am
doing
an
interop
between
objective-c
and
javascript,
and
there
is
a
collision,
I
want
to
be
able
to
specifically
do
that
because
it's
a
very
special
case
and
I'll
use
an
alias.
So
I
I
almost
think
that
namespace
is
serving
its
function
in
this
case
and
it
does
allow.
F
B
F
Mean
what
you're
saying
is
not
wrong.
It's
just
that
I
think
like
there
are
some
examples
where
what
you
said
is
true
in
the
sense
where
you
know
the
namespaces
are
mutually
exclusive,
but
you're
very
likely
to
write
code
that
uses
both
objective
c
and
javascript
in
the
same
file
right
because
you're
clearly
writing
intervals
for
one
of
them
and
not
you
know
both
of
them
usually
right
but,
like
the
that's,
usually
not
true
for
most.net
stuff
right,
so
it's
completely
reasonable
to
use
and
as
in
one
reader
and
an
xml
document.
F
At
the
same
time,
because
I
parsed
my
config
file
and
I
construct
some
asm
file
right
and
so
at
that
point
because
of
this
mixing
and
matching.net.
That's
why
we
try
to
avoid
conflicts
in
the
common
cases,
because
you
know
what
you
can't
declare
aliases
it
just
generally
sucks
right
and
it's
not
like
you
know
something.
You
basically
want
to
do.
Every
single
time
like
in
your
case.
Here
I
mean
symmetry,
is
good
but
keep
in
mind.
Symmetry
can
be
also
achieved
just
using
a
naming
convention
or
a
suffix
right.
F
If
you
call
something
objective,
c
bridge
and
then
the
corresponding
other
namespace,
you
call
it
the
javascript
bridge.
You
also
have
symmetry
right,
but
then
you
effectively
prescribe
what
these
aliases
are
right,
but
yeah.
I
don't
feel
super
strongly
on
the
on
the
collision
here.
It's
like,
like
I
don't
expect
people
to
have
name
spaces
for
objective
c
or
even
interrupt
namespaces
if
you
put
it
in
the
room.
So
to
me
you
know,
if,
if
you
insist
on
bridge
I
mean
that's
fine,
I
I
don't
think
I
have
a
yeah
logic
reaction
to
that.
A
Yeah,
my
so
then
the
rules
we
have
for
the
names
and
name
collisions
this
is
off
top
of
my
head.
I'm
not
looking
at
what
we
have
written
down
is
if
the
name
is
absolutely
the
best
name
for
a
thing
so
like
in
winforms,
there's
window
right,
it
represents
a
window,
it's
win32
calls
it
a
window
like
window
is
the
absolute
best
word
for
this
thing,
except.
A
Form
but
yeah
sure
button
button
is
the
absolute
best
word
for
the
thing
that
is
a
button.
Well,
wpf
also
has
a
thing
called
button,
but
there
are
the
number
of
things
that
will
be
winforms
and
wpf
at
the
same
time
are
essentially
zero
and
there's
not
really
a
thing
that
we
would
have
as
because
we've
said
that
a
button
is
only
a
use,
a
user
experience
thing,
it
would
be.
A
You
would
have
yet
a
different
thing
before
button
came
in
as
yet
another
word,
but
bridge
is
to
look
at
bridge
in
the
specific
it
could
end.
A
Up
being
that
you
know,
bridge
makes
sense
as
an
interrupt
thing
and
bridge
makes
sense
as
a
game
of
cards,
and
it
makes
sense
as
a
you're
just
connecting
any
other
two
components,
and
so
bridge
may
be
a
thing
that
lots
of
components
that
have
nothing
to
do
with
each
other
and
nothing
that
guarantees
mutual
exclusion,
and
so
that's,
where
bridge
becomes
like
you're,
not
really
tied
to
the
concept
of
objective
c
anymore.
It's
just
a
word
that
you
were
using
to
say
that
you're
tying
two
things
together,
and
so
that's
why?
B
Sure,
oh
yeah,
my
I
I
wasn't-
I'm
not
sold
on
bridge
either
more
of
what
I'm,
what
more
of
kind
of
what
I
was
getting
at,
I
think
is
I
I
am
somewhat
I
when
I
when
I
see
these
prefixes,
like
so
let's
say
it's
obj
c,
whatever
it's
in
an
objective,
c,
name
space,
it
seems
redundant
to
me
it
just
just.
I
very
much
don't
like
that,
but
if
that
is
the
policy
I
I
understand
it
like.
I
just
I
don't
like
that.
Redundancy.
F
To
be
clear,
like
we
like
it's,
it's
a
it's,
not
a
you
know
hard
and
fast
rule
right
like.
I
think
that
I
think
the
problem
is
kind
of
it's
a
as
jeremy's
example.
It's
kind
of
like
a
taste
thing
right
so
button,
for
example,
clearly
has
a
conflict
across
all
gui
frameworks
right
but
like
if
we
were
to
prefix
every
single
ui
concept
like
checkbox
radio
button
button
with
like
wpf
or
winforms,
you
basically
create
a
very
untasteful.
F
You
know
ui
toolkit
right,
and
so
we
said
like
yeah.
While
there
are
collisions
it
just
does
it's
just
not
practical
to
prefix
them
all
right,
and
in
this
case
this
button
is
arguably
the
best
name
for
the
concept.
F
But,
like
I
mean
there's
very
few
examples
where
that's
true
and
like
the
one
thing
that
has
bitten
us
in
the
past
is
that
many
of
the
namespaces
that
we
regularly
contribute
to
like
collections
or
the
system
root
name
space
are
all
the
reference
and
so,
for
example,
we
recently
had
this
issue
with
systemtext.json,
where
we
introduced
a
node
namespace
and
fortunately,
due
to
the
way
the
bb
binder
works
is,
if
you
have
a
local,
you
know.
F
Basically,
I
forgot
how
bb
calls
it,
but
basically
the
equivalent
of
bar,
I
think
in
bb,
when
you
have
a
for
loop,
that
you
name
your
your
your
photo
variable
node
now
it
starts
conflicting
with
the
node
namespace
and
bb
is
now
generating
arrows
rather
than
compiling.
Happily
right,
and
so
this
is
kind
of
the
problem
that
we
have
when
you
have
namespaces
that
everybody
imports,
and
now
we
insert
a
name
in
there
that
might
conflict
with
user
provided
names
or
other
names
and
other
namespaces.
F
Then
now
everybody
has
to
kind
of
work
this
around
and
you
know,
come
up
with
some
naming
convention
for
that
right
and
I
think,
in
your
case
here,
yeah
interrupting
space
is
a
very
specialized
namespace.
It's
only
used
by
very
small
amounts
of
people,
and
you
know
the
there's,
probably
more
dragons
anywhere,
so
the
naming
is
the
least
of
your
of
your
of
your
problems.
It's
just
that
you
know.
Namespaces
are
an
organizational
tool,
but
most
of
the
time
when
you
look
at
source
code,
you
don't
see
the
namespaces
right.
F
So
in
that
sense
it's
not
really
redundant
right
like
if
you,
if
you
just
stare
at
like
10
lines
of
code-
and
you
see
the
word
bridge-
is
it
obvious
that
it's
the
objective
c
bridge?
Maybe
I
mean,
but
that
seems,
contextual
right,
okay,
so
that's
that
that's
kind
of
why
we
very
often
end
up
with,
like
some
prefix
notation.
B
F
That
I
mean
once
you
prefix
it,
I
think
rich
is
fine.
I
think
it's
like
because
then
you're,
like
you
know,
you
make
it
clear
what
kind
of
you're
talking
about
right.
It's
no
longer
the
the
card
game
bridge
right
and
I
mean
yeah
host
or
bridge
I
mean
post-
is
equally
undefined
right
or
component
or
manager
or
provider
factory.
Whatever
right,
there's
all
these
words
that
mean
nothing
without
context.
So
that's
fine
in
terms
of
name
spaces
yeah.
I
don't
feel
strongly.
F
A
Yeah,
if
we
already
have
sub
namespaces
for
other,
particularly.
B
F
At
the
way
docs
are
presented,
it's
like
every
time
you
have
a
namespace,
there's
just
one
more
item
to
click
on
right,
and
so
the
interrupt
service
is
expanded.
Namespace
is
an
anti-pattern
because
it
has
exactly
one
type
in
it
and
it's
like
really.
We
needed
the
namespace
to
hold
one
type.
That
seems
a
bit
over
the
top
like
the
windows.
Runtime
one
is
a
good
one
because
it
has
like,
I
think,
20
types
in
it
or
something
so
that's
kind
of
reasonable
grouping
right
and
interrupt
services
itself
is
a
huge
namespace.
F
A
Also,
a
heuristic,
I'm
gonna
say
the
number
six,
but
I
don't
know
what
the
actual
number
is
of
once
you
have
more
than
that
many
usings
in
a
file
people
consider
that
your
your
concept
is
busted
and
too
thin
like
or
too
scatter
shot
of.
You
didn't
build
a
thing
you
built
100
things
that
you're
trying
to
integrate
together.
So
it's
don't
make
people
do
too
many
name
space
imports
again.
In
this
case
it's
not
really
going
to
apply,
but
that
would
be
you
know
for
something
like
jason
of
the.
F
So
yeah
it's,
I
will
always
leave
it
up
to
you
like
I.
I
can't
go
either
way
on
namespace
I
mean
one
thing
that
is
nice
of
having
an
airspace.
Is
you
have
a
home
to
put
conceptual
docks
right
because
it's
kind
of
you
can
put
it
on
the
namespace
itself,
but
in
in
your
case,
given
again
that
you
build
an
api
for,
like
literally
people,
that
you
know
by
name
it's
a
bit,
it
doesn't
really
matter.
I
guess
it's
a
very
specialized
api,
so
either
one
is
fine.
A
Name,
documentation
in
the
update,
I'm
not
fixing
all
your
docks.
Just
when
I
got
rid
of
the
the
event
okay,
so
track
native
reference
attribute
should
be
sealed.
B
A
G
J
C
Know
objective-c,
martial
or
objective-c
support
or
whatever
you
know
like.
I
had
kind
of
mixed
feelings
about
the
bridge
thing,
so
I
know
there's
this
other
thing
called
bridge.
B
I
I
really
have
no
strong
preference.
I
think
you've
all
made
your
arguments.
I
think
pretty
well
that
having
an
objective
c
prefix
makes
sense.
I
absolutely
would
not
be
happy
with
a
class
called
support,
so
objective-c
support
makes
perfect
sense
to
me.
C
C
E
F
F
A
Move
this
down
to
my
bullets,
make
sense
all
right
did
we
feel
we're
keeping
the
name
space.
I
think
we
decided
yes.
F
I
mean
I
I
don't
know
enough
about
this
stuff
right,
but
it's
just
it
seems
like
interweb.
Is
this
thing
that
tends
to
grow,
not
shrink?
So
I
I
mean
unless
we're
absolutely
positive,
it's
everything's
ever
going
to
be
less
than
five
types.
I
think
that
doesn't
strike
me
as
a
terrible
idea
to
have
its
own
name
space.
A
C
F
B
So
I
would
say
yes
for
right
now,
like
the
concept
that
it
is
trying
to
represent,
I
think
is
something
that
we
will
reuse,
but
I
think
that
this
particular
instance
is
worth
keeping
targeted
to
objective
c.
I
can
get
into
more
details
on
why
that
is,
but
this
is
only
for
objective
c
and
I
think
we
will
want
something
that
says
this
type.
I
C
The
way
this
attribute
is
used,
it's
actually
used
to
tech
types
right.
So
the
thing
that
you
are
applying
it
to
isn't
actually
reference.
It's
like
the
objective
c
type
sort
of
you
know
I
see
so
you
know
I
understood
whether
he
was
but
you
know,
objective
c
type,
maybe
yeah.
I
D
I
F
I
mean
objective
c
type
seems
more
sensible
to
me
because,
as
jan
said,
I
mean
you're,
not
you're,
not
putting
it
on
the
record,
but
you're
really
putting
it
on
the
type.
So
it's
a
bit
weird
to
say
this
is
a
reference.
It's
when
really
it's
you're
talking
about
a
time,
it's
a
kind
of
things
backwards.
A
bit
I
mean
on
the.
C
F
So
I
mean
looking
at
the
windows
runtime
one:
we,
we
didn't
really
prefix
the
windows,
runtime
attributes,
but
a
lot
of
those
actually
appear
in
signatures
because
you
actually
put
it
on
parameters
and
that
kind
of
makes
sense
to
have
shorter
names,
because
otherwise
signatures
become
completely
unreasonable
right,
but
versus
this
one
you
actually
apply
it
on
the
type
level.
So
having
a
slightly
longer
name
is
probably
actually
desirable.
B
A
A
B
C
Yeah
my
one
month,
like
we
touched
on
it,
you
know
like
the
fourth
threat,
like
the
set
message
pending
exception
for
threat.
We
generally
don't
especially
in
the
interrupts,
but
in
eighth
days
we
don't
highlight
the
threat
localness
of
the
things
that
you
know
set,
set
things
for
current
threat.
You
know,
for
example,
it's
like
set
last
error.
It's
not
set
last
error
for
threat
right
or
you
know
so.
C
E
A
Okay,
symbolic
links
two
four,
two,
seven
one,
carlos
are
you
okay,.
L
L
L
L
L
We,
the
main
proposal
is
to
add
support
to
the
file
system
info
class
or,
alternatively,
alternatively,
to
the
child
classes
and,
additionally,
if
possible,
we
would
also
like
to
offer
support
to
the
static
file
system,
classes,
file
and
directory.
I
explained
them
below
or
it
could
be
path
as
well
yeah
those
ones.
L
We
want
to
make
sure
that
to
be
careful
to
keep
in
mind
future
expansions,
because
we
also
have
other
types
of
links
like
junctions.
So
in
the
case
of
the
top
apis
for
file
system
info,
we
can
add
a
the
methods,
create
a
symbolic
link
and
get
target
info
if
we
add
them
to
file
system
info.
L
L
The
advantage
of
having
the
methods
in
file
system
info
or
the
main
advantage
would
be
when
I
iterating
in
file
system
enumerable.
Whenever
we
can,
we
finish
checking
a
file
or
a
directory.
We
have
it
in
the
form
of
a
file
system
entry,
but
we
have
a
method
that
converts
it
to
file
system
info.
A
A
G
L
Okay,
yes,
you're
correct,
it
makes
sense
when
you
retrieve
the
target
info
if
the
file
happens
to
be
a
symbolically.
Yes,
where
was
I
well.
L
L
A
L
A
F
So
when
you,
I
think,
when
you
create
a
new
directory
info
and
you
pass
a
string
that
doesn't
exist
yet
exists
will
return
false
right
and
then,
when
you
call
create
it
will
actually
physically
create
the
directory,
so
it
it
makes
sense
to
call.
You
know,
create
symbolic
link
on
an
instance
that
doesn't
exist
yet
right,
yeah.
A
L
L
No
yeah
emo
touch
that
point
correctly.
It
would
be
the
opposite
way.
You
can
create
a
directory
info
or
file
info
without
the
file
existing
and
then,
if
you
want
to
create
a
symbolic
link
to
that
file,
then
you
pass
as
argument
the
path
to
target
the
full
path
of
the
file
that
doesn't
yet
exist
that
that's
how
it
would
make
sense,
but
anyway,
the
reason
why
we
make
the
differentiation
between
file
and
directory
links
is
because
of
windows.
L
L
A
A
L
G
G
L
I
think
in
the
latest
versions
of
windows:
that's
not
a
requirement
anymore,
I'm
not
entirely
sure
if
that's
already
removed
by
default.
But
as
far
as
I
remember
yeah,
that
was
the
case.
I
didn't
have
to
modify
tweak
the
user
policies
to
avoid
so
that
so
that
I
could
only
I
could
create
it
as
a
normal
user.
F
L
Is
basically
a
creating
a
new
name
that
points
to
a
location
in
in
disk,
so
you
can
have
two
different
files
that
point
to
the
same
location
in
disk
identified
by
different
names.
If
you
edit
one
you're,
going
to
see
the
modifications
in
the
other
one,
but.
L
F
F
L
Not
to
include
it
here,
but
I
mentioned
them
where
it
says
future
expansions
to
keep
in
mind.
If
you
can
expand
that
generally,
please
so
we
could
add,
analogous
methods
called
create
junction
and
create
hard
link.
Create
junction,
obviously,
would
only
work
on
windows
and
create
hard
link
is
universal.
F
So
unix
also
has
the
difference
between
a
symbolic
link
and
a
hard
link.
Then
so.
F
L
F
F
Right
because
once
you
have
that
yeah
I
mean
my
question
is
once
you
have
multiple
things
I
mean
because,
basically
right
now
you
we
don't
have
really
a
symbolic
link
type
right,
so
we
couldn't
really
expose
well,
which
kind
of
link
is
that
kind
of
thing
right?
So
if
we
ever
wanted
that,
then
right,
we.
L
L
Which
applies
more
to
windows,
because
a
repairs
point
is
just
a
additional
user
information
that
you
add
to
a
file
and
user
defined
data
and,
depending
on
the
type
of
object,
the
that
user-defined
information
will
tell
you
if
it's
a
symbolic
link
or
a
junction
but
yeah.
This
is
specifically
just
to
create
the
symbolic
link.
L
K
K
L
Since
I
mean
we
could
have
junction
supported
from
now,
but
we
since
that
wasn't
the
main
request
and
junctions
are
a
legacy,
the
legacy
kind
of
symbolically
from
windows.
We.
G
F
L
The
other
reason
why,
in
file
info
and
directory
info,
we
didn't
want
to
add
the
is
symbolic
link.
Property
was
precisely
for
what
you're
just
mentioning.
If,
in
the
future
we
have
junctions,
we
would
rather
have
sorry
support
for
junctions.
We
would
rather
have
an
api
properly
designed
that
would
return
you
a
minimum
value
telling
you
it's
a
symbolic
link
or
a
junction,
but
right
now
we
don't
really
need
that
differentiation.
L
If
it's
done
yes
correct,
that's
why
it's
nullable
right,
so
the
user
will
have
to
check
first
for
the
for
the
flag
and
then
get
target
info
will
return.
The
the
target.
A
L
L
F
F
Yes,
yes,
correct
so
yeah
that
will
be
the
same
as
you
know,
you
you
instantiated
with
an
actual
file.
That
is
not
a
symbolic
link
right,
so
that
would
be
interferentiable
yeah
and
that
seems
fine
yeah.
That
makes.
L
L
Make
sure
I
understood
why
jeremy
said
so:
there
are
three
cases
the
file
itself
exists.
The
file
doesn't
exist
in
which
case
target
info
will
return
no
and
the
file
exists,
but
the
target
doesn't
exist,
in
which
case
we
would
return
a
file
system
info
instance
that
doesn't
exist.
Okay,
three
cases.
G
Are
we
missing
an
api
here
for
path
is
equal
to
say
I
want
to
consider
re-parse
points
as
part
of
the
equality
logic.
E
I
have
a
feeling:
jeremy
k
would
have
a
lot
to
say
about
the
difficulties
of
that
yeah.
G
Say
that
you
have
a
a
a
sim
link
like
say:
you've
got
c
users
tagu
source
and
you've
got
that
redirecting
to
d
users
tagu
source,
because
you
don't
want
a
bunch
of
source,
repos
floating
your
your
ssd
right,
but
for
the
purposes
of
path
comparisons
you
want
to
know
if
the
user
said
c,
but
I'm
seeing
d,
but
the
the
c
path
actually
redirects
to
d
then
treated
as
the
same.
G
We
actually
do
in
a
lot
of
our
own,
like
infrastructure,
scripts
path,
checks
of
like
if
the
path
that
was
passed
in
matches
the
path
that
I
the
current
working
directory
then
do
one
thing.
Otherwise
do
another
thing
and
when
those
account
for
re-parse
points
which
is
common
in
shell
script,
then
everything
works
as
expected.
F
I
mean,
I
don't
think
that
I
think
the
feature
you're
requesting
makes
sense.
I
think
it's
kind
of
additional,
though
I
would
not
link
it
to
this
proposal
here,
because
you
know
so
that
it's
bad,
it's
just
feature
creep
for
this
money.
I
would
just
keep
this
one
scoped,
for
you
know
creating
siblings
and
asking
them
to
exist.
You're,
asking
for
more
like
a
high
level
concept
that
uses
those
apis
to
do
comparisons
right
right,.
G
It
was
more
a
question
of
like
we're
exposing
siblings
as
a
thing
in.net.
Are
we
missing
the
corresponding
functionality
that
makes
it
seem
like
a
complete
and
integrated
feature
in
the
ecosystem?
I
mean
we
kind
of
have.
G
A
Because
I
mean
really
what
you
the,
I
think
the
thing
that
most
people
want
is,
if
I,
when
I
open
this
and
read,
am
I
reading
the
same
state
off
of
storage
right
right?
But
I
don't
think
that
there's
anything
that
you
can
do
with
path
apis
to
answer
that
and
I
think
the
only
way
you
can
really
do
it
is
actually
to
open
and
then
ask:
are
these
two
open
handles
the
same
state
on
disk.
G
L
L
That
we
handle
and
get
target
info,
we
either
return
the
link
the
link
object
directly
or
we
traverse
through
all
the
linked
symbolic
links
until
we
reach
a
final
target.
We
should
also
keep
in
mind
cycles
here
yeah
when.
L
David
cantu,
he
solved
the
a
similar
problem
in
jason,
jason's
cycle,
so
yeah
we
have
a
an
idea
of
how
this
could
be
solved.
It
could
be
expensive
but
yeah.
It's
it's
something
to
keep
in
mind.
G
And-
and
I
would
assume
that
most
apis
that
now
most
of
our
apis
that
deal
with
path,
comparisons
would
and-
and
it
does
sound
like
this-
is
a
separate
proposal
then,
but
it
sounds
like
they
would
basically
take
an
additional
thing
of
bool
resolve
symbolic
links,
and
if
that's
true,
the
first
thing
it
would
do
for
each
input
path
is
you
know,
get
target
info,
get
full
path.
F
J
F
Yeah
it
just
I
don't
know
like
I
barely
ever
work
with
file
system
infos
directly,
I
almost
always
use
the
static
ones
yeah
and
just
from
the
from
a
consistency
standpoint,
it
seems
weird
to
do
half
the
work
and
not
the
other
half.
L
A
A
A
The.
So
I
do
see
that
you
have
a
parody
mismatch
of
the
get
symbolic
link
target
here.
A
uses,
symbolic
link
target
instead
of
target
and
meaning
it
shouldn't
go
through
junctions.
A
I
guess
and
the
it
doesn't
take
the
boolean
and
then
now
you
have.
This
question
is
symbolic
link
where,
on.
L
A
L
Correct
yes,
just
for
support
for
this
scenario.
Another
way
to
solve
this
would
be
to
have
like
a
set
an
enum
and
check
if
it's
or
make
the
method
return.
The
type
of
link
we're
dealing
with
and
regarding
the
name
of
the
other
method,
get
symbolic
link
target.
Yes,
the
idea
is
that
we
would
only
return
something
if
it's
a
symbolic
link.
A
L
Yeah
I
mean
it
if
you
disagree,
that
that's
a
valid
point.
A
I,
the
words
were
different
and
I
was
if
the
concept
is
different
than
the
words
being
different
is
great.
Words
were
different,
but
the
concept
is
the
same,
as
is
the
problem.
L
Right
also,
an
alternative
to
having
those
methods
created
on
file
or
directory
would
be
to
have
them
in
path,
and
we
could
in
turn,
determine
on
windows
if
the
path
we're
talking
about
the
yeah.
The
the
path
that
we
want
to
create,
a
link
for
is
a
directory
or
a
file,
and
the
user
would
not
have
to
care
about
that.
L
A
Okay,
so
windows
is
not
does
not
have
that
the
directory
entry
type
is
symbolic
directory
versus
symbolic
file.
It's
just
symbolic.
It
basically
returns.
F
L
L
A
F
L
A
A
A
At
least
but
it
would
depend
on
if
we
have
other
members
on
path
that
answer
data
about
a
path
instead
of
just
manipulate
a
path
yeah.
Sorry,
if
they,
because
I
think
most
of
the
things
on
path
are
about,
you
know:
where
does
slashes
go
and
how
do
you
pop
off
and
what's
an
extension
mean-
and
it
doesn't
ever
say
anything
about
the
contents?
K
F
The
one
downside
of
putting
it
on
file
directory
is
that
if
you,
if
there's
code
that
doesn't
know
whether
the
target
is
to
follow
directory,
then
you
have
to
ask
upfront
if
it's
a
file
and
then
call
father,
create
symbolic
link
and
otherwise
call
directory
or
create
symbolic
link
right.
That's
the
right.
C
F
L
L
F
L
Question
that
was
asked
in
the
chat
in
youtube:
how,
if
you
used
the
path
method,
to
create
a
symbolic
link
on
unix,
for
example,
and
it
points
to
a
file
without
extension,
since
we
don't
differentiate
what
would
it
return,
but
I
think
we
could,
before
creating.
L
Create
symbolically
a
directory
info
that
grabs
the
target,
no
sorry
create
symbolic
link,
so
it.
L
C
L
A
Yeah
and
technically,
I
don't
think
that
the
file
system
infos
populate
themselves
until
you
ask
the
first
member
so
because
of
race
conditions,
it
could
not
exist
by
the
time
that
you
ask
exists
but
sure,
but
in
a
single
threaded,
universe
that
makes
sense
exists,
would
always
return.
True,
yeah.
A
F
A
F
Think
it
all
makes
sense.
So,
basically,
we
would
have
like
file
info
directory
info
file
and
directory
and
they
even
have
two
methods
and
we
probably
should
align
the
names
right.
So
we
call
it
always
create
symbolic
link.
We
always
call
it
get
symbolic
link
target.
A
Right
well
so
I'm
like
I'm
wondering
so
we
have
file
system
info,
create
as
symbolic
link
which
operates
off
of
the
path
information
stored
in
this.
Yes,
if
we're
concerned
about
the
like,
oh
it's
weird
file,
dot,
create
symbolic
link
and
directory.create
symbolic
link.
We
could
do
filesysteminfo.create
without
the
word
as
symbolic
link,
which
takes
the
two
things
now
we're
not
having
the
same
method
group
have
a
instance
in
static,
but
we
have
the
static
without
the
word.
A
Well,
this
is,
we
said
it
was
weird
for
file.create
symbolic
link
because
you
need
to
like
it
can't
actually
return
a
file
info.
If
or
sorry
it
can,
but
I
don't
even
know
what
it
would
do.
If
you
say
file.create
symbolic
link,
you
give
it
a
name
and
it
points
to
a
directory
like.
Is
that
going
to
blow
up
because
what
it
wants
to
return
now
is
a
directory
info.
A
L
L
Info,
that's
where
you
could
have
a
the
error:
yes
exception.
Maybe
mk
link
if
you
create
on
windows
a
link
without
a
slash.
The
argument
which
indicates
that
the
target
is
a
directory
and
you
point
it
to
a
directory.
Then
you
get
an
error.
F
I
think
it's
it's
very
simple
for
us
to
fix.
All
we
have
to
do
is
instead
of
returning
file
interactive
info.
We
just
return
file
system
info
and
we
can
just
say
whatever
you're
pointing
to
is
what
we
return,
and
so
we
just
have
to
say
if
the
link
path
doesn't
exist.
Fine,
let
me
just
return
you
in
in
a
file
a
file
info
where
exist
returns,
false
right,
because
we
just
had
to
pick
one
of
the
two.
A
G
A
L
A
If
path
ever
answers
any
questions
about
the
target
of
a
link,
instead
of
just
about
the
construction
of
the
string,
I
don't
know
if
it
does.
L
L
A
L
Another
option
is
to
yeah
like
going
back
to
what
emo
says:
make
create
symbolic
link,
return
a
file
system
info,
which
could
also
mean
that
we
can
avoid
having
the
three
methods
in
directory,
because
we're
passing
a
path,
and
it
doesn't
matter
what
it
is.
It
will
return
a
file
system
info.
L
If
it's
on
windows
and
target
happens
to
be
a
directory,
it
should
succeed
even
if
we're
calling
it
from
file
from
the
file
class.
F
Yeah
I
mean
we
can
basically
decide
to
only
have
it
on
directory,
only
have
it
on
file
or
having
it
on
both,
but
basically
they
would
always
do
the
exact
same
thing
right,
because
it's
effectively,
depending
on
what
path
to
target
results,
to
either
return
a
file
in
a
file
and
for
directory
info
right.
L
L
L
Oh
and
going
back
to
this
to
the
main
proposal,
is
it
okay?
Does
it
make
sense
to
have
it
on
file
system
info?
We
will
still
have
to
check
if
we
are
dealing
with
a
directory
or
a
file,
and
it
sounds
like.
L
L
F
A
Yeah,
it's
true
yeah.
You
can
call
create
a
symbolic
link
and
point
it
on
directory
info,
create
a
link
to
dev
null
and
then
ask
a
directory
question,
and
now
it's
probably
going
to
explode
you
because
you've
changed
the
instance.
I
mean
it
would
be
the
same
as
if
you
get
the
directory
info
from
enumeration.
Haven't
read
any
of
the
members,
delete
the
direct,
remove
the
directory
and
then
create
a
file
of
the
same
name
that
probably
blows
up
horribly.
A
So
so
maybe
we
don't
want
the
instance
methods.
I
mean
there's
another
option.
F
I
mean
maybe
we
should
just
have
a
new
class
called
symbolic
link
and
then
there's
also
symbolic
link
info
that
derives
file,
system
info
and
so
all
symbolic
links
are
their
own
thing
and
basically
they
are
neither
directories
nor
their
files.
They
are
symbolic
links
and
then
the
only
thing
that
is
either
a
file
or
a
symbolic
link
or
a
directory
is
the
target
itself
right
and
then
it's
actually
kind
of
reasonable.
Because
then
the.
A
H
F
A
Like
I
feel
like
in
linux,
you
can
name
a
symbolic
link
ending
with
a
slash
which
is
a
like
hint.
You
should.
I
expect
this
to
be
a
directory,
but
I
don't
think
it
has
to
be,
and
then
you
just
get
in
a
weird
state.
I
could
be
wrong.
It
could
be
that
ls
puts
the
slash
on
there
when
it
sees
the
target
as
a
directory,
but.
A
Indeed,
I
assume
we
have
a
behavior
for
when
we
see
symbolic
links
right
now
and
I
I
don't
think
we
can
change
that.
We
just
need
like
this
is
new
metadata
on
it,
which
makes
the
get
target
info
here
makes
total
sense
to
me
if
you're,
a
symbolic
link,
go,
tell
me
where
you
point:
100,
no
problem
the
create
on
the
file
system
info
instance
is
complicated
because
you
can
inherently
change
which
type
of
thing
it
believes
it
is
while,
when
you
call
that
create-
and
that
feels
weird
so.
L
A
But
again
that
doesn't
make
sense,
because
you
can
say
file
info,
create
a
symbolic
link
and
then
you
point
to
a
directory
like
sure
we
can
make
that
throw
of
here.
Like
sorry,
you
pointed
to
the
wrong
thing,
which
is
what
windows
make
link
is
doing,
but
otherwise
I
think
the
creating
the
link
just
needs
to
be
the
static.
F
I
think
when
you
look
at
windows
right
like
if
you
know
the
current
situation
is
right:
if
you
do
directly.get
charge
directories,
we
will
return
directory
infos
for
symbolic
links,
because
they're
resolved
through
directory
right.
So
I
think
the
problem
really
is
is
that
the
only
scenario
that
is
ill
defined
here
is
the
creating
a
symbolic
link
to
a
thing
that
doesn't
exist
yet.
F
So
the
question
really
is:
if
you
create
a
symbolic
link
using
the
windows
apis
that
resolves
to
nothing
what
does
path
so,
what
does
directory
enumerate
files
and
file
new
yeah?
Basically,
what
does
it
do?
Does
it
include
it
at
all?
My
assumption
is
it
would
it
would
show
up
neither
as
a
subdirectory
nor
as
a
file,
because
it's
neither
a
file
or
directory
it
just
points
to
nothing,
in
which
case,
maybe
that's,
okay,
maybe
we
can
just
say
our
apis.
Just
don't
support
creating
a
symbolic.
F
Target
that
doesn't
exist
yet,
like
you
have
to
like
I
mean
we
can't
say
we
do
support
it,
but
we
will
create
the
target
right.
Maybe
absolutely
it
needs
to
be
a
follow
directory
at
the
time
you
created,
because
otherwise
you
don't
know.
A
Right,
this
is
simply
the.
If
you
say,
file
info
dot
create
a
symbolic
link
and
target
happens
to
be
a
directory.
Then
we
can't
populate
the
file
info
members.
They
don't
make
sense
anymore
great,
and
so
that's
why,
like
I
I'm
just
saying
for
create
if
we
get
rid
of
it
on
file
system
info
and
just
leave
it
as
file.create
symbolic
directory.
There's
no
ambiguity,
so
I.
L
A
A
F
So
I
think
the
problem
is
that
might
be
a
breaking
change
right,
because
the
question
is,
if
I'm
on
dot
net
five
right,
where
we
don't
have
those
apis
and
I
do
directory
dot
enumerate
files
and
there's
inside
there's
a
symbolic
link
that
it
happens
to
point
to
a
file.
It
will
return
this
as
a
as
a
as
a
file
info
right,
because
the
thing
it
points
to
is
a
file.
F
F
You
should
probably
test
it.
On.Net
5
what
actually
happens
with
the
normal
windows
enumeration
apis?
That
don't
know
about
symbolic
links,
but
that's
why
I
think
you
can't
treat
them
as
always
files.
You
would
have
to
treat
them
as
what
is
it
they
are
pointing
to
because
that's
effectively
what
they
are,
and
I
think
that
kind
of
makes
me
believe
that
the
design
that
you
have
is
just
when
you
create
one.
F
You
have
to
make
a
decision,
what
it
is
and
then
it's
immutable,
and
so
we
can't
have
the
create
method
on
file
system
info.
I
mean
we
can,
but
we
would
then
have
to
check
whether
it
actually
is
the
right
type
right,
and
that
seems
a
bit
odd,
maybe
but
it's
probably
not
the
worst
in
the
world
either.
F
L
Is
a
symbolic
link,
then
you
can
call
get
target
info
and
you
know
that
you
may
get
something
valid
and
since
we're
expected
to
return
file
system
info,
we
check
if
it's
a
file
or
a
directory
and
then,
if
it's
a
directory
we
can
go
deep
deeper
into
it.
If
you
were
iterating
recursively,
I
don't
know
if
that
makes
sense.
L
L
F
L
F
If
you
ask
windows,
you
know,
is
the
symbolic
link,
a
follow
directory
and
production
windows
will
effectively
do
that
recursion
for
you
right,
so
that
so
you
don't
have
to
do
anything.
You
can
just
be
dumb
honestly,
like.
I
think
that
I
think
that
the
big
problem
here
realistically
is
is
just
we
can't
have
a
create
symbolic
link
info.
It's
incredible
symbolic
link
api
on
file
system
info.
F
Unless
we
are
willing
to
check,
does
the
path
resolve
to
the
correct
type,
and
if
so,
let
it
succeed,
I
mean
we
could
decide
and
say
if
the
thing
doesn't
exist,
we
also
let
it
succeed
because,
well
you
know.
If
it
doesn't
exist,
it
could
either
be
a
follow
directory,
but
it
doesn't
really
matter
right,
so
it
would
only
say
if
this
thing
exists
and
it
is
the
right
thing
then
succeed
otherwise
go
away.
L
F
L
F
L
F
Well,
I
mean
like,
I
think,
you're
providing
that
information
by
the
suffix
of
symbolic
link,
but
if
you
just
call
it
create
then
yeah
that
would
be
weird
right
but,
like
you
probably
create
symbolic
links,
so
it's
kind
of
clear
that
you're
creating
a
symbolic
link
right
so
that
to
me
the
ass
just
doesn't
add
anything.
It's
just.
A
F
F
A
Yeah,
I'm
just
I
guess
it's
the
it's
just
the
code
review
thing
right.
You
see
new
directory
info
of
you,
know
home,
slash
home,
slash,
emo
and
then
you
know,
dot
create
symbolic
link,
and
then
you
see
you
know
like
that.
Goes
off
the
right
hand.
Side
of
the
screen
is
that
creating
emo
foo
as
a
symbolic
link,
or
is
that
creating
a
symbolic
link
under
the
directory
emo
foo?
A
So
it's
creating
emofu
bar
bar
points
to
devnl
I
just
like
it
it.
You
can
infer
it
by
the
number
of
arguments
it
took.
It's
just
it's
not.
G
K
F
A
F
Yeah
I
mean
I,
I
also
like
the
the
the
other
name
you
had
for
the
target
info.
One
like
was
it
get
symbolic,
link
target
or
whatever?
That
makes
more
sense
to
me
than
get
target
info.
L
F
F
A
F
Right-
and
so
I
would
probably
say,
get
target
info
would
also
return
now
for
junctions.
Is
this
that's
a
different
thing?
You
have
to
ask
basically-
and
maybe
we
have
an
uber
thing,
then
that
works
for
everything
and
then
gives
you
back
the
target
path
and
the
kind
or
something
right
right,
yeah,
fair
enough,
so
I
will
probably
just
call
it
get
symbolic
link
target
and
okay.
I
could
either
and
make
it
just
return.
The
file
system
info
question
mark
okay,
so
I
just
pasted
in
chat
what
like
what
I
think
this
should
look
like.
F
F
I
would
just
say
call
get
some
bollywing
target
and
check
with
it
now
like.
Why
would
you
only
care
whether
it
is
one
you
probably
want
to
know
what
it's
pointing
to
too.
A
L
F
It
would
be
no
right,
I
mean
it
is
literally
the
null
check
right
because
it.
F
A
A
F
I
mean
true,
but
at
the
same
time
like
directory
dot,
you
know
create,
for
example,
returns
a
directory
in
for
today.
Right
so,
like
I
mean
for
better
or
worse
the
pattern
and
even
the
static
ones
is
that
they
will
generally
create
these
info
objects.
So
I
mean
I,
I
still
have
trouble
believing
that
this
is
your.
As
you
said,
the
performance
bottleneck,
because
if
you
do
this
in
a
tight
loop,
you
have
other
issues
right
like
it's.
Probably
the
I
o
is
the
thing
that
kills
you're,
not
the
oh,
my
god.
L
E
F
No,
I
think
libra
is
fine.
We
only
have
them
on
path,
because
the
extension
is
because
path
is
just
in
memory,
manipulation
and
important
thing
right
and
that's
where
we
actually
have
spans,
but
I
think
for
fallen
and
directory
where
you
actually
do
io.
We
never
added
span-based
overloads
because
well
you
do
io.
So
who
cares?
Okay,
so.
F
A
F
Yeah
to
me
it's
kind
of
like
they
would
do
the
same
thing.
It's
just.
I
think
it
depends
on
your
mental
model,
which
one
you
would
call
right.
I
mean
fair
enough,
I
I
don't.
I
don't
have
strong
opinions,
it's
just
I
mean
yeah,
it's
weird
either
way,
but,
like
I
don't
know,
I
mean
we
can
decide
to
keep
it
only
on
one.
But
then
could
we
get
a
vote
where
we
all
agree
on
what
the
one
is.
That
would
make
sense
to
us.
F
L
Yeah,
I
will
also
leave
it
in
file
and
make
it
return.
File
system
info
email
already
had
that
in
his.
A
A
Because
really
they're,
just
like
one
of
them's,
just
gonna
call
the
other
yeah
or
they're.
Both
gonna
call
the
same
implementation
with
no
extra
validity,
which
is
why
it's
weird,
because
we
generally
don't
do
that.
But
this
is
a
it
doesn't
actually
pertain
to
either
files
or
directories.
But
those
are
the
two
places
that
you
would
go
to
look
for
it.
So
we're.
F
A
It's
fine.
The
note
that
I
had
taken
was,
we
can
add
it
back
later,
if
there's
pushback
and
I
think
emo
adding
it
back
in
the
proposal
was
pushed
back
so.
F
A
F
A
Right
because
now
we
just
say
like
because
it's
directory
that
create
symbolic
link
that
returns
file
system
info.
Our
answer
is
we
don't
care,
it
does
something
we're
not
asserting
it
returns
directories
we're
not
saying
it
has
to
we're
not
like
we
it
whatever
we
do
for
enumerate,
that's
what
we're
going
to
do
from
here,
basically
pretty
much
and
and
then
the
like,
so
that
and
similarly
forget
symbolic
link
target.
A
I
will
the
one
thing
that
I
want
to
ask,
even
though
we're
now
half
an
hour
over
is
on
file
system
info.
We
added
the
recur
option
and
on
file
we're
making
you
just
call
it
yourself
in
a
loop.
Do
we
think
we
want
the
recur
option
on
file
and
no.
A
To
false,
because
we
don't-
I
mean,
I
think
people
generally.
L
In
favor
of
setting
it
to
false
is
that
powershell
someone
working
on
powershell
down
below
mentioned
that
they
do
not
look.
They
avoid
cycles
by
setting
this
to
false,
also
because
it's
expensive
so.
L
A
L
F
A
A
F
F
L
I'm
okay
either
way,
I
feel,
like
you're,
more
inclined
to
having
false
so.
F
K
L
L
Yeah
I'll
keep
in
mind
be
careful
with
the
enumeration.
I
know
that
file
system
enumerable
is
flexible
enough
to
let
us
check
if
we
want
to
traverse
the
symbolic
links
or
not,
but
obviously
the
directory
ones
are
the
ones
that
need
to
have
the
same.
E
Behavior
yeah,
so
you
you
have
a
proposal
here,
saying
that
you'll
throw
a
few
detect
cycles,
correct.
G
A
E
A
E
Think
I
think
that's
the
best
thing
to
do
honestly,
because
I
can
very
easily
imagine
this
ending
up
like
in
service
code,
like
as
a
windows
service,
for
instance,
where
they
start
looking
over
a
directory
and
some
malicious
local
user
with
low
privileges
has
just
spammed
20
000
sim
links
into
a
single
folder
trying
to
stack
overflow.
The
process.
A
E
A
E
You'd
also
want
to
document
like
do
you
follow
unc
paths?
If
someone
does
a
sim
link,
because
I
believe
sim
links
can
actually
go
across
volumes
because
they're
not
functions
correct,
they
do
yeah.
I
mean
on.
E
Yeah,
so
you
would,
you
would
absolutely
want
I'm
again
just
from
a
security
head-on.
I
can.
I
can
easily
imagine
services
calling
into
this
where
the
input
files
are
untrusted,
so
there
would
have
to
be
a
warning
block
on
here
saying
like
hey
if
you're
a
service-
and
you
don't
trust
the
path
that's
being
passed
to
you,
you
really
don't
want
to
pass
true
in
for
this
parameter,
because
it
could
do
some
really
crazy
things.
E
Along
those
lines,
actually,
when
you're,
when
you
are
getting
the
destination
of
a
sim
link,
you
actually
should
not
attempt
any
type
of
resolution
without
the
explicit
consent
of
the
caller.
So
if
assembling
does
point
to
unc
path,
for
instance,
you
you
should
feel
free
to
return
the
unc
path
to
the
caller
and
potentially
even
say
like
here's.
You
know
return
it
in
a
nice
structure,
but
under
no
circumstance
should
we
ever
attempt
to
actually
hit
it
like
to
actually
make
a
network
connection
to
that
unc
share
without
the
caller.
A
E
E
I've
seen
like
I've
been
involved
with
a
lot
of
these
with
lots
of
different
ms
hrc's
along
these
lines
with
regard
to,
like
impersonation
network
shares,
everything
else
and
apis
like
this
tend
to
be
the
things
that
bite
those
services.
A
Okay,
yeah,
I
mean
I
will
say
looking
looking
at
it.
I
do.
I
feel
that
the
as
belongs
in
the
instance
member
create
as
symbolic
link
but
me
saying.
L
L
I
also
think,
at
least
in
the
file
system
info,
should
we
convince
emo.
What
do
you.
L
F
A
It's
just
the
fact
that
it's
doing
this
other
weird
thing
like
you're,
not
asking
the
file
to
create
a
symbolic
link,
you're
telling
the
file
system
info
to
create
itself
as
a
symbolic
link,
and
that's
where
it's
you're,
not
asking
the
file
system
info
to
do
or
the
file
that
it
represents
to
do
work.
So
we
have
file
system
or
directory
info
enumerate
directories
right,
you're,
not
you're,
asking
about
the
contents
of
the
directory
to
do
something.
A
F
A
F
A
A
Oh
yeah,
I
definitely
heard
so
create
symbolic
links
bye.
It's
like
no,
no.
F
A
K
A
Yeah,
that's
what
it
is
all
right
so
for
anyone
who's
still
watching
live.
I
don't
know
why,
but
thank
you
for
joining
us
and
for
anyone
who's
watching,
recording
you
probably
just
skipped
to
this
part,
so
we
don't
have
a
session
on
friday.
A
I
don't
think
right,
emo,
we
don't
have
one
tomorrow
we
do
no,
tomorrow
or
but
next
week
we
have
a
session
on
monday
instead
of
tuesday.
So
for
anyone
who
wants
to
join
us
live.
That
is
10
am
monday,
pacific
time,
because
we
have
conflicts
on
tuesday.