Kendra M. L. Cooper

A knowledge-based COTS-aware requirements engineering approach

The goals of developing systems better, faster, and cheaper continue to drive software engineering practitioners and researchers to investigate software engineering methodologies. In requirements engineering, the focus has been on modeling the software engineering process and products for systems that are being built from scratch. As the size and complexity of systems continues to grow the use of commercial off the shelf (COTS) components is being viewed more and more as a promising, and also perhaps inevitable, solution. The effective use of COTS components, however, requires a systematic approach that provides a set of concepts for modeling the subject matter, a set of guidelines for using such concepts, and tool support to assist the developer.In this paper, we present a COTS-Aware Requirements Engineering (CARE) approach that explicitly supports the use of COTS components. Our CARE approach is knowledge based, has a defined process, and is agent- and goal-oriented. In particular, we present part of our meta-model for the knowledge base and a prototype of the CARE Assistant Tool. Our CARE approach is validated using a part of a Digital Library System example.

Defining goals in a COTS‐aware requirements engineering approach

The goals of developing systems better, faster, and cheaper continue to drive software engineering practitioners and researchers to investigate software engineering methodologies that are novel, yet practical. As the size and complexity of systems continues to grow, there has been a growing interest in the investigation of social paradigms (e.g., agent- and goaloriented approaches) and the use of COTS components. These are being viewed more and more as promising, and also perhaps inevitable, solutions to this problem. The effective application of social paradigms and use of COTS components, however, requires a systematic approach that provides a set of concepts for modeling the subject matter, a set of guidelines for using such concepts, and tool support to assist the developer. In this paper, we present an overview of a COTS-Aware Requirements Engineering (CARE) approach that explicitly supports the use of COTS components. Our CARE approach is knowledge based, has a defined process, and is agent- and goal-oriented. In more detail, we present the models and ontology that support the definition of agents. Our CARE approach is validated using a part of a Digital Library System; a prototype of the CARE Assistant tool is used to present some preliminary results.

Developing adaptable software architectures using design patterns: an NFR approach

Just about everything changes, and so should a software system accordingly in order to survive and succeed. But how can we develop such a software system? Lately, a growing number of practitioners have shown great interests in using design patterns towards the development of an adaptable system, since design patterns represent high-level abstractions that reflect the experience of no other than skilled practitioners themselves. According to a given format, design patterns describe the context, problems, solutions and consequences of making specific design decisions. This paper presents, Proteus--a framework which is intended to support the development of adaptable software architectures using design patterns. The main concepts of Proteus are illustrated by way of a home appliance control system.

Aspect-oriented model-driven skeleton code generation: A graph-based transformation approach

Model-driven code generation has been investigated in traditional and object-oriented design paradigms; significant progress has been made. It offers many advantages including the rapid development of high quality code. Errors are reduced and the consistency between the design and the code is retained, in comparison with a purely manual approach. Here, a model-driven code generation approach based on graph transformations for aspect-oriented development is proposed. The approach has two main transformation activities. The first activity transforms a visual (graphical) model of the design into a formal, text-based notation that can be readily processed. The graphical model is created by the software designer and uses a UML profile for aspect-oriented software (i.e., FDAF) to represent aspects and their components. XML is the target notation for this step; the transformation uses the XML meta-model to ensure that the output complies with the language. The second activity transforms the XML model into AspectJ source code. The transformation uses the AspectJ meta-model to ensure the output complies with the language. The transformations from the extended UML model to XML and from XML to AspectJ code are fully automated. The transformation algorithms are based on graph transformations; tool support has been developed. Key technical issues in the approach are discussed, including performance, the amount of code generated, correctness, and adaptability, in addition to a comparison of the proposal with existing alternative approaches. The approach has been validated on three example systems: a banking system, classroom scheduling system, and an insurance system. The banking system example is presented in the paper.

A meta-model for developing simulation games in higher education and professional development training

Games and simulations can be powerful educational tools for higher education and professional development training. At the same time, the labor and technical costs of development is sufficiently high that simulation games tend to be rather static and course or program specific. The main contribution of this paper is an effort to define a new meta-model for educational simulation games that is transferable to a broad range of disciplines and technical training fields. A meta-model provides a formal structure upon which similar categories of game play components are tied to specific learning objectives and easily updatable knowledge content while offering an infinite combination of playing experiences and maintaining consistent pedagogical standards. To illustrate, this paper draws from the application of our meta-model as used in developing a simulation game for software engineering education. Preliminary validation results are presented, in which the meta-model is used as a foundation in the architecture for a game development platform.

QoS analysis for component-based embedded software: Model and methodology

