Further research in the area of the before mentioned Story-Telling systems [039] is preferable. If there exist related works or such would appear later, which are currently under research, I will stimulate an exchange, if this could be profitable.

Altogether, there are only a few attempts in the area of pure natural-language programming what is in our opinion to be led back mainly on the fact that at the time of the development of such systems technical developments, which are inalienable for a natural-language programming system, for example efficient parsing of natural language, semantic data formats as well as sufficient computing and storage capacities were not yet available.

Discussion

Problems with natural-language programming could emerge from the fact that in the natural language there are often different ways to express the same, for example „Write a string.“ or „Display a string.“. However, the number of these semantically equivalent expressions is strongly limited and can be grasped. Besides, natural-language expressions are often equivocal, however, this can be solved by further inquiries of the system like „With the word „it“, do you mean the set or the string?“.

Formal notation is sometimes preferred to linguistic description, for example in mathematics. Hence, a natural-language computer language should additionally support formal notation, so that the optimal program technology is always available to the user, so that he himself can decide, when he would like to use formal notation and when not.

Conclusion

Finally the following can be said in the opinion of the author: Object-Oriented Languages have already reached the peak of what is possible with this program paradigm. They are the result of a long way which has begun with assembler languages and has led to programming languages, which more and more got closer to human thinking. One should suppose that this development continues in the future. Natural-language programming could play a crucial role here. However, it will be at least of interest for further research.

Pegasus will be the first theoretically founded and practically applicable system of this kind, therefore we hope to perceptibly enlarge the scientific knowledge in the area of software technology and computer languages, but also in affected areas, for example computer linguistics.

The technology

Pegasus reads a natural-language text and generates a working program out of it, which implements the ideas contained in the text.

Architecture

The following diagram shows the architecture of Pegasus in a metaphoric sense.

Resolving of idea language expressions

Pegasus reads an input sentence and generates an expression in the idea language that is equivalent to the input sentence. The example „If the first element of the second row of the matrix is smaller than 3 then write "I can understand you!" would be equivalent, for example, to the following expression in the idea language:

(
   (
      ((be, action), normal mode, present tense, predicate),
      ((element, entity), (first, positive, property),
         ((row, entity), (second, positive, property),
            ((matrix, entity), single, entity reference,
               reference, normal phrase, phrase),
            single, entity reference, reference, normal phrase, phrase),
         single, entity reference, reference, normal phrase, phrase, subject),
      (smallness, comparative, property),
      ((three, entity), single, entity reference, reference,
         comparation phrase, phrase, object),
   statement clause, clause, first),
   (
      ((writing, action), normal mode, present tense, predicate),
      (direct personal reference, reference entity, subject),
      (("I can understand you!", character string symbol),
         symbol phrase, phrase, object),
   command clause, clause, second),
condition sentence, sentence)

The necessary lexical knowledge would be stored in a dictionary that contains all grammatical forms of words, as well as the allocation of the idea for the respective words of the supported languages. An entry could look like this:

After an input sentence is expressed in the idea language, Pegasus tries to determine the meaning of the sentence. An expression of the idea language would be resolved gradually from the outside inwards and compared to the meanings stored in the internal library. The example sentence would match, for example, the following entry in the library:

Here the instructions are stored, which cause exactly the intended behavior of a causal connection in a corresponding Java program, namely the if-then instruction.

With the help of the short-term memory, a queue which internally stores the last seven used entities, references like „the number” or "he" would be resolved.

Generation of the output program

Afterwards, the output program would be generated out of the resolved meanings in the library. For the short example program:

Take the matrix ([2, 2, 1], [1, 4, 3]).
Print it.
New line.
If the first element of the second row of the matrix is smaller than 3 then write "I can understand you!".

this will look as follows:

// Take the matrix ([2, 2, 1], [1, 4, 3]).
long[][] matrix74 = new long[2][3];
matrix74[0] = new long[]{2, 2, 1};
matrix74[1] = new long[]{1, 4, 3};

// Print it.
System.out.print("(");
for (int i7 = 0; i7 <= 1; i7++)
{
   System.out.print("[");
   for (int i8 = 0; i8 <= 2; i8++)
   {
      System.out.print(matrix74[i7][i8]);
      if (i8 < 2) System.out.print(", ");
   }  
   System.out.print("]");
   if (i7 < 1) System.out.print(", ");
}
System.out.print(")");

// New line.
System.out.println("");

// If the first element of the second row of the matrix is
// smaller than 3 then write "I can understand you!".
if (matrix74[1][0] < 3)
   System.out.println("I can understand you!");

Pegasus could now express the example also in German, by mapping the corresponding expression in the idea language by means of the German grammar to the syntactically correct sentence:

Wenn das erste Element der zweiten Zeile der Matrix kleiner als drei ist, dann schreibe „I can understand you!“.

Related works

Since the beginnings of computer science, there were computer languages which made use of natural language to a very large extent. However, these are no natural-language computer languages in the real sense because they are not based on a subset of the natural language, i.e. on a limited, but correct syntax and on a limited, but correct lexicon, but represent merely a natural-language supplement to formal computer languages. COBOL, FORTRAN and BASIC belong among others to these natural-language supplemented computer languages, of newer date are KlarDeutsch and AppleScript [010]. KlarDeutsch is a commercial program language supplemented with natural-language, which is used in machine control. AppleScript is a scripting language for writing simple programs for the Mac OS. In former versions AppleScript was available even in several languages. Natural Java [045] is a language, which can generate Java code with the help of natural language. However, the use of the natural language is limited to a pure mapping of the Java structure, for example with orders like "I would like to create a public method that is named XYZ ...".

Since the eighties there were also attempts of purely natural-language programming languages: The language NLC [054, 006], which allows programming in English natural-language in the restricted domain of matrix operations, is the first of these attempts. A newer interesting attempt is the Metafor-Prototype [039], that considers a program as a story to be told in style of Story-Telling systems [034] with sentences like „Pacman is a character who loves to run through a maze and eat dots.“. Beside these scientific projects there is also an initiative of private individuals: „Osmosian“ [049].

Pegasus transcends this by integrating all features of the mentioned systems:

中文

English

Русский