Barrett R. Bryant

Challenges and Directions in Formalizing the Semantics of Modeling Languages

Developing software from models is a growing practice and there exist many model-based tools (e.g., editors, interpreters, debuggers, and simulators) for supporting model-driven engineering. Even though these tools facilitate the automation of software engineering tasks and activities, such tools are typically engineered manually. However, many of these tools have a common semantic foundation centered around an underlying modeling language, which would make it possible to automate their development if the modeling language specification were formalized. Even though there has been much work in formalizing programming languages, with many successful tools constructed using such formalisms, there has been little work in formalizing modeling languages for the purpose of automation. This paper discusses possible semantics-based approaches for the formalization of modeling languages and describes how this formalism may be used to automate the construction of modeling tools.

Automated conversion from requirements documentation to an object-oriented formal specification language

In software engineering there have been very few attempts to automate the translation from a requirements document written in a natural language (NL) to one of the formal specification languages. One of the major reasons for this challenge comes from the ambiguity of the NL requirements documentation because NL depends heavily on context. We use Contextual Natural Language Processing (CNLP) to overcome the ambiguity in NL, and Two-Level Grammar (TLG) to construct a bridge between a NL requirements specification and a formal specification in VDM++, an object-oriented extension of the Vienna Development Method. The result is a system for mapping natural language requirements documents into an object-oriented formal specification language.

MARS: A metamodel recovery system using grammar inference

Domain-specific modeling (DSM) assists subject matter experts in describing the essential characteristics of a problem in their domain. When a metamodel is lost, repositories of domain models can become orphaned from their defining metamodel. Within the purview of model-driven engineering, the ability to recover the design knowledge in a repository of legacy models is needed. In this paper we describe MARS, a semi-automatic grammar-centric system that leverages grammar inference techniques to solve the metamodel recovery problem. The paper also contains an applicative case study, as well as experimental results from the recovery of several metamodels in diverse domains.

A quality‐of‐service‐based framework for creating distributed heterogeneous software components

Component‐based software development offers a promising solution for taming the complexity found in todays distributed applications. Todays and future distributed software systems will certainly require combining heterogeneous software components that are geographically dispersed. For the successful deployment of such a software system, it is necessary that its realization, based on assembling heterogeneous components, not only meets the functional requirements, but also satisfies the non‐functional criteria such as the desired quality of service (QoS). In this paper, a framework based on the notions of a meta‐component model, a generative domain model and QoS parameters is described. A formal specification based on two‐level grammar is used to represent these notions in a tightly integrated way so that QoS becomes a part of the generative domain model. A simple case study is described in the context of this framework. Copyright

Pattern transformation for two-dimensional separation of concerns

Design patterns are utilized in software development to decouple individual concerns, so that a change in a design decision is isolated to one location of the code base. However, multidimensional concerns exist in software development and therefore no single design pattern offers a panacea toward addressing problems of change evolution. By analyzing the matrix of concerns during the software development process and utilizing transferable aspect-orientation and object-orientation, a pattern transformation based two-dimensional separation of concerns is described, which integrates the benefits derived from the Inheritance pattern and several GoF patterns. An example implementation is shown using Java and AspectJ.

To explore or to exploit: An entropy-driven approach for evolutionary algorithms

An evolutionary algorithm is an optimization process comprising two important aspects: exploration discovers potential offspring in new search regions; and exploitation utilizes promising solutions already identified. Intelligent balance between these two aspects may drive the search process towards better fitness results and/or faster convergence rates. Yet, how and when to control the balance perceptively have not yet been comprehensively addressed. This paper introduces an entropy-driven approach for evolutionary algorithms. Five kinds of entropy to express diversity are presented; and the balance between exploration and exploitation is adaptively controlled by one kind of entropy and mutation rate in a metaprogramming fashion. The experimental results of the benchmark functions show that the entropy-driven approach achieves explicit balance between exploration and exploitation and hence obtains even better fitness values and/or convergence rates.

Can a parser be generated from examples

One of the open problems in the area of domain-specific languages is how to make domain-specific language development easier for domain experts not versed in a programming language design. Possible approaches are to build a domain-specific language from parameterized building blocks or by language (grammar) induction. This paper uses an evolutionary approach to grammar induction. Grammar-specific genetic operators for crossover and mutation are proposed to achieve this task. Suitability of the approach is shown by small experiments where underlying grammars are successfully genetically obtained and parsers are than automatically generated.

An architecture for the UniFrame resource discovery service

Frequently, the software development for large-scale distributed systems requires combining components that adhere to different object models. One solution for the integration of distributed and heterogeneous software components is the UniFrame approach. It provides a comprehensive framework unifying existing and emerging distributed component models under a conmion meta-model that enables the discovery, interoperability, and collaboration of components via generative software techniques. This paper presents the architecture for the resource discovery aspect of this framework, called the UniFrame Resource Discovery Service (URDS). The proposed architecture addresses the following issues: a) dynamic discovery of heterogeneous components, and b) selection of components meeting the necessary requirements, including desired levels of QoS (Quality of Service). This paper also compares the URDS architecture with other Resource Discovery Protocols, outlining the gaps that URDS is trying to bridge.

Extracting grammar from programs: evolutionary approach

The paper discusses context-free grammar (CFG) inference using genetic-programming with application to inducing grammars from programs written in simple domain-specific languages. Grammar-specific heuristic operators and non-random construction of the initial population are proposed to achieve this task. Suitability of the approach is shown by small examples where the underlying CFGs are successfully inferred.

Context-free grammar induction using genetic programming

While grammar inference is used in areas like natural language acquisition, syntactic pattern recognition, etc., its application to the programming language problem domain has been limited. We propose a new application area for grammar induction which intends to make domain-specific language development easier and finds a second application in renovation tools for legacy systems. The genetic programming approach is used for grammatical inference. Our earlier work used grammar-specific heuristic operators in tandem with non-random construction of the initial grammar population and succeeded in inducing small grammars.