Teodor Rus

Transformation-Based Reactive Systems Development

Crucial notions on which Computer Science is based originated in Ramon Llull (a 13th-century philosopher from Majorca). Here we explore some of his original insights --and his plausible inspiration sources-and how these ideas have been available to us by way of Leibniz (and others). 1 I n t r o d u c t i o n Something unusual has happened to Ramon Llull (Raimundus Lullus, 12321316), the franciscan thinker from Majorca. He has been at the same time derided and hailed as a philosopher. He has been instrumental in creating our foundational insights as computer scientists and logicians, yet he occupies a very minor place in the histories of Philosophy, Mathematics or Logic. He was one of the first philosophers to claim a logical basis for religious belief yet he has been considered a source of alchemy, cabbalistics and mysticism. He is considered a conceited eccentric fool and jus t read Martin Gardners 1958 piece--a maze of confused thinking, but such indictment hardly squares with the undeniable fact that he had foresights which anticipated developments 700 years in the future. So, what is the t ruth? and what is the man? That Llull is really a marginal sidepiece in the history of Western Philosophy is clear--as it was to him. And, because he resented it, he innovated, and tried to convince the Parisian intellectuals that his innovative ideas had meri t to no avail. He was not understood at his first Sorbonne appearance in 1289. His combinatorics were definitely not the method to use for logical analysis (causal chaining was). When he came back in 1309-11 with a more accessible system he was greeted with a flurry of sympathy rather than real acceptation. Some found in him a firm advocate of basing faith solely on logic, and all understanding on reason (against the revelationists and the mystically-inclined). But after his death the sympathy faded out, a victim of the Inquisition and the dominicanfranciscan 14th-century struggle. In an ironic twist, Llull, who had always put logic before faith, and had done this by propounding innovative ideas, became a thinker derided by the first science pioneers (Bacon or Descartes, who had a lot to thank him for), while he became the hero of alchemists, cab balists and general mystics (thanks to being attributed authorship of esoteric apocrypha). The usual charge today (for Gardner, as it was for Descartes), that his thinking was actually confused, is not the whole reason for the misrepresentation of Llulls thought: confusion between religious faith, ethical motives, apologetics

Algebraic processing of programming languages

Abstract Current methodology for compiler construction evolved in small increments over a long period of time. Its heritage is machine-dependent and derived from sequential Von Neumann machines. There is a growing emphasis on increasingly abstract paradigms for new programming languages. At the same time todays high performance distributed/parallel computing facilities depart from Von Neumann machines and provide a much more intricate execution environment. Therefore current methodology is being stretched beyond its intrinsic capacity in order to accommodate these two accelerating trends. We develop an alternative compiler construction methodology whose fundamental principles are: 1. (1) decomposition of programming languages into simpler components 2. (2) development of machine independent specification and implementation tools for each language component 3. (3) mathematical integration of language component processing algorithms into an algebraic compiler. This allows the specification and implementation of provably correct (commercial) compilers. This paper is a tutorial dedicated to presenting the infrastructure of an algebraic compiler in a do-it-yourself manner.

Algebraic tools for language processing

Abstract A language space provides a unified framework to deal with the properties of language constructs by associating them with their specification rules. The concrete syntax is represented by segments of the language space. The semantics is given by derived operations of the algebras where these constructs are interpreted by the processing tools operating on the language space. We examine in this paper only processing tools that collect syntactic information over the language space. Tools involved in semantics processing such as translators and interpreters are also integrated in the language space but are not discussed here.

An algebraic model for programming languages

Abstract The language of universal algebras is used as a model for programming language specification. BNF rules are employed for specifying the signature of the language algebra instead of the context free syntax. The algorithm for program evaluation is inductively defined by the following universal algebraic construction: Any function defined on the generators of a free algebra taking values in the carrier of another similar algebra can be uniquely extended to a homomorphism between the two algebras. Any conventional programming language can be specified by a finite set of BNF rules and its algebra of symbols is generated by a finite set of generator classes. Thus any function defined on the finite set of generators offers an algebraic mechanism for a universal algorithm for source language program evaluation.

CONTEXT-FREE ALGEBRAS

Abstract Virtually all algebraic approaches to formal language theory involve an intervening notion of machine, and it is the machine theory which is treated algebraically. The present article details a direct algebraic treatment of context-free languages by means of the recently-developed theory of hetrogeneous algebras. It is seen that many of the classic notions for context-free grammars have highly suggestive algebraic equivalents, and, further, that the algebraic treatment suggests new, fruitful notions.

Application Driven Software Development

Even in its very infancy computer technology has been seen as a collection of tools destined to solve problems of a given application domain (AD) 1. The problem solving process using computers is (and has been) carried out within the computer environment and requires the AD experts to formalize their problems in computer terms. The effort put forth so far toward making this process easier for AD experts has generated a rich and well-defined information technology (IT) domain, populated by computer artifacts such as programming languages and program generation tools. Successes of this approach to problem-solving led to the development of current computer technology whose complexity overwhelms computer experts themselves. Nevertheless, the usage of current IT for problem solving still requires AD experts to manipulate IT domain concepts and tools rather than AD concepts and tools. To further help this process, more and more complex IT tools are generated thus increasing software complexity to a level where only with formidable difficulties can AD experts manage to develop their application systems. Among the side effects of this situation are the lack of efficiency in application system development, poor performance in computer utilization, and even threat to the future evolution of computer technology itself. Our conjecture is that in order to break this vicious circle we need to rethink the problem solving process. We need to abandon the requirement that AD experts manipulate computer terms and to allow them to manipulate AD specific terms using AD specific languages. The recent advances created by computing research makes it feasible to move the problem solving process from the IT domain into the AD domain.

Generating Model Checkers from Algebraic Specifications

AbstractThere is a great deal of research aimed toward the development of temporal logics and model checking algorithms which can be used to verify properties of systems. In this paper, we present a methodology and supporting tools which allow researchers and practitioners to automatically generate model checking algorithms for temporal logics from algebraic specifications. These tools are extensions of algebraic compiler generation tools and are used to specify model checkers as mappings of the form

An Algebraic Language Processing Environment

{\mathcal{M}}{\mathcal{C}}:L_s \to L_t