In the pantheon of early programming languages, useful content a few names — FORTRAN, COBOL, LISP, ALGOL — still echo through modern computer science curricula. Others, despite their profound influence on language design and compiler technology, have faded into obscurity. One such gem is MAD/I, a high‑level scientific programming language developed in the late 1960s at the University of Michigan. Designed to blend the algorithmic clarity of ALGOL, the data‑handling power of PL/I, and the pragmatic efficiency of its predecessor MAD (Michigan Algorithm Decoder), MAD/I was a bold experiment in making computers more accessible to scientists and engineers. This article provides a deep‑dive into MAD/I: its origins, features, syntax, sample programs, and the legacy it left behind.
A Tale of Two MADs: From MAD to MAD/I
To understand MAD/I, we must first look at MAD, the Michigan Algorithm Decoder. Created in 1959 by Bernard Galler, Bruce Arden, and Robert Graham, MAD was a compiled language for the IBM 704 and later the 709/7090 mainframes. Its syntax was heavily inspired by ALGOL 58, but it added practical extensions like easy I/O formatting, fast compilation (the “Mad” compiler prided itself on speed), and a debugger that was remarkably advanced for its time. MAD became the dominant language at the University of Michigan and was adopted at dozens of other institutions.
By the mid‑1960s, however, the computing landscape was shifting. PL/I had arrived with its ambitious “everything for everyone” philosophy, ALGOL 68 was gestating, and interactive time‑sharing systems demanded new language capabilities. The MAD team decided to design a successor, initially called “MAD/2” but quickly renamed MAD/I. The “I” originally stood for “Interactive”, but as the language grew beyond its original scope, it came to signify a generational leap — an entirely new dialect that incorporated modern ideas. Development began around 1967, with the first compiler implemented for the IBM System/360 Model 67 running the Michigan Terminal System (MTS), a pioneering time‑sharing operating system.
Design Philosophy: Scientific Computing without Fuss
MAD/I’s creators had a clear manifesto: give scientists and engineers a language that was both mathematically expressive and practical for writing large, maintainable programs. From ALGOL they took block structure, recursion, and a clean syntax. From PL/I they borrowed rich data types, string handling, and list processing. From the original MAD they inherited a lean compilation model, superb diagnostic messages, and a “no‑nonsense” attitude toward solving real problems.
The result was a language that felt modern decades ahead of its time. MAD/I supported dynamic storage allocation, first‑class strings, pointers, based variables, linked lists, and even a limited form of operator overloading. It allowed programmers to define their own data structures and control abstractions, making it one of the earliest extensible languages in the scientific domain.
Key Language Features
Block Structure and Scope. Like ALGOL 60, MAD/I allowed blocks delimited by BEGIN and END. Variables could be declared local to a block, and their scope followed static nesting rules. This promoted modularity and disciplined programming long before structured programming became mainstream.
Rich Type System. MAD/I provided the usual INTEGER, REAL, and BOOLEAN types, but also STRING, COMPLEX, POINTER, and LABEL. Arrays could be dynamically dimensioned, and their bounds were part of the type. The BASED storage class allowed a variable to have no inherent storage of its own but instead reside at an address specified by a pointer — an explicit and safe form of pointer dereferencing.
Strings and Pattern Matching. One standout feature was its string manipulation. Strings were variable‑length, first‑class objects that could be concatenated, substringed, and compared. MAD/I even included a pattern‑matching facility reminiscent of SNOBOL, learn this here now enabling the kind of text processing that later languages like Python would popularise.
List Processing. MAD/I treated lists as a built‑in abstract data type. A program could create a list simply by declaring a variable of type LIST, then build structures using ALLOCATE nodes with HEAD and TAIL components. This made it possible to write symbolic mathematics programs, artificial intelligence experiments, and simulation models without resorting to low‑level pointer juggling.
Recursion and Procedures. Recursive functions and procedures were fully supported, with parameters passed by value or by name. The “by name” mechanism, inherited from ALGOL, allowed a parameter to be an expression that was re‑evaluated each time it was referenced, giving effects similar to modern closures or lazy evaluation.
Extensibility. MAD/I allowed user‑defined operators and even overloading of existing ones. A programmer could, for instance, define a CROSS operator for vector cross product and use it with the same syntactic precedence as built‑in multiplication. Combined with the ability to define new data types, this feature made the language highly adaptable to domain‑specific notations.
I/O and Formatting. Drawing on MAD’s tradition, input and output in MAD/I were straightforward. The PUT DATA statement printed variable names along with their values — a simple debugging aid that anticipated modern debugger watches. Formatted output used familiar FORTRAN‑style edit descriptors, making it easy for engineers to produce neatly tabulated reports.
A Glimpse of MAD/I Code
To appreciate the language’s flavour, consider a few short examples.
Factorial with Recursion:
text
INTEGER PROCEDURE FACT(N); INTEGER N; IF N ≤ 0 THEN RETURN 1; RETURN N * FACT(N-1); END; PUT DATA(FACT(10)); ! prints "FACT(10) = 3628800"
String Manipulation:
text
STRING S, T; S = "Hello, "; T = "MAD/I!"; S = S || T; ! concatenation PUT DATA(S); ! prints "S = Hello, MAD/I!" IF S MATCHES ".*MAD.*" THEN PUT "matched";
Simple Linked List:
text
MODE NODE = STRUCT(REAL VALUE, POINTER(NODE) NEXT); POINTER(NODE) P, Q; ALLOCATE NODE SET P; P->VALUE = 3.14; ALLOCATE NODE SET Q; Q->VALUE = 2.718; P->NEXT = Q;
Notice the use of MODE to define a structure, the arrow operator for field access through a pointer, and the ALLOCATE … SET syntax that is both readable and safe. These constructs let scientists model complex data without wrestling with the machine’s memory layout.
MAD/I in Context: Competing with Giants
When MAD/I emerged around 1970, it faced formidable competition. FORTRAN IV and FORTRAN 66 were entrenched as the lingua franca of science. ALGOL 68, though immensely powerful, was struggling with implementation complexity and a notoriously difficult formal definition. PL/I was IBM’s corporate answer to multi‑paradigm programming, but its immense size and performance issues frustrated many. MAD/I carved out a niche by being smaller than PL/I, more expressive than FORTRAN, and more pragmatic than ALGOL 68.
The MAD/I compiler itself was a tour de force. Written in a mixture of MAD/I and assembly language, it achieved respectable compilation speed and generated efficient code. The team implemented a unique “in‑core” compiler design that kept the entire compilation unit in memory, reducing I/O overhead on time‑sharing systems. Diagnostic messages were intentionally verbose and written in plain English, often telling the programmer not just what was wrong, but why it was wrong and how to fix it — a philosophy that would only become standard decades later.
Why MAD/I Deserves to Be Remembered
Despite its virtues, MAD/I never achieved widespread adoption outside the University of Michigan and a few collaborating institutions. Several factors contributed: IBM’s heavy marketing of PL/I, the rise of C and UNIX in the 1970s, and the sheer inertia of FORTRAN in the scientific community. Development of the language essentially stopped after the mid‑1970s, though the MTS continued to host the compiler for many years.
Yet MAD/I’s influence quietly seeped into later languages. Its clean syntax and emphasis on readable diagnostic messages informed the design of educational languages such as Pascal. Its string pattern matching pre‑echoed the regular expression engines now ubiquitous in scripting languages. The concept of based variables and pointer safety appeared in revised forms in Ada and Modula‑2. Even the language’s extensibility and operator overloading foreshadowed the capabilities of C++ and modern functional languages.
Moreover, MAD/I stands as a testament to a philosophy that is still relevant today: a programming language for scientists should be both powerful and humane. It should not force the user to become a computer architect, nor should it hide so much that the computation becomes a black box. MAD/I walked that fine line with elegance.
Finding Help with MAD/I Today
Given that MAD/I is no longer in active use, obtaining practical help requires delving into historical archives. The definitive reference is the MAD/I Reference Manual, published by the University of Michigan Computing Center around 1970. Scanned copies circulate among computer history enthusiasts. The Bitsavers.org archive and the University of Michigan’s own digital collections hold original manuals, compiler listings, and even example programs. Emulators for the IBM System/360 and the MTS operating system exist, allowing the curious to run genuine MAD/I code in a simulated environment.
For those seeking to understand the language’s structure and learn from its design, the following resources are invaluable:
- MAD/I Language Description by Arden, Galler, and Graham (often cited in historical surveys of programming languages).
- The MTS Volume 2: MAD/I manual, which explains the interactive environment and debugging facilities.
- Academic papers from the late 1960s and early 1970s, many available through the ACM Digital Library, that discuss the compiler’s implementation and the rationale behind the language’s features.
If you are a student of programming language history or a designer seeking inspiration, MAD/I offers a rich case study. Its blend of mathematical notation, structured programming, and user‑centric tooling makes it a language that was truly ahead of its time.
Conclusion
MAD/I was more than a mere upgrade to its predecessor. It was a forward‑thinking attempt to define what a modern scientific programming language should be: expressive, extensible, and forgiving. While the language itself has long since retired, the ideas it championed — block structure, safe pointers, string patterns, extensible syntax — have become woven into the fabric of today’s programming practice. The next time you enjoy Python’s intuitive string methods, C++’s operator overloading, or Rust’s ownership semantics, spare a thought for MAD/I, a quiet pioneer from the dawn of interactive computing. Its story reminds us that the best languages are not always the most famous ones, browse around these guys but often those that dared to imagine a better conversation between human and machine.