On this page
Frances Allen didn't plan on a career in computer science. After earning her master's degree in mathematics from the University of Michigan in 1957, she took a job at IBM with a single goal: to clear the debts from her student loans so she could quickly return to teaching high school math.
Her first assignment at IBM was teaching Fortran, the early programming language created by John Backus to let scientists write mathematical formulas directly, to research scientists. Instead of leaving once her debts were paid, her position grew into a 45-year career that fundamentally shaped the foundations of software performance and modern computing.
Who was the first woman to win the Turing Award?
In 2006, Frances Allen became the first woman to receive the A.M. Turing Award. The Association for Computing Machinery (ACM) awarded this prize for her contributions to the theory and practice of optimising compiler techniques.
Before Allen's research, compilers were seen as simple, straightforward translators that turned human-readable code into raw machine instructions. Allen proved that a compiler could also act as an intelligent editor, analysing and reorganising the structure of code to make it run faster. Her techniques are still actively used in the software that builds today's apps, web browsers and complex operating systems.
What is compiler optimisation?
Compiler optimisation is the process of automatically rewriting code so it takes less time and memory for a machine to execute, without changing the final output. When you write a program, you write it in a way that makes sense to a human, which often includes calculations that are repeated unnecessarily.
In 1971, Allen and John Cocke published "A Catalog of Optimizing Transformations", a paper that gave compiler design a formal mathematical foundation, just as Donald Knuth laid down the formal analysis of algorithms. They detailed automated techniques such as common subexpression elimination, where the compiler spots a mathematical calculation that happens twice and simply reuses the first answer, saving precious processing cycles.
Another key technique they formalised was loop-invariant code motion. If a specific calculation inside a loop produces the exact same answer every time it runs, the compiler automatically moves it outside the loop so it only executes once.
Understanding how compilers parse and optimise code requires a solid grasp of data structures like graphs and trees. If you have gaps in your understanding of these critical topics, the Concept Library contains every concept in physics, chemistry, biology, mathematics and computing, each with its own lesson and its place in the map.
How did Frances Allen change computing?
Allen introduced the use of graph theory to map out precisely how a program flows from one instruction to the next. By treating a block of code as a control-flow graph, a compiler can automatically spot performance bottlenecks and discover opportunities to combine individual steps.
This mathematical and graphical approach paved the way for her later experimental work on the PTRAN (Parallel TRANslator) project. As computers began using multiple distinct processors simultaneously, Allen's team built systems that could automatically break a single large program into parallel streams of work, allowing for much faster execution.
Her career was full of significant milestones: she was named the first female IBM Fellow in 1989, and she later helped develop the software stack for the Blue Gene supercomputer that successfully mapped the human genome. Through it all, the teacher who initially started at IBM solely to pay off her student debt remained a lifelong, dedicated mentor to young women in technology.
A checklist for writing code today
Because modern compilers are so good at optimising, you no longer need to write cryptic code just to make your programs run fast. When writing your next program, follow these practical rules:
Focus on readability: Write clear code that another human can easily read, understand and maintain in the future.
Choose the right algorithm: A compiler cannot change a slow algorithm into a fast one; it can only speed up the individual steps. Focus your energy on the big picture.
Avoid manual micro-optimisations: Trust the compiler to handle tedious tasks like loop unrolling and constant folding. Trying to do this yourself often confuses the compiler and leads to slower execution.
Profile before you tweak: If your program is running slowly, always use a profiling tool to find the exact bottleneck before rewriting any logic.
