►
From YouTube: OMR Architecture Meeting 20221103
Description
Agenda:
* Compiler API unit testing ideas [ @dsouzai ]
A
B
All
right
so
I
I
brought
this
issue
up
actually
an
open
day
night,
but
then
because
there
is
overlap
and
any
implementation
there
I
think
would
also
depend
on
at
Walmart.
These
they're
also
just
to
bring
it
up
here,
just
to
kind
of
in
that
it
might
be
more
General
before
I
get
into
it.
I
wanted
to
put
a
like
mild,
disclaimer,
slash
sort
of
Preamble
that
the
thing.
C
B
B
So
the
the
as
I
put
in
the
issue,
the
the
general
idea
sort
of
was
inspired
a
bit
by
like
languages
like
rust
and
go
where
they
in
the
language
itself.
You
can
have
a
test
I'm,
not
sure
about
gold,
but
I
didn't
roster
the
test
module
where
it's
essentially
like
your
main
program
is
linked
into
another
program.
B
E
D
B
B
B
Did
if
you
want
me
to
I,
can
open
the
code
and
we
can
look
at
it
a
bit
more,
but
the
actual
implementation,
I
think
is,
is
less
important
more.
So
what
I
wanted
to
discuss
was
like
the
fact
that
it's
not
actually
that
hard
to
do
unit
testing
and
it
is
possible,
but
this
is
just
a
prototype
to
sort
of
bring
up
discussion
for
things.
C
B
Hours
or
so
or
less
I'm
in
an
Optimizer
that
I
have
no
idea,
what's
going
on
like
if
you,
if
you
look
at
how
I
had
to
create
the
actual
unit
test
case,
there's
VP
constraints
that
make
no
sense,
but
I
just
needed
them
to
exist
so
that
I
could
test.
One
specific
thing
my
whole
claim
is
that
people
who
know
this
code
will
actually
do
it
better
and
write
unit
tests
that
are
actually
same
as
possible.
A
A
A
Like
Russellville,
so
the
challenge
that
I
thought
so
and
I
don't
know
how
rust
or
go
handled
this,
and
maybe
you
know,
maybe
so
a
lot
of
times
you
have
to
provide
a
lot
of
context
around
like
you
have
to
provide
an
environment
in
which
that
function
can
be
tested.
You
can't
just
pass
in
one
thing:
I.
E
B
C
D
D
A
B
B
Unit
test
is
to
slowly
start
breaking
it
up
into
smaller
methods
that
are
easier
and
over
time,
as
a
general,
you
know
like
cleanup
effort
that
you
do
slowly
when
you
get
into
a
particular
part
of
the
code.
You're
like
I
could
refactor
this
and
when
I
refer
to
this,
if
it's
not
too
complicated,
I
could
write
a
test
score
so
that
and.
D
C
B
Whole
one
place,
I
could
start
is:
do
you
want
to
have
all
of
the
jits
be
unit
testable
and
therefore
you
want
to
move
towards
that
by
factoring
refactoring
routines,
as
you
were
saying
earlier,
some
are
ready
for
unit
tests,
others
aren't
maybe
refactoring
would
get
that
part
of
the
code
ready.
Do
you
want
that
to
be
the
best
of
this
work
or
they
want
to
identify
certain
parts
of
it
that
can
be
more
readily
unit
tested
and
but
I'll
give
you
three
examples.
B
B
My
whole
thing
is
to
make
in
general
that
is
I'm,
not
saying
that
you
can
easily
that's
sort
of
the
whole
point.
I
mean
I.
Think
the
fact
that
evaluators
and
others
are
more
amenable
that
the
stuff
is
good.
There's
going
to
be
so
much
overlap
between
I
think
what
Ben
did
before,
where,
when
he
cleaned
up
the
power
evaluated,
he
had
written
a
whole
bunch
of
tests
in
Walmart
yeah,
and
some
of
that
there's.
B
Overlap
which
requires
this
mechanism
in
general,
Maybe
like
while
it's
closer
to
what
you
know,
go
and
rust,
do,
which
is
a
test,
module
and
I
think
this
is
not
a
module.
This
is
you're
running
the
whole
thing
again
and
again
it
may
not
be
the
right
way
to
go
about
it,
but
the
goals
for
me
anyways
is
to
have
it
so
that
eventually.
D
B
B
C
B
B
C
F
B
B
Right
now,
it's,
how
do
you
force
them
like
this
I
think
that
leads
two
big
obstacles
and
I
think
you
touched
on
one
of
them.
The
Code,
the
routines
themselves
are
not
granular
enough,
but
there
is
another
problem
if
I
was
getting
into
in
my
comments
and
the
issue,
but
also
the
view
is
the
data
structures
have
a
certain
nature
to
them
right
they
sort
of
expand
out.
If
you.
B
Was
that
right
that
you
created
a
note,
you
pass
it
in
okay,
that's
maybe
node
you
can't
go
to
Treetop,
but
actually
from
some
nodes.
You
can
go
to
straight
talk,
but
let's
say
you
pass
in
a
tree
top
and
then
you
said
free
top
get
blocked
no
block
around
here.
I
spent
all
this
time
creating
this
tree.
B
C
F
There's
another
comment
that
I
wanted
to
make
to
just
that
of
a
response
to
your,
like
the
pointing
out
that
there
is
a
test
compiler
and
the
table
Trails
up,
yeah,
sorry
that
we
have
that
in
Omar,
I
would
say
so.
I
hadn't
seen
a
pull
request
until
10
minutes
ago.
So
forgive
me
if
I've
drawn
in
any
correct
assumption
from
what
I
read
in
the
code.
But
it
does
look
to
me
like
what
you've
done
in
open
chain
line
is
essentially
what
the
test
compiler
is
supposed
to
be.
F
It's
infrastructure
to
be
able
to
load
a
compiler
without
necessarily
being
connected
to
all
of
the
other
stuff
and
having
to
go
through
all
of
the
other
startup
and
digitalization,
and
configuration
that's
associated
with
bringing
a
compiler
up
in
a
specific
runtime
right
like
you're
doing
it
in
the
context
of
java.
You
know
you've
created
the
raw
allocator,
like
you
kind
of
went
through
the
steps
that
we
do
when
we're
initializing
the
chip,
so
that
all
the
main
kind
of
pieces
are
available
to
it.
F
I
think
that's
completely
in
line
with
what
the
testified
you're
going
to
do.
It's
just
that
I
only
ever
used
it
to
build
IL
and
inject
it
directly
into
the
as
a
function
or
a
method
right,
but
there's
nothing
to
stop
you
from
starting
with
the
dust
compiler
and
aborting.
That
and
saying
all
right,
like
don't
generate
ILS,
start
running
a
test
that
just
pulled
directly
into
some
part
of
the
compiler
and
I.
Think
the
same
thing
could
be
done
with
open.
Like
you.
B
B
F
I
think
it
might
be
interesting
to
start
so
I,
like
your
idea
of
focusing
on
the
like
starting
looking
at
the
support.
Handler
is
the
value
of
propagation
handlers
and
the
handlers
and
the
and
the
code
jet
evaluators,
because
they're
they're
already
very
focused
on
looking
at
a
very
specific
pattern
of
IL,
which
might
make
it
easier
to
build
up
a
set
of
Builders
I'll
call
them
that
can
help
you
construct
little
bits
of
Il
outside
of
the
rest
of
the
context.
So
you
get
enough
context
here,
like
you.
F
F
A
B
B
B
Sometimes,
a
test
is
only
different
from
another
one,
with
a
minor
sort
of
Delta,
so
you
could
write
one
Trill
sequence,
let's
say,
and
it
gets
processed
and
some
data
structure
gets
created
or
the
three
tasks
everything
gets
created
properly.
And
then
you,
if
you
had
the
ability
to
say,
go
change
this
part
of
that
sequence
and
just
specify
the
Delta
right
like
instead
of
having
an
I
load
here,
see
you
just
put
in
an
L
load
here
kind.
D
D
D
Way,
okay,
but
I.
Think
from
from
my
point
of
view,
Mark's
point
about:
how
do
you
test
the
output
is
crucial,
I
think
I,
don't
know
there
are
some
of
these
more
testable
like
little
bits
of
things
like
you
know,
a
single
evaluator
or
simplifier
Handler
or
something
but
I
think
that
you
know
this.
This
idea
that
well
what
we
need
is
to
just
be
able
to
write
down
some
IL
and
say:
okay.
Well,
what
does
something
do
with
this
IL
and
I
I
I?
D
D
D
You
know
at
a
more
granular
level
like
say
you
know
your
example
of
the
the
simplifier
Handler
right,
but,
interestingly,
you
don't
need
to
be
able
to
test
at
a
more
granular
level
to
test
the
simplifier
Handler.
You
just
you
know,
write
some
IL.
That
just
has
you
know
just
that
note
in
it
basically
and
then
run
simplifier
on
it.
B
E
B
C
B
B
Actually
this
may
only
run
under
a
certain
circumstances
or
whatever
right
like
we
have
to
find
the
points
in
the
branching
in
the
tree,
where
you
can
hit
as
many
as
hit
as
many
leaves
as
you
can.
It's
the
only
concern
with
sort
of
an
obsessed
by
itself,
but
other
than
that
like
that
that
would
be
the
like
when
I
was
thinking
about
this
stuff.
C
D
But
I
think
a
large
part
of
the
reason
why
we're
not
there
with
with
openj9
yet
is
just
that
there's
a
bunch
of
stuff
that
we
do
in
j9
that
that
we
don't
know
how
to
generate
from
trill
or
we
don't
know
how
to
generate.
You
know
hook
up
Trill
to
to
specify
that
you
know
say
this
method
should
just
magically.
Have
this
IL
or
something
yeah.
A
After
the
initial
implementation
of
trill
I
know
that
Leo
was
working
on,
for
example,
how
do
you
reconstruct
a
node
with
node
Flags,
or
how
do
you
create
a
symbol
reference
for
the
purpose
of
creating
a
symbol
reference
table
and
it
I
think
it's
possible
to
do,
but
it
was
you
know
it
needed
a
lot
of
thinking
and
polish
to
get
everything
just
right,
but
even
if
you
were
to
do
something
like
that,
I
think
it
was
an
issue
that
you
would
raise
BJ
in
the
in.
In
the
comments
to
everything
about
something.
A
Like
you
know,
the
Civil
reference
or
symbol,
for
example,
needs
a
constant
pool
address
and
a
constant
pool
index,
but
we
don't
have
either
of
those
so
there's
paths
through
the
code
that
we're
trying
to
test
that
are
going
to
fail
because
you're
trying
you
need
to
create
some
kind
of
an
artificial
version
of
some
of
these
things.
That
would
naturally
be
there
in
the
wild,
but
we
just
don't
have
it
in
our
little
incubator.
So
we
need
to
almost
find
all
these
different,
artificial
things
that
we
need
to
create
for
all
these
different
structures.
D
Right
right
because
we
we
need
to
be
able
to
specify
things
like.
Oh
this
node
can't
overflow,
but
then
things
like
you
know:
oh
the
constant
pool
entry.
For
you
know
this
is
the
constant
pool
entry
for
this
field
or
whatever,
and
then
we
you
know,
we
would
have
to
make
sure
that
such
a
constant
pool
entry
exists
in
the
class
that
is
supposed
to
contain
it
and
then
go
looking
for
it
or
something.
B
B
B
F
I
I
don't
want
this
to
sound,
discouraging
because
I
really
do
want
to
encourage
this
kind
of
work
to
proceed.
One
of
the
one
of
the
biggest
challenges
that
I
see
with
it
is
the
longer
term
maintainability
of
the
infrastructure.
The
fact
that
when
you're
unit
testing
your
your
by
definition,
kind
of
testing,
very
low
level
details
and
as
7.0
there
there's
like
any
number
of
these
little
details
that
you
might
need
to
kind
of
serve
Us
in
the
test
and
those
all
become
aspects
of
fertileness
between
the
tests
that
you've
got
and
the
infrastructure.
F
The
code
like
people
are
continuing
to
work
on
the
code
and
changing
it,
which
means
the
set
of
details
that
you
might
depend
on
in
the
unit
tests
are
changing
over
time.
Any
significant
refactoring
of
code
can
also
come
with
a
bunch
of
tests
that
got
busted
because
you
no
longer
have
these.
You
know
I
refactored
this
code,
and
it
now
expects
this
symbol
reference
to
have
a
symbol
in
it,
whereas
it
didn't
before
and
now
all
the
tests
that
go
through.
F
That
path
now
need
to
also
have
a
symbol
in
place
right
and
if
the
mechanisms
that
we
use
to
write
unit
tests
expose
that
detail
in
the
test,
then
now
you've
got
millions
of
tests
potentially
where
you
have
to
go
and
add
the
simple
right.
So
I
think
this
is.
This
is
a
a
significant
problem
that
we
need
to
think
about
the
building
of
this
infrastructures.
How
do
we
do
this
in
a
way
that
we
don't
end
up
tying
ourselves
in
knots?
F
D
D
F
F
C
B
A
F
So
my
example
right,
like
there's,
there's
like
there's
certain
IL,
where
you'll
have
to
generate
the
flag
one
way,
because
that's
the
way
the
IL
looks,
other
tests
could
be
generating
the
IL
another
way
and
it
relies
on
the
value
being
something
else.
But
the
test
wasn't
written
to
take
that
into
account.
Okay,.
G
G
Thank
you,
hello.
Sorry
I
had
to
join
a
bit
late,
but
I.
Think
Mark's
point
is
it's
a
very
good
point
and
this
is
actually
a
problem
in
general
right
with
unit
testing
that
you,
you
have
to
make
sure
that,
when
you're
changing
something
that
you're
not
breaking
a
whole
bunch
of
tests
to
the
point
that
maintaining
the
tests
is
more
work
than
maintaining
the
actual
code
in
the
context
of
unit
testing,
specifically
the
way
one
tries
to
address
this
is
the
tests
have
to
be
specific?
G
So
if
you
change
one
thing
in
the
compiler
and
all
of
a
sudden,
you
have
a
hundred
tests.
Failing
the
first
question.
I
would
ask
myself
is:
are
those
100
tests
really
needed,
or
are
they
all
testing
the
same
thing?
If
anytime,
one
changes?
Something,
though,
if
any
time
one
of
those
tests
fails,
the
other
100,
the
other
99
are
likely
to
also
fail.
That
probably
means
that
the
tests
are
redundant.
F
So
if
that
assumes
that
the
things
you're
testing
are
small
functions,
that
don't
have
a
lot
of
complexity,
if
you
have
a
one
a
function,
that's
got
a
lot
of
complexity
in
it.
Then
aren't
you
necessarily
going
to
have
to
write
a
bunch
of
tests
that,
like
I,
have
to
get
to
this
code
tab
somehow
so
I
have
to
have
a
bunch
of
common
stuff
between
the
tests
that
will
get
to
that
code
path
and
then
there's
all
the
code
paths
Downstream
of
that
that
I
want
to
test
success.
Those
variations.
B
The
data
data
type
different
data
type
different
credits
may
take
operations
like
subs
and
ads
right.
Those
sorts
of
things
could
lead
to
multiple
tests,
while
still
fundamentally
being
driven
by
like
they
could
all
break.
At
the
same
time,
if
you
added
a
flag
that
applied
to
a
arithmetic,
hint
and
long.
B
S
styles
of
unit
testing,
one
is
the
one
that
I
was
sort
of
philosophically
inspired
by,
which
is
the
contract
of
an
API
and
then
there's
the
thing
that
debit
is
talking
about,
which
is
test.
Optimization
I,
love
the
code
and
make
sure
that
the
code
and
I
think
both
are
probably
useful,
because
the
contract
of
the
API
doesn't
mean
anything
if
the
code
you've
generated
by
scripture
right.
But.
B
Api
helps
you
in
terms
of
new
functionality
that
that
forgotten,
some
implicit
assumption
and
I.
Think
that's
where
my
thing
was
inspired
by
it,
but
by
no
means
does
it
have
to
be
limited
to
that
scope,
but,
like
you're
testing
that
you
can
go
through
all
the
thoughts
in
the
routine
without
trash
I'm
testing,
essentially
the
leaves
of
the
project.
It's
just
like
specific
methods
where
they're
small
enough-
and
you
can
say
I-
want
to
test
the
contract
of
mistake.
B
B
That
that
second
side
of
testing
is
where
these
redundancies
can
come
up
because,
like
you
said,
different
data
types
will
generate
different
code.
You
need
to
have.
They
have
different
semantics,
whereas
unit
testing
is
some
other
programs
and
other
products
will
not
have
this
problem
because
they're
not
also.
F
It's
also
I
mean
just
to
extend
what
you
said
too
right
I
mean
it's
they're.
All
different
forms
of
testing
are
going
to
be
valid
in
different
places.
Right
like
okay
in
the
optimizer,
which
is
basically
running
on
top
of
Il
and
making
IL
Transformations.
It's
understandable
that
at
one
level,
you
want
to
be
able
to
unit
test
what
it
does
to
input
IL
and
generates
output.
F
Il,
and
what's
the
code
can
do
if
you
look
at
some
of
the
runtimey
aspects
like
the
that
are
associated
with
aot
or
what
accessing
the
shared
class
cache.
There's
no
in
some
places,
there's
no
IL
at
all.
It's
just
kind
of
I've
got
these
code
pads
that
I
want
to
test
that
I
have
detected
all
of
the
scenarios
properly
and
did
the
right
thing
that
that
one's
actually
even
harder
to
figure
out
that
you
did
the
right
thing
like.
B
D
Basically,
in
inside
of
there
there's
going
to
be,
you
know,
there's
stuff,
that
we
do
right
and
if
you
test
that
stuff,
you
can
go
change
that
stuff
and
then
you
know
now,
maybe
you
know
now
you
have
to
rewrite
those
tests
or
or
whatnot
right,
but
if,
if
it
doesn't
affect
the
behavior
of
the
past,
then
you
know
changing.
Those
tests
is
not
necessarily
very
worthwhile,
depending
on
how
tricky
the
particular
stuff
is
that
you,
you
know,
maybe
maybe
it's
a
very
tricky
thing
and
it's
it's
this.
D
You
know
analysis
that
you
can
separate
out
and
la
la
there
will
be
cases
for
that,
but
I
think
that
the
opt
pass
granularity
again,
at
least
for
Optimizer.
Things
is
a
good
way
to
try
to
avoid
being
too
coupled
to
the
specific
implementation,
while
also
sort
of
being
a
good
granularity
to
try
to
express
where
we
want
to
like
sort
of
over
specify
in
the
test,
because
I
think
there
are
cases
where
you
know
functionally
functionally.
D
We
don't
want
to,
or
you
know
we
don't
have
a
requirement
that
you
know
in
a
certain
way
that
that
any
optifast
does
anything
right.
We
could
just
say:
well,
it
just
does
nothing,
and
you
know
the
code
works
when
it
comes
out,
so
that
you
know
that's
good,
but
with
respect
to
that
level
of
functional
requirement,
you
know
we
do
want
to
over
specify
what
it's
doing
so
things
like.
Oh
in
a
situation
like
this.
This
thing
here
shouldn't
prevent
this
transformation
from
happening.
We
should
transform
right.
E
D
G
C
G
C
G
You
can
do
to
avoid
that
really,
which
are
closely
related,
and
one
is
you
have
to
make
your
tests
more
specific,
the
other
one
is
you
have
to
make
your
code
more
testable,
which
I
know
is
a
challenge,
because
historically
the
Omar
compiler
has
not
been
architected
to
be
testable,
but
I
guess.
My
point
is
that
that
might
need
to
be
part
of
the
final
solution
is
not
just
thinking
about
how
we're
going
to
test
it,
but
also
how
we're
going
to
make
it
more
testable.
B
B
B
When
I
was
talking
about
it,
go
back
then
yeah,
but
when
I
was
talking
back,
then
we
hadn't
gotten
into
what
Devin
adminster.
So
my
mind
was
still
very
much
in
the
unit
test
of
the
smallest
method.
We
could
unit
test
with
the
least
amount
of
data
structures,
but
obviously
that's
not
a
good
way
of
being
able
to
where
my
mind
was
at
that
point
of
the
meeting.
D
D
G
Yeah
I
mean
for
sure
absolutely
you
don't
take
what
I
said
as
an
absolute
that
one
bug
must
only
trigger
one
test:
failure,
it's
more
of
an
issue
when
you
have
like
one
small
change,
triggering
a
hundred
or
more
test
failures.
That's
usually
a
sign
that
there's
a
broader
problem
with
the
test.
Suite
I
think
if
it
triggers
maybe
10
test
failures,
20
test
failures,
that's
more
reasonable,
yeah
slightly
differently,
either.
There's.
D
F
D
There
there
are
serious
disadvantages
to
doing
far
fewer
things
at
once
in
in
the
compiler
right.
So
you
know
we
we
want
to
have
like
if
you
had.
If,
if
our
simplifier
Transformations
were
each
separate
passes,
we
would
have
to
run
obscene
numbers
of
them
right,
yep,
it's
it's
very
important
that
it
does
a
lot
of
things
at
once.
D
You
know
version
or
now
as
well,
just
as
an
example,
it
does
some
number
of
versioning
Transformations
that
you
know
there's
an
analysis
to
determine
whether
it
can
do
them
because
they
can
depend
on
each
other.
So
you
could
have
a
situation
where
we
can't
do
transformation,
a
or
transformation
b
or
transformation,
C
or
transformation
D
on
their
own.
But
if
we
do
all
of
them,
it's
good.
C
D
What
what
I
would
just
add
before
the
the
comment
from
Mark
it
was
that
right,
if,
if
we
distinguish
why
the
change
is
causing
the
failures
so
when,
when
Leo
says
oh,
if,
if
the,
if
a
single
change
is
causing
100
test
failures,
that's
bad
or
you
know
what
whatever
you
can
come
up
with.
Whatever
number
you
like
a
thousand
just
to
make
it
really
obvious
that
it's
bad
I
think
it
depends
on
the
it
depends
on
the
nature
of
that
change.
D
B
Mean
there's
definitely
I
I
feel
merits
and
what
Devin
was
saying
that
if
you
can
test
it
on
optimization
level,
some
things
some
seem
more
practical,
doable
going
back
to
where
you
started
like
routine
at
a
time.
I
still
think
there's
value
for
that
in
certain
places,
as
we
discussed
earlier,
but
the
other
place
where
that
may
have
values.
Even
if
there
are
more
complex
routines,
you
pass
an
input
that
exercises
paths
in
there
and
emerges
out
of
the
other
end
without
crashing
yeah.
B
D
B
Not
be
something
that
you
want
to
do
in
every
single
case,
like
some
basic
stuff,
where
you're
just
changing
one
note
to
something
else
or
something
it
doesn't
mean
anything
big,
but
maybe
if
you're
I
don't
know
taking
a
loop
and
hoisting
something
else.
You
want
to
see
that
that
thing,
maybe
that's
just
simple
someone
optimize
them
like.
B
B
C
B
Looks
in
the
form
you
want
to
look
for
a
particular
IL.
You
don't
have
to
try
every
single
version
of
that
of
that
that
thing,
but
like
some,
this
is
going
to
be
some
more
universe,
but
then
in
general,
you're
right,
stop.
Making
an
optimize
itself
might
just
be
something
where
you
need
to
test
the
entire
path
and
evaluators.
C
B
C
E
C
B
I
want
to
run
you
now
right.
It's
it's
normal
contract
is
to
come
in
without
sort
of
the
same
paraphernalia
surrounding
it.
It's
like
I
will
take
in
a
node
and
yes,
I'll
need
to
access
the
code
gen
and
the
compilation
for
certain
things,
but
chances
are
I'm
not
going
to
have
to
access
the
previous
freedom.
B
Things
inside
there's
a
like
the
binary
encoding.
Maybe
I
think
that
maybe
this
is
where
Ben
was
doing
his
work
right,
that
he
was
testing
the
that
sounds
like
again,
like
it's
less
likely
to
be
dependent
on.
Why
do
you
need
to
look
at
another
instruction?
If
you
need
to
binary
code
this
one
right
there
going.
C
B
B
Of
having
a
back
towards
getting
somewhere,
do
we
want
to
the
first
step,
be
sort
of
identifying
components,
because
clearly,
it
seems
like
Optimizer
has
a
different
philosophy:
how
to
get
a
test.
Cogen
has
a
different
floor.
Even
if
they're,
like
evaluators
versus
binary
coaching
might
be
different,
feel
a
patient
is
different,
so
on
and
so
forth.
B
B
B
C
D
C
B
B
B
E
F
I,
don't
care.
Okay,
we
use
t-test
as
part
of
like
Google
test
is
part
of
the
Old
Market
testing
right
I've
been
able
to
get
some
jv2
as
well.
It's
actually
quite
simple
to
get
up
and
running
and
get
going
and
it
doesn't
place
any
restrictions
and
plus
this
is
only
a
test
framework.
So
as
long
as
it
can
run
on
the
platform
that
you
care
about
in
some
ways,
it
doesn't
have
to
be
part
of
the
pioneer,
so
it
doesn't
have
the
same
well,
I
mean
at
some
levels.
B
B
B
F
Would
I
would
say
I
mean
the
way
I
would
do
this,
which
maybe
not
everyone
will
agree
with,
but
I
I
would
say
your
your
early
days
here,
get
something
up
and
running
to
the
point
where
you
can
play
with
it
and
do
some
stuff
with
it
and
then
just
like
continue
to
look
back
on
what
you've
done
and
save
this.
The
right
thing
to
keep
going
to
the
next
stage
of
this
like
I've,
used
this
for
to
write
a
few
tests
here.
F
D
G
G
B
And
then
there
are
other
parts
of
legit
that
I
feel
could
be
unit
tested,
but
we
didn't
talk
about
here.
I
mean
we
have
to
conclude
here
probably
soon
anyway,
but
options
is
another
area
which
is
the
murky
area,
but
it
feels
like
one
that
could
be
unit
tested
certain
ways,
but
obviously
none
of
what
we
do
in
il
and
orgen
is
like
likely
to
apply
there.
So
maybe
it's
really
there's
multiple
problems
here,
and
we
should
also
start
talking
about
some
of
those
things
that.
C
F
C
B
B
That's
the
whole
reason
for
us
that
I
didn't
want
to
start
doing.
I
mean
I
would
just
say:
I
tried
this
out.
I
will.
But
the
reason
I
didn't
go
too
far
is
because
I
didn't
want
to
get
down
a
path
where
the
infrastructure
is
too
narrow
and
can't
be
broadened
anymore,
but
I
suppose
you're
saying
about
this
too
much
anyway.
So
you
might
as
well
start
that
faster.
C
F
Get
to
a
point
where
you
feel
too
damn
strong
to
continue,
then,
obviously
you
know
we
need
to
sit
back
and
think
a
little
bit
harder
about
it
and
say:
are
you
just
trying
to
do
you're
trying
to
broaden
it
beyond
what
the
really
the
the
the
value
of
using
that
testing
infrastructure
is
like?
Are
you
trying
to
do
too
much
with
it
or
or
is
there
a
way
that
we
could
broaden
it
so
that
it
could
Encompass
more
I,
think
I
think
we're
too
early
to
be
able
to
even
make
research.
B
A
A
C
C
A
B
A
B
B
I'm
about
to
look
into
is
the
test
compiler
what
it
does
and
also
pick
up,
but
I
guess
one
idea
would
be
just
design
it
such
a
way
that
it's
a
abstracted
away,
API
for
getting
the
IL,
how
you
how
you
implement
that
could
be
in
my
case,
right
now,
it'll
be
garbage,
but
then
later
on
it
could
be
Trails
or
whatever
yeah.
So
yeah.
B
D
C
C
B
E
B
D
C
D
Il
and
then
I,
don't
even
remember
how
how
targeted,
if
it's,
if
it's
like
they
run
one
pass
or
whatnot
the
the
ones
that
I've
seen
were
just
in
when
when
I
was
away
in
another
job
and
I
think
those
ones
were,
they
were
clang
ones.
So
the
input
wasn't
IL,
it
was.
It
was
C
plus
plus,
but
there
were
special
comments
in
there.
That
said,
you
know
oh
well.
We
should
be
able
to
find
this
sequence
of
instructions
in
the
output
and.
G
It
basically
works
the
way
Devon
described
as
you.
You
can
feed
it
input
and
I
believe
it
can
be
either
llvmir
or
source
code.
A
little
like
what
Trill
aspired
to
be
once
upon
a
time,
but
yeah
you
could
write.
You
can
write
in
comments
that
are
basically
just
asserts
to
make
sure
that
you,
whatever
the
output,
is
satisfy
certain
properties.
G
F
G
F
Right
because
I
mean,
as
usual,
we
focus
a
lot
on
the
I
guess
you
don't
tend
to
have
very
complicated
units
of
it.
Maybe
it's
not
as
big
an
issue
for
units,
but
obviously,
if
you're
running,
if
you
write
a
test
that
then
generates
code,
you
want
coverage
on
that
on
the
paths
in
that
generated
code
as
well.
So
it's
like
it's
not
as
simple
as
just
running
a
test.
You
have
to
run
a
test
that
makes
exercise.
B
B
F
F
The
complexity
there
then
boils
down
to
we'll
control.
It
is
controlling
the
conditions
on
the
input
like
conditions
that
are
in
the
input
code
that
are
also
in
the
output
code.
You
can
sort
of
Envision
it's
like
well.
I
just
have
to
provide
different
inputs
to
be
able
to
go
down.
Those
different
paths
and
I
can
in
principles,
get
100
code
coverage
on
all
of
the
code
paths,
because
I
know
what
the
input
conditions
are,
but
in
zip
code,
that's
not
the
case
because
we
inject
our
own
conditions
right.
F
B
B
F
D
B
D
G
D
I
think
that
that's
where
you're
going
to
run
into
easily
the
most
trouble
with
something
like
say,
g-test,
which
I
think
wants
to
take
over
Maine
and
or
you
know,
if
you
have
like
when
we
compile
a
method.
It's
going
to.
You
know
it's
not
just
the
compiler
that
wants
to
run
in
a
specific
environment.
It's
the
resulting
code
that
also
wants
to
run
in
a
specific
environment,
and
it's
a
different
one
right.
It
wants
to
run
on
a
Java
stack
as
part
of
a
Java
thread
with
all
kinds.
B
That's
why
like,
because
of
the
way
the
framework's
set
up
right
now,
the
JVS
is
sleeping
right.
You
could
have
Java
code,
that's
just
sort
of
sitting
there,
I
don't
know,
reading
a
system
properly
or
something
the
compiler
is
done.
Compiling
and
updating
system
Java
code
goes
and
calls
this
empty
method.
That's
actually
empty
and
white
codes,
but
we
said.
B
B
B
E
A
Work
up
until
nine
but
I
think
we're
yeah.
So,
however,
like
Mark
was
saying,
even
if
there
are,
there
may
be
ways
of
working
around
some
of
these
problems
right,
so
that
because
because
the
feature
that
it
was
Brad
that
wanted
to
get
these
features
that
are
detest
to
restrict,
which
kinds
of
tests
were
being
run
on
certain
architectures,
which
is
a
feature
available
in
the
latest
version,
I
mean
it
would
be
a
shame
not
to
have
that
90
of
the
platforms,
because
one
well
yeah
exactly
so.
B
A
C
G
Or
a
few
people
had
come
up
with
the
idea.
That's
not!
It
doesn't
sound
to
be
too
different
from
what
Irwin
was
talking
about
of
in
open
G9,
basically
adding
some
functionality
so
that
you
can
add,
say
an
annotation
to
a
method
that
makes
it
so
and
have
The
annotation.
Take
like
a
string
as
parameter
that
would
be
some
Trill
code
and
have
some
Machinery.
That
makes
it
so
that
when
you
have
that
annotation,
the
body
of
the
method
would
get
swapped
out
for
the
compiled
Trail
code.
G
D
B
A
B
One
quote-unquote
downside
of
that
like
in
the
contents
of
Walmart,
like
that's
very
Japanese
specific
they
would
you
have
to
be
something
similar
for
how
you
would
simply
and
a
lot
more
but
or
do
you
just
I
guess
depend
on
on
trail.
There
have
the
the
framework
take
in
the
thrill
code
in
a
different
way.
I.