Grammar Inference Technology Applications in Software Engineering
There are many problems whose solutions take the form of patterns that may be expressed using grammars (e.g., speech recognition, text processing, genetic sequencing, programming language development, etc.). Construction of these grammars is usually carried out by computer scientists working with domain experts. Grammar inference (GI) is the process of learning a grammar from examples, either positive (i.e., the pattern should be recognized by the grammar) and/or negative (i.e., the pattern should not be recognized by the grammar). This research makes a fundamental contribution toward software engineering and grammar inference technology by: 1) advancing GI algorithms which may also have new applications in other areas of computer science (e.g., bioinformatics), 2) facilitating development of domain-specific languages (DSL's) for domain experts, thus increasing productivity and reliability, and 3) providing tools for recovering software model descriptions (metamodels) from models which have evolved independently of the metamodel.
Formalizing the Semantics of Modeling Languages
This research investigates five major challenge areas in formalizing modeling languages and constructing automated tools from such formalizations. They include: (i) inventing a behavioral semantics formalism that is easier to use than existing formalisms and is amenable to further processing for automatic generation of modeling tools (e.g., editors, debuggers, and simulators); (ii) extending not only models, but also metamodels, with semantics; (iii) automatic generation of different modeling tools would require tool-specific information and different generative algorithms to construct them; (iv) mapping to existing low-level formalisms/tools must be automatic and transparent to end-users of the modeling language; and (v) development of new tools that are not possible without a formal semantics (e.g., model checker that can verify domain-specific properties).
Component-Based Aspect-Oriented Compiler Development
The intrinsic complexity engaged in a language implementation is revealed by the fact that compiler entities in a language implementation cannot be easily modularized. The goal of our new language implementation framework is to break the compiler constructs into pluggable components, which helps to improve the modularity in the language development process and alleviate the development and maintenance complexity. By utilizing component-based software engineering and the aspect-oriented development paradigm, this framework is targeted to address the modularity problem in compiler design in both structural and functional dimensions.
A Unified Approach for the Integration of Distributed Heterogeneous Software
A framework is proposed for assembling software systems from distributed
heterogeneous components. For the successful deployment of such a software
system, it is necessary that its realization not only meets the functional
requirements but also non-functional requirements such as Quality of
Service (QoS) criteria. The approach described is based on the
notions of a meta-component model called the Unified Meta Model (UMM),
a generative domain model, and specification of appropriate QoS parameters.
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.
Natural Language Specification Technology for Object-Oriented Designs
A methodology is proposed for the formal development of software systems from
a user's requirements specification in natural language into a complete
implementation, proceeding through the steps of formal specification,
and detailed design and implementation
in an automated manner. Our methodology is based
upon the theories of Two-Level Grammar (TLG) and object-oriented design
and takes advantage of the existence of several existing software design
tools. We develop an iterative transformation process from the natural
language specification into the final implementation, with a specification
development environment to assist the user, as well as the designer in
accomplishing this transformation. Our underlying formal specification
methodology may also be used in the final development of the implementation.
This methodology will advance object-oriented software
development and the software engineering process in general.