File: sather/doc/sather_summary.txt
Author: Stephen M. Omohundro
Created: Mon May 20 14:42:06 1991
Copyright (C) International Computer Science Institute, 1991


                        Summary of Sather

This note is a short description of a new object-oriented language
called Sather under development at the International Computer Science
Institute. Sather has clean and simple syntax, parameterized classes,
object-oriented dispatch, multiple inheritance, strong typing, and
garbage collection. The compiler generates efficient and portable C
code which is easily integrated with existing code.

The initial beta test release of the language was in May, 1991. The
compiler, debugger, Emacs development environment, documentation, and
library classes are available by anonymous ftp from
"icsi-ftp.berkeley.edu". "sather@icsi.berkeley.edu" is a mailing list
for discussing aspects of Sather and "sather-admin@icsi.berkeley.edu"
should be used for bug reports and requests to be added or deleted
from the mailing list.

Sather is based on Eiffel but is more concerned with efficiency and
less with some of the formal and theoretical issues addressed by
Eiffel. The language is much smaller than the current Eiffel,
it eliminates over 40 keywords and simplifies the syntax and
inheritance rules. Several features were added to increase efficiency
and to simplify programming. Efficient arrays are built into the
language itself (objects may have a dynamically allocated array
portion after their static features). The typing scheme allows the
programmer to distinguish between dispatched and non-dispatched
declarations. As in C++ local variables may be declared at the point
of use. Sather classes may have shared variables which are accessible
from every instance of that class. For efficiency reasons, the
exception handling mechanism based on setjump and long-jump has been
eliminated and the garbage collector is not based on the Dijkstra
algorithm. Many cosmetic issues have been changed (eg. more than one
class may be defined in a file).

Like Eiffel, Sather code is compiled into portable C and efficiently
links with existing C code. The Sather compiler is written in Sather
and has been operational for almost a year, though it is still being
improved. Preliminary benchmarks show a performance improvement over
Eiffel of between a factor of 4 and 50 on basic dispatching and
function calls. On the benchmarks used at Stanford to test Self
(including 8 queens, towers of hanoi, bubblesort, etc), Sather is
even slightly faster than C++.

The Sather compiler and libraries are publicly available under a very
unrestrictive license aimed at encouraging contribution to the public
library without precluding the use of Sather for proprietary projects.
The goal is to establish a repository for efficient, reusable, well
written, publicly available, classes for most of the important
algorithms in computer science. There are currently several hundred
classes in the library. Some examples of classes being worked on
include:

base: integers, strings, random number generation, etc.
compiler: classes used in the compiler
connectionist: back propagation, radial basis functions, competitive 
   learning, Kohonen nets, perceptrons and other neural network 
   algorithms
datastr: various hash tables, priority queues, union find, lists based
   on amortized doubling of extendible arrays, gap lists, binary trees,
   bit_vectors, stacks, queues, sorts, etc.
debugger: classes used in interpreter/debugger
geometry: vectors, boxes, balls, Delaunay triangulation, Voronoi
   diagrams, kd-trees, point location, etc.
grammar: deterministic finite automata, dfa minimization, parsers,
   string search algorithms
graph: minimal spanning tree, depth first search, connected
   components, max flow, shortest path, etc.
graphics: plotting routines, ray tracing, modelling, graphics pipeline
imageproc: bitmaps, dithering, filtering, FFT, etc.
interface: XView classes, PostScript and Framemaker output
numerical: matrix classes (SVD etc.), special functions, complex
   numbers, linear programming, conjugate gradient optimization, etc.
statistics: least squares fits, density estimators, nonlinear
   regression, hidden markov models, nearest neighbor classifiers, 
   decision tree induction, etc.

The libraries are growing quickly and will collect together classes
from many authors under the same unrestrictive license. 

A GNU emacs development environment for Sather is available. In
addition to automatically indenting Sather code, it automatically
generates documentation files, runs the compiler, parses compiler
error messages and puts you at the error, runs the debugger and
graphically points the current line, keeps track of the inheritance
hierarchy and provides search facilities accross all classes in a
program.

A debugger based on gdb from the Free Software Foundation is also
available. This allows you to set breakpoints and steps through Sather
code, to set variables, and browse through Sather objects. In
conjunction with the Emacs environment, it graphically displays the
source code corresponding the the currently executing code. It
switches into debugging C code when any user written C code is
encountered. 

A parallel version of Sather for shared memory machines called
"Psather" is also under development.

