Formal Language Definition Research Articles

Introducing Geometric Constraint Expressions Into Robot Constrained Motion Specification and Control

The problem of robotic task definition and execution was pioneered by Mason, who defined setpoint constraints where the position, velocity, and/or forces are expressed in one particular task frame for a 6-DOF robot. Later extensions generalized this approach to constraints in 1) multiple frames; 2) redundant robots; 3) other sensor spaces such as cameras; and 4) trajectory tracking. Our work extends tasks definition to 1) expressions of constraints, with a focus on expressions between geometric entities (distances and angles), in place of explicit set-point constraints; 2) a systematic composition of constraints; 3) runtime monitoring of all constraints (that allows for runtime sequencing of constraint sets via, for example, a Finite State Machine); and 4) formal task descriptions, that can be used by symbolic reasoners to plan and analyse tasks. This means that tasks are seen as ordered groups of constraints to be achieved by the robot’s motion controller, possibly with different set of geometric expressions to measure outputs, which are not controlled, but are relevant to assess the task evolution. Those monitored expressions may result in events that trigger switching to another ordered group of constraints to execute and monitor. For these task specifications, formal language definitions are introduced in the JSON-schema modeling language.

Pāṇini's Grammar and Modern Computation

Pāṇini's fourth (?) century BC Sanskrit grammar uses rewrite rules utilizing an explicit formal language defined through a semi-formal metalanguage. The grammar is generative, meaning that it is capable of expressing a potential infinity of well-formed Sanskrit sentences starting from a finite symbolic inventory. The grammar's operational rules involve extensive use of auxiliary markers, in the form of Sanskrit phonemes, to control grammatical derivations. Pāṇini's rules often utilize a generic context-sensitive format to identify terms used in replacement, modification or deletion operations. The context-sensitive rule format is itself defined using Pāṇini's more general method of auxiliary markers, the latter used to define many dozens of linguistic categories and rules controlling derivations of Sanskrit sentences through the manipulation of ‘non-terminal’ and ‘terminal’ symbols. This technique for controlling formal derivations was rediscovered by Emil Post in the 1920s and later shown by him to be capable of representing universal computation. The same implicit computational strength of Pāṇini's formalism follows as a consequence: while Pāṇini's Sanskrit grammar is computationally limited, the metalanguage through which his formalism is defined can be directly used to define any rule-based system by mimicking standard formal language definitions as an extension of the grammatical system proper. Pāṇini's formal achievement is historically distinctive, as derivations of grammatically correct, spoken Sanskrit, are designed for oral recitation, with the grammar itself constructed as an organic extension of the spoken object language. Pāṇini's formulation of what amounts to an orally realized symbolic calculus stands in contrast to the implicit inscriptional methods of contemporary formalisms, such as Gottlob Frege's appropriately named Begriffsschrift and the early computing paradigms of Post and Alan Turing. Nonetheless, contemporary views on the cognitive status of phonemic recognition and historical writing systems support the conjecture that, in spite of Pāṇini's rigorous oral formulation, construction of the grammar almost surely relied on alphabetic writing.

ATLAS Replica Management in Rucio: Replication Rules and Subscriptions

The ATLAS Distributed Data Management system stores more than 150PB of physics data across 120 sites globally. To cope with the anticipated ATLAS workload of the coming decade, Rucio, the next-generation data management system has been developed. Replica management, as one of the key aspects of the system, has to satisfy critical performance requirements in order to keep pace with the experiment's high rate of continual data generation. The challenge lies in meeting these performance objectives while still giving the system users and applications a powerful toolkit to control their data workflows. In this work we present the concept, design and implementation of the replica management in Rucio. We will specifically introduce the workflows behind replication rules, their formal language definition, weighting and site selection. Furthermore we will present the subscription component, which offers functionality for users to proclaim interest in data that has not been created yet. This contribution describes the concept and the architecture behind those components and will show the benefits made by this system.

K Semantics for Assembly Languages: A Case Study

