Since their conception in 1951, compilers have gone through three major evolutionary steps.

First, compilers were conceived as mere translators. 

Their job was to translate code written in a programming language to a semantically equivalent binary code.

Then, compilers earned the ability to optimize code while translating it; they became optimizing compilers.

Since then, most of the innovations in compilers have been targeting their ability to optimize code, so it is no surprise that abstractions included within compilers have been code-centric; code is the first-class citizen while other aspects of computation are (at most)  afterthoughts.

The last phase of compilers started when they adopted a series of dependence abstractions that identified whether or not a code transformation preserved the original semantics.

This adoption enabled compilers to expand their optimization capability to code that uses memory pointers.

In this talk, I will argue for the need to start a new phase for compilers where two dimensions of computation become first-class citizens.

First, the memory used by a program (and its hierarchical organization in collections and objects) becomes a first-class citizen, easily analyzable, and optimizable.

Then, dependences between instructions and code regions, their hierarchical organization, and their heterogenous semantics need to become first-class citizens to the point where compilers can manipulate them directly, while the underlying code gets modified as a side-effect.

Complementing current code-centric compilers with dependence-centric and memory-centric abstractions/representations both opens a new family of optimizations that compilers can now do and massively reduces the complexity of state-of-the-art aggressive optimizations.

Together with my collaborators and students, we have both designed several optimizations of this new kind (optimizations that no code-centric compilers can do) and we have re-implemented state-of-the-art aggressive optimizations in a few hundred lines of code (rather than several tens of thousands needed by their code-centric implementation).