Comparisons

That these are properties of a language rather than of an implementation, which produces sentences like "Python is interpreted". Every mainstream Python implementation compiles source to bytecode before executing any of it, and there are ahead-of-time compilers for languages usually described as interpreted.

That they are the same tree drawn at different levels of detail. They are not: the parse tree contains a node for every grammar rule applied and every token consumed, including parentheses and semicolons, and the AST deliberately deletes exactly those.

That LR is "more powerful" in a way that makes LL obsolete. The power difference is real — every LL(k) grammar is LR(k) and not conversely — but most production compilers with hand-written frontends use recursive descent anyway, because error recovery and diagnostics are far easier when the code follows the grammar.

That static typing prevents runtime errors. A static type system proves the properties it models and says nothing about the rest: null dereferences, index-out-of-range, division by zero, protocol violations and wrong answers all survive a clean type check unless the type system was designed to model them.

That generics mean the same thing everywhere. Erasure keeps one body and forgets the type argument; monomorphization emits one body per type argument; reification keeps the type argument available at run time. They produce different performance, different binary sizes and different reflection capabilities from the same-looking source.

That a JIT is a slower fallback for languages that could not be compiled properly. A JIT has information no static compiler can have, and routinely produces faster code for dynamically typed programs than any ahead-of-time compiler could; what it cannot do is produce it instantly, or for free.

That "register-based" means the VM uses hardware registers. It does not — the registers are slots in a frame, indexed by the instruction. The difference is in the operand encoding, not in where the values live.

That linear scan is simply the worse algorithm. It produces more spills on high-pressure code, but it runs in roughly linear time, and in a JIT the time spent allocating is time the program is not running — so the faster algorithm can win on end-to-end performance.

That the choice is only about file size. It is mainly about when symbol resolution happens and who owns the upgrade: a statically linked program keeps whatever version it was built against forever, including the security bugs; a dynamically linked one gets whichever version the loader finds, including an incompatible one.

That they are two names for "the aggressive build". They answer different questions: LTO gives the optimizer more code to look at, PGO gives it evidence about what that code does. They compose, and neither substitutes for the other — LTO without a profile still guesses which calls are hot.