In November 2021, the Association for Computing Machinery announced the recipient of its most prestigious honor, the A.M. Turing Award, for the year. The laureate was not a creator of a famous programming language, not the inventor of a revolutionary hardware architecture, and not the founder of a technology company worth billions. The award went to Jack Dongarra, a man whose name most programmers have never heard — yet whose software runs beneath virtually every scientific computation, every machine learning model, every weather forecast, every physics simulation, and every supercomputer benchmark on the planet. The award citation read: for pioneering contributions to numerical algorithms and libraries that enabled high-performance computational science and engineering. It was, in a sense, the most overdue recognition in the history of computing. For more than four decades, Dongarra had been building the invisible mathematical infrastructure on which modern scientific computing stands.
Early Life and Path to Technology
Jack Joseph Dongarra was born on July 18, 1950, in Chicago, Illinois. Growing up in a working-class neighborhood on the South Side, Dongarra showed an early aptitude for mathematics — a subject that came to him naturally in a way that other school subjects did not. Chicago in the 1950s and 1960s was not an obvious incubator for future computer scientists. The city was defined by its steel mills, stockyards, and political machine, not by its technology sector. But Dongarra found his way to mathematics through curiosity and determination rather than privilege or circumstance.
After completing high school, Dongarra enrolled at Chicago State University, where he earned his bachelor’s degree in mathematics in 1972. He went on to the Illinois Institute of Technology for a master’s degree, and then to the University of New Mexico, where he completed his PhD in applied mathematics in 1980. His doctoral work focused on numerical linear algebra — the branch of mathematics concerned with solving systems of linear equations, eigenvalue problems, and matrix decompositions using computer algorithms. This field may sound abstract, but it is the mathematical engine behind nearly everything a modern computer does when it processes scientific data, trains a neural network, or simulates a physical system.
What set Dongarra apart from the beginning was not just his mathematical ability but his deeply practical orientation. He was not interested in proving theorems for their own sake. He wanted to build software — reliable, efficient, portable software that scientists and engineers could actually use. This practical bent led him to Argonne National Laboratory, where he began working in the late 1970s, and eventually to the University of Tennessee and Oak Ridge National Laboratory (ORNL), which would become his intellectual home for the next four decades.
The LINPACK Revolution
The Problem of Portable Numerical Software
To understand what Dongarra accomplished, one must first understand the state of scientific computing in the 1970s. Scientists and engineers needed to solve linear algebra problems constantly — systems of equations that arose in structural analysis, fluid dynamics, quantum mechanics, signal processing, and dozens of other fields. Every research group wrote its own code to solve these problems, typically in Fortran, the dominant language for scientific computing. The result was chaos: thousands of slightly different implementations of the same algorithms, each containing its own bugs, its own performance limitations, and its own incompatibilities with different hardware platforms.
The idea behind LINPACK was simple but radical: create a single, definitive collection of Fortran subroutines for solving linear equations and related problems, written by experts, thoroughly tested, and designed to be portable across different computer architectures. Dongarra, working with Jim Bunch, Cleve Moler, and Pete Stewart, published LINPACK in 1979. The library provided routines for solving dense and banded linear systems using LU, Cholesky, and QR factorizations — the fundamental building blocks of numerical computation.
C LINPACK-STYLE LU FACTORIZATION DEMONSTRATION
C Shows the core pattern behind DGETRF — the workhorse
C routine that factors a matrix A = P * L * U
C
SUBROUTINE MYLU(A, LDA, N, IPIV, INFO)
INTEGER LDA, N, INFO
INTEGER IPIV(N)
DOUBLE PRECISION A(LDA, N)
C
C Local variables
INTEGER I, J, K, IDAMAX
DOUBLE PRECISION TEMP
EXTERNAL IDAMAX
C
INFO = 0
DO 30 K = 1, N
C
C Find pivot — the largest element in column K
IPIV(K) = K - 1 + IDAMAX(N-K+1, A(K,K), 1)
C
C Swap rows if needed
IF (IPIV(K) .NE. K) THEN
DO 10 J = 1, N
TEMP = A(K, J)
A(K, J) = A(IPIV(K), J)
A(IPIV(K), J) = TEMP
10 CONTINUE
END IF
C
C Check for singularity
IF (A(K,K) .EQ. 0.0D0) THEN
INFO = K
RETURN
END IF
C
C Compute multipliers and update submatrix
DO 20 I = K+1, N
A(I,K) = A(I,K) / A(K,K)
DO 20 J = K+1, N
A(I,J) = A(I,J) - A(I,K) * A(K,J)
20 CONTINUE
30 CONTINUE
C
RETURN
ENDLINPACK was not just a collection of algorithms. It was a philosophy made concrete. Dongarra and his collaborators demonstrated that numerical software could be written once, written well, and shared across the entire scientific community. Before LINPACK, every scientist was a reluctant numerical programmer, reinventing the wheel with varying degrees of competence. After LINPACK, scientists could call a tested, optimized subroutine and trust the result. This separation of concerns — let mathematicians handle the math, let domain scientists handle their domains — was a conceptual breakthrough that transformed scientific productivity.
From LINPACK to the LINPACK Benchmark
One of Dongarra’s most far-reaching decisions was to create a benchmark based on LINPACK. The LINPACK benchmark measures how fast a computer can solve a dense system of linear equations — a task that stresses floating-point arithmetic, memory bandwidth, and communication between processors. Dongarra compiled the results into what became the TOP500 list, a semiannual ranking of the world’s 500 most powerful supercomputers, first published in 1993 and still published today. The TOP500 has become the definitive measure of supercomputing performance worldwide. Governments, research institutions, and corporations plan their supercomputing strategies around their TOP500 rankings. When China’s Tianhe-2 or America’s Frontier claims the top spot, they are measured by the benchmark Dongarra created. No single person has done more to define how the world measures computational power.
BLAS, LAPACK, and ScaLAPACK: Building the Mathematical Stack
The Basic Linear Algebra Subprograms (BLAS)
While LINPACK provided high-level routines for solving complete problems, Dongarra recognized that a deeper layer of infrastructure was needed. In the late 1970s and throughout the 1980s, he played a central role in developing the Basic Linear Algebra Subprograms, or BLAS — a standardized set of low-level routines for performing common linear algebra operations: vector addition, scalar multiplication, dot products (Level 1 BLAS), matrix-vector operations (Level 2 BLAS), and matrix-matrix operations (Level 3 BLAS).
The genius of the BLAS was the separation between interface and implementation. The BLAS defined what operations should be performed (multiply these two matrices, compute this dot product), but left how they were performed to hardware vendors. Intel, AMD, IBM, ARM, and every other processor manufacturer could provide their own optimized BLAS implementations — tuned to their specific cache hierarchies, vector units, and memory architectures — while maintaining exact compatibility with the standard interface. This meant that higher-level software (including LINPACK and its successor LAPACK) could achieve near-optimal performance on any hardware simply by linking against the vendor’s BLAS library.
This architectural decision — define the interface, let vendors optimize the implementation — has become one of the most important design patterns in high-performance computing. It is the reason that a NumPy array operation in Python can run at near-hardware speed: NumPy calls BLAS, and BLAS calls hand-optimized machine code written by Intel (MKL), AMD (AOCL), or the open-source community (OpenBLAS). Every time a data scientist trains a machine learning model in TensorFlow, PyTorch, or scikit-learn, BLAS routines are executing underneath. Donald Knuth famously warned against premature optimization, but Dongarra’s approach made optimization invisible — the right optimizations happened automatically, beneath the API surface, without the application programmer needing to know or care.
LAPACK: The Next Generation
By the late 1980s, computer architectures had evolved significantly. Processors now had deep memory hierarchies — registers, L1 cache, L2 cache, main memory — and algorithms that did not respect these hierarchies suffered catastrophic performance penalties. LINPACK’s algorithms, designed in the 1970s for machines with flat memory models, were no longer optimal. Dongarra led the development of LAPACK (Linear Algebra PACKage), released in 1992, which restructured the algorithms to use block operations — processing data in chunks that fit within the processor’s cache. LAPACK was built on top of the Level 3 BLAS, which performed matrix-matrix operations that naturally exhibited the kind of data reuse that cache hierarchies rewarded.
LAPACK superseded LINPACK for most purposes and became the definitive standard library for dense linear algebra. It provided routines for solving linear systems, least-squares problems, eigenvalue problems, and singular value decompositions — the full toolkit required for scientific computing. LAPACK was written in Fortran and designed to be called from both Fortran and C programs, reflecting the practical reality that scientific software was increasingly written in both languages. The library has been ported to virtually every computing platform in existence, from laptops to the world’s largest supercomputers.
ScaLAPACK: Scaling to Supercomputers
As parallel computing became dominant in the 1990s, Dongarra extended the LAPACK model to distributed-memory systems with ScaLAPACK (Scalable LAPACK). ScaLAPACK used the same algorithmic principles as LAPACK but distributed computations across multiple processors connected by a network, using the MPI (Message Passing Interface) standard for communication. This allowed the same linear algebra operations to scale from a single workstation to a supercomputer with thousands of processors.
The hierarchy Dongarra built — BLAS at the bottom, LAPACK in the middle, ScaLAPACK at the top — created a complete mathematical software stack that could run efficiently on any computing platform, from embedded systems to the largest machines on Earth. This stack remains, more than three decades later, the foundation of virtually all scientific computing. Modern computational tools that scientists and engineers rely on daily — from MATLAB to R to Python’s scientific ecosystem — are all built on top of Dongarra’s libraries.
Parallel Computing: PVM and MPI
Dongarra’s contributions extend well beyond linear algebra libraries. In the late 1980s, he and his colleagues at Oak Ridge developed PVM (Parallel Virtual Machine), a software system that allowed a heterogeneous collection of networked computers to be used as a single parallel computing resource. PVM was groundbreaking: it demonstrated that you did not need a purpose-built supercomputer to do parallel computing. A collection of ordinary workstations, connected by a network, could cooperate on a single computational problem.
PVM influenced the development of MPI (Message Passing Interface), which became the dominant standard for parallel programming and remains so today. Dongarra was a key contributor to the MPI standardization effort. MPI provides a standardized, portable interface for sending messages between processes running on different processors — the fundamental operation required for distributed parallel computing. Every modern supercomputer application, from climate modeling to genomics to computational fluid dynamics, uses MPI. The connection between Dongarra’s work and the broader history of operating systems and distributed computing is direct — just as Fernando Corbato pioneered time-sharing to let multiple users share a single machine, Dongarra pioneered the software infrastructure that lets multiple machines share a single computation.
Philosophy and Engineering Approach
Core Principles
Dongarra’s career is defined by a set of engineering principles that distinguish him from both pure mathematicians and pure software engineers. The most fundamental is portability: the conviction that scientific software must work correctly and efficiently on every platform, not just the one it was developed on. This principle drove every major design decision in BLAS, LINPACK, LAPACK, and ScaLAPACK. When Dongarra designed a library interface, he was thinking not about one machine but about every machine — present and future.
His second principle was layered abstraction. The BLAS/LAPACK/ScaLAPACK stack is a masterclass in software architecture: each layer provides a clean interface to the layer above and delegates performance-critical details to the layer below. Application programmers call LAPACK, LAPACK calls BLAS, BLAS calls vendor-optimized machine code. This separation of concerns means that when a new processor architecture appears, only the BLAS layer needs to be reoptimized — everything above it continues to work unchanged. Edsger Dijkstra championed the idea of hierarchical system design, and Dongarra implemented it in one of the most successful software stacks ever created.
Third, Dongarra believed in open, community-driven standards. BLAS, LAPACK, MPI — all are open specifications that anyone can implement. This openness created a competitive ecosystem in which hardware vendors competed to provide the fastest BLAS implementation, driving performance improvements that benefited the entire scientific community. It is a model that modern open-source projects still follow, and it reflects the same collaborative philosophy that drives tools like Taskee in coordinating complex technical work across distributed teams.
Fourth, and perhaps most distinctively, Dongarra believed in benchmarking as a discipline. The LINPACK benchmark and the TOP500 list are not just rankings — they are instruments for understanding how computing performance evolves over time. Dongarra has maintained meticulous records of computational performance spanning decades, creating a dataset that allows researchers to track exponential growth in computing power, identify architectural trends, and forecast future capabilities. His benchmarking work has made supercomputing measurable and accountable in a way it never was before.
The Invisible Infrastructure
One of the most remarkable aspects of Dongarra’s career is the invisibility of his work. Most programmers have never heard of BLAS or LAPACK, yet they use these libraries every day — indirectly, through the tools built on top of them. When a data scientist writes numpy.linalg.solve(A, b) in Python, they are calling LAPACK’s DGESV routine, which calls BLAS’s DGEMM routine, which calls vendor-optimized machine code that executes matrix operations at near-theoretical peak performance. When a researcher trains a deep neural network, the matrix multiplications that dominate the computation are performed by BLAS. When an engineer runs a finite element simulation, LAPACK computes the eigenvalues. The entire modern stack of scientific computing — from machine learning frameworks to engineering simulation tools — rests on the libraries Dongarra built.
This invisibility is, paradoxically, a measure of success. The best infrastructure is the kind you never think about. The C programming language is invisible in a similar way — it underlies operating systems, databases, and compilers without most users knowing it. Dongarra’s numerical libraries occupy an analogous position in the world of scientific computing. They are the bedrock on which everything else is built, and they work so reliably that no one needs to think about them. Organizations developing sophisticated digital products, whether through specialized agencies or internal teams, benefit daily from this mathematical infrastructure without ever realizing it.
/*
* Calling LAPACK from C — solving a linear system Ax = b
* This is the pattern used by NumPy, SciPy, MATLAB, R,
* and virtually every scientific computing tool.
*
* DGESV: Double-precision GEneral SolVer using LU factorization
*/
#include <stdio.h>
#include <stdlib.h>
/* LAPACK routine declaration */
extern void dgesv_(int *n, int *nrhs, double *A, int *lda,
int *ipiv, double *b, int *ldb, int *info);
int main(void)
{
/* System size: 3 equations, 3 unknowns */
int n = 3, nrhs = 1, lda = 3, ldb = 3, info;
int ipiv[3];
/* Matrix A (column-major, Fortran convention) */
double A[] = {
6.0, 1.0, 1.0, /* column 0 */
1.0, 7.0, 2.0, /* column 1 */
1.0, 2.0, 10.0 /* column 2 */
};
/* Right-hand side b */
double b[] = { 8.0, 10.0, 13.0 };
/* Call LAPACK — one line replaces hundreds of hand-written code */
dgesv_(&n, &nrhs, A, &lda, ipiv, b, &ldb, &info);
if (info == 0) {
printf("Solution: x = [%.4f, %.4f, %.4f]
",
b[0], b[1], b[2]);
} else {
fprintf(stderr, "DGESV failed with info = %d
", info);
return 1;
}
return 0;
}
/* Output: Solution: x = [1.0000, 1.0000, 1.0000] */The Turing Award and Recognition
In 2021, the Association for Computing Machinery awarded Jack Dongarra the A.M. Turing Award — often called the Nobel Prize of computing, named after Alan Turing himself. The award recognized his “pioneering contributions to numerical algorithms and libraries that enabled high-performance computational science and engineering.” It was the first time the Turing Award was given primarily for work in numerical software and high-performance computing, and it acknowledged a truth that the computing community had long known but rarely articulated: the mathematical libraries underlying scientific computing are as important to the modern world as the programming languages, operating systems, and networks that get most of the attention.
The Turing Award was the culmination of a career filled with recognition. Dongarra has received the IEEE Computer Society Sidney Fernbach Award (2003), the SIAM/ACM Prize in Computational Science and Engineering (2010), and election to the National Academy of Engineering, the American Academy of Arts and Sciences, and numerous other honors. He holds honorary doctorates from universities around the world. But these honors, impressive as they are, are secondary to the impact of the software itself — software that runs on virtually every supercomputer ever built and underpins virtually every computational science result published in the last four decades.
Legacy and Modern Relevance
Jack Dongarra’s legacy is measured not in products sold or companies founded but in computations performed. Every time a weather forecast is generated, LAPACK routines solve the linear systems embedded in atmospheric models. Every time a pharmaceutical company uses molecular dynamics to screen drug candidates, BLAS routines compute the interatomic forces. Every time an autonomous vehicle’s perception system processes sensor data, matrix operations optimized by Dongarra’s software transform raw measurements into actionable information. Every time a large language model generates text, the matrix multiplications at the heart of the transformer architecture execute through BLAS-descended routines.
The machine learning revolution of the 2010s and 2020s would not have been possible without the numerical infrastructure Dongarra built. Neural networks are, at their mathematical core, sequences of matrix multiplications and nonlinear transformations. The frameworks that train these networks — TensorFlow, PyTorch, JAX — all depend on optimized linear algebra libraries that trace their lineage directly to BLAS and LAPACK. When NVIDIA developed cuBLAS for GPU computing, they were implementing the same BLAS interface that Dongarra standardized in the 1980s, adapted for a new hardware architecture. The abstraction held: the interface stayed the same, the implementation was optimized for new hardware, and the entire software ecosystem benefited without modification. This is the power of good software architecture, and Dongarra understood it before almost anyone else.
The TOP500 list, now in its fourth decade, continues to shape supercomputing strategy worldwide. It has documented the rise of cluster computing in the 2000s, the GPU revolution in the 2010s, and the emergence of heterogeneous architectures in the 2020s. Dongarra has also led the development of newer benchmarks — including the HPCG (High Performance Conjugate Gradients) benchmark, which measures performance on sparse linear algebra operations that are more representative of real scientific workloads than the dense matrix operations of the original LINPACK benchmark. His benchmarking work provides the empirical foundation for understanding how computing performance evolves.
At the University of Tennessee and Oak Ridge National Laboratory, Dongarra continues to lead research on next-generation numerical algorithms for exascale computing — machines capable of performing a quintillion (10^18) floating-point operations per second. The Frontier supercomputer at ORNL, which became the world’s first exascale machine in 2022, runs software descended from the libraries Dongarra has spent his career developing. The problems have grown — from kiloflops in the 1970s to exaflops today — but the fundamental approach remains the same: portable, layered, open, and rigorously benchmarked.
Dongarra’s influence extends into education as well. He has mentored generations of graduate students and postdoctoral researchers who have gone on to lead their own research groups in numerical computing, high-performance computing, and data science. The Innovative Computing Laboratory at the University of Tennessee, which he directs, has been a training ground for many of the field’s leading researchers. His emphasis on open-source software, reproducible results, and community standards has shaped the culture of computational science as much as his technical contributions have shaped its tools.
In the broader context of computing history, Dongarra occupies a unique position. While John Backus gave scientists Fortran to express their computations, Dongarra gave them the optimized mathematical building blocks that made those computations fast, correct, and portable. While Bjarne Stroustrup and others advanced programming languages to handle increasing software complexity, Dongarra advanced the numerical libraries that those languages called upon to do actual scientific work. While Niklaus Wirth championed simplicity and elegance in language design, Dongarra championed simplicity and elegance in numerical software interfaces — creating APIs so clean that they have survived unchanged for forty years across five generations of hardware architecture.
The measure of a software engineer is not always visibility. Some build products that millions of users interact with directly. Others build infrastructure that millions of products depend on invisibly. Jack Dongarra belongs to the second category. His libraries do not have user interfaces. They do not have logos or brand names. They are called by other software, deep inside computational stacks, far from human eyes. But they are everywhere — in every supercomputer, in every scientific computing cluster, in every machine learning framework, in every numerical simulation. They are the mathematical bedrock of the computational world, and they were built by a quiet, determined man from Chicago who spent his career getting the mathematics right.
Key Facts
- Born: July 18, 1950, Chicago, Illinois, United States
- Known for: LINPACK, LAPACK, ScaLAPACK, BLAS, LINPACK benchmark, TOP500 supercomputer list, PVM, contributions to MPI
- Education: BS Mathematics (Chicago State University, 1972), MS (Illinois Institute of Technology), PhD Applied Mathematics (University of New Mexico, 1980)
- Career: Argonne National Laboratory (1970s–1980s), University Distinguished Professor at the University of Tennessee, Distinguished Research Staff at Oak Ridge National Laboratory (ORNL), Director of the Innovative Computing Laboratory
- Turing Award: 2021 — “for pioneering contributions to numerical algorithms and libraries that enabled high-performance computational science and engineering”
- Other honors: IEEE Sidney Fernbach Award (2003), SIAM/ACM Prize in Computational Science and Engineering (2010), Member of the National Academy of Engineering, Fellow of the ACM, IEEE, SIAM, and AAAS
- Impact: His software libraries (BLAS, LINPACK, LAPACK, ScaLAPACK) underpin virtually all modern scientific computing, machine learning frameworks (NumPy, TensorFlow, PyTorch), and engineering simulation tools
Frequently Asked Questions
Who is Jack Dongarra?
Jack Joseph Dongarra (born July 18, 1950) is an American computer scientist and mathematician who is a University Distinguished Professor at the University of Tennessee and a Distinguished Research Staff member at Oak Ridge National Laboratory. He is the creator or co-creator of LINPACK, LAPACK, ScaLAPACK, and BLAS — the fundamental numerical linear algebra libraries that underpin virtually all scientific computing, machine learning, and engineering simulation software. He also created the LINPACK benchmark used to rank the TOP500 list of the world’s most powerful supercomputers. In 2021, he received the A.M. Turing Award for his pioneering contributions to numerical algorithms and high-performance computing.
What is LINPACK and why does it matter?
LINPACK is a collection of Fortran subroutines for solving systems of linear equations, published in 1979 by Jack Dongarra, Jim Bunch, Cleve Moler, and Pete Stewart. Before LINPACK, every scientist and engineer wrote their own linear algebra code, resulting in duplicated effort and inconsistent quality. LINPACK provided a single, expertly written, thoroughly tested library that the entire scientific community could share. Its successor LAPACK, also led by Dongarra, modernized the algorithms for machines with cache-based memory hierarchies and remains the standard library for dense linear algebra to this day.
What is the TOP500 list?
The TOP500 list is a semiannual ranking of the 500 most powerful supercomputers in the world, measured using the LINPACK benchmark created by Jack Dongarra. First published in 1993, the TOP500 has become the definitive measure of supercomputing performance. Governments, research institutions, and corporations worldwide use the TOP500 rankings to plan their high-performance computing strategies. The benchmark measures how quickly a system can solve a dense system of linear equations — a computation that stresses floating-point performance, memory bandwidth, and inter-processor communication.
How does Dongarra’s work relate to machine learning?
Machine learning, particularly deep learning, is fundamentally built on linear algebra operations — matrix multiplications, decompositions, and transformations. The frameworks used to train and run neural networks (TensorFlow, PyTorch, JAX, scikit-learn) all rely on BLAS and LAPACK routines that Dongarra created or co-created. When a data scientist calls NumPy or when a GPU performs matrix multiplication via cuBLAS, they are using interfaces and algorithms that trace directly to Dongarra’s work. His numerical libraries form the invisible mathematical layer between high-level AI frameworks and raw hardware performance.
What is BLAS and why is it important?
BLAS (Basic Linear Algebra Subprograms) is a standardized specification for low-level linear algebra operations: vector operations (Level 1), matrix-vector operations (Level 2), and matrix-matrix operations (Level 3). Dongarra played a central role in defining and promoting the BLAS standard. The key innovation of BLAS is the separation of interface from implementation: the standard defines what operations to perform, while hardware vendors (Intel, AMD, NVIDIA, ARM) provide optimized implementations tuned to their specific processors. This means that any software built on BLAS — including LAPACK, NumPy, MATLAB, R, and virtually every scientific computing tool — automatically benefits from hardware-specific optimizations without code changes.