Formal verification of embedded software systems often requires a low-level representation of the program under scrutiny. It is often the case that the verification tools rely on ad-hoc encodings of particular assembly language semantics. In this paper we use the K framework to formally define a MIPS-based assembly language. Our proposed definition is modular in the sense that it accommodates various organizations for the storage-related aspects of the semantics. We also present how to instantiate our K language definition on two main memory models, corresponding to different representations of the assembly code. Such a formal language definition could be directly used by the program verification tools.

Formal languages through web forms and regular expressions

We present a practical and up-to-date proposal to teach formal languages. It takes advantage of frequent use of regular-expressions to specify entry data forms in different contexts and, particularly, in three-layer web applications. Compared to more classical approaches our method improves significantly the acquainting of students with the immediate practical utility of the concepts involved in formal language definition. Students must develop code fragments based on JavaScript notation of regular-expressions. Accordingly, any web browser can be a suitable platform for the execution of solutions. The experience has proved to be effective and well-accepted by students and teachers.

Automatic Generation of Language-based Tools

Many tools can be automatically derived from formal language definitions, such as compilers/interpreters, editors, analyzers, visualizers/animators, etc. Some examples of language-based tools generated automatically by the LISA system are described in the paper. In addition the specification of an algorithm animator and program visualizer, Alma, generated from an extended LISA input-grammar is discussed; LISA principles and code are reused in Alma implementation.

Preface: Volume 65, Issue 3

ForewordThis is the second edition of the Workshop on Language Descriptions, Tools, and Applications (LDTA). Theme of this workshop is the description of (programming) languages and the development and/or generation of tools for these languages based on formal descriptions. The aim of this workshop is to bring together researchers from academia and industry interested in the formal definition of languages, and the use of these definitions for the derivation of tools and software applications (e.g., interactive transformation tools, software renovation tools, application generators). The contributions for this workshop are based on all kinds and styles of formal language definition including attribute grammars, algebraic approaches, action semantics, operational semantics, and denotational semantics. Many aspects of the definition of languages, and the derivation of tools and applications are independent of the actual formalism used. The workshop also welcomes contributions to compare formalisms or to discuss the benefits and drawbacks of specific formalisms.The LDTA 2002 program consists of 6 regular peer-reviewed papers, which were selected from 14 submissions, one invited talk by Charles Consel on “Domain-Specific Languages: What, Why, How”, and 4 invited tool demonstrations. The selected papers cover a broad range of themes like: applying rewriting strategies to build interpreters, program slicing based on XML, application of aspect oriented programming and XML, multi-lingual bibliography tooling, and incremental attribute evaluators. The tool demonstrations are concerned with presentations of the new ELAN environment, an environment for action semantics, the Grammar Deployment Kit (GDK), and the ELI system.This volume will be published as volume 65-3 in the series Electronic Notes in Theoretical Computer Science (ENTCS). This series is published electronically through the facilities of Elsevier Science B.V. and its auspices. The volumes in the ENTCS series can be accessed at the URL http://www.elsevier.nl/locate/entcsWe would like to thank the program committee members for their help in evaluating the papers and making a scientifically interesting selection. Furthermore, we would like to thank the ETAPS organizing committee for taking care of the local organization of our workshop. We are very pleased that these proceedings are published in the Electronic Notes in Theoretical Computer Science (ENTCS) by Elsevier, which increases the visibility of the LDTA workshop.Organizing CommitteeGorel Hedin(Lund Institute of Technology, Lund, Sweden)Marjan Mernik(University of Maribor, Maribor, Slovenia)Didier Parigot(INRIA, Sophia Antipolis, France)Program CommitteeMark van den Brand(CWI, Amsterdam, The Netherlands)Barrett R. Bryant(University of Alabama, Birmingham, USA)Katsuhiko Gondow(JAIST, Japan)Ralf Lämmel(Vrije Universiteit Amsterdam, The Netherlands)Jan Heering(CWI, Amsterdam, The Netherlands)Oege de Moor(Oxford University Computing Laboratory, Great Britain)Pierre-Etienne Moreau(INRIA/LORIA, Nancy, France)Peter D. Mosses(BRICS, Aarhus, Denmark)Joao Saraiva(University of Minho, Portugal)David Watt(University of Glasgow, Great Britain)

