Sather

Sather is a statically typed, object-oriented programming language designed at the International Computer Science Institute (ICSI) at the University of California, Berkeley, beginning in 1990. It was conceived as a corrective to a specific frustration: researchers at ICSI liked the clean, safe object-oriented design of Bertrand Meyer’s Eiffel, but found the Eiffel implementations available at the time too slow for the numerically intensive research software - neural-network simulators, geometric algorithms, image processing - that the institute actually needed to run. Sather set out to keep Eiffel’s discipline while compiling to code competitive with C, C++ and Fortran, and to do so as freely available, non-proprietary software from the start. Its name is a small joke on its origins: Sather Tower is the Berkeley campanile that stands over the UC Berkeley campus, visible from ICSI’s offices.

History and Origins

Design and an initial compiler were built over the summer of 1990 by a team led by Stephen Omohundro, with early language contributions from Chu-Cheow Lim and Heinz Schmidt. That first compiler was itself written in Sather and bootstrapped by hand-translation into C - a pattern the project repeated at every subsequent stage. ICSI made the language publicly available for the first time as version 0.1 in June 1991, a design close to a subset of Eiffel 2.0. Versions 0.2 and 0.5 followed, each compiler again bootstrapped from the last, as the team gathered experience from early adopters and reworked the specification.

That process culminated in Sather 1.0, released in summer 1994 by a team that by then included David Stoutamire and Robert Griesemer alongside Omohundro. Sather 1.0 added the features that distinguish the mature language from its Eiffel-like beginnings: parameterized (generic) classes, multiple inheritance with implementation and type inheritance kept as separate mechanisms, bound routines, iterators, and an exception-handling model; it was a fresh compiler implementation, itself written in the preceding 0.5 line of the language as the new features came online. Omohundro described the language and its design rationale in an October 1993 Dr. Dobb’s Journal article, which reported the then-current (pre-1.0) Sather compiler at roughly 30,000 lines of Sather across 183 classes, translating to about 70,000 lines of generated C; by that point a parallel-programming dialect, pSather, was already being developed with contributions from Jerome Feldman, Chu-Cheow Lim, Franco Mazzanti and Stephan Murer, running on Sequent Symmetry multiprocessors and Thinking Machines CM-5 supercomputers.

Sather 1.1 followed in summer 1996 - the version documented in ICSI’s surviving language tutorial, and the last complete release ICSI itself produced. Work continued for a couple more years, but by the end of 1998 development at ICSI had stalled, leaving only a 1.2b beta unfinished. A related but independently diverging implementation, Sather-K, had already been built at the University of Karlsruhe under Gerhard Goos starting from the 0.1 specification.

Rather than disappearing, the ICSI codebase found a second home: in 1999, Norbert Nemec picked up the 1.2b sources and continued them as GNU Sather, relicensing the compiler and libraries under the GNU GPL and LGPL as part of the GNU Project. Under that stewardship the language reached its final stable release, GNU Sather 1.2.3, in July 2007. It has not seen a further release since, and the project is now archived rather than actively maintained.

Design Philosophy

Sather’s designers were explicit that they wanted a language that was simple, efficient, safe, and non-proprietary, and that let programmers work both interactively (in the manner of Lisp or Smalltalk) and with the raw performance of compiled C, C++ or Fortran. Where Eiffel combined interface and implementation inheritance into a single mechanism, Sather deliberately split them: a class could inherit an interface (a subtype relationship) independently of inheriting an implementation, giving programmers finer control over what multiple inheritance actually shared. Static, strong typing with a contravariant type system was intended to catch as many errors as possible at compile time while still supporting genuinely reusable, parameterized data structures - a STACK{CHAR} and a STACK{STR} sharing one implementation, type-checked at each instantiation.

Sather also leaned toward Lisp and Scheme-derived habits ICSI’s researchers were already comfortable with: garbage collection was built in rather than left to the programmer, and the language borrowed CLU’s notion of iterators, exposed in Sather as first-class “iter” routines usable directly in loop control structures. Design-by-contract-style assertions, inherited conceptually from Eiffel, let classes declare preconditions, postconditions, and invariants that the compiler could check.

Key Features

• Parameterized classes for compile-time generic programming, resolved and specialized per instantiation rather than through runtime dispatch
• Separate implementation and type inheritance, letting multiple inheritance share code without forcing subtype relationships, and vice versa
• Iterators (iter) as first-class abstractions over iteration, usable directly inside loop constructs instead of hand-written cursor objects
• Bound routines and exceptions, added in the 1.0 release, giving the language closures over routines and a structured error-handling model
• Design-by-contract assertions, following Eiffel, for preconditions, postconditions and class invariants
• Garbage collection, built into the runtime rather than left to programmer discretion
• Compilation to portable C, letting Sather programs link directly against existing C object code and libraries and travel to any platform with a working C toolchain
• pSather, a parallel-programming extension adding threads, synchronization and locking constructs, developed and tested on Sequent Symmetry and Thinking Machines CM-5 hardware

Current Relevance

GNU Sather has been dormant since its 1.2.3 release in July 2007; the GNU Savannah project page and source repository remain online, but there has been no further development. ICSI’s own historical Sather pages document the language’s design rationale and its 1990s history and remain a primary source for anyone studying it today. Its clearest continuing legacy is indirect: Alexander Aiken’s Cool (Classroom Object-Oriented Language), used for decades to teach compiler construction in Stanford’s CS143 course and its online successors, is based on Sather164, itself a dialect of Sather, meaning generations of compiler students have encountered a descendant of Sather’s object model - static typing, inheritance, an expression-oriented core - without necessarily knowing its source.

Why It Matters

Sather occupies a specific, useful place in programming-language history: it is a working record of what a research group in the early 1990s judged worth keeping from Eiffel and worth fixing. Its split between implementation and type inheritance, and its insistence that safety and performance were not in tension, anticipated design choices that later mainstream languages would also have to make. Even in its current dormant state, Sather is a clear example of how a research language, once its home institution moves on, can still be preserved and extended by a small volunteer community - and how its ideas can outlive the language itself by seeding a much smaller, purpose-built successor used to teach the next generation how compilers work.