Sather is an object oriented language designed to be simple, efficient, safe, flexible and non-proprietary. One way of placing it in the "space of languages" is to say that it aims to be as efficient as C, C++, or Fortran, as elegant as and safer than Eiffel or CLU, and support higher-order functions and iteration abstraction as well as Common Lisp, Scheme, or Smalltalk.

Sather has parameterized classes, object-oriented dispatch, statically-checked strong (contravariant) typing, separate implementation and type inheritance, multiple inheritance, garbage collection, iteration abstraction, higher-order routines and iters, exception handling, assertions, preconditions, postconditions, and class invariants. Sather programs can be compiled into portable C code and can efficiently link with C object files.

ICSI maintains a stable public class library and a growing body of contributed code including classes for mathematics, data structures, GUI interfaces and compiling; the Sather compiler, written entirely in Sather, is one such contribution. Sather has a very unrestrictive license which allows its use in proprietary projects but encourages contribution to the public library. A language-aware browser allows new users to explore the library with integrated documentation.

There is a separate page for pSather, an extension to Sather for high-performance distributed computation.


Getting Started:


General Information:


The ICSI Compiler:


Sather 1.1:

Sather 1.1 is a major polish of the 1.0 spec, adding substantial support for interoperability, out and inout arguments, and partial classes. pSather is now integrated into the 1.1 spec as a language extension. We are presently working on the 1.1 compiler, and hope to be able to make a preliminary release at the end of August. The new manual attempts to be more readable and precise than the old manual, and now has an extensive introduction and lots of examples. Please check it out and let me know what you think!


Other stuff:


ICSI tech reports available on Sather:

TR 94-062: Sather 1.0 Tutorial
This document provides basic information on how to obtain your copy of the Sather 1.0 system and gives several pointers to articles discussing Sather 1.0 in more detail.

We thoroughly describe the implementation of a basic chess program. By carefully reading this document and the discussed example program, you will learn enough about Sather 1.0 to start programming in Sather 1.0 yourself. This document is intended for programmers familiar with object oriented languages such as Eiffel or C++.

The main features of Sather 1.0 are explained in detail: we cover the difference between subtyping and implementation inheritance and explain the implementation and usage of iters. Moreover, the example program introduces all the class elements (constants, shared and object attributes, routines and iters) are introduced. Most statements and most expressions are also discussed. Where appropriate, the usage of some basic features which are provided by the Sather 1.0 libraries are demonstrated. The Tutorial is completed by showing how an external class can be used to interface to a C program.

TR 93-045: Sather Iters: Object-Oriented Iteration Abstraction
Sather iters are a powerful new way to encapsulate iteration. We argue that such iteration abstractions belong in a class' interface on an equal footing with its routines. Sather iters were derived from CLU iterators but are much more flexible and better suited for object-oriented programming. We motivate and describe the construct along with several simple examples. We compare it with iteration based on CLU iterators, cursors, riders, streams, series, generators, coroutines, blocks, closures, and lambda expressions. Finally, we describe how to implement them in terms of coroutines and then show how to transform this implementation into efficient code.

TR 93-064: Engineering a Programming Language: The Type and Class System of Sather
Sather 1.0 is a programming language whose design has resulted from the interplay of many criteria. It attempts to support a powerful object-oriented paradigm without sacrificing either the computational performance of traditional procedural languages or support for safety and correctness checking. Much of the engineering effort went into the design of the class and type system. This paper describes some of these design decisions and relates them to approaches taken in other languages. We particularly focus on issues surrounding inheritance and subtyping and the decision to explicitly separate them in Sather.

davids@icsi.berkeley.edu