Fundamental research: Różnice pomiędzy wersjami
(→How to determine the direct superclass?) |
(→How to determine the direct superclass?) |
||
| Linia 23: | Linia 23: | ||
This question is a fundamental one for the definition of semantics. Consider the following '''example''' written in Java. | This question is a fundamental one for the definition of semantics. Consider the following '''example''' written in Java. | ||
| − | {|class="wikitable" | + | <small>{|class="wikitable" |
| − | + | ||
:'''class''' A '''extends''' B { // ''this can be class B or A.B i.e. class B contained in class A'' | :'''class''' A '''extends''' B { // ''this can be class B or A.B i.e. class B contained in class A'' | ||
::'''class''' C '''extends''' D { // ''this can be class B.D or E.D'' | ::'''class''' C '''extends''' D { // ''this can be class B.D or E.D'' | ||
| Linia 41: | Linia 40: | ||
::class D {} | ::class D {} | ||
:} // end E | :} // end E | ||
| − | |||
|} | |} | ||
| + | </small> | ||
* Which of possible 64 assignments is correct? See that a real program may contain hundreds of classes. | * Which of possible 64 assignments is correct? See that a real program may contain hundreds of classes. | ||
* How to diagnose incorrect programs? For there are innocently looking programs that do not posses a correct solution. See [{}] for an example. | * How to diagnose incorrect programs? For there are innocently looking programs that do not posses a correct solution. See [{}] for an example. | ||
Wersja z 15:37, 22 gru 2014
Work on programming language Loglan'82 and its compiler was accompanied by vivid discussion and fundamental research. On these pages we shall report some of results as well as an attempt to define an axiomatic semantics of Loglan'82.
Spis treści
- 1 Problems and reports
- 1.1 Safe dealocation of objects
- 1.2 How to determine the direct superclass?
- 1.3 Static binding
- 1.4 Is it possible to keep the Dijkstra's mechanism of Display Vector ?
- 1.5 Coroutines
- 1.6 Alien call
- 1.7 Connecting virtual machines into a virtual multiprocessor
- 1.8 Mathematical model of concurrent computations
- 2 Part II Axiomatic definitions of sublanguages of Loglan'82
Problems and reports
Safe dealocation of objects
The problem is how to dealocate unused objects in a safe way?
Some programming languages (Pascal, C++) allow to use instruction delete(x). Other languages (Java, Python) forbid such instructions and relay on the garbage collection gc(). In this way the Java's object management system gains safety but becomes much less controlled. It may happen that another danger named memory leakage will appear. We are happy to present you the object managing system invented by Antoni Kreczmar. In his system one can use the atomic instruction kill(x) in order to dealocate an object being the value of the variable x.
The axiom of kill is here
| [math] \underbrace{((x= y = ... =x_n) \wedge x \neq \textbf{none})}_{precondition}\Rightarrow \underbrace{[kill(y)]}_{\mathrm{statement}}\underbrace{(x= y = ... =x_n = \textbf{none})}_{postcondition} [/math] |
It tells that all references to an object x obtain the value none. No dangling reference error appears. The cost of the kill operation is fixed, independent of how many variables share the object x as common value. For more information see
- The paper by G. Cioni \& A. Kreczmar Programmed dealocation without dangling reference of 1984 yr.
- Report safe dealocation of objects.
Note, no other programming language enjoys the property of safe dealocation.
How to determine the direct superclass?
One program may contain many classes of the same name. This is true of any programming language that allow to nest one class in another. Now, let us consider the inheritance relation between classes.
Suppose that a class B inherits (i.e. extends) the class A. Which of possibly many classes A we should identify as a base class?
This question is a fundamental one for the definition of semantics. Consider the following example written in Java. {|class="wikitable"
- class A extends B { // this can be class B or A.B i.e. class B contained in class A
- class C extends D { // this can be class B.D or E.D
- class F extends G {} // this can be class A.E.G or E.G
- } // end C
- class E {
- class G {}
- } // end E
- class B extends E {} // this can be class E or A.E
- class C extends D { // this can be class B.D or E.D
- } // end A
- class B {
- class D extends E {} // this can be class E or A.E
- } // end B
- class E {
- class G extends B {} // this can be class B or A.B
- class D {}
- } // end E
|}
- Which of possible 64 assignments is correct? See that a real program may contain hundreds of classes.
- How to diagnose incorrect programs? For there are innocently looking programs that do not posses a correct solution. See [{}] for an example.
- Is there any efficient algorithm to determine direct superclasses?
There are 4 languages which admit both nesting of modules (i.e. block structure ) and inheritance:
- Simula67
- Loglan'82
- BETA
- Java
Each language gives another definition of the base class. We shall mention ...
- This paper solves the problem of determination of direct superclass in Java and other languages. We give a short and complete specification of the problem - to be confronted with somewhat fuzzy and dispersed description of the problem in Java Language Specification. We are presenting a non-deterministic algorithm A and prove that the algorithm correctly solves the problem and moreover that the algorithm is complete, i.e. if it finds that an instance of a problem has no solution then it is really so. Media:C3149.pdf This algorithm after some simplifications applies as well to Loglan programs and even to Simula67 programs.
- A practical deterministic algorithm for the same problem. Media:pracaFI22.10.2007.pdf
- A discussion of methodological issues taken in a paper by A. Igarashi and B. Pierce. Media:IPET-09-2Nov.pdf
Static binding
Let a be an applicative occurence of an identifier i. (Applicative means in an instruction.)
Where to find a proper declaration of the idenfifier i? The problem known for block structured programming languages is far more complicated in the languages that admit not only nesting of modules but also inheritance.
For Loglan'82 a solution was find by Danuta Szczepańska (not published, validated through compiler).
A general case is considered in ...
Is it possible to keep the Dijkstra's mechanism of Display Vector ?
The problem arises when a programming language allows to nest declarations of classes as well as their extensions by inheritance. Now, if one defines a constructor of a class as a concatenation of constructors of inherited classes (it is so called rule of concatenation), then is it possible to define Dijkstra's Display Vector once for all instructions of the consolidated (by concatenation) constructor?
After some monthsof discusions the creators of Loglan programming language came to a solution see
Some time later Hans Langmaack found that the proposed semantic can not be called the correct static semantic.
Two papers appeared that led to a satisfactory solution
The experience gained through this research enabled later to solve the problems of determining drect base class in Java.
Coroutines
How to define the meaning of coroutine operations? in a way free of inconsistency?
Alien call
This is a protocol invented by Bolek Ciesielski in 1988(!) for communication and synchronisation among active objects of process modules. For the first time implemented in Loglan'82 programming language, it remains still little known for programmers.
- Media:Bolek1988.pdf - an original presentation of alien call protocol
- Media:AlienCall.pdf -
Connecting virtual machines into a virtual multiprocessor
The virtual Loglan processors VLP can be connected through network thus forming a virtual multiprocessor computer. Each VLP obtains a unique node number.
Some screenshots may be helpful.
Mathematical model of concurrent computations
During the work on Loglan project we conceived and published a model explaining how the execution of concurrent programs look like. The model was named Max model of concurrency. Later it was known under the name of true concurrency model.
Part II Axiomatic definitions of sublanguages of Loglan'82
Here we shall present an increasing sequence of sublanguages [math]\mathcal{L}_0\subset\mathcal{L}_1\subset\mathcal{L}_2\subset \mathcal{L}_3\subset\mathcal{L}_4\subset \dots[/math]Loglan'82. For each language [math]\mathcal{L}_i[/math] we shall present its grammar and some axioms and inference rules that define its semantics.
Program
Program in Loglan'82 has the following structure
| definiendum | definiens |
|---|---|
| program | program <name>;
begin
end |
where name is any identifier, i.e. a finite sequence of letters and digits beginning with a letter.
The declarations and instructions are finite sequences of declarations and instructions respectively, empty squence included.
This allow us to define the first sublanguage [math]\mathcal{L}_0[/math] of Loglan'82.
[math]\mathcal{L}_0 \stackrel{df}{=}\{p\in \mathcal{A}^*: p=\textbf{program}\ \textit{id}; \textbf{begin end} \}[/math]
Programs of the language [math]\mathcal{L}_0[/math] are empty programs, they posses just a name. Their list of instructions as well as list of declarations are empty. The effect of execution of such program is do nothing.
Now we shall define a new language [math]\mathcal{L}_{0.1}[/math]. First, we say that any expression of the form:
writeln;
write(integer);
write("here your text");
is an output instruction.
[math]\mathcal{L}_{0.1} \stackrel{df}{=}\{p\in \mathcal{A}^*: p=\textbf{program} \textit{ id}; \textbf{begin} \lt\textit{output instructions}\gt \textbf{end} \}[/math]
| program print; begin
end |
Declarations of variables. Assignment instructions
Example
program P2 ;
- var x,y: integer;
begin
- y:=74;
- x:= y+ 8;
end
Grammar
Context free grammar
Well formed expressions
Axiom
[math]\{x:=\tau\}( \alpha ) \Leftrightarrow \alpha(x/\tau)[/math]
