Research Projects
Current Projects
My research projects investigate modularization and re-use techniques,
with a focus on Requirements Engineering and Software
Architecture. The paradigms under investigation include component
based software engineering, aspect-oriented software engineering, and
most recently, product line engineering techniques. The projects use applications of formal methods and empirical studies. In the future, I
would like to investigate the service oriented development paradigm.
A repository of components we have been using in our research is under construction 
Repository (v1)
My Ph.D. research project:
The need to rapidly develop high quality software in specific domains
has lead to interesting research in agile methods, component
engineering, and product-line development. Here, these three areas are
integrated into a requirements driven technique that draws upon the
strengths of each area.
Currently, we are investigating an intelligent systems approach to
tailoring a requirements engineering process that is well suited for a
project in terms of 1) degree of agility and 2) degree of product line
engineering techniques used. The process covers traditional activities
in requirements engineering including elicitation, specification,
validation, and management.
A questionnaire to elicit expertise from the community is being
prepared. The questionnaire has two main parts. The first part is
intended to collect specific information about the the expertise of
the person taking the questionnaire. This is important, as an expert
in agile and/or product line requirements engineering techniques for
embedded real time systems may not be an expert in healthcare
information systems. Based on the information provided in Part I, a
set of scenarios that are closely related to the expertise of the user
are selected and presented to the user in Part II. The user is
prompted for their opinion on what would be the most appropriate
requirements engineering techniques to use.
The results of the questionnaire will be embodied in an expert
system. The tool will prompt the user for information about the
proposed project such as the domain, type (e.g., embedded, information
system, etc.), estimated size, presence of safety or security critical
requirements, number of development locations, etc. Given the
information about the proposed project, the exeprt system will
recommend suitable requirements engineering processes; the user can
make the final selection from the alternatives.
A two page summary is available here
Several publications are available for our preliminary results:
"Developing a Survey to Collect Expertise
in Agile Product Line Requirements Engineering", Agile 2007 Conference, Research in Progress Workshop here
"Developing a Survey to Collect Expertise in Agile Product Line
Requirements Engineering Processes", Technical Report here
"Defining Project Scenarios for the Agile Requirements
Engineering Product-line Development Questionnaire", Technical Report here
Much attention has recently been focused on the problem of effectively
developing software systems that meet their non-functional
requirements. Architectural frameworks have been proposed as a
solution to support the design and analysis of non-functional
properties such as security, performance, adaptability, etc. A
significant benefit of performing such analysis work is to detect and
remove defects earlier in the design phase which improves the quality,
reduces the cost, and reduces the development time for the
product. This research project is focussed on developing a new,
aspect-oriented framework, the Formal Design Analysis Framework
(FDAF), which is intended to support the analysis of multiple,
non-functional properties using a combination of existing semi-formal
and formal methods for distributed, real-time systems. Aspect-oriented
approaches use a Separation of Concern strategy, in which a set of
simpler models, each built for a specific purpose (or aspect) of the
system, are defined and analyzed. Each aspect model can be constructed
and evolved relatively independently from other aspect models. This
has three implications:
1. An aspect model can focus on only one type of property, without
burden of complexity from other aspects. Hence an aspect model is
potentially much simpler and smaller than a traditional mixed system
model. This is expected to dramatically reduce the complexity of
understanding, change, and analysis.
2. Different levels of detail or abstraction can be used in the
construction of different aspect models. This allows us to leverage of
existing understanding of certain aspect of the system to reduce the
complexity of modeling and analysis. For example, if the timing
property of a component/subsystem is well understood, we can build an
extremely simple timing model for the component.
3. Existing formal notations normally are only suitable for describing
one or a few types of system properties. By adopting the aspect
concept, we can select the most suitable notation to describe a given
aspect. Likewise, we can select the most suitable analysis techniques
to analyze a given property.
The Formal Design Analysis Framework (FDAF) project has focused on
defining a framework that supports the modeling and analysis of
aspect-oriented software architectures. This was Lirong Dai's
Ph.D. topic. The approach features aspect-oriented extensions to UML
class and activity diagrams and a repository of re-usable aspects that
can be selected, instantiated and woven into a base design. The
extended UML models have been automatically translated into formal
notations (e.g., Rapide, Armani, Promela) to support the rigorous,
automated analysis of the design. A substantial body of work in the
software engineering community on existing formal methods and their
tool support has been integrated and re-used in FDAF.
Substantial progress has been made on this project. The contributions include:
Definition of a UML meta-model extension to support aspects, pointcuts and advice
Automated translation of extended UML class and activity diagrams into established formal notations (e.g.,
Rapide, Armani, Promela), which have strong tool support for analysis
Definition of a repository of re-usable security and performance aspects
Extensive validation of the approach on a Domain Name System and an ATM Banking example
Tool support, which has been made available to the community
The results have been published in over a dozen peer reviewed
workshop, conference, and journal articles, including in the Journal
of Science of Computer Programming and the International Journal of
Software Engineering and Knowledge Engineering. On the Science Direct
website (http://top25.sciencedirect.com/), two articles on this AOSD
project have been on the Top 25 list of most read articles for the
Journal of Science of Computer Programming. A third has been
recognized on the top accessed articles for the International Journal
of Software Engineering and Knowledge Engineering.
The three publications recognized as Top Accessed articles are:
International Journal of Software Engineering and Knowledge Engineering (August 2007), L. Dai, K. Cooper, and E. Wong, .Modeling and Analysis of Performance Aspects for Software System Architecture Designs: a UML Based Approach., International Journal Software Engineering and Knowledge Engineering, Volume 16, No. 3, June 2006, pp.347-378..
Journal of Science of Computer Programming (Jul. - Dec. 2006), K. Cooper and L. Dai, .Modeling and Performance Analysis for Security Aspects., Journal of Science of Computer Programming, Volume 61, Issue 1, June 2006, pp: 58 . 71.
Journal of Science of Computer Programming (Oct. 2005 - present), K. Cooper, L. Dai, and Y. Deng, "Performance Modeling and Analysis of Software Architectures: An Aspect-Oriented UML Based Approach., Journal of Science of Computer Programming, System and Software Architectures, Volume 57, Issue 1, July 2005, pp. 89-108.
A submission to the
IEEE Transactions on Software Engineering is in progress. Here, the
results of translating a software architecture enhanced with three
security aspects into Promela and its subsequent analysis using the
model checker SPIN are going to be presented.
This research is being extended in two directions. The first is to consider the modeling and analysis of re-usable aspectual requirements and their traceability to the software architecture. The second is to investigate automated model driven code generation. First, partial code generation will be achieved, followed by full code synthesis. When these two extensions are completed, framework will support the modeling and analysis of early aspects (requirements and architecture) and aid in rapid code development. It will be the first aspect-oriented framework to provide all of these capabilities.
The tool support for the model-driven aspect-oriented skeleton code generation is available here
Additional details on this project are available at
here
Component based software engineering (CBSE) methods propose to build
software systems out of existing, re-usable components like using
"lego" blocks. Since the components have already gone through the time
consuming activities to specify, design, implement, test, and document
their capabilities, the premise is that buying the components is a
better decision, especially with respect to development time and
quality, in comparison to building the capabilities from
scratch. However, there are numerous issues to address in CBSE
including how to specify the functional and non-functional behavior of
the components, how to evaluate, rank, and select components, how to
predict the interoperability of components, etc.
The Component Aware Technologies (CAT) approach has focused on the
specification, evaluation, ranking and selection of components in the
requirements and software architecture activities. In this
methodology, the functional and quality/non-functional behaviors of
components are captured by a component engineer; the components (XML
specifications of behavior, documentation, code, etc.) are maintained
in a repository. A variety of techniques are used to match and rank
the components in the repository to the stakeholders. requirements,
including keyword searches, case based reasoning and multi-criteria
decision making algorithms. The methodology provides heuristics on how
to proceed based on the results of the matching and ranking. For
example, if the components in the repository are not a good match for
the stakeholders. requirements, then the options include: 1) finding
additional component available in the marketplace and updating the
repository; 2) negotiating a change in the stakeholders. requirements
so they can be realized by components; 3) developing the requirement
from scratch. The methodology also supports the realization of the
requirements in a software architecture. The project webpage is at
www.utdallas.edu/~weiminma/public; this is a collaborative project
with Dr. Lawrence Chung.
The contributions made so far include:
Definition of a UML meta-model extension to support agents, goals, and components
Definition of both product and process models for the approach
Extensive validation of the approach on a Home Appliance Control System, Digital Library System, and Quality Assurance Review Assistant Tool
Tool support, which has been made available to the community
The results have been published in over a dozen peer reviewed
workshop, conference, and journal articles, including the IEEE
International Conference on COTS-Based Systems, organized by the
Software Engineering Institute, and the INCOSE Systems Engineering
Journal.
The current research is focused on the integration, or composition, of
components. This is a challenging, open issue in the component
research community. For example, if a collection of components that
individually realize (some of) the stakeholders. needs is identified,
then there is a need to represent and reason about their composition
into a system. The composition analysis needs to consider both
functional and non-functional capabilities. If mismatches are
discovered early, then costly and time- consuming mistakes can be
avoided. Currently, a taxonomy of integration mismatches and a set of
rules for automatically identifying these inconsistencies among
components is being defined and validated.
In the future, a new component based systems engineering project
will be launched, which will consider hardware/operating systems and
communication networks in addition to software components.
Please visit our CARE/SA website here
The environments where software products are executing today have
considerably increased in complexity as software needs to support a
large number of simultaneous users on a variety of distinct platforms;
each platform has different resource constraints such as memory, disk
space, bandwidth, etc. The dynamic interaction among these elements
constitutes the basis for this complex environment. A question arises
from this scenario: ``How can we design software to cope with such
dynamic environments?'' Recently, dynamic adaptive systems have been
proposed as a solution to this problem. A dynamic adaptive system is
one in which the system adapts itself at run-time according to changes
in the environment.
When designing a dynamic adaptive system, new issues arise that one
must take into consideration. For example, some of the inputs may not
be observable such as the amount of unused memory available, the
behavior is non-deterministic resulting in executions that are unique,
the monitoring and control of the system occur continuously, and the
adaptation of the system is at run-time rather than at compile-time.
In this work we propose a new approach to the design of adaptive
systems called the KAROO Framework. This is a collaborative project
with Dr. J. Cangussu and Dr. E. Wong. KAROO innovatively integrates
two areas of leading edge research in software engineering. The first
is use of feedback control theory to support the continuous monitoring
and control of the system in a dynamically changing environment. The
second area is the effective specification, matching, and selection of
commercial-off-the-shelf (COTS) components. KAROO provides a
knowledge-based repository of components. The functional and
non-functional behavior of the components are rigorously specified;
the system can run queries that identify components. In addition to
the advantages of many adaptive system approaches (self-adaptation,
robustness, better resource usage, etc.), the KAROO Framework provides
two distinguishing features.
- Flexibility - the majority of the adaptive techniques are domain
specific. This is due to the fact that partial or complete knowledge
about the relationship of the inputs and systems resources have to be
known a-priori. The System Identification Module in the KAROO
Framework dynamically identify these relationships and therefore
allows its application to a variety of different domains.
- Predictability - the availability of a state model capturing the dominant behavior of the system allows the prediction of future behavior. The time when changes are necessary can be predicted and the system preparation to swap to a new component can be done in advance resulting in an overall increase in the systems performance and robustness.
The results of extensive experimental
evaluation of a KAROO based prototype system have been excellent: 100%
of the violations are predicted; the system has been able to avoid the
violations by adapting itself almost 98% of the time. Preliminary
results have appeared in conference papers, including the proceedings
of the 31st Annual International Computer Software and Applications
Conference (COMPSAC 2007). There are a number of issues to address in
future work, including the refinement and extensive validation using a
wide variety of applications with different software architectures.
Code reuse, or component-based system development, has been under
investigation for over 30 years. The idea behind code reuse is
pragmatic: it is viewed as a means to reduce the overall time and
effort needed to produce a high quality software product. If a
software component has been developed for a specific application and
has gone through a development lifecycle (specification, design,
development, and verification), then it seems reasonable that it could
be used as a component in another system.
On the surface, component reuse sounds like a straightforward problem:
the developer 1) has functionality to implement 2) finds a component
that provides the functionality based on its specification 3) tailors
the component and 4) develops the glue code to integrate the
component.
If the problem seems so simple, then why is component-based system
development an active research area? In practice, there are many
issues including how to build and document a component so that it is
well suited for reuse; how to update development processes to support
developing and (re)using components; how to store components in
repositories; how to find and select matching components; and if a
component is not built with reuse in mind, how can it be modified to
make it more useful as a reusable component?
The open question of how to make a component better suited for reuse
is the focus of this work. More specifically, we plan to investigate
how the non-functional behaviour of a component for embedded software
can be parameterized to support trade-offs including time vs. space,
time vs. quality, and space vs. quality.
A new approach to adapt the QoS behavior of components has been
proposed; this was Jia Zhou's Ph.D. topic. This is a semi-automated,
rule-based approach for achieving QoS trade-offs such as time-space,
time-quality, space-quality, etc. The rules identify data elements
(variables, constants, etc.) within the source code that impact the
QoS trade-offs; they are transformed into externally visible
parameters that can be readily adapted.
The results have been reported
in six published workshop, conference, and journal articles, including
an IEEE Transactions on Knowledge and Data Engineering article.
Additional information on this project is available
here