day is anecdotal. In many disciplines,
reviewers and peer scientists expect papers to include sufficient information
so other groups are able to reproduce
the results being obtained, but papers
do not adequately capture compiler
experiments where numerous implementation details determine the final
outcome. With the help of open source
software, the Web can be used to publish the software and data used in the
evaluations being reported. Major
conferences and organizations (such
as ACM) must provide mechanisms
for publishing software, inputs, and
experimental data as metadata for the
publications that report these experiments. Such repositories are useful
for measuring progress and could also
serve as a resource to those interested
in the history of technology.
Develop curriculum recommendations on compiler technology. Compiler
technology is complicated, and advances in the discipline require bright
researchers and practitioners. Meanwhile, computer science has grown as
a discipline with numerous exciting areas of research and studies to pursue.
The compiler community must convey
the importance and intellectual beauty
of the discipline to each generation of
students. Compiler courses must clearly demonstrate to students the extraordinary importance, range of applicability, and internal elegance of what is
one of the most fundamental enabling
technologies of computer science.
Whereas compiler technology used
to be a core course in most undergraduate programs, many institutions
now offer their compiler course as an
optional upper-level course for computer science and computer engineering students and often include interesting projects that deliver a capstone
experience. A good upper-level compiler course combines data structures,
algorithms, and tools for students as
they build a large piece of software that
performs an interesting and practical
function. However, these courses are
considered difficult by both faculty and
students, and students often have other interesting choices. Thus, fewer students are exposed to the foundational
ideas in compilers or to compilers as a
potential area only for graduate study.
Compiler algorithms are of tremendous educational value for anyone in-
terested in compiler implementation
and machine design. Knowledge of
the power and limitations of compiler
algorithms is valuable to all users of
compilers, debuggers, and any tool
built using compiler algorithms that
encapsulate many, if not most, of the
important program-analysis and transformation strategies necessary for performance and correctness. Therefore,
learning about compiler algorithms
leads to learning about program optimization and typical programming
errors in a deep and rigorous manner.
For these reasons, programmers with a
solid background in compilers tend to
excel in their profession.
One approach to promoting knowledge of compiler algorithms involves
discussion of specific compiler algorithms throughout the computer science curriculum—in automata theory,
programming languages, computer
architecture, algorithms, parallel programming, and software engineering.
The main challenge is to define the key
compiler concepts that all computer science majors must know and to suggest
the content that should be included in
core computer science courses.
A second complementary approach
is to develop advanced courses focusing on compiler-based analyses for
software engineering, scientific computing, and security. They could assume the basic concepts taught in core
courses and move quickly into new material (such as virus detection based on
compiler technology). The challenge
is how to design courses that train
students in advanced compiler techniques and apply them to areas that are
interesting and relevant (such as software reliability and software engineering). They may not be called “compiler
courses” but labeled in ways that reflect
a particular application area (such as
computer security, verification tools,
program-understanding tools) or perhaps something more general like program analysis and manipulation.
Although the compiler field has transformed the landscape of computing, important compilation problems remain,
even as new challenges (such as multicore programming) have appeared. The
unsolved compiler challenges (such
as how to raise the abstraction level of
parallel programming, develop secure
and robust software, and verify the entire software stack) are of great practical
importance and rank among the most
intellectually challenging problems in
computer science today.
To address them, the compiler field
must develop the technologies that enable more of the progress the field has
experienced over the past 50 years. Computer science educators must attract
some of the brightest students to the
compiler field by showing them its deep
intellectual foundations, highlighting
the broad applicability of compiler technology to many areas of computer science. Some challenges facing the field
(such as the lack of flexible and powerful
compiler infrastructures) can be solved
only through communitywide effort.
Funding agencies and industry must be
made aware of the importance and complexity of the challenges and willing to
invest long-term financial and human
resources toward finding solutions.
1. kirkegaard, k.J., haghighat, M.r., narayanaswamy, r.,
shankar, b., faiman, n, and sehr, d.c. Methodology,
tools, and techniques to parallelize large-scale
applications: a case study. Intel Technology Journal
11, 4 (nov. 2007).
2. Mccarthy, J. a basis for a mathematical theory
of computation. in Computer Programming and
Formal Systems, P. braffort and d. hirschberg, eds.
north-holland Publishing company, amsterdam, the
netherlands, 1963, 33-70.
3. Merritt, r. computer r&d rocks on. EE Times
(nov. 21, 2005); www.eetimes.com/showarticle.
We thank vikram adve, calin cascaval, susan graham,
Jim larus, Wei li, greg Morrisett, and david sehr for
their many valuable and thoughtful suggestions. special
thanks to laurie hendren for organizing the discussion on
education and preparing the text of the recommendation
concerning curriculum recommendations on compiler
technology. We gratefully acknowledge the support of
the U.s. national science foundation under award no.
0605116. the opinions and recommendations are those
of the authors and do not necessarily reflect the views of
the national science foundation. We also acknowledge
all workshop participants whose insight and enthusiasm
made this article possible, v. adve, a. adl-tabatabatai, s.
amarasinghe, a. appel, d. callahan, c. cascaval, k. cooper,
a. chtchelkanova, f. darema, J. davidson, W. harrod,
J. hiller, l. hendren, d. kuck, M. lam, J. larus, W. li, k.
Mckinley, g. Morrisett, t. Pinkston, v. sarkar, d. sehr, k.
stoodley, d. tarditi, r. tatge, and k. yelick.
Mary Hall ( firstname.lastname@example.org) is an associate professor
in the school of computing at the University of Utah, salt
lake city, Ut.
David Padua ( email@example.com) is the donald biggar
Willett Professor of computer science at the University of
illinois at Urbana-champaign.
Keshav Pingali ( firstname.lastname@example.org) is the W.a.
“tex” Moncrief chair of grid and distributed computing
Professor in the department of computer sciences at
the University of texas, austin, and a professor in the
institute for computational engineering and sciences also
at the University of texas, austin.
© 2009 acM 0001-0782/09/0200 $5.00
feBRuaRY 2009 | vol. 52 | No. 2 | CommunICatIons of the aCm