Loglan'82 an object oriented programming language available

salwicki@infpc1.univ-pau.fr (Andrzej Salwicki Professor
Tue, 15 Feb 1994 03:24:21 GMT

          From comp.compilers

Related articles
Loglan'82 an object oriented programming language available salwicki@infpc1.univ-pau.fr(AndrzejSalwickiProfess (1994-02-15)
| List of all articles for this month |

Newsgroups: comp.compilers
From: salwicki@infpc1.univ-pau.fr (Andrzej Salwicki Professor
Keywords: OOP, parallel, available, FTP
Organization: Compilers Central
Date: Tue, 15 Feb 1994 03:24:21 GMT

Institute of Informatics, University of Warsaw
LITA, Universite de Pau

an object oriented programming language

We have the privilege and the pleasure to inform you that since August 1993
the programming language LOGLAN'82, its compilers and its environments
are accessible for the usage from

the server: infpc1.univ-pau.fr =
user: anonymous = ftp
Password:{your internet mail address}
directory: pub/Loglan82

          These programs are free software; you can redistribute it and/or modify
          it under the terms of the GNU General Public License as published by
          the Free Software Foundation; either version 2 of the License, or
          (at your option) any later version.

          These programs are distributed in the hope that it will be useful,
          but WITHOUT ANY WARRANTY; without even the implied warranty of
          See the GNU General Public License for more details.

Why Loglan'82?

There are good reasons for using Loglan'82 in:
      - education,
      - fast prototyping of software,
      - research.


The academic community has a need for one language which enables to teach
all elements of object programming: classes & objects, coroutines, processes
(in Loglan'82 processes are objects which are able to act in parallel),
inheritance, exception handling, dynamic arrays etc.
      Loglan'82 offers the complete sets of programming tools used in object
and modular and structural programming. It is suggested to use it during
the first two years of teaching and afterwards too.

It is of importance to have compilers acting in different operating
environments: MS-DOS, Unix, Atari, etc. in order to assure the exchange
of sources between students and teachers, between users of :
personal computers, workstations and servers of university's networks.
We are working on the prolongation of the list of machines and systems
that support Loglan'82.

Loglan'82 supports other styles of programming e.g. programming by rules,
functional programming etc.

The teacher and the students can use different computers (see "Machines" file)
and still they can exchange the sources and to follow the experiments
of others. You can distribute the files of Loglan'82 among the students
which own PC/DOS, ATARI, PS2, PC/Unix. You can install Loglan'82 in your
computing centre on Unix or Vax/VMS or Novell servers. You can install
Loglan'82 on your workstation (Sun, PC/Unix, Apollo etc.).
On all machines you can compile and execute the same program. Whether it
will be a student's program checked by a teacher, or an instructive program
transmitted to the students. And students can work at home or in a computer
room of your University.

For the PC users Loglan'82 comes with an environment consisting of
      - lotek - a text editor integrated with compiler and other tools,
      - a structural editor which guides you when you do not know the
          syntax of Loglan'82,
      - an electronic manual to be used with Norton Guide or its clones.

The sources enable to develop the system or simply to install it.

A set of instructive examples is added to the distribution package.

We encourage you to experiment with the system since:
- you can find it useful and interesting to teach the object programming,
- you can find Loglan'82 useful in fast prototyping of software,
- you can apply and extend several predefined classes which define and
    implement the problem-oriented languages extending Loglan'82 in various


Loglan'82 has been used as a tool with a success in research in:
* object oriented databases,
* symbolic computation (computer algebra, ...),
* formal proofs,
* proving the properties of programs.
this list is not the exhaustive one.

  Loglan'82 is a source of many problems of broader interest.
1. The problem of giving one non-contradictory semantics to the language admitting both nesting
of modules and inheritance from various levels.
2. Dangling reference problem.
3. Mathematical models of concurrent processes.
Loglan'82 is the result of a research on fundamental questions like 1-3 .

4. Multiple inheritance and nesting.
5. Libraries of predefined classes - how to define the meaning of separately
      compiled modules in the presence of nesting and multiple inheritance.
6. The virtual Loglan'82 machine as a federation of co-processes.
7. Execution of processes of a Loglan'82 program in a LAN of heterogeneous
8. Execution of Loglan'82 programs on parallel computers e.g. transputers.
  - to find a complete, axiomatic definition of the notions of class and
      of inheritance,
  - is it possible to make efficiently the nesting of modules and
      the multiple inheritance?
  - how to manage the libraries of predefined procedures and classes
      in the presence of nesting?
  - how to install the language on a real multiprocessor system?

The problem 1 was solved by the team lead by A.Kreczmar in co-operation
with the group of H. Langmaack.

The problem 2 was solved by A.Kreczmar and was analyzed formally by H. Oktaba.

T.Muldner and A.Salwicki gave the Max model of parallel computations.
H.-D. Burkhard proved that it differs essentially from the interleaving model.

B. Ciesielski gave a new concept of objects of processes and
a communication mechanism of alien calls of procedures.
This version was implemented by him in 1988.

The problems 4 - 8 are open. We would be happy to co-operate on solving
them together with you.

We recommend Loglan'82 as a TOOL to be used in the research in:
object-oriented databases, development of CASE tools, VHDL,
silicon compilers, simulation, etc.

Production of new software

    There are only a few languages which, like Loglan'82, enable both ways
of modules' developing: nesting (- a module can be declared in other module)
and inheritance (also called prefixing). The modules of your software can
share the environment (by means of nesting) or they can inherit
other modules as private copies of the modules declared elsewhere.

The inheritance in Loglan'82 permits to inherit a module declared somewhere
in the tree of nested modules. Moreover, the inheritance is no longer
restricted to classes. Any module, whether it will be a class, a block,
a procedure, a function, a coroutine or a process can inherit from a class.
Coroutines and processes can be inherited in classes, coroutines or processes.

Another kind of module is a handler. Handlers serve to handle signals
(of exceptions).

Altogether one can use 7 kinds of modules.

The tools offered by Loglan'82 enable in various ways to create generic modules
whether they are to serve as generic procedures or parameterized data types.
In order to do so one can use either the possibility to pass types as formal
parameters or the inheritance mechanisms together with the nesting.
The language makes possible overloading the names of operations via
the mechanism of virtual functions or procedures.

This and other programming tools offered by Loglan'82 permit to quickly create
a prototype of a program and to test it in a friendly environment.
The compiler gives a good diagnostic of the eventual errors. For the time
being we can not offer a code generator. Instead you can use the Loglan_to_C

The language is especially well suited for the
- reusability and
- proving the correctness.

There is a companion of Loglan'82 - the calculus of algorithmic logic, which
facilitates the work on specification of programs and data structures,
serves as the calculus for analysis of programs, will be used for the speci-
fication of the new version of the language.

Assertions and other tools of dynamic checking of correctness of an execution
of a program are easy to implement grace to the exception handling mechanism.

It would be more ambitious to develop a program assisting in static, "a priori"
verification of program w.r.t. a specification.

Please forward this information to your colleagues.

You can subscribe to the bulletin of Loglan'82.
        Send a mail to
        The only line of your mail should contain
                      SUBSCRIBE loglan82 <your_first_name> <your_name>
        Your E-mail address will be added automatically.


We would appreciate any news (comments, questions, suggestions, objections,...)
from you.

Please write to


                       Pau, le 14 Fevrier 1994


    A brief comparison of several object oriented languages

                    Languages -> S o C M S E A L
                                                i b + o m i d o
                                                m j + d a f a g
        Comparison u . u l f l
    of main features l P l l e a
                      | a a a t l n
                      | - s 3 a '
                      V 6 c l 8
                                                7 a k 2

      nesting of modules + + - - - - + +
      inheritance + + + + + + - +
          - multilevel - - - - - - - +
          - multiple inh. - - + - + + - + 1)
        inherit in other - - - - - - - + 2)
      static binding + + - + - - + +
            of identifiers

Classes & Objects + + + + + + - +

Coroutines + - - + - - - +

Processes - - - + - - + +
          alien call - - - - - - - + 3)
                  of methods

Signals & Exceptions - - - - - - + + 4)

safe deallocation i.e.
        no dangling - - - - - - - +
    type checking + + - - - - + +
    protection of private + - - + - - + +

        types as formal - - - ? - -+ -+ +
        overloading - - + + ? + + -
            of operators
        virtual methods + - + ? + + - +


In Loglan'82:
1) - multiple inheritance may be obtained from multi-level inheritance and
2) - it is possible to inherit a class in a procedure, a function, a process,
                                    a coroutine, a block,
3) - alien call is a truly object oriented protocol of executing a method of
        a callee process in cooperation between a calling and the callee processes,
4) - exceptions are handled with continuations and last will actions.

Post a followup to this message

Return to the comp.compilers page.
Search the comp.compilers archives again.