related topics
{math, number, function}
{language, word, form}
{work, book, publish}
{game, team, player}

Sather is an object-oriented programming language. It originated circa 1990 at the International Computer Science Institute at the University of California, Berkeley, developed by an international team led by Steve Omohundro. It supports garbage collection and generics by subtypes.

Originally, it was based on Eiffel, but it has diverged, and now includes several functional programming features. It is probably best to view it as an object-oriented language, with many ideas borrowed from Eiffel. Even the name is inspired by Eiffel; the Sather Tower is a recognizable landmark at Berkeley. Sather also takes inspiration from other programming languages and paradigms: iterators, design by contract, abstract classes, multiple inheritance, anonymous functions, operator overloading, contravariant type system. Some of these features are normally only found in functional programming languages.

The original Berkeley implementation is now maintained by many people, not all at Berkeley, and has been adopted by the Free Software Foundation therefore becoming GNU Sather. There are at least two other implementations: Sather-K from the University of Karlsruhe, and Sather-W from the University of Waikato.

The former ICSI sather compiler (now GNU Sather) is implemented as a compiler to C, i.e., the compiler does not output object or machine code, but takes Sather source code and generates C source code as an intermediate language. Optimizing is by the C compiler, Sather code often performs better than the corresponding C++ code, and the generated C code can always be optimized by hand.

The GNU Sather compiler, written in Sather itself, is dual licensed under the GNU GPL & LGPL.

Hello World

class HELLO_WORLD is
 main is 
  #OUT+"Hello World\n"; 

A few remarks:

  • Class names are ALL CAPS; this is not only a convention but is enforced by the compiler.
  • The method called main is the entry point for execution. It may belong to any class, but if this is different from MAIN, it must be specified as a compiler option.
  • # is the constructor symbol, calling method create of the corresponding class; here it is used for instantiating the OUT class, which is actually stdout.
  • The + operator has been overloaded here to stand for stream append.
  • Operators such as + are syntactic sugar for conventionally named method calls: a + b stands for The usual arithmetic precedence conventions are used to resolve the calling order of methods in complex formulae.
  • The program layout allows for pre- and post-conditions (not shown here), showing Sather's Eiffel lineage.

[edit] Example of iterators

class MAIN is
  main is
     i := 1.upto!(10);
     #OUT + i + "\n";

This program prints numbers from 1 to 10.

The loop ... end construct is the preferred means of defining loops (although while and repeat-until are also available). Within the construct, one or more iterators may be used. Iterator names always end with an exclamation mark (this convention is enforced by the compiler). upto! is a method of the integer class INT accepting one once argument, meaning its value will not change as the iterator yields. upto! could be implemented in the INT class like this:

 upto!(once m:INT):SAME is
   i: INT := self; -- initialise i to the value of self, 
                   -- that is the integer of which this method is called
     if i>m then 
       quit -- leave the loop when i goes beyond m
     yield i; -- else use i as return value and stay in the loop
     i := i + 1; -- and increment

Type information for variables is denoted by a postfix syntax variable:CLASS. The type can often be inferred and thus the typing information is optional, like in anInteger::=1. SAME is a convenience pseudo-class referring to the current class.

Full article ▸

related documents
Symmetric tensor
Commutative diagram
Catalan's conjecture
Constant term
Atlas (topology)
Matrix addition
Linear prediction
Interpreted language
Cauchy's integral theorem
Finitely generated abelian group
Infinite set
Wreath product
Canonical LR parser
Nilpotent group
Vector calculus
Dirichlet's theorem on arithmetic progressions
Most significant bit
Condition number
Merge algorithm
Hilbert's basis theorem
Addition of natural numbers
Axiom of extensionality
Directed set
Removable singularity
Symbolic logic
NC (complexity)
Linear span
List of small groups