Informatica

We consider a generalization of heterogeneous meta-programs by (1) introducing an extra level of abstraction within the meta-program structure, and (2) meta-program transformations. We define basic terms, formalize transformation tasks, consider properties of meta-program transformations and rules to manage complexity through the following transformation processes: (1) reverse transformation, when a correct one-stage meta-program M¹ is transformed into the equivalent two-stage meta-meta-program M²; (2) two-stage forward transformations, when M² is transformed into a set of meta-programs, and each meta-program is transformed into a set of target programs. The results are as follows: (a) formalization of the transformation processes within the heterogeneous meta-programming paradigm; (b) introduction and approval of equivalent transformations of meta-programs into meta-meta-programs and vice versa; (c) introduction of metrics to evaluate complexity of meta-specifications. The results are approved by examples, theoretical reasoning and experiments.

The genetic information in cells is stored in DNA sequences, represented by a string of four letters, each corresponding to a definite type of nucleotides. Genomic DNA sequences are very abundant in periodic patterns, which play important biological roles. The complexity of genetic sequences can be estimated using the information-theoretic methods. Low complexity regions are of particular interest to genome researchers, because they indicate to sequence repeats and patterns. In this paper, the complexity of genetic sequences is estimated using Shannon entropy, Rényi entropy and relative Kolmogorov complexity. The structural complexity based on periodicities is analyzed using the autocorrelation function and time delayed mutual information. As a case study, we analyze human 22nd chromosome and identify 3 and 49 bp periodicities.

We propose a layered Soft IP Customisation (SIPC) model for specifying and implementing system‐level soft IP design processes such as wrapping and customisation. The SIPC model has three layers: (1) Specification Layer for specification of a customisation process using UML class diagrams, (2) Generalisation Layer for representation of a customisation process using the metaprogramming techniques, and (3) Generation Layer for generation of the customised soft IP instances from metaspecifications. UML allows us to specify customisation of soft IPs at a high level of abstraction. Metaprogramming allows us to manage variability in a domain, develop generic domain components, and describe generation of customised component instances. The usage of the SIPC model eases and accelerates reuse, adaptation and integration of the pre‐designed soft IPs into new hardware designs.

We discuss the application of heterogeneous metaprogramming (MPG) for the interface‐based design, which deals with the synthesis of the communication interfaces between Intellectual Property components (IPs). Heterogeneous MPG is based on the simultaneous usage of a domain language for describing domain functionality and a metalanguage for developing generic components and program generators. We present a design framework based on the MPG techniques. The novelty of our approach is that we apply the concept of heterogeneous MPG for the automatic generation of IP wrappers for communication between the third‐party soft IPs systematically. We present a case study for the synthesis of the communication interfaces using a FIFO protocol.

We present an analysis of the separation of concerns in multi-language design and multi-language specifications. The basis for our analysis is the paradigm of the multi-dimensional separation of concerns, which claims that multiple dimensions of concerns in a design should be implemented independently. Multi-language specifications are specifications where different concerns of a design are implemented using separate languages as follows. (1) Target language(s) implement domain functionality. (2) External (or scripting, meta-) language(s) implement generalisation of the repetitive design features, introduce variations, and integrate components into a design. We present case studies and experimental results for the application of the multi-language specifications in hardware design.

In this paper, we analyze the abstractions used for developing component-based domain generators. These include programming paradigms, programming languages, component models, and generator architecture models. On the basis of the analysis, we present a unified relationship model between the domain content, technological factors (structuring, composition, and generalization), and domain architecture. We argue that this model is manifested in the known software generator models, too.

In this paper we suggest a three-language (3L) paradigm for building the program generator models. The basis of the paradigm is a relationship model of the specification, scripting and target languages. It is not necessary that all three languages would be the separate ones. We consider some internal relationship (roles) between the capabilities of a given language for specifying, scripting (gluing) and describing the domain functionality. We also assume that a target language is basic. We introduce domain architecture (functionality) with the generic components usually composed using the scripting and target languages. The specification language is for describing user's needs for the domain functionality to be extracted from the system. We present the framework for implementing the 3L paradigm and some results from the experimental systems developed for a validation of the approach.

We present the capabilities of the scripting language Open PROMOL and its processor. The intention of the language is to pre-program specifications for modifying programs written in a target language. We use its processor either as a tool for developing the stand-alone reusable components or as a “component-from-the-shelf” in generative tools for generating domain specific programs. The processor itself uses the module (lexical analyser and parser) produced by Lex & Yacc as a reusable component. We describe the generation, computation, control, parameterization and gluing capabilities of the language. We compare our approach with the similar approaches known in the literature.