Summary

  • FORMAC represented formulas as structures that could be differentiated, substituted, expanded and simplified; it could then emit a FORTRAN-compatible form for conventional compilation and numerical evaluation.
  • A transformed expression showed that specified formal rules had run on that representation. It did not automatically prove equivalence across every domain or branch, numerical stability, program correctness or a scientific conclusion.
  • Jean E. Sammet initiated and directed the language effort, while the record separately preserves E. R. Bond, Robert G. Tobey, Stephen N. Zilles, other IBM contributors and a wider symbolic-computation community.

An algebraic expression enters a machine as more than a line of ink. Its operators, operands and nested parts become a structure. The system differentiates it, substitutes one variable for another, removes parentheses or simplifies the result. The new expression is then reshaped into notation that FORTRAN IV can accept, compiled and evaluated with numbers.

That sequence was the practical promise of FORMAC. It was also a chain of different claims.

The Computer History Museum profile of Jean E. Sammet records that she joined IBM in 1961 and directed the development of FORMAC, which became a widely used system for symbolic mathematics. In her oral history, Sammet described the motivating decision as adding symbolic capability to an existing numerical language. FORTRAN was the obvious operational base, but using it also constrained how symbolic work could be expressed.

A formula became an object of computation

Sammet and E. R. Bond's 1964 Introduction to FORMAC documented a language in which formulas could be named, inspected and transformed. Formal differentiation, replacement of variables, algebraic expansion, simplification and later numerical evaluation were operations on a representation, not instructions to a human algebraist.

That distinction matters. Ordinary numerical FORTRAN computes values after variables have values. FORMAC could first operate on the form of an expression. It made the expression itself part of the executable working material.

Sammet's 1966 Survey of Formula Manipulation placed that work in a larger field: differentiation, integration, simplification, display and editing, precision arithmetic, batch and interactive systems, and application programs. FORMAC was a major system, not a solitary invention outside a research community.

The internal history was also collective. An IBM retrospective says Sammet developed the initial concepts with assistance from Robert G. Tobey in July 1962, followed by an internal proposal in August, language specifications by December, a complete system in April 1964 and release that November. The 1964 ACM record for FORMAC—an experimental formula manipulation Compiler names Elaine R. Bond, Marc A. Auslander, S. Grisoff, Robert Kenney, Mat Myszewski, Sammet, Tobey and Stephen N. Zilles. Leadership and implementation are related facts, not interchangeable credits.

The FORTRAN boundary was a real engineering interface

A 1968 NASA technical note shows the boundary in use. Engineers described a linear block-diagram model symbolically, then used FORMAC to eliminate variables, solve equations and produce transfer expressions. The symbolic stage could form ratios, substitute system relations and, where memory allowed, expand complex rational expressions.

The next stage was deliberately separate. The resulting equations were punched in a form suitable for insertion into a FORTRAN IV subroutine. Notation that FORTRAN would not accept—such as FORMAC's trailing marker and some exponent forms—was removed. FORTRAN compiled the subroutine, accepted numerical inputs and produced real and imaginary parts, magnitude and phase.

The authors used this division because repeated numerical evaluation inside the symbolic environment was slow and consumed substantial expression storage. FORMAC handled algebraic reduction; FORTRAN handled repeated numerical work. Integration shortened the route between them, but the handoff did not disappear.

The same document records limits. The model had to be linear. Time-varying coefficients were excluded. An arbitrary function needed a matching FORTRAN function supplied by the user. Expression growth and memory could prevent an expansion. A contemporary geophysics application likewise treated FORMAC as a symbolic preprocessor whose output entered another language and machine environment.

A successful transformation proves less than it appears to

If a system returns a simpler expression, one fact is established: particular rules ran on a particular representation and produced that output. Several further claims still need evidence.

Cancellation can remove a point where the original denominator was zero. Square roots, logarithms and non-integer powers carry domain and branch conditions. Reordering a symbolic expression can expose a numerically unstable subtraction. A generated FORTRAN program may compile and still contain a wrong model, an incorrect user function, poor scaling or unsafe rounding behaviour. A stable numerical result may faithfully evaluate assumptions that do not describe the physical system.

FORMAC did not fail because these questions survived. On the contrary, its design made a crucial transition operational: algebra could generate program material. The disciplined reading is to keep a ledger of what each stage adds:

  1. the input records a model and its stated assumptions;
  2. the symbolic result records transformations on a defined representation;
  3. generated FORTRAN records the translation into a conventional program form;
  4. compiler output records acceptance by a particular toolchain;
  5. runtime output records behaviour for particular inputs and numerical conditions; and
  6. domain review decides whether the result supports a scientific claim.

No entry in that ledger authorises the next one automatically.

The historical credit should be just as well typed

Sammet's 1993 retrospective, The Beginning and Development of FORMAC, described the conceptual work, subsequent development, related systems, IBM software management and influence. The separation is useful: “Sammet led FORMAC” does not mean that Bond's documentation, Tobey's early and algorithmic work, Zilles's contribution, the rest of the implementation group or neighbouring computer-algebra work can be collapsed into her name.

The more exact account is stronger. Sammet identified and directed a language project that crossed symbolic algebra and production computing. Bond coauthored the contemporary introduction and wrote an early user reference cited by the NASA team. Tobey helped with the first concepts. Zilles and other named IBM authors helped build and explain the experimental compiler. A broader community tested what formula manipulation could mean.

FORMAC's lasting lesson is therefore both technical and institutional. A boundary can be made fast, useful and repeatable without pretending that the things on either side have become one proof.

Sources