The article focuses on how optimizing compilers track the effects of intermediate representation (IR) instructions. The effects can range from none to writing specific variables or altering overall state. Understanding these effects is essential for optimizing code, particularly when it comes to instruction re-ordering, dead code elimination, or other optimizations that depend on knowing whether two instructions can interfere with each other. The author emphasizes the importance of asking what effects an opcode has instead of simply identifying the opcode itself. Different compilers adopt various methods for representing these effects. The article highlights two primary approaches: bitsets and heap range lists. Cinder, a Python JIT compiler, uses a bitset representation defined by an alias class. Each bit in this representation corresponds to a distinct memory location, allowing the compiler to determine whether instructions can safely be reordered based on their memory effects. For example, if one instruction reads from a tuple and another writes to a list, their effects don’t overlap, allowing for re-ordering. In contrast, JavaScriptCore employs an “abstract heaps” model that feels more complex than the bitset approach. The author references Fil Pizlo’s work on representing nested heap effects using integer pairs. This method seems less intuitive but serves the same purpose of tracking dependencies between instructions. Both representations aid in optimizing compilers by enabling them to discern which instructions can be eliminated or rearranged without altering the program's behavior. The article serves as a catalog of these approaches, inviting further exploration and suggestions from readers.