Component-based development (CBD) techniques have been widely used to enhance the productivity and reduce the cost for software systems development. However, applying CBD techniques to embedded software development faces additional challenges. For embedded systems, it is crucial to consider the quality of service (QoS) attributes, such as timeliness, memory limitations, output precision, and battery constraints. Frequently, multiple components implementing the same functionality with different QoS properties (measurements in terms of QoS attributes) can be used to compose a system. Also, software components may have parameters that can be configured to satisfy different QoS requirements. Composition analysis, which is used to determine the most suitable component selections and parameter settings to best satisfy the system QoS requirement, is very important in embedded software development process. In this paper, we present a model and the methodologies to facilitate composition analysis. We define QoS requirements as constraints and objectives. Composition analysis is performed based on the QoS properties and requirements to find solutions (component selections and parameter settings) that can optimize the QoS objectives while satisfying the QoS constraints. We use a multi-objective concept to model the composition analysis problem and use an evolutionary algorithm to determine the Pareto-optimal solutions efficiently.

A control theory based framework for dynamic adaptable systems

The increasingly complex environments in which systems need to execute has lead to the need for tools and techniques to systematically design dynamically adaptable systems. A new framework for the design of these adaptive systems is proposed here. The framework, named SMART (State Model Adaptive Run Time), is based on the mathematics of control theory and system identification techniques. This foundation allows the system to accurately predict constraint violations in the environment, such as a memory overflow, and avert them by selecting components that better utilize a particular resource. The result is a more robust system. An example of the application of SMART is presented to show the need and applicability of the framework. Experimental results demonstrate the framework has an 86% accuracy in predicting and averting memory constraint violations. These results indicate the SMART Framework is feasible and has the potential to be a useful design solution for dynamic adaptable systems. Improvements to the framework are proposed as future work.

An empirical study on the specification and selection of components using fuzzy logic

The rigorous specification of components is necessary to support their selection, adaptation, and integration in component-based software engineering techniques. The specification needs to include the functional and non-functional attributes. The non-functional part of the specification is particularly challenging, as these attributes are often described subjectively, such as Fast Performance or Low Memory. Here, we propose the use of infinite value logic, fuzzy logic, to formally specify components. A significant advantage of fuzzy logic is that it supports linguistic variables, or hedges (e.g., terms such as slow, fast, very fast, etc.), which are convenient for describing non-functional attributes. In this paper, a new systematic approach for the specification of components using fuzzy logic is presented. First, an empirical study is conducted to gather data on five components that provide data compression capabilities; each uses a different algorithm (Arithmetic Encoding, Huffman, Wavelet, Fractal, and Burrows-Wheeler Transform). Data on the response time performance, memory use, compression ratio, and root mean square error are collected by executing the components on a collection of 75 images with different file formats and sizes. The data are fuzzified and represented as membership functions. The fuzzy component specifications are ranked using a set of test queries. Fuzzy multi-criteria decision making algorithms are going to be investigated for the selection of components in the next phase of the work.

Software engineering senior design course: experiences with agile game development in a capstone project

The importance of capstone senior design project courses is widely recognized for undergraduate software engineering curricula. They provide students with an opportunity to integrate and apply theoretical knowledge (both from previous courses and newly acquired for the project) on a team, improving both their technical and soft-skills. Here, we report our experiences using an agile development method for a game project; this is a radical shift from our previous course offerings that were based on waterfall, model driven development. This report is unique and valuable, especially for software engineering education, which goes beyond the discipline-specific limits of computer science curricula.

Using FDAF to bridge the gap between enterprise and software architectures for security

The vision, strategies, and goals of enterprises involve numerous security issues; these stem from legal and business concerns. In turn, these goals are realized by the enterprise, organized into business groups, departments, divisions, etc. For example, a financial organization, such as a bank, needs to provide a range of services to their customers including private banking, commercial banking, international banking, and investment services. These services are provided by sub-organizations in the enterprise (i.e., the enterprise architecture); the sub-organizations are often partitioned along the business lines. For example, one sub-organization is responsible for private banking, another for commercial banking, etc. When providing financial services, there is a need to ensure that customer and account data are kept private, not corrupted, and safely backed up. Some of these needs may be realized in a collection of software applications. The problem of effectively designing secure software systems to meet an organizations needs is a critical part of their success. This paper focuses on the problem of how to bridge the gap between enterprise and software architectures for security using a set of UML based notations: the Business Modeling Extension for UML, standard UML use case diagrams, and the Formal Design Analysis Framework (FDAF). The Business Modeling Extension and standard UML are established approaches we adopt in this work. FDAF is an aspect-oriented approach that supports the design and analysis of non-functional properties for distributed, real-time systems at the software architecture level. An empirical study for an online banking system is used to illustrate the approach.