►
From YouTube: Lang Design Meeting: Const eval skill tree + unsafe code
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
B
B
C
C
Yeah
today's
meeting
is
basically
you
to
figure
out
the
long
term
plans.
What
is
coming
to
country
well,
I
mean
we
reasonably
got
things
like
if
and
blue,
but
there's
no.
We
didn't
have
a
big
picture.
Well
written
down.
Lots
of
us
had
big
pictures
of
what
comes
about
it
should
be
doing
in
their
heads,
but
it
was
really
shareable
in
a
reasonable
way.
C
So
we
have
created
the
constable
skill
tree,
which
is
the
skill
tree
roughest
thing
that
Nico
wrote,
which
allows
you
to
generate
a
kind
of
dependency
graph
of
features
that
dependent
on
other
features
to
first
get
implemented,
and
so
you
get
like
this
in
a
like
in
a
computer
game
where
you
have
a
skill
tree
for
getting
certain
skills.
If
you
want
like
an
end
feature
in
constable,
for
example,
you
want
four
loops
with
I,
don't
know
in
integer
ranges.
C
There
are
certain
other
features
that
you
need
implement.
First,
before
you
can
even
think
about
going
to
for
loops.
For
example,
you
need
any
kind
of
loop
at
all,
and
so
in
the
skill
tree
you
can
easily
see
which
ground
features
you
need
to
be
able
to
implement.
Some
higher
level
features
that
we
all
can
kind
of
agree
on.
We
would
like
to
see
and
come
to
us
through
this.
C
If
you
open
the
skill
tree,
you'll
see
that
on
the
very
far
left,
there
are
some
very
prominent
features,
mostly
because
there's
lots
of
arrows
pointing
at
them.
This
means.
Basically,
a
lot
of
other
features
depend
on
these.
You
route
blocking
features.
Now
we
just
have
stabilized
or
I
the
process
of
stabilizing
if
and
Luke.
C
So
these
two
can
drop
off,
there's
a
bunch
of
others
that
are
also
route
blocking
issues,
the
main
ones
being
unsafety
and
like
alpha
calling
trade
methods
inside
constable
I
think
these
are
like
the
two
main
ones,
there's
others
that
offer
certain
nice
features
by
example.
If
we
had
a
heat
during
constable,
but
you
seem
a
little
bit
further
off,
but
the
general
idea
of
today's
meeting
is
to
figure
out
if
they
plan
that
we
are
having
here
for
constable
is
something
that's.
E
C
So
ecstatic,
Morris
and
I
are
basically
on
par
with
kind
of
that,
a
big
picture
that
we
see
there
that
it
might
be
minor
details
the
greatest
dancing
about,
but
like
it's
more,
we
have
a
fairly
good
picture
of
what's
coming.
But
the
main
question
is
like:
how
can
we
make
sure
that
the
rest
of
the
Lange
team
is
not
just
up
to
date
right
now?
But
if
we
finish
the
we're
discussing
Mississippi,
but
also
keeping
you
in
sync.
F
So
I
mean
I,
think
there's
we
should
try
and
resolve
a
bit
about
prioritization
like
what
stuff
do
we
want
to
be
doing
which
of
these
items
do
we
want
to
be
doing
in
the
near
term
and
then
there's
also
kind
of
a
separate
question
about
how
to
schedule
this
with
the
Lange
team
and
like
how
do
we,
you
know,
how
do
we
set
up
productive
discussions
because,
especially
the
unsafe
time
constant
is
pretty
in
the
weeds
and
also
sort
of
quite
important
to
get
right?
In
my
opinion,.
B
A
C
C
At
all,
we
we
have
some
of
this
guy
or
most
of
these
discussions
in
public.
So
technically
anyone
can
be
in
there,
but
it's
like.
Sometimes
people
randomly
participate,
and
this
often
brings
up
some
good
points
that
we
need
to
figure
out
or
clarify.
But
we
don't
have
anybody
like
really
looped
in
there.
B
B
Suppose
not
my
real,
my
most
media
reaction
is,
you
know,
there's
a
there
is
a
question
here
in
terms
of
whether
we
need
a
line
team
member
actually
looped
in
continuously
to
be
a
sort
of
representative
of
the
Lange
team
and
decide
and
helping
to
decide.
Okay,
now
is
the
point
where
we
should
actually
bubble
this
up
to
the
whole
line
team,
or,
if
it's
more,
that
we
should
trust
you
all
to
make
those
kinds
of
choices.
B
Like
you
said
you'd,
it's
not
it's
not
easy
to
like
actually
schedule
something
with
the
road
with
the
whole
line
team,
but
I
can't
tell
whether
your
concern
is
whether
it's
just
whether
it's
deciding
whether
matter
you
see
bubbled
up
or
if
it's
more
that
you
you
think
you
know
which
metric
need
to
be
bubbled
up.
It's
just
that
it's
very
difficult
to
actually
get
attention
from
the
line
team
right
now.
C
It's
kind
of
a
mixture,
so
we
we're
trying,
for
example,
last
year
to
figure
out
a
bunch
of
features
and
they
ended
up
being
an
RFC,
for
example.
That
was
like
not
had
anything
happen
on
it
for
like
nine
months
and
like
in
the
end,
a
decision
was
not
even
to
do
anything
on
the
RFC,
but
just
do
some
experimental
implementation,
for
example,
and
these
are
things
that
we
could
have
probably
figured
out
in
just
like
the
constable
group,
and
mainly
just
like,
like
smaller
requests,
to
rank
him
like
keeping
it
that
yeah.
C
D
I
don't
know
about
anybody
else,
but
my
initial
thought
is
that
it
is
frankly
much
easier
to
deal
with
the
little
bite-sized
chunks
of
like
what
here's
a
thing.
Here's
the
explanation
of
why
it's
safe
than
it
is
to
deal
with
here's
a
giant
RFC
with
23
things
in
it.
I
think
it
makes
a
lot
more
sense
to
do
exactly
what
you're
saying
of
having
a
roadmap.
And
then
the
question
is
more
just
how
much
autonomy
do
we
feel
comfortable
with
for
individual
points?
D
For
that
part,
I
would
say:
I,
don't
think
that
we
need
to
really
be
individually
consulted
at
all,
what's
possible
in
nightly
and
I.
Think
I
would
mostly
be
happy
to
say.
Here's
like
roadmap
approval
after
some
discussion,
feel
free
to
move
forward
on
each
one
of
those
individually
and
nightly
and
then
like
check
back
with
us
before
they
go
stable,
mm-hmm.
C
D
C
D
That
makes
sense,
but
yeah
I
think
removing
the
uncertainty
there
of
like
giving
a
clear
charter
for.
Please
go
ahead
with
this
chart
on
Knightley
ping,
us
if
something
major
changes
and
otherwise
we'll
hear
back
with
you
know
one
or
small
batches
of
bees
ready
for
stabilization,
pointing
back
to
the
chart
saying.
A
D
Are
in
the
plan?
Here's
why
this
works.
Now
that
seems
like
it
would
be
a
great
forward
plan,
and
then
we
just
need
to
go
through
your
skill
tree,
which
I
think
is
a
great
presentation
of
this
and
talk
through
kind
of
what
are
the
major
roadblocks.
What
makes
different
things
difficult?
What
should
we
expect?
That
kind
of
thing?
Okay,.
C
D
Just
gonna,
say
I
think
linking
to
an
issue
for
more
detailed
discussion
is
completely
reasonable
and
it's
more.
It
might
be
particularly
helpful
if
all
of
those
issues
are
like
some
of
them
seem
very,
very
clear
up
front,
like
I
was
looking
at
heap
allocation
in
constants
in
the
final
value
of
confidence
and
that
linked
to
constable
hu
20,
which
has
a
really
detailed
explanation
in
the
very
top
comment
it
links
to,
and
several
of
them
seemed
to
be
that
way.
C
D
A
D
D
Makes
more
sense
so,
for
example,
once
you
have,
while
let
and
you
have
the
ability
to
call
trade
methods,
then
for
just
D
triggers
to
a
while.
Let
some
equals
something
next
and
an
into
it
or
call
yeah.
Is
there
any
other
complexity
to
Ford,
like
I,
think
there's
an
edge
versus
node
question
here?
Is
there
complexity
to
four
that
makes
it
any
more
complicated
than
once
you
have
its
dependencies
or
is
trivial?
D
C
C
D
And
that's
in
other
cases,
libs
related
items
like
we
can
easily
sign
off
on
this
roadmap
from
a
lang
team
perspective.
There
are
points
in
this
roadmap
where
you
will
need
to
mark
a
bunch
of
things
Const,
which
you
know
we're
happy
with
I.
Think
beyond
what
we're
just
talking
about
like
check
back
with
stabilization
there
and
I,
don't
know
to
what
extent
that's
a
lips
question
as.
C
C
C
C
B
Okay
makes
sense:
do
we
want
to
take
some
time
to
actually
look
at
the
concrete
steel
tree
itself
to
make
sure,
because
I
think
there
was
some
concern
amongst
the
working
group
that
whether
the
linking
is
on
board
for
everything
that's
on
here
that
the
end
of
the
big
picture?
Should
we
wait
until
all
he
revises
it?
I
would.
C
D
C
C
G
B
C
C
Is
pretty
much
with
a
wish
list
of
things
that
we
want
and
that
people
have
open
issues
about
or
that
we
kind
of
wanted
and
maybe
not
even
have
issues
about
it's
not
exhaustive,
but
most
of
the
things
here,
an
able
like
things
in
user
space
or
even
in
just
the
standard
library
that
could
be
implemented.
But
if
we
add
all
of
that
here,
we
are
basically
adding
half
the
standard
library
into
the
skill
tree.
C
E
D
One
thought
on
this:
once
the
skill
tree
is
like
ratified
and
agreed
to
as
a
roadmap,
then
could
we
arrange
to
have
an
inside
rust,
blog
post
that
talks
about
like
here's,
where
constable
uation
is
going
here?
Is
our
you
know
rough
organization
of?
Like
you
know,
let's
say
you
want
to
do
Veck
in
a
constant
here's.
What
needs
to
happen
for
that
to
happen,
and
some
explanations
of
like
this
is
how
we're
building
up
from
individual
components
just
having
a
one-page
blog
post.
That
explains
here's
where
constable
is
going.
D
B
Have
a
suggestion
there
I
understand
that
it
can
be
very
hard.
You
know
grab
his
grass
did.
You
have
no
control
over
the
layout,
but
I
was
wondering
if
you
can
at
least
annotate
edges
in
some
way
with
color,
so
that
would
be
able
to
switch
them
visually
when
looking
at
this
looking
at
them
on
the
screen.
C
D
B
D
So
it's
like
hard
positioning,
it's
not
trying
to
it
doesn't
do
things
like
I
want
this
at
this
exact
pixel
position,
but
what
it
can
do
our
things
like,
despite
the
fact
that
this
is
at
depth
3
from
what
appears
to
be
a
route
I
want
you
to
position
this
at
depth,
5,
so
that
it
stretches
it
out
a
little
bit
more.
You
can
do
things
like
that.
D
D
C
B
D
C
C
C
B
That
sounds
okay,
I
was
curious,
so
one
of
the
topics
that
I'm
ecstatic
Morse
had
mentioned
was
prioritization
I,
don't
know
if
you
all
wanted
to
try
to
just
decide
that
on
your
own
or
if
you
want
feedback
from
us
about,
like
which
items
seemed
important.
It's
unfortunate
to
dock
the
skill
tree
currently
doesn't
seem
to
other
than
the
in
degree
of
nodes.
There's
no
like
notion
of
what's
important
here.
Right,
like
it's
like.
B
C
B
D
B
D
Little
notion
of
you
know
there
are
one
or
two
useful
ordering
constraints.
I
think
I
agree
with
the
thing
that
was
posted
in
the
last
couple
of
weeks
saying
we
should
have
proper
loops
as
soon
as
possible
so
that
people
don't
start
emulating
them.
Maybe
a
general
recursion
yeah.
C
So
we
mainly
have
I
think
as
a
prayer
is
that
for
prioritization
I
think
the
important
part
is
their
high
level
features
like
which
of
these
are
priority,
that
we
want
to
get
to
to
users
and
then
look
at
the
skill
tree
and
figure
out
like
okay.
Then
these
low
level
features
are
probably
important,
too,
and
by
and
I'm.
C
D
Would
personally
say
that,
like
at
a
high
level,
the
two
that
jump
out
at
me
most
are
assert
because
I
would
love
to
have
static?
Assert
back
I
would
even
take
like
a
version
of
that
that
doesn't
support
formatting
yet
and
only
supports
you
know
static
messages.
If
that
gets
us
a
certain
sooner
and
then
we
could
have
panics
and
formatting
yep
and
then
the
other
is
the
ability
to
have
a
static
string
or
Veck
would
be
very
nice
yeah
it
is,
it
is
no
yeah.
A
E
C
E
C
D
Think
this
is
the
kind
of
thing
where
we
need
to
make
constellation
more
heavily,
promoted
and
explained,
because
when
people
realize
how
big
a
feature
constant
valuation
is
and
I
mean
that
not
just
in
terms
of
complexity
of
implementation,
but
in
terms
of
what
it
will
enable
and
how
big
a
part
of
the
language
it
will
become,
then
realizing.
Oh,
okay,
we're
just
evaluating
a
big
chunk
of
rust
code
and
that
code
panicked,
and
so
we
had
a
compile
time
error.
D
Then
people
will
go
from
that's
confusing
to
that's
awesome
bonus
if
we
add
a
couple
of
methods
for
like
here's,
how
to
give
a
more
impressively
format
in
kind,
compile
time
error
like
actually
able
to
give
spans
and
suggestions,
but
that's
a
different
yeah.
F
So
reload
for
prioritization,
it
seems
like
so
we
could
do
cons
panic
in
a
relatively
quick
time
line
and
that
would
have
some
value.
So
maybe
we
should
put
that
near
that,
if
we're
discussing
a
blog
post
of
like
what's,
if
we're
gonna
write,
a
blog,
Coates
I
think
we
should
include
like
hey
here's
what's
coming
next,
maybe
in
the
near
term,
and
maybe
in
the
long
term
and
cons.
F
E
F
D
My
thought
on
this
in
the
interests
of
trying
to
make
sure
we
get
you
everything
you
need
in
the
amount
of
time
we
have.
Why?
Don't
we
allocate
10
or
15
minutes
to
having
you
go
through
the
open
questions
around
unsafe
con
step
in
so
we
can
talk
through
what
the
plan
is,
and
we
can
agree
that
that
makes
sense,
and
then
we
can
reserve
the
last
10
minutes
or
so
of
the
call
for
hey
here
are
things
we'd
love
to
see
on
the
graph.
D
F
D
E
C
Very
quick
thing
that
I
need
to
clarify
in
the
very
beginning
any
single
unsafety
feature
that
allows
you
to
do
something
like
transmute
in
any
kind
of
way
will
get
give
you
basically
all
the
other
unsafe
features
that
are
flying
around.
So
they
are
all
interconnected
and
we
basically
bundle
that
into
in
the
Union
issue,
because
unions
are
the
same
thing.
Yeah.
E
So
the
the
status
quo
is
that
Union
field
accesses
are
allowed
in
constants,
because
that
was
even
primary.
That
was
already
allowed
or
very
early
after
Mary,
so
we
had
to
keep
it,
but
they
are
not
allowed
in
constant
functions
and
the
the
problem
with
all
of
this
is
that
when
you
write
unsafe
code,
of
course,
there's
like
there
are
some
extra
requirement
that
you
have
to
oppose
I'm,
not
talking
about
general
general
Russ
code,
because
you
have
to
make
sure
that
you
don't
cause
a
different
behavior
of
course.
E
So
the
issue
with
constant
email
is
that
there's.
Basically,
there
are
some
new
things
that
can
go
wrong
besides
undefined
behavior
and
it's
doing
things
which
are
impossible
at
compile
time
at
the
number.
One
thing
that
is
impossible
to
compile
time
is
anything
that
depends
on
the
complete
integer
address
of
a
pointer,
because
we
don't
have
those
and
we
cannot
have
those,
because
we
have
to
be
compatible
with.
However,
a
VM
put
stuff
and
like,
ultimately,
this
is
even
non-deterministic
with
address
space,
layout,
randomization
and
stuff.
E
So
if
you
ask
in
constable
if
the
pointer
is
greater
than
the
other
there's
no
answer,
we
can
give,
because
we
don't
know
in
general
and
that's
a
problem
because
asking
this
question
is
possible
in
safe
rest.
You
can
just
you,
can
just
take
your
references,
convert
them
to
raw
pointers
and
do
the
greater
test
and
it's
all
safe.
So
this
is
an
operation
which
is
normally
it
doesn't
even
have
any
extra
precondition.
D
E
The
status
quo
is
that,
if
you
cast
to
as
I
don't
know
exactly
what
the
static
checks
are
ruining
out,
but
I'm
just
saying
if
you
actually
get
something
to
pass
like
to
run,
if
you
cast
something
to
use
as
that
that
works,
but
that
doesn't
actually
do
anything.
So
maybe
I
should
say
a
bit
about
what
happens.
Another
hood
under
the
hood.
We
have
a
symbolic
representation
of
pointers.
We
have
a
pointer
is
represented
as
a
symbolic
allocation
ID,
which
is
basically
the
base
address
of
their
location
and
then
an
offset
into
that
block.
E
And
so
there
are
actually
two
kinds
of
values
that
local
variable
can
have
in
in
Murray,
which
is
integers
or
Condors.
And
when
you
do
a
cast,
nothing
happens.
We
just
have
a
pointer
value
at
integer
type
when
you
cast
back,
nothing
happens
again
and
that
if
you
just
cast
forwards
and
backwards
that
have
no
problem.
E
D
You
are
doing
full,
like
abstract
evaluation
on
your
pseudo
pointer
values,
and
then
you
just
complain
if
you
ever
do
something
with
one
other
than
put
it
right
back
into
a
pointer.
Yes,
ok
does
that
also
include
making
assumptions
about
the
alignment
of
a
pointer?
Yes
does
that
include
things
like
offset
of,
for
example,.
D
E
We
all
want
constant
offset
right.
So
that's
why
I'm
getting
two.
So
we
have
these
operations
that
are
always
safe
at
run
time
and
at
compile
time
in
general,
not,
but
in
special
cases
they
are
so
as
as
Josh
does
mentioned.
If
the
two
pointers
that
we
are
subtracting
are
in
different
locations,
there's
nothing
we
can
do
or
if
you're
subtracting
an
integer
from
a
pointer
in
general.
Also
if
it's
the
wrong
way
anyway,
but
if
you
have
two
pointers
that
point
into
the
same
allocation,
they
don't
even
have
to
both
be
in
bounds.
E
They
just
have
to
be
the
arrive
both
from
the
same
base
errors.
Then
we
know
what
that
difference
is
because
the
base
addresses
don't
matter,
and
then
we
could
do
this
and
we
even
have
an
intrinsic
for
that
already,
there's
the
offset
from
intrinsic,
which
even
the
runtime
form
of
that
is
currently
still
unstable,
but
I'm
trying
to
push
for
civilization.
It's
yes,
please.
D
E
The
problem
comes
up
when
people
write
on
function.
So
that's
why
we
make
a
constant
of
difference
between
constants
and
cons
function.
When
you
just
have
a
Const,
then
it's
just
the
thing.
That
is
really
it
evaluates
correctly
and
we
give
you
a
result
and
we
even
check
it
for
the
result
makes
sense
for
the
type
or
a
relation
goes
wrong
and
you
get
a
reasonable
error.
E
So
if
you
write
a
constant
that
takes
reference
and
then
what
it
does
is
and
that's
all
safe
code
is,
it
has
to
to
an
integer
and
multiplies
it
by
two
and
which
one's
the
integer.
Then
that's
that
you
don't
get
an
error
in
your
code,
but
there
can
be
users
that
call
your
constant
that
don't
do
anything.
Weird
call!
Your
safe
constant
and
they
get
a
weird
Conti
Valero
and
that's
all
and
that's.
D
E
A
E
B
Promising
so
the
soul,
I
might
be
misunderstanding
that
the
problem
that
Ralph
is
outlining,
but
this
surely
isn't
the
only
case
where
we've
got
a
constable
error,
that
only
surfaces
effectively
evaluation
time
of
the
body
of
the
constant
and
right.
There
must
be
other
instances
like
this.
No
basically.
E
C
H
E
A
E
Function
which
basically
in
the
terminology
of
my
blogpost,
is
not
constantly
because
there
are
reasonable
inputs,
for
which
doesn't
behaved
reasonably
at
constant.
So
that's
of
times
that
we
don't
want
people
to
write
a
basically
just
like
we
don't
want
people
to
write
a
function
that
calls
undefined
to
give.
You
is.
E
H
E
Might
remember
I
mean,
and
so
basically
we
have
these
operations
that
we
call
unconstant
things
that
are
safe
at
runtime,
but
bad
at
compile.
Time
and-
and
there
is
some
discussion
around
whether
like
should
we
help
people
figure
out,
make
sure
that
they
don't
have
that.
Should
we
require
an
unsafe
block
in
this
function
to
acknowledge
that
that's
currently
what
we
do
a
thing
for
some
of
these
cars.
They
aren't.
A
E
E
And
so
there
is
a
question
here
of
what
do
we
guarantee
or
not
about
Const
code
that
causes
undefined
behavior,
and
there
is
a
spectrum
here
where
we
could.
We
could
guarantee
that
it
is
caught
like
full
maria-style
all
the
way
to
it
causes
anything
behavior
on
the
host
compiler,
which
could
actually
happen
if,
for
example,
widget
Const
:
son
ran
it
without
supporting
and
like
somewhere
in.
There
is
a
point
that
we
have
to
decide
is
where
our
guarantees
are
for
constable.
H
So
I
got
a
little
lost
in
the
second
half
now
in
the
conover.
But
I
have
a
few
questions
about
the
first
half
possible
just
to
make
sure
I'm
clear
on
it.
So
in
particular,
and
what
would
you
say
about
a
function
like
what?
If
the
evil
function
just
cast
X
to
a
you
size
and
returned
it
that's
a
case
where
it
doesn't
directly
cause
any
problems,
but
the
consumer
might.
E
Function
because
the
to
use
some
of
the
functionality
from
that
blog
post,
a
a
a
runtime
correct
function,
is
one
which
takes
safe
values
and
returns
safe
values.
Yeah
a
constant
function
is
one
that
takes
constant
values
and
returns.
Constant,
safe
values
right
and
a
pointer
value
in
integer
disguise
is
not
a
constant
value
because
they
are
operation
that
we
want
to
consider
constant,
safe,
like
multiplication
by
two
on
which
that
value
arrows
right.
H
H
E
C
E
H
H
E
E
In
principle,
yes,
we
are
guarding
against
that
as
good
as
we
can
by
validating
the
return
value
of
a
constant
like
when
you
have
a
concept,
says
it's
a
GUI
and
we
will
check
if
the
final
value
is
true
or
false.
We
don't
check
this
for
intermediate.
We
have
to
check
it
for
the
final
boolean,
but
that
check.
Isn't
it
doesn't
cover
all
the
possible
cases.
So
there's
especially.
C
E
There
you
could
just
create
a
constant
Veck
that
has
a
bad
stuff
in
it
and
then
it's
safe
coded
by
blow-up.
So
this
this
is
definitely
yes.
There
are
more
long
term
contact
method,
so
to
speak
of
positive
that
constant
evil
results.
Even
if
you
say
it's
just
an
arbitrary
unspecified,
constant
evil
result.
If
you
have
constant
value
B,
that
could
still
mean
you'll
be
at
runtime,
depending
on
how
that
country
by
result
gets
used,
especially.
A
E
E
E
E
Okay,
I
talked
about
the
potentials
of
the
design
space
for
the
second
problem,
which
is
a
guarantee
anywhere
between
its
detected
to
no
guarantees
at
all.
I
know,
but
like
it's
like
I'm,
not
sure
what
what
what
to
say
beyond
that
for
the
first
point,
I
think
the
options
we
discussed
so
far
are
number
one
make
make
these
unconscious
operations
unsafe.
So
you
that's
currently
what
you
have
to
do.
E
E
Because
of
because
of
these
constants
issues
that
we
talked
about
number
two,
we
ignore
it,
it's
not
actually
going
to
cost
you
B,
it's
just
going
to
cause
a
clean
interpreter
shutdown.
It
it's
not
going
to
have
all
these
side
effects
for
optimizations
and
stuff
as
the
norm
and
marubi.
So
we
could
just
make
it
a
safe
operation
and
try
to
otherwise
teach
people
about
it
and
number
three
have
a
different
keyboard
with
a
different
kind
of.
H
B
E
There's
two
ways
in
which
well
there's
more
than
but
there's
two
interesting
way:
I
think
which
conceived
I
can
go
wrong
it
can.
There
can
be
you
be
during
constant
Eva,
like
all
of
bounds,
access
of
your
get
unchecked
access
or
like
using
an
intrinsic
the
wrong
way
like
reaching
the
unreachable
transit,
and
there
can
be.
E
B
Hold
on,
let
me
stop
you,
because
I'm
worried
that
you're
explaining
a
lot
of
details
that
I
don't
really
need.
I,
just
I,
want
to
know
the
bigger
picture
of
like
your.
Your
claim
here.
I
think
is
that
everything
that
you
can't
detect
would
be
caught
by
some
sort
of
sandboxing.
You
know
in
the
worst
case
scenarios
and
you.
B
Attaching
will
okay
hold
on.
Let
me
know
if
I'm
wrong
about
that
correct
me,
but
I'm.
Let
me
just
finish
this
for
a
second,
the
the
worst
case,
behavior
you're,
expecting
given
whatever
safeguards
your
company
in
place,
is
some
kind
of
error
or
compile
time
like
it
just
says
something
went
wrong.
Sorry,
they
may
not
be
a
great
diagnostic,
but
it
won't
be
on
deterministic
behavior
from
your
resulting
object
code,
because
there
will
no
be
object
code.
It
will
not.
B
B
E
E
C
E
That's
the
strongest
possible
thing,
that's
probably
unrealistic,
but
so
so,
given
that
that's
unrealistic,
all
realistic
solutions
are
probably
going
to
involve
that
when
you
have
your
media,
your
constable,
the
return
value
of
constable
like
the
final
value
in
the
Const
is
unconstrained
like
it
could
be
anything
it's
unspecified
behavior.
Basically,
so,
like
you
have
a
thing
that
computes
a
pool
and
the
computation
of
that
rule,
checks
like
that
has
you
be
well
result,
is,
unfortunately,
that
you
might
be
true
or
false,
or
some
other
value
could
even
be
an
insurance
memory.
E
E
E
A
E
E
And
then
there
is
an
even
more
extreme
version,
but
we
don't
even
guarantee
that,
because
we
could
imagine
that,
like
you
could
implement
the
ANSI.
The
unchecked
array
access
during
CT
IV,
with
a
truly
unchecked
access
in
the
compiler
for
extra
conformance
or
something
like
I'm,
not
saying
that's
reasonable,
it's
something
we
could
do.
We
could
get
the
CT
IV
code
and
just
to
run
the
assembly
without
any
checks,
and
then
we
would
escalate
even
one
level
further
I
would
say
we
have
actually
compiled
a
UB
from
Cydia
vup
I.
B
Feel
free
to
review
my
they
hack
into
your
budget
leisure.
That's
figure
out!
If
I've
got
it
right:
okay,
okay,.
B
Yeah
we
were
over
time
now.
I
think
you
glad
to
drop
off
Ralph.
Did
we
cover
everything
you
wanted
to
about
unsafe
stuff?
This
recently
spent
time
on.
E
B
E
B
So
I
think
Nico
was
actually
present,
then
for
revenue
you
wanted
to
talk
about
and
it
got
across
to
them.
Okay,
good,
good,
alright,
I
think,
don't
think
I
know
it's
over
the
hour.
Is
there
anything
when
you
decide
besides
I?
Think
we've
also
like
Serb
cyclically,
said
we'd
like
to
see
more
of
the
skill
tree
like
sort
of
cleaned
up
and
maybe
you're
in
a
lot
of
blog
post,
and
then
we
can
have
a
final
sign-off
of
the
big
picture.
Is
that
sound
right
in
terms
of
what
the.
B
B
E
E
A
That
was
a
great
here's
sort
of
some
bounds
on
either
side
of
this
base.
It
felt
like
you're
getting
towards
a
you
think
that
this
sort
of
particular
point
in
here
is
probably
the
restrictions
that
we
want
to
give
that
seemed
plausible.
To
me
at
least
I,
don't
know
if
that
should
become
like
right
up
to
get
signed
off
as
yes,
these
are
going
to
be
the
unsafe
guarantees
or
I'm.
C
A
So
actually
one
thing
we
talked
about
like
unconstant,
unsafe
all
that
sort
of
thing.
How
much
of
that
so
I
guess
we
didn't
make
a
decision
on.
Do
we
want
to
say
that
unconscious
actually
unsafe
or
if
it
just
died?
Is
it
evaluation
time
so
I,
don't
know
that
I
have
a
strong
reason
to
say:
oh,
we
should
definitely
do
the
it
needs
to
like
comparisons
need
to
be
in
an
unsafe
block
versus
have
an
unconscious
forces.
Just
say
that
it'll
be
a
evaluation
time.
Error
versus
I,
don't
know.
C
A
E
E
C
E
E
A
C
A
E
Sounds
like
we
have
another
RFC,
which
is
what
is
the
behavior
of
you
be
doing
constable
and
it
might
actually
be
worth
having
that
first
I
think
you
have
I
think
there.
We
have
a
more
agreement
on
what
the
what
the
solution
is,
and
it's
and
and
there's
kind
of
a
dependency
of
the
the
unconstant
could
just
say
it's
UB,
and
then
we
have
to
have
that
other
decision
later.
Even
for
what
that
means,
but.
B
It's
right
with
you,
don't
you
say
it
saying
what
you
be
during
constable
means.
You
mean
like
putting
bounds
on
how
bad
it
can
be
like,
for
example,
saying
it
can't
be.
It
can't
cause
I'm
you
be
within
the
compiler
itself.
That's
what
you
mean
by
that
right.
Just
it's
not
like
I,
actually
find
down
concrete
semantics.