The Syntax and Parsing of the Two-Dimensional Languages

This report introduces the idea of expressing programming concepts in a two-dimensional (pictorial) language. A specific two-dimensional language, Show and Tell, is briefly presented and formalisms that might be used to define the syntax of such a language are discussed. An abstraction of Show and Tell is defined, and a specific grammar formalism is presented for defining the syntax of this abstraction. The mechanisms found in expert systems are shown to be sufficient to parse languages defined by this formalism

Extending the DEVS Formalism with Initialization Information

DEVS is a popular formalism to model system behaviour using a discrete-event abstraction. The main advantages of DEVS are its rigourous and precise specification, as well as its support for modular, hierarchical construction of models. DEVS frequently serves as a simulation "assembly language" to which models in other formalisms are translated, either giving meaning to new (domain-specific) languages, or reproducing semantics of existing languages. Despite this rigourous definition of its syntax and semantics, initialization of DEVS models is left unspecified in both the Classic and Parallel DEVS formalism definition. In this paper, we extend the DEVS formalism by including an initial total state. Extensions to syntax as well as denotational (closure under coupling) and operational semantics (abstract simulator) are presented. The extension is applicable to both main variants of the DEVS formalism. Our extension is such that it adds to, but does not alter the original specification. All changes are illustrated by means of a traffic light example

Dimensional Confluence Algebra of Information Space Modulo Quotient Abstraction Relations in Automated Problem Solving Paradigm

Confluence in abstract parallel category systems is established for net class-rewriting in iterative closed multilevel quotient graph structures with uncountable node arities by multi-dimensional transducer operations in topological metrics defined by alphabetically abstracting net block homomorphism. We obtain minimum prerequisites for the comprehensive connector pairs in a multitude dimensional rewriting closure generating confluence in Participatory algebra for different horizontal and vertical level projections modulo abstraction relations constituting formal semantics for confluence in information space. Participatory algebra with formal automata syntax in its entirety representing automated problem solving paradigm generates rich variety of multitude confluence harmonizers under each fundamental abstraction relation set, horizontal structure mapping and vertical process iteration cardinality.Comment: The current work is an application as a continuation for my previous works in arXiv:1305.5637 and arXiv:1308.5321 using the key definitions of them sustaining consistency, consequently references being minimized. Readers are strongly advised to resort to the mentioned previous works for preliminaries. arXiv admin note: text overlap with arXiv:1408.137

A Model-Driven Engineering Technique for Developing Composite Content Applications

Composite Content Applications (CCA) are cross-functional process solutions built on top of Enterprise Content Management systems assembled from pre-built components. Considering the complexity of CCAs, their analysis and development need higher level of abstraction. Model-driven engineering techniques covering the use of Domain-specific Modeling Languages (DSMLs), can provide the abstraction in question by moving software development from code to models which may increase productivity and reduce development costs. Hence, in this paper, we present MDD4CCA, a DSML for developing CCAs. The DSML presents an abstract syntax, a concrete syntax, and an operational semantics, including model-to-model and model-to-code transformations for CCA implementations. Use of the proposed language is evaluated within an industrial case study

A dependent nominal type theory

Nominal abstract syntax is an approach to representing names and binding pioneered by Gabbay and Pitts. So far nominal techniques have mostly been studied using classical logic or model theory, not type theory. Nominal extensions to simple, dependent and ML-like polymorphic languages have been studied, but decidability and normalization results have only been established for simple nominal type theories. We present a LF-style dependent type theory extended with name-abstraction types, prove soundness and decidability of beta-eta-equivalence checking, discuss adequacy and canonical forms via an example, and discuss extensions such as dependently-typed recursion and induction principles

Proofs for free - parametricity for dependent types

Reynolds' abstraction theorem shows how a typing judgement in System F can be translated into a relational statement (in second order predicate logic) about inhabitants of the type. We obtain a similar result for pure type systems: for any PTS used as a programming language, there is a PTS that can be used as a logic for parametricity. Types in the source PTS are translated to relations (expressed as types) in the target. Similarly, values of a given type are translated to proofs that the values satisfy the relational interpretation. We extend the result to inductive families. We also show that the assumption that every term satisfies the parametricity condition generated by its type is consistent with the generated logic