Challenge 1: Why x86_64 Won't Work for ARM Native Code — Solution Walkthrough

Why x86_64 isn't appropriate here:

Per this chapter's own material, x86/x86_64 system images run fast
precisely because they're genuinely hardware-accelerated on a typical
development machine's own CPU, which is itself an x86/x86_64
processor. Native code compiled specifically for ARM is compiled to
ARM machine instructions, which an x86/x86_64 image cannot execute
natively — the instruction sets are fundamentally different.

Why speed doesn't make this a valid trade-off:

The choice here isn't "fast but slightly less accurate" versus "slow
but accurate" — it's "can actually run this specific code" versus
"cannot run it at all." An x86_64 image being faster doesn't matter if
it's structurally incapable of executing the ARM-compiled code in the
first place; speed is irrelevant if the code can't run on that
architecture to begin with.

The correct choice:

An ARM system image, accepting the slower, emulated execution as the
necessary cost of actually being able to run and test the ARM-specific
native code at all.

WHY THIS WORKS AS AN ANSWER
------------------------------
This exercise checks that the x86/ARM distinction from this chapter is
understood as a genuine compatibility requirement, not merely a
speed-vs-accuracy trade-off to weigh — some situations require the
ARM image specifically, with no faster alternative that still works.