Abstract Syntax and Semantics of Visual Languages

The effective use of visual languages requires a precise understanding of their meaning. Moreover, it is impossible to prove properties of visual languages like soundness of transformation rules or correctness results without having a formal language definition. Although this sounds obvious, it is surprising that only little work has been done about the semantics of visual languages, and even worse, there is no general framework available for the semantics specification of different visual languages. We present such a framework that is based on a rather general notion of abstract visual syntax. This framework allows a logical as well as a denotational approach to visual semantics, and it facilitates the formal reasoning about visual languages and their properties. We illustrate the concepts of the proposed approach by defining abstract syntax and semantics for the visual languages VEX, Show and Tell and Euler circles. We demonstrate the semantics in action by proving a rule for visual reasoning with Euler circles and by showing the correctness of a Show and Tell program.

Constructing formal language definitions, can we manage? What can we learn from Modula-2 standardization?

In this paper, we try to capitalize on the experiences gained during the standardization process of the programming language Modula-2. The Modula-2 standard is almost unique in that it defines the complete language using a formal notation. We will not discuss the technical details here but instead try to learn from the managerial process that has led to the current standard for Modula-2. Currently, standardization discussions are underway for the Java language and system and for UML (Unified Modeling Language). It is hoped that the experiences described in this paper can contribute to a controlled process for further formalization of programming languages.

Automatic implementation of programming languages using object oriented approach

We present our implementation of a tool for automatic language implementation. From formal language definition, Language Implementation System based on Attribute Grammars (LISA) produces an interpreter or a compiler for the defined language. We describe the development of the tool. It is one of the first such tools developed using the object oriented technology and is coded in the C+ + programming language.

LISA

In the paper a tool for automatic language implementation is described. From formal language definition LISA 1 produces efficient interpreters or compilers in C++. For lexical and syntax analysis well known formal methods: regular expressions and BNF are used. Semantics of the defined language is described with attribute grammars. LISA is a part of the ongoing effort to build an environment that supports experimentation in automatic language implementation for educational and industrial purposes.

A meta-environment for generating programming environments

Over the last decade, considerable progress has been made in solving the problems of automatic generation of programming/development environments, given a formal definition of some programming or specification language. In most cases, research has focused on the functionality and efficiency of the generated environments, and, of course, these aspects will ultimately determine the acceptance of environment generators. However, only marginal attention has been paid to the development process of formal language definitions itself. Assuming that the quality of automatically generated environments will be satisfactory within a few years, the development costs of formal language definitions will then become the next limiting factor determining ultimate success and acceptance of environment generators. In this paper we describe the design and implementation of a meta-environment (a development environment for formal language definitions) based on the formalism ASF + SDF. This meta-environment is currently being implemented as part of the Centaur system and is, at least partly, obtained by applying environment generation techniques to the language definition formalism itself. A central problem is providing fully interactive editing of modular language definitions such that modifications made to the language definition during editing can be translated immediately to modifications in the programming environment generated from the original language definition. Therefore, some of the issues addressed are the treatment of formalisms with user-definable syntax and incremental program generation techniques.

Design and structure of a semantics-based programming environment

We present, from a user's point of view, an overview of the PSG system, a generator for semantics-based programming environments. The PSG system generates an interactive, language-specific environment from a complete formal language definition. Both the syntax, as well as the static and dynamic semantics of the language are specified in the definition. The definition is used to generate a context-sensitive hybrid editor and an interactive interpreter with debugging facilities. The paper describes the structure and the main features of PSG-generated environments, as well as the design decisions which led to the development of the PSG environment.

A view of formal semantics

