Challenge 3: Why Both Languages Use a Two-Stage Compile-Then-JIT Model — Possible Solution
====================================================================

// C# was created in 2000 specifically as Microsoft's own direct
// answer to Java, following a Sun Microsystems lawsuit over
// Microsoft's non-compliant J++ implementation. Rather than continue
// fighting over control of Java itself, Microsoft built an entirely
// separate language AND runtime -- the CLR -- from scratch. Because
// C# was designed as a genuine alternative occupying the exact same
// niche Java already held (a managed, portable, garbage-collected,
// VM-based language), it makes sense that C#'s designers adopted the
// same fundamental architecture Java had already proven out, rather
// than inventing a fundamentally different execution model just to
// be different.
//
// The two-stage model itself (source -> intermediate format -> JIT
// to native code at runtime, rather than source -> native code
// directly) buys both languages the same benefit Java pioneered:
// portability. IL (C#) and bytecode (Java) are both platform-neutral
// formats -- the SAME compiled output can run on any machine with a
// compatible runtime (a CLR or a JVM) installed, with the JIT
// compiler handling the platform-specific translation to real
// machine code at the point where the program actually runs, not at
// the point where it was originally compiled.
//
// Since C# existed specifically to compete directly with Java in the
// same market (managed, enterprise, cross-platform-capable
// applications), abandoning that exact portability model would have
// undermined the entire reason C# was built in the first place --
// so adopting the same two-stage approach was a natural, even
// necessary, design choice rather than a coincidence.

WHY THIS WORKS AS AN ANSWER
------------------------------
This ties the shared two-stage compilation model directly back to the
chapter's own stated history -- C# built specifically to compete with
Java in the same niche -- and correctly identifies portability as the
real benefit both languages get from choosing an intermediate format
over direct-to-native compilation.