►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
B
Yeah,
so
here
is
the
original
proposal
and
the
changes
in
the
original
proposal,
so
this
is
just
the
left,
the
between
the
original
proposal
and
and
addressing
the
feedback
that
we
got
last
time.
So,
of
course,
I
mean
like,
as
you
see,
the
red
line
is
what
what
gets
removed
and
green
line
is
what
get
added.
B
So
should
we
go
to
one
by
one
on
the
death
or
should
should
we
just
give
people
some
time
to
read
the
diff.
A
I
think
we
can
just
walk
over
what
has
actually
changed.
So
if
you
wanna.
B
Yeah,
okay,
so
first
one
we
removed
the
constructors
that
it
takes
and
and
as
a
daily
number,
and
we
said
that
this
would
be
confusing
with
other
constructors
that
start
with
entry
with
year.
So
people.
C
B
B
Yeah
and
next
we
removed
days
in
month,
because
this
is
existing
bit
time
also,
so
we
don't
need
it
here
is
leap
year
removed
also
it's
the
same.
It
existed
in
the
dead
time,
so
we
removed
it
from
here
too,
and
we
have
removed
the
explicit
and
implicit
operations
and
we
replace
those
with
effective
methods.
B
A
D
D
I
I
just
told
you
for
what
it's
worth
your
youtube
stream
is
frozen,
so
I
think
it
was
your
network
reset.
A
B
F
G
A
B
Okay,
yeah:
it's
between
go
ahead;
remo.
H
B
And
for
the
operators
plus
operator
minus
operators,
we
removed
those
and
also
we
removed
the
implicit
and
explicit
operators
for
the
sake
of
using
a
factory
method.
Instead,
as
we
did
in
the
in
the
date
only
so
right
now
we
removed
almost
all
the
operators,
the
plus
minus
and
and
the
explicit
and
implicit
conversions.
C
A
A
D
D
H
Past
one
of
these
to
a
sql
parameter
at
the
moment
like
until
we
adjust
those
things,
we'll
also
need
a
way
to
get
over
to
a
time.
A
H
B
B
D
K
A
A
Cool
so
like
in
terms
of
names,
we
are
still
cool
with
date,
only
and
time
of
day,
right.
B
Yeah,
I
think
this
is
the
best
option.
We
have
so
much
miss
calendars,
whatever.
A
H
Having
gone
through
all
this
naming
argument
on
on
multiple
different
proposals
in
other
languages
really
with
without
a
grouped
name,
space
for
all
the
date
and
time
types
to
belong
together,
you
have
to
rely
on.
H
H
L
A
C
I'll
present
it
for
in
the
description,
I
didn't
change
what
we
have
in
the
issue
description,
but
I
put
the
api
proposal
in
a
comment.
So
if
you
find
searching
in
the
page
for
background
and
motivation,
you'll
find
the
comment.
C
The
word
of
more
usable
and
the
this
issue
is
aiming
to
make
use
of
source
generated
code
to
help
users
have
better
usability
with,
and
also
have
like,
more
maintainable
code
and
everything.
So
the
person
who
did
the
prototype
is
also
in
the
meeting
today.
I'm
marching
and
yes.
C
Well,
so
I'll
assume,
so
basically,
if
anyone
is
interested
in
the
issue
page,
there
is
this
comment
that
has
a
list
of
samples
as
well
and
over.
There
you'll
see
logging
samples
of
this
issue.
Basically,
when
you
scroll
through
the
comments
is
that
the
the
main
focus
is
on
usability
and
enforcing
strong
blogging,
and
it
would
be
great
for
users
to
come
up
with
a
like
specific
blogging,
only
templates
and
what
I
was
hoping
to.
I.
A
Mean
the
stream
will
see
whatever
the
stream
sees,
but
given
that
youtube
seems
to
be
dead
anyway,
it
is
what
it
is
so
just
share
your
screen
where
it.
C
Teams-
okay,
so
here
it
is,
if
you
guys
see
the
screen,
let
me
know.
C
Of
how
we
use
logger
message
define
and
you
define
this
action
and
then
basically,
a
bunch
of
a
main
key
advantage
is
that
we
don't
have
to
parse
messages
on
every
single
to
find
the
templates
to
substitute
and
now
going
to
a
new
proposed
approach,
static
being
able
to
have,
like
instance,
method
as
well
as
like
static
methods
and
for
logging,
and
this
like
in
terms
of
usability.
C
It
helps
a
lot
but
not
having
users
to
define
having
to
write
these
kinds
of
actions
for
each
logging
method
right,
but
rather
defining
their
logging
methods
and
like
advantages,
can
also
have
string
names.
So
there's
an
optional
with
classes
that,
like
would
be
like
hello,
some
like
type,
and
then
we
could
auto
generate
types
realization
behind
the
scenes
as
well.
And
that
would
very
well.
K
C
Yeah,
the
generated
code
is
actually
up
top
here.
So
for
something
like
this,
this
is
what
the
generated
code
would
look
like.
K
Okay,
so
might
I
I
want
to
mention
something-
and
I
don't
know
if
it's
completely
relevant
or
only
partially
relevant,
but
for
c
10,
there's
a
95
chance
that
c
sharp
10
will
include
improved
support
for
interpolated
strings,
where
someone
can
write
a
custom
builder
and
as
part
of
that
pattern,
I
know
one
of
the
key
things
as
part
of
this
generated
code
is
guarding
the
the
interpolation
such
that
it
doesn't
happen
unless
logging
is
enabled,
and
the
pattern
from
the
compiler
enables
that
so
you
can
write,
you
know
you
could
write
your
log
message
that
took
an
interpolated
string
and
have
it
not
evaluated
at
all,
unless
that
particular
log
level
was
enabled.
K
C
F
We
don't
actually
use
interpolator
string,
it's
sort
of.
If
you
go
back
and
look
at
the
usage
example,
it
looks
a
bit
like
interpolator
strings,
but
we're
actually
using
message
templates.
E
F
D
So
can
I
can
I
trim
in
so
sure
so
the
implementation
that
we
have
right
now
hides
the
string
formatting
process
within
the
generated
code
and
is
designed
to
and
in
fact
leverages
interpolation
internally.
So
it
turns
what
is
not
suitable
for
an
interpolation
model
into
something
that
is
that
uses
interpolation
so
automatically
when
this
gets
compiled
with
c-sharp
10,
it's
efficient
all
right.
So
if
you
look
at
the
generated
code,
the
the
example
generated
code.
There's
a
formatting
function
in
there
somewhere.
Where
are
we
here,
yeah,
so
the
function
above
the.
D
K
B
D
K
G
K
G
I
think
that
makes
sense.
I
don't
know
if
it
if
it
affects
this,
though
maybe
it
affects
the
code
gen
itself,
but
I
don't
know
if
it
affects
the
end
to
end.
We
we
still
need
cost.
K
K
D
K
Let
me
let
me
suggest
that
before
we
say
yes,
this
is
blessed,
let's
go
ahead
and
do
it
I'd
appreciate
it
if
someone
would
would
sync
up
with
fred
on
the
c-sharp
team
to
work
out
what
a
solution
like
this
would
look
like.
D
G
C
Arbitrary
example,
let's
say
if
it
was
like
log
information
and
then
we,
if
in
terms
of
I'm
gonna,
ignore
like
for
a
second
like
park
that
topic
that
we
talked
about,
but
given
that,
if
we
assume
that
we
were
going
to
use
this
logger
message
attribute,
one
thing
I
wanted
to
like
showcase
was
like
how
the
api
would
have
looked
like
and
also
there's
also
a
bunch
of
other
things
as
well
so
like
in
terms
of
the
co.
The
generated
code
itself
exposes
some
apis
that
I
was
like.
C
A
Well,
I
mean
it
depends
on
like
how
you
see
this
right,
like
my
understanding
is
that
you
know
there
is
an
ask
to
just
you
know:
reconcile
the
design
with
c-sharp
interpolated
strings
like
if,
if
the
feature
crew
genuinely
feels
that
this
will
have
no
impact
on
the
design,
I'm
okay
with
doing
that.
If
you
feel
the
design.
D
I
A
G
A
H
D
All
right,
so
so
people
like
the
the
benefit
here
is
as
the
author
of
a
component,
I
can
have
a
class
that
says
this
is
the
stuff
that
I
support
to
be
logged
period.
You
can't
just
pass
an
I
logger
and
call
log
information
on
it
that
doesn't
work.
I
can
now
audit
all
my
logging
statements
in
one
place
see
their
levels
see
their
strings
are
consistent.
B
D
I
D
C
Another
one,
so
blogging
methods
must
be
partial,
loving
methods
must
cannot
have
a
body
cannot
be
generic.
This
is
another
example.
If
someone
wrote
this.
C
Also,
like
the
they
also
must
have
to
pass
a
parameter
to
the
logging
method.
This
one
also
with
corner
and
in
total
there's
like
18
of
them.
A
F
Because
I
know
like
otherwise
they're
like
based
on
category
like,
like
thousand,
is
like
code
styles.
I
forget
how
it's
done
in
the
bco
right.
N
A
The
actual
error,
the
actual
diagnostics
that
are
raised
by
the
generator,
so
I
think
I
think
the
one
I
don't
know
exactly
how
we
do
this,
but
we
one
or
two
files
that
we
share.
You
know
as
widely
as
possible,
and
you
know
it
doesn't
to
me
honestly.
I
don't
care
about
the
ranges
I
mean.
If
there
are
ranges
right
now,
so
be
it
but
like
we
should
just
make
sure
that
we
have
unique
ids
and
then
just
make
sure
we
have.
We
reduce
overlap
if
that
makes
sense.
D
A
B
K
A
Revit,
like
somebody
already
claimed
the
next
four
numbers,
and
then
yours
is
the
one
down
like.
I
would
honestly
not
care
about
the
numbers
at
all
like
realistically,
what
matters
is
that
the
number
is
unique.
I
can
copy
and
paste
it
into
bing
or
google
and
get
a
unique
hit
and
whether
it's
consecutive
or
organized
or
divided,
by
tens
or
hundreds.
I
don't
think
anybody
really.
D
Optional,
so
if
you
don't
supply
it,
the
code
generator
is
going
to
produce
automatically
a
a
format.
That'll
produce
all
of
your
parameters
as
json
encoded
text,
so
we've
had
several
places
where
that
kind
of
functionality
is
desirable.
C
Level
being
dynamically
like
provided
and
one
where,
like
you,
don't
have
the
string
message,
but
you
pass
down
the
like
the
key
one
and
key
two
and
then
you
the
result
you
get
is
the
json
serialized
log
message
and
like
the
apis
are
here
so
string
message
here
and
event
id
event
80
by
the
way
needs
to
be
unique
and
unique.
G
N
Mentioned
deriving
event,
ids
from
event
names.
If
I
look
at
like
lou's
original
thing,
is
that
still
a
thing
that
we're
considering.
D
N
D
N
A
But
does
the
event
id
mentally
mess
up
right
and
that's
it?
I
think
it's
probably
like
it
is
it's
also
if
you
can
write
down
a
rule
that
basically
says
like
must
be
unique
within
an
assembly
very
easy
to
understand.
If
you
say
something
like
within
the
scope
of
your
logger,
which
you
know,
there's
1200
different
ways,
you
can
define
that
scope,
not
so
easy
to
explain
right
and
then
people
will
definitely
screw
up.
D
N
A
D
Ids,
when
you're
having
these
different
log
categories
means
that
somebody
needs
to
have
in
their
head
some
global
numbering
scheme.
To
make
sure
this
class
doesn't
overlap
with
this
class,
which
kind
of
sucks.
D
All
ids
are
globally
unique
across
the
entire
assembly.
Then
I'm
forcing
somebody
to
have
that
discipline
to
keep
them
unique
if
instead,
we
enforce
it
on
a
class.
So
all
the
logging
methods
declared
in
one
class
or
base
class
thereof,
those
need
to
be
unique.
Then
you
have
local
reasoning
at
least.
A
G
The
partial
method
pattern
works
for
both
having
it
on
a
class
that
implements
some
interface.
That
actually
seems
a
good
balance
between
the
two
patterns
and
you
can
still
expose
the
logger.
G
N
D
It's
king
in
the
the
source
in
our
large
source
space
that
we
use
within
our
product
here.
Several
log
messages
are
we're
using
log
information,
log,
debug,
log
warning
log
error
and
in
the
message
string
itself,
we're
passing
warning
colon
error,
colon
that
kind
of
stuff
right,
redundantly.
D
Similarly,
they're
passing
they
timed
out
now
as
a
parameter
and
even
though
it's
captured
by
the
logger
under
the
covers,
so
the
source
generator
flags.
These
things
explicitly
says:
hey,
you
probably
don't
need
info
colon
in
your
message.
String!
Hey!
You
probably
don't
want
to
pass
the
date
time
because
the
infrastructure
will
supply
it
for
you.
D
It
doesn't
need
to
be
mentioned
in
the
in
the
message
text.
G
Right,
the
the
other
thing
that
I
think
we
should
talk
about,
I
guess,
if
time
hasn't
run
out
yet
is
the
struct
that
we
actually
want
to
expose.
That's
it.
D
G
G
D
So
there
is
just
somebody
suggested
that
I
try
to
understand
how
that
would
work,
and
I
couldn't
figure
out
how
to
make
it
existing
longer
defined.
Logger
message
defined
is
limited
to
six
arguments
with
this
model,
you're
limited
to
six
arguments
with
no
boxing
and
then
the
rest
is
passed
as
a
params
array.
So
it's
an
unbounded
number
of
primate
logger
logging
parameters.
C
And
today
the
internal
types
that
we
have
we
have
so
we
have
six
different
logger,
message.defined
apis
and
from
t1
to
t6
and
like
theoretically
like
what,
whatever
maybe
just
a
little
quickly
is
in
case
in
the
future.
Someone
wanted
to
type
wanted
to
have
a
strongly
type
serialization
with
different
prototypes.
Then,
if
we
have,
we
can
easily
like
have
it
as
an
add-on
to
the
source
generator
so
that
a
lot
of
the
code
doesn't
need
to
be
written
by
the
developer.
A
Right
so
the
one
thing
I
want
to
mention-
because
I
just
see
it
on
my
screen
here-
is
you:
have
this
microsoft,
extensions
logging,
internal
namespace,
where
you
have
an
argument,
formatter
that
you
say
you
will
be
using
it
by
the
generated
code.
I
would.
A
Yeah,
so
the
problem
with
internal
like
because
the
queue
cuts
both
ways
right
like
so
the
the
problem
is
whatever
we
ship.
We
have
to
support
right,
and
so
the
question
now
becomes,
if
we
put
it
in
internal,
that
kind
of
seems
to
indicate
for
us
all.
This
is
stuff
we
can
still
change
when
in
practice,
we
can't
right.
So
I'm
totally
fine
with
saying
put
it
in
a
different
name
space
to
make
it
less
discoverable
right
or
make
it.
A
You
know,
use
a
more
ugly
name
or
pro
editor
browser,
but
that's
all
fine
but,
as
jeremy
said,
like
don't
invent
new
name
spaces
that
you
specifically
use
for.
You
know
internal
stuff,
because
it's
not
internal
right,
there's,
no
such
thing
as
internal,
so
that
that's
the
only
feedback.
So
I
think
the
the
general
idea
you
have
is
sound.
It's
just
don't
don't
use
that.
D
All
right,
so
what
I
have
on
my
list
so
far
is
that
you
need
to
nail
down
the
uniqueness
scope
for
the
event.
Ids
improve
the
this.
The
field
selection
algorithm
for
the
instance
mode
consider
using
value
tuples,
changing
the
namespace
of
for
internal
these
internal
types.
M
It's
a
serviceable
burden,
it's
a
complexity,
cost
to
the
customer
and
then,
when
you
have
multiple
instances,
I
just
think
that
one
applies
here.
A
D
K
M
We
we
could
follow
the
obsoletion
patterns
of
this,
because
he
has
some
concerns
around
the
the
dll
import
generator
and
its
use
of
marshall,
and
that,
like,
I
think
there
does
need
to
be
some
affordance
there
for
code
generated
code
being
that
does
use
obsolete
methods
and
having
those
diagnostics
be
raised.
A
Control
serve
right
because
you
you
can
suppress
message
whatever
you
want
right,
so
it
depends
on
what
file
you're
generating,
but
I
think
the
the
the
bigger
problem
is
the
generator
itself.
You
know
the.
I
think
the
idea
is,
if
you,
if
you
have
a
companion
type
and
you
you
change
the
generator
to
use
the
companion
type,
and
then
you
say,
okay,
that
companion
type
doesn't
work
for
me.
Introduce
a
new
companion
type
change
your
generator
to
use
the
new
one.
A
Basically,
people
that
already
build
an
assembly,
they
already
have
it
built,
and
it
just
runs
at
this
point:
it's
it's
just
a
binary
right
as
soon
as
they
upgrade
your
package
to
the
new
version.
Well,
the
generator
will
now
also
use
the
new
type
right
so
like,
and
so
that
means
people
that
rebuild
will
never
get
an
obsoletion
warning
because
you
know
once
they
rebuild.
They
also
use
the
new
version
of
the
of
the
generator
anyway
right.
So
it's
more
about
people
that
have
existing
binaries.
K
All
right,
the
time
you
know
so
a
decade
ago,
if
you
wanted
to
use
the
type
as
the
return
type
of
an
async
method,
you
would
attribute
that
return
type
with
the
builder
for
that
return,
type
that
the
compiler
should
use.
So,
for
example,
value
task
has
on
an
attribute,
async
method,
builder
attribute
that
specifies
async
value
task
method
builder
and
then
the
compiler
compiler
will
allow
you
to
substitute
a
different
builder.
K
To
do
that,
though,
you
need
to
be
able
to
sort
of
override
the
one
that's
specified
on
the
return
type
and
specify
a
different
one,
and
that
will
be
done
via
an
attribute.
So
the
idea
is,
we
introduce
an
advanced,
very
advanced.
This
is
you
know,
a
one
percent
users
thing,
but
that
includes
some
of
our
own
code
and
async
method.
The
problem
today
is
people
end
up.
K
Writing
their
own
return
types
just
to
be
able
to
control
that
kind
of
thing,
so
they
write
my
custom
task
just
so
that
they
can
control
the
builder
and
we
don't
want
to
see
a
proliferation
of
return
types
just
for
the
purposes
of
controlling
that
stuff.
So
now
someone
could
write
their
own
builder
for
a
value
task
that
adds
logging
or
I've
seen
someone
do
it
that
goes
back
to
you
know,
forces
going
back
to
the
ui
thread
on
every
completion.
K
Things
like
that
custom
builders,
one
for
value
task
and
one
for
value
task
of
t
that
does
that
pooling,
and
then
someone
can
opt
in
by
slapping
this
attribute
on
their
method,
naming
that
builder
type
and
the
compiler
will
bind
to
the
new
version
instead.
A
A
K
Everything
in
the
scope
and
below
yes,
so
that
the
attribute
can
also
be
applied
to,
for
example,
a
class
which
means
every
async
method
in
this
class
this,
so
the
first
part
is
just
the
attribute
that
allows
someone
to
specify
a
different
builder
and
then
the
the
second
part
of
this
are
pooling
builders
for
value
task
and
value,
tasker
t
which
look
exactly
like
exactly
like
async
value
task
method
builder,
except
a
pooling
prefix
on
the
names.
K
Okay,
I
know
that
you
at
one
point
were
considering
to
those
fields.
You
could
enable
your
builder
to
basically
store
your
object
into
those
fields
and
get
the
object
from
those
fields
rather
than
going
to
a
global
pool.
I
have
not
included
that
in
the
these
types
today.
K
The
compiler's
design
is
such
that
we
can
do
it
in
the
future
by
adding
well
where
the
builder
has
a
static,
create
method
and
that
static,
create
method
returns.
The
same
builder
type
on
which
it
is
defined.
We
are
allowing
that
to
now
vary,
so
you
can
have
a
builder
that
all
it
has
is
a
create
method
that
does
some
logic
in
its
create
method
and
then
returns
a
different
builder
type.
K
So,
for
example,
if
we
wanted
to
allow
some
configuration
on
these
pooling
builders,
for
example,
to
control
the
size
of
the
pool
analogy,
you
know
we
could
figure
out
some
way
to
make
it
work.
A
M
I
D
Yeah,
I
know
I
talked
offline
with
steve
about
where
the
word
pooling
should
go
in
the
other
two
types,
and
I
personally
liked
it
as
the
prefix
instead
of
trying
to
align
the
front
half
of
the
names,
especially
because
these
are,
I
said,
five
people
steve
says.
One
percent
he's
obviously
inflating
his
numbers.
K
Arguments
and
kind
of
feed
them
through
and
then
the
builder
would,
you
know,
know
how
to
use
that
state
to
do
something
which
would
probably
then
require
us
adding
augmenting
our
pooling
implementation
to
accept,
rent
and
return
delegates.
Something.
J
Sharing
awesome,
so
there
is
a
scenario
that
the
orleans
team
has
and
there's
a
link
in
this
to
to
some
discussion,
but
basically
they
want
to
be
able
to
serialize
exception
instances
across
the
wire
with
decent
fidelity,
and
they
don't
want
to
use
binary
for
route
or
runtime
in
libraries,
so
one
of
the
basin
and
then
say:
oh,
let
me
set
the
the
inner
exception
or
the.
J
Let
me
set
the
stack
trace
string
for
you
that
method
right
here
as
you're
reading
the
the
json
string
from
the
payload
to
do.
There
is
a
little
bit
of
discussion
that
I
have
on
this,
mainly
like
hey.
If
you're,
if
you're
calling
set
sacktrace
string,
we're
not
going
to
set
things
like
the
method
base
property
hanging
off
of
exception,
like
we,
we
can't
turn
it
back
into
a
method
info.
We
don't
know
how
to
do
that.
J
The
string
is
just
opaque
to
us
and
it
should
be
opaque
to
whoever
reads
the
exceptional
object
as
well.
There
were
also
some
alternative
designs.
They
well
documented
on
stack
overflow
so
because
that
hasn't
historically
been
a
problem.
I
don't
see
that
this
would
make
it
any
more
of
a
problem.
What
what
are
you
thinking
of.
K
Mostly
just
that
we
might
start
to
see
exceptions
showing
up
that
make
no
sense
and
again
it's
not
a
real
concern.
I
just
wanted
to
talk
it
through
that.
You
know
people
started
just
storing
arbitrary
blobs
in
exceptions,
and
now
we
get,
you
know,
stack
traces
submitted
or
crash
dumps
or
whatever,
and
the
exceptions
are
just.
J
Gobbledygook
sure
so
one
one
thing
that
would
guard
against
that.
If
the
exception
has
ever
been
thrown,
you
can't
change
a
stack
trace.
The
stack
trace
is
captured
at
the
time
that
it's
thrown.
This
would
all
in
order
to
figure
out
where
the
crash
actually
happened
and
in
per
the
discussion
here,
we
intentionally
don't
touch
that
bucket.
A
Yeah
so
my
other
question,
similar
to
what
stephen
was
asking
is
so
stacktrace
is
your
position
as
a
string
which
basically
means
we
don't
parse
it
right.
We
just
basically
put
it
into
the
whatever
the
field
and
the
exception.
Is
that
stores
that,
but
like
what
happens
now,
when
I
say
things
like,
you
know,
stack
trace
from
exception
and
pass
in
the
exception
like
we
can't.
You
know,
of
course,
reverse
engineer.
The
data
that
was
in
them
right
is
that
a
problem
are
there
other
things?
You
know.
J
That's
not
something
you
were
able
to
do
anyway.
If
you
call
set
current
status
race,
I
believe
trying
to
pass
throne.
A
A
Yeah,
so
all
I'm
asking
is
now
like:
if
somebody
does
it
in
the
infrastructure
somewhere,
are
there
cases
like
this?
You
know
stack
trace
dot,
you
know,
whatever
you
know,
new
stack
transfer
from
exception
where
things
wouldn't
work
with.
Basically,
maybe
I
don't
understand
like
what
does
that
current
stack
trace,
do
them
when
you're
passing
in
an
exception
that
has
no
stack
trace.
Where
does
the
stack
trace
come
from.
J
If,
if
you
pass
an
exception,
that
has
already
been
thrown
set,
current
stack
trace
literally
throws
an
exception
itself
saying
I
can't
mutate
this
exception.
It's
already
been
thrown
the
only
scenario,
for
it
is
you're,
literally
fabricating
an
exceptional
object
by
calling
the
constructor
and
then
before
existing
behavior.
J
Now,
with
the
existing
method,
could
set
things
like
the
watson
bucket
if
it
wanted
to
it,
doesn't,
but
it
has
the
ability
to
set
that
information-
and
I
mentioned
that
at
the
bottom
of
the
thread
here,
because
steve
and
I
had
a
brief
discussion
on
whether
one
method
could
be
written
in
terms
of
the
other,
if
you're
taking
an
arbitrary
string.
J
Instead
of
saying,
please
set
this
to
be
the
current
stack
trace,
then
the
sure
we
could
change
set
current
stack
trace
to
store
the
frame
information
because
we
obviously
have
it
available
to
us
right.
We
could.
We
could
never
do
such
a
thing
with
something
that
just
takes
a
string
as
a
parameter
yeah.
J
A
K
A
J
Or
set
remote
stack,
trace
or
something
I
I
I
don't
really
have
a
strong
preference
honestly.
If,
if
we
had
the
word
string
in
there,
I'd
probably
want
it
at
the
end,
not
the
middle,
but.
J
J
If,
if
we
wanted
to
put
something
in
the
in
the
middle
to
kind
of
to
to
kind
of
act
as
a
counterpart
to
current,
then
I
would
probably
say
remote,
because
the
scenario
specifically
is,
I
think
at
that
point
that
would
just
be
a
dock
issue.
We
would
say:
here's
here's,
what
you
need
to
check
in
order
to
be
successful,
calling
this
api,
if
you're
a
d,
serializer
you're,
going
to
be
fine
anyway,
because
you've
just
hydrated
the
exception
object,
you
clearly
haven't
thrown
it
yet.