When writing a programming lagnuage standard, one must achieve comprehensibility and correctness in the face of complexity. Achieving both with informal methods requires an almost nonexistent combination of technical and literary skills. Because informal methods are inadequate, resort is often made to formal ones. This report outlines the major styles of formal semantic definitions, describes several specific definition methods, and enumerates various attempts to produce formal semantic definitions of real standardised languages. Until definition techniques improve, we recommend that standards contain both complete formal and complete informal language definitions, whenever feasible.

A generator for language-specific debugging systems

We present a system which generates interactive high-level debugging systems from formal language definitions. The language definer has to specify a denotational semantics augmented with a formal description of the language specific debugging facilities. The generated debugger offers the traditional features such as tracing programs, setting breakpoints, displaying variables etc; interaction with the user is always on language level rather than on machine level. The concept has been implemented as part of the PSG-Programming System Generator, and has successfully been used to generate debuggers for Pascal and Modula-2. The core of the implementation consists of an interpreter for a functional language, which has been extended with the language-independent mechanisms needed in order to allow interaction with the user during program execution.

The PSG system: from formal language definitions to interactive programming environments

The PSG programming system generator developed at the Technical University of Darmstadt produces interactive, language-specific programming environments from formal language definitions. All language-dependent parts of the environment are generated from an entirely nonprocedural specification of the language's syntax, context conditions, and dynamic semantics. The generated environment consists of a language-based editor, supporting systematic program development by named program fragments, an interpreter, and a fragment library system. The major component of the environment is a full-screen editor, which allows both structure and text editing. In structure mode the editor guarantees prevention of both syntactic and semantic errors, whereas in textual mode it guarantees their immediate recognition. PSG editors employ a novel algorithm for incremental semantic analysis which is based on unification. The algorithm will immediately detect semantic errors even in incomplete program fragments. The dynamic semantics of the language are defined in denotational style using a functional language based on the lambda calculus. Program fragments are compiled to terms of the functional language which are executed by an interpreter. The PSG generator has been used to produce environments for Pascal, ALGOL 60, MODULA-2, and the formal language definition language itself.

Specifications and an implementation of the type‐ambiguity problem in pascal

AbstractCertain ambiguities in the definition of Pascal imperil the portability of Pascal programs. Specifications and an implementation of alternative interpretations are presented. Context‐free grammars augmented with guarded commands are demonstrated as a notation for specifying the static context‐sensitive constraints of programming languages.Most of the advantages of context‐free grammars are preserved and yet the potential range of the syntactic definition component has been extended to encompass all static constraints. Context‐sensitive syntax typically tends to either clutter the semantic definition component or (as with type equivalence in Pascal) result in undesirable implementor‐dependent decisions.An implementation of a CFG‐based parser that automatically checks for the defined context‐sensitive constraints is also described. In addition stepwise abstraction is introduced as a practical technique for communicating formal programming language definitions.

The PSG - Programming System Generator

The programming system generator developed at the Technical University of Darmstadt generates sophisticated interactive programming environments from formal language definitions. From a formal, entirely non-procedural definition of the language's syntax, context conditions and denotational semantics, it produces a hybrid editor, an interpreter and a library system. The editor allows both structure editing and text editing, guaranteeing immediate recognition of syntactic and semantic errors. The generator has been used to generate environments for PASCAL, MODULA-2 and the formal language definition language itself. A brief description of the generated environments and the definition language is given, and our experiences with formal language definitions are discussed from the language definer's point of view as well as from the programmer's point of view using the generated environments.

Formal Semantics and Abstract Properties of String Pattern Operations and Extended Formal Language Description Mechanisms

Two formal models of string patterns are introduced. One is based on an idealization of patterns as systems of set equations, and the other is based on an abstract procedure model of a pattern. Each model is then shown to yield certain insights and in particular is used to explore an operation not commonly considered in conjunction with string patterns. These two new pattern operations are (set) complementation and reversal of cursor direction. Each is shown to have a dramatic effect on both the expressive power and the complexity of patterns in which they are included. These pattern operations may in turn be regarded as extensions to the usual formal language definition mechanisms (i.e., grammars and equation systems), and our results interpreted in terms of formal language description.