*** NEW O'small compiler available by ftp !!! ***
From: hense@sol.cs.uni-sb.de (Andreas Hense)
Date: 25 Jun 1993 13:54:35 GMT
Organization: Universitaet des Saarlandes,Rechenzentrum
O'small - THE object-oriented language for teaching
---------------------------------------------------
(Announcement of a new compiler)
*** An object-oriented language for teaching?
Depending on which aspects of object-orientation you want to convey you
may choose your teaching language. If you want to teach the aspect of
software reuse and nice graphical user interfaces, you should choose
Smalltalk. If you want to show students how to program in a best
selling language you should choose C++.
*** In which case should I choose O'small?
You should consider O'small if you believe that computer languages
should have a GOOD FORMAL SEMANTICS. Everyone will agree that a
language needs a formal semantics. Otherwise, your program will yield
different results on different implementations. A good formal
semantics does not only serve the purpose of precisely defining what
the results of your programs are, it also gives insights about the
nature of the language.
You should consider O'small if you do not want to waste time on
unnecessary details. O'small is CONCISE. Its syntax and semantics
takes no more than one page (if you choose the right font). Its syntax
is similar to more traditional languages. O'small has been used in a
lecture showing the differences between wrapper semantics
(denotational) and method lookup semantics (operational).
O'small is FREE! Up to now, there has only been an O'small interpreter
written in Miranda [Hen91b]. This interpreter is directly based on the
denotational semantics of O'small [Hen91d]. The interpreter itself is
available by ftp. However, you need Miranda in order to run it. Now,
there is a NEW IMPLEMENTATION of O'small based entirely on EASILY
AVAILABLE SOFTWARE. This software is not free but it does not cost
anything. The new implementation is based on an abstract machine [Boe93].
You can MODIFY the language and have your students make experiments
with it. The source code of the abstract machine and the
specifications for the parser and scanner generators are available.
Using these generators you can make experiments for your own research
in statical analysis of object-oriented languages.
*** I would like to TRY O'small
You get the implementation by anonymous internet ftp.
The following table gives the ftp connection information.
Host: Net Address: Directory:
-------------------------------------------------------------
cs.uni-sb.de 134.96.7.254 /pub/osmall/machine
The directory /pub/osmall/machine contains the files
README
ANNOUNCE this file
HowToGetML
oma.1.00.tar.Z compressed tar-file
***************************************************************************
NOTE: Ftp should be put into binary mode before transferring the compressed
tar file.
***************************************************************************
Here is a sample dialog:
ftp
ftp> open cs.uni-sb.de
Name: anonymous
Password: <your name>
ftp> binary
ftp> cd /pub/osmall/machine
ftp> get README
ftp> get ANNOUNCE
( ftp> get HowToGetML )
ftp> get oma.1.00.tar.Z
ftp> close
ftp> quit
If you have a Sun 4 or a SPARC you can use the existing executable files.
Otherwise, you need 'sml-yacc', 'sml-lex' and 'sml-noshare'. Read
'HowToGetML' to obtain them.
Instructions on using the machine are contained in the file README.
References
[Boe93] Christoph Boeschen. Christmas - An abstract machine for
O'small. Master's thesis, Universit"at des Saarlandes,
Fachbereich 14, June 1993.
[Hen91b] Andreas V. Hense. An O'small interpreter based on denotational
semantics. Technical Report A 07/91, Universit"at des Saarlandes,
Fachbereich 14, November 1991.
[Hen91c] Andreas V. Hense. Type inference for O'small. Technical Report A
06/91, Universit"at des Saarlandes, Fachbereich 14, October 1991.
[Hen91d] Andreas V. Hense. Wrapper semantics of an object-oriented pro-
gramming language with state. In T. Ito and A. R. Meyer, editors,
Theoretical Aspects of Computer Software, volume 526 of Lecture No-
tes in Computer Science, pages 548-568. Springer-Verlag, September
1991.
[Hen93] Andreas V. Hense. Denotational semantics of an object-oriented
programming language with explicit wrappers. Formal Aspects of
Computing, 5(3), 1993. to appear.
[HS92] Andreas V. Hense and Gert Smolka. A verification of extensible
record types. In Zhongzhi Shi, editor, Proceedings of the IFIP
TC12/WG12.3 International Workshop on Automated Reasoning,
pages 137-164, Beijing, P.R. China, 13-16 July 1992. Internatio-
nal Federation for Information Processing, Elsevier, North-Holland,
Excerpta Medica.
[HS93] Andreas V. Hense and Gert Smolka. Principal types for object-
oriented languages. Technical Report A 02/93, Universit"at des Saar-
landes, Fachbereich 14, June 1993.
>9 OBJ3 (OO lang)
What: Release 2.0 of OBJ3 (needed for FOOPS and OOZE, concurrent OOP)
Date: Thu, 4 Jun 92 15:07:26 BST
From: Paulo.Borba@prg.oxford.ac.uk
OBJ is available from SRI, see the message below; prototypes implementations of
FOOPS (without the concurrent extension) and OOZE are due to the end of the
year, but for both you also need OBJ.
Unfortunately, I don't have any document about the FOOPS extension now, but
probably by the end of the year. I will send it to you as soon as possible.
What: Release 2.0 of OBJ3 is now available
From: winkler@csl.sri.com (Timothy Winkler)
Date: 6 Apr 92 08:35:40 GMT
Release 2.0 of OBJ3 is now available!
Improvements in this version include some language extensions and additional
theorem proving features. In addition, an effort has been made to speed up
the implementation; rewriting is often twice as fast as in the original
implementation. We are including the AKCL patches from the University of
Texas at Austin in the distribution, which are necessary for maintaining the
portability of OBJ3 and also improve its efficiency. In addition, we are
distributing a SPARC version of OBJ3.
OBJ3 has pattern matching modulo associativity, commutativity, and identity.
New: the system automatically computes conditions for rules involving matching
modulo identity that are used to prevent obvious non-termination problems.
Also new to this version of OBJ3 is a facility for controlled rewriting. This
provides substantially increased support for the use of the system for
equational theorem proving.
To receive the OBJ3 distribution tape or an OBJ3 license, send a request
to:
Judith Burgess (OBJ3)
Computer Science Laboratory
SRI International
333 Ravenswood Ave.
Menlo Park, CA 94025-3493, USA
Telephone: (415) 859-5924
Fax: (415) 859-2844
email: obj3dist@csl.sri.com
Be sure to give us your postal mailing address. Then we will send you the
OBJ3 Information Form, and License Agreement, with instructions on how to
fill them out. (A KCL license form will also be included.) When you return
them to us, appropriately filled out and signed, we will send you the tape,
somedocumentation, and, in case you are requesting a tape, an invoice for
$150.00 plus any required taxes.
If you already have an OBJ3 license, then you don't need to get a new license,
but, if you are requesting a tape from SRI, you are asked to pay the above
distribution fee.
It is also possible to get a license for OBJ3 at no charge from SRI and then
get the OBJ3 distribution itself from some third party also having a license.
Jose Meseguer, Timothy Winkler, and Patrick Lincoln
Computer Science Laboratory
SRI International
333 Ravenswood Avenue
Menlo Park, California 94025, USA
Joseph Goguen
Programming Research Group
Computing Laboratory
Oxford University
11 Keble Road
Oxford OX1 3QD, United Kingdom
>10 OBST (lang, perst, OODB)
What: OBST (Version: OBST3-2)
From: stone@fzi.de
Date: 19/3/92
[ Formerly, we used the acronym SOS, which led to a conflict
with an object oriented operating system of the same name.
Therefore we changed the name to OBST ("Obst" is the German
word for "fruit"). As many people already use SOS (OBST) we
did not change internal things like class names, environment
variables and so on. ]
The persistent object management system OBST was developed by
Forschungszentrum Informatik (FZI) as a contribution to the STONE
project. This project (supported by grant no. ITS8902A7 from the
BMFT, i.e. the German Ministry for Research) aims at the development
of a software engineering environment for education purposes and is
carried out as a joint project of nine german universities and
research institutions.
An essential feature of STONE is that the object oriented paradigm
is pursued consequently as a key concept. OBST is the common persistent
object store for all tools within the STONE environment.
The OBST data model can be characterized by the following properties:
* Schema definition language syntactically similar to C++
* Support of multiple inheritance
* Generic classes
* Distinction between public, protected, and private methods
* Redefinition of methods
* Overloading of methods
Schemas are compiled by the OBST schema compiler. The compilation
results are instances of classes of the meta schema. From these
instances in a next step interfaces to different programming languages
can be generated. At present the C++ language binding is implemented,
interfaces to Lisp and other languages are planned.
Objects are stored in so-called containers. The container an object
belongs to is determined at the time of object creation and fixed
throughout the object's lifetime. Containers are the units of
clustering, synchronization, and recovery. Objects can be referenced
by other objects across container boundaries.
OBST provides a mechanism to incrementally load methods. This enables
programs to deal with objects whose type is defined after the program
itself has been developed. This is useful in systems that provide for
inheritance and it supports schema evolution.
Since end 1990 the first prototype of OBST is available and is shipped
to interested universities and research institutions.
The system comes with the schema compiler, a library of predefined
classes, a graphical object browser, the structurer and flattener and the
OShell, and all
manuals.
Structurer and Flattener is a tool to build objects from bytestrings and
flatten objects down to bytestrings. It is intended to be used when coupling
UNIX tools to the object management system. The user defines a grammar
that describes her objects. Afterwards, the structurer parses an ascii
text according to the given grammar and creates an OBST object structure that
represents the corresponding parse tree. The flattener does the inverse
transformation, that means it generates an ascii text from a given OBST object
structure according to the given grammar.
OShell is a tool which provides interactive access to the OBST object base.
There is a language called OSL which is based on the lambda calculus and
defines the interface to the OShell tool.
For the prototype's installation a C++ compiler (GNU g++ 1.37 or later or AT&T
2.0/2.1) and the X-Windows system (currently X11R4) for the graphical tools
are required. Installation is well-tried on SUN 3/* and SUN 4/* systems and
should be no problem on other UNIX machines, too.
--------------------------------------------------------------------
For more information please mail to:
Forschungszentrum Informatik (FZI)
STONE Projekt
Haid-und-Neu-Strasse 10-14
D-7500 Karlsruhe 1
Germany
or email to: stone@fzi.de
Phone: ++49-721-9654-601
Fax: ++49-721-9654-609
Teletex: 721 190 fziKA
The OBST system is available via anonymous FTP from gate.fzi.de
[141.21.4.3]. The system can be found in the directory /pub/OBST.
Sites interested in getting information about new OBST developments
are welcome to register in our mailing list by sending an email with
subject "obst-mailing-list" to stone@fzi.de.
>11 OOT (OO Turing demo)
What: OOT
From: holt@turing.toronto.edu (Ric Holt)
Date: 26 Apr 93 20:14:43 GMT
OBJECT ORIENTED TURING: DEMO AVAILABLE VIA FTP
OOT (Object Oriented Turing) is a programming language that has been
developed at the University of Toronto. An OOT demo, which includes the
fully implemented language, is available for Sun/4's running X windows.
See below for instructions to copy the demo to your site.
OOT supports the standard OOPL features of information hiding, classes,
polymorphism and generics, as well as the usual features in C and Pascal
style languages. It also supports concurrency, exception handling
and system programming (pointer arithmetic, bit manipulation, etc).
The OOT environment is designed for teaching Computer Science.
It is being used in introductory programming courses, courses
on OO concepts, compiler courses, OS courses, etc.
The OOT environment is fully integrated, with multi-window editing, turbo
speed compiler, integrated color graphics, GUI user interface, implicit MAKE,
on-line manual, integrated demos, etc. The system includes an experimental
CASE tool with an interface browser and a visual system browser.
>12 Sather (simple Eiffel)
What: SATHER
Sather is 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.
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 about 120 classes in the library. 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. A debugger based
on gdb from the Free Software Foundation is also available. A parallel version
of Sather for shared memory machines called "Psather" is also under
development.
From the Sather FAQ, August 16, 1993 (See Section 1.24):
Q 1: What is Sather?
~~~~~~~~~~~~~~
Sather is an object oriented language which aims to be simple,
efficient, interactive, safe, and non-proprietary. It aims to meet the
needs of modern research groups and to foster the development of a
large, freely available, high-quality library of efficient
well-written classes for a wide variety of computational tasks. It was
originally based on Eiffel but now incorporates ideas and approaches
from several languages. One way of placing it in the "space of
languages" is to say that it attempts to be as efficient as C, C++, or
Fortran, as elegant and safe as Eiffel or CLU, and to support
interactive programming and higher-order functions as well as Common
Lisp, Scheme, or Smalltalk.
Sather has garbage collection, statically-checked strong typing,
multiple inheritance, separate implementation and type inheritance,
parameterized classes, dynamic dispatch, iteration abstraction,
higher-order routines and iters, exception handling, assertions,
preconditions, postconditions, and class invariants. The development
environment integrates an interpreter, a debugger, and a
compiler. Sather code can be compiled into C code and can efficiently
link with C object files.
>13 Self
What: Self 2.0 Release
From: hoelzle@Xenon.Stanford.EDU (Urs Hoelzle)
Date: 10 Aug 92 21:08:25 GMT
Announcing Self Release 2.0
The Self Group at Sun Microsystems Laboratories, Inc., and Stanford University
is pleased to announce Release 2.0 of the experimental object-oriented
exploratory programming language Self.
Release 2.0 introduces full source-level debugging of optimized code, adaptive
optimization to shorten compile pauses, lightweight threads within Self,
support for dynamically linking foreign functions, changing programs within
Self, and the ability to run the experimental Self graphical browser under
OpenWindows.
Designed for expressive power and malleability, Self combines a pure,
prototype-based object model with uniform access to state and behavior. Unlike
other languages, Self allows objects to inherit state and to change their
patterns of inheritance dynamically. Self's customizing compiler can generate
very efficient code compared to other dynamically-typed object-oriented
languages.
Self Release 2.0 runs on Sun-3's and Sun-4's, but no longer has an optimizing
compiler for the Sun-3 (and therefore runs slower on the Sun-3 than previous
releases).
This release is available free of charge and can be obtained via anonymous ftp
from self.stanford.edu. Unlike previous releases, Release 2.0 includes all
source code and is legally unencumbered (see the LICENSE file for legal
information.) Also available for ftp are a number of papers published about
Self.
Finally, there is a mail group for those interested in random ramblings about
Self, self-interest@self.stanford.edu. Send mail to
self-request@self.stanford.edu to be added to it (please do not send such
requests to the mailing list itself!).
The Self Group at Sun Microsystems Laboratories, Inc. and Stanford University
>14 C++ gram, etc.
What: ftp site for C++ material
From: schrod@iti.informatik.th-darmstadt.de (Joachim Schrod)
Date: 27 May 92 22:32:35 GMT
There were a lot of questions about C++ material in the last time and some
announcements which involved our ftp server.
ftp.th-darmstadt.de [130.83.55.75]
/pub/programming/languages/C++
At the moment we have:
-- documentation and assorted stuff
C++ products list as announced by Saumen K Dutta (in a subdirectory!)
C++ YACC grammar, ET++ tutorial, summaries from the Net,
sources from James Coplien's book (idioms...), etc.
-- class libraries
NIHCL (original, persistent for ObjectStore, with g++ 1.4x changes)
COOL, OATH, RogueWave vector, ET++,
RPC package, a package for sockets, awe (thread package)
-- tools
class browser (for GNU Emacs), indent++, yacc+, template
processor of Brad Cox[sp?], DEC garbage collector
More stuff is always welcome. (Btw, Interviews and Motif C++ wrapper
classes are to be found in the /pub/X11 subtree.)
>15 ConceptBase (OODB, reqkey)
What: ConceptBase
See APPENDIX B.
A four week test-version of ConceptBase V3.1 is available
on the FTP server ftp.informatik.rwth-aachen.de in the
directory pub/CB. For running the ftp version you must ask for a
key by email.
>16 C++ OODB
Exodus (Storage Man, perst)
Go Back Up
Go To Previous
Go To Next