Ján Kollár

Abstract syntax driven language development: defining language semantics through aspects

The paper presents an approach for defining a computer language driven by a languages abstract syntax. The whole process of language specification including abstract syntax, concrete syntax and semantics definition is explained. Particular emphasis is put on language semantics definition and two approaches are introduced in detail -- via annotations and aspects. For this purpose, as the main example used throughout the paper, the DESK language has been selected. A simple approach to semantics definition through semantic methods in the language model is presented. The paper continues with more advanced semantics definition through aspects. As a proof of concept, a short description of the YAJCo experimental research parser generator is given.

Abstract syntax driven approach for language composition

Popularity of domain-specific languages brings the problem of language components reuse. It should be possible to use parts of different languages in development of new one to lower costs and also allow incremental development. This problem could be solved using the composition of languages. In this paper we discuss the view of language composition from the perspective of concepts composition, where the role of concrete syntax is lowered. We present examples of language composition based on the principles of object composition implemented using YAJCo parser generator, that allows to specify the language based on its abstract syntax.

A Task-driven Grammar Refactoring Algorithm

This paper presents our proposal and the implementation of an algorithm for automated refactoring of context-free grammars. Rather than operating under some domain-specific task, in our approach refactoring is perfomed on the basis of a refactoring task defined by its user. The algorithm and the corresponding refactoring system are called mARTINICA. mARTINICA is able to refactor grammars of arbitrary size and structural complexity. However, the computation time needed to perform a refactoring task with the desired outcome is highly dependent on the size of the grammar. Until now, we have successfully performed refactoring tasks on small and medium-size grammars of Pascal-like languages and parts of the Algol-60 programming language grammar. This paper also briefly introduces the reader to processes occurring in grammar refactoring, a method for describing desired properties that a refactored grammar should fulfill, and there is a discussion of the overall significance of grammar refactoring.

Genetic evolution of programs

We present evolutionary approach to program development based on absorption of genetic strings at different metalevels. Introducing the principles of software evolution as processes of semantical stability, expansion and contraction, we continue with an example illustrating how it is possible to integrate metalevel with base level and how this integrated computation works when driven by genetic string of codons, determining decisions for program construction and the result of constructed program execution. Next, we analyse the evolutionary circle at metalevel and we show that mentioned expansion and contraction is possible. The main contribution of the paper is that it breaks classic boundaries between models and programs because formal binding of metalevels and base level have been reached.

Role of Patterns in Automated Task-Driven Grammar Refactoring

Grammarware engineering, and grammar-dependent software development has received considerable attention in recent years. Despite of this fact, grammar refactoring as a significant cornerstone of grammarware engineering is still weakly understood and little practiced. In this paper, we address this issue by proposing universal algorithm for automated refactoring of context-free grammars called mARTINICA, and formal specification language for preserving knowledge of grammar engineers called pLERO. Significant advantage of mARTINICA with respect to other automated refactoring approaches is that it performs grammar refactoring on the bases of user-defined refactoring task, rather then operating under some fixed objective of refactoring process. In order to be able to understand unified refactoring process of mARTINICA this paper also provides brief insight in grammar refactoring operators, which in our approach provide universal refactoring transformations for specific context-free grammars. For preserving of knowledge considering refactoring process we propose formalism based on patterns which are well-proven method of knowledge preservation in variety of other domains, such as software architectures.

Towards Automated Program Abstraction and Language Enrichment

This paper focuses on the presentation of a method for automated raise of programming language abstraction level. The base concept for the approach is a code pattern -- recurring structure in program code. In contrast to design patterns it has a specific representation at a code level and thus can be parameterized and replaced by a new language element. In the article two algorithms for automated recognition of patterns in samples of programs are described and examined. The paper also presents an approach for language extension based on the found patterns. It is based on an interactive communication with the programming environment, where recognized patterns are suggested to a programmer and can be injected into the language in a form of new elements. Conducted experiments are evaluated in regard to the future perspective and contributions.

Towards machine mind evolution

We introduce the principles of symbolization and conceptualization of perceived reality. We show them as processes that are applicable inside of a computer mind. We derive those processes from principles of a human mind. We present process of higher order regular abstraction and state automata acceptance as possible machine reality realization mechanism. We present the algorithm for evolution of machine mind language. Verification of this algorithm is presented in functional language Haskell. On the output, we have obtained fine-grained parallel non-redundant structure. It is in super-combinator form and represents elements of a machine mind language. Count of elements applications highly exceeds the count of elements themselves. Instead of accumulating acquired information, they are dissolved in the language of a mind. Vice versa, the information can be reconstructed from this language. We show that non-redundancy of a machine language is the decisive criterion for restructuring the machine mind language in each moment of communication. It is like that, so we can achieve more powerful and abstract communication between humans and computers or between computers themselves.

Data-driven executable language model

Executable language model driven by data streams is proposed. At the same time, this model is language architecture developed from context-free grammar enriched with communication channels. Four types of formal communication channels and one type of informal communication channel were identified for functional languages, to provide systematic background for human-machine communication. Formal channel positions are determined by a grammar, not by a programmer. Data streams are approximately as concise as computer machine code but they are semantically equivalent to high-level programs. Using simple example of functional language we present the principle of functional language architecture construction and its driving by data stream. In particular, we show how the program is initially recorded, and how it can be repeatedly generated, either in original or in a modified version. Data streams radically decrease structural complexity of current programs, preserving their semantics, since they are not executed at low-level computer architecture but at high-level language architecture.

Haskell clone detection using pattern comparing algorithm

Detection of clones - repeating fragments in source code - is an important task for ensuring maintainability of software systems. This paper presents an algorithm for clone detection based on comparing parts of abstract syntax tree of programs and finding repeating patterns. The algorithm is implemented in the prototype tool that allows to detect clones in programs written in Haskell programming language. The main contribution is believed to be proposal and experimental verification of the new technique for identifying exact and syntactical clones in Haskell code.

Supercombinator set construction from a context-free representation of text

Grammars might be used for various other aspects, than just to represent a language. Grammar inference is a large field which main goal is the construction of grammars from various sources. Written text might be analysed indirectly with the use of such inferred grammars. Grammars acquired from processed text might grow into large structures as the inference process could be continuous. We present a method to decompose and store grammars into a non-redundant set of lambda calculus supercombinators. Grammars decomposition is based on their structure and each distinct element is stored only once in such a structure. We present a method that can create such a set from any context-free grammar. To prove this and to show the possible applications in the field of natural language processing we present a case study performed on samples from two books. Those samples are the entire Book of Genesis from The King James Bible and the first 24 chapters of War and peace by Tolstoy. We obtain context-free grammars with the Sequitur algorithm and then we process them with our method. The results show significant decline in the number of grammar elements in all cases.