Sherif M. Yacoub

Dynamic metrics for object oriented designs

As object-oriented (OO) analysis and design techniques become more widely used, the demand on assessing the quality of OO designs increases substantially. Recently, there has been much research effort devoted to developing and empirically validating metrics for OO design quality. Complexity, coupling, and cohesion have received a considerable interest in the field. Despite the rich body of research and practice in developing design quality metrics, there has been less emphasis on dynamic metrics for OO designs. The complex dynamic behavior of many real-time applications motivates a shift in interest from traditional static metrics to dynamic metrics. This paper addresses the problem of measuring the quality of OO designs using dynamic metrics. We present a metrics suite to measure the quality of designs at an early development phase. The suite consists of metrics for dynamic complexity and object coupling based on execution scenarios. The proposed measures are obtained from executable design models. We apply the dynamic metrics to assess the quality of a pacemaker application. Results from the case study are used to compare static metrics to the proposed dynamic metrics and hence identify the need for empirical studies to explore the dependency of design quality on each.

A component-based approach to reliability analysis of distributed systems

This paper proposes a reliability analysis technique for distributed software systems. The technique is based on scenarios that are modeled as sequence diagrams. Using scenarios, we construct component-dependency graphs (CDG). CDGs have been introduced for reliability analysis of component-based systems. They are extended to serve the complex nature of distributed systems by applying nesting and hierarchy. CDGs include component and link reliabilities, which are treated as first class elements of the model. Based on CDGs, we present an algorithm to analyze the sensitivity of system reliability to reliabilities of its components, subsystems, and links. The proposed analysis technique is useful in identifying critical components and critical component links. An example based on medical informatics standard is presented to illustrate our methodology.

A methodology for architectural-level risk assessment using dynamic metrics

Risk assessment is an essential process of every software risk management plan. Several risk assessment techniques are based on the subjective judgement of domain experts. Subjective risk assessment techniques are human-intensive and error-prone. Risk assessment should be based on product attributes that we can quantitatively measure using product metrics. This paper presents a methodology for risk assessment at the early stages of the development lifecycle, namely the architecture level. We describe a heuristic risk assessment methodology that is based on dynamic metrics obtained from UML specifications. The methodology uses dynamic complexity and dynamic coupling metrics to define complexity factors for the architecture elements (components and connectors). Severity analysis is performed using FMEA (failure mode and effect analysis), as applied to architecture simulation models. We combine severity and complexity factors to develop heuristic risk factors for the architecture components and connectors. Based on component dependency graphs that were developed earlier for reliability analysis, and using analysis scenarios, we develop a risk assessment model and a risk analysis algorithm that aggregates the risk factors of components and connectors to the architectural level. We show how to analyze the overall risk factor of the architecture as the function of the risk factors of its constituting components and connectors. A case study of a pacemaker is used to illustrate the application of the methodology.

A fault model for fault injection analysis of dynamic UML specifications

Verification and validation (V&V) tasks, as applied to software specifications, enable early detection of analysis and design flaws prior to implementation. Several fault injection techniques for software V&V are proposed at the code level. In this paper, we address V&V analysis methods based on fault injection at the software specification level. We present a fault model and a fault injection process for UML dynamic specifications. We use a case study based on a cardiac pacemaker for illustrating the developed approach.

Pattern-oriented analysis and design (POAD): a structural composition approach to glue design patterns

To improve software productivity, we have to stop developing applications from scratch and make use of exiting solutions that have been applied, tested, and proven useful in successful projects. Patterns promise new design reuse benefits early in the development lifecycle. To reap the benefits of deploying these proven design solutions, we need to define systematic development approaches to construct application designs using patterns. We introduce a novel pattern-oriented analysis and design (POAD) approach that utilizes patterns as building blocks (components) at the design level. The approach glues the design structure of patterns at various levels of abstraction for the purpose of developing pattern oriented designs. We describe the development phases and steps using a purpose/process/product template. We use a running example to describe the application of each step. The POAD approach produces hierarchical traceable design models that capture interaction between patterns.

Automating the development of pattern-oriented designs for application specific software systems

Object-oriented design patterns are introduced to document good-quality reusable design practices. A design pattern abstracts a solution structure that is mostly described in terms of a set of collaborating classes or objects. Composing these design structures to develop application-specific designs involves an integration process that glues patterns together. A tool-support for the integration process will expedite the design phase. Current OO modeling tools do not explicitly support patterns as architecture constructs with interfaces. We report on a prototype tool that supports visual composition of design patterns. The tool is called the Pattern-Oriented Design (POD) tool. The POD tool can be used to develop application-specific pattern-oriented designs. It facilitates the process of integrating patterns at the architecture level using the notion of pattern interfaces. The tool supports three hierarchical traceable pattern-level design models, namely the Pattern-Level view, the Pattern Interfaces view, and the Detailed Pattern-level view. Current visual modeling tools do not explicitly support the concepts of pattern views and pattern interfaces. The proposed tool facilitates the process of designing applications using patterns as design components, it integrates with existing object-oriented modeling tools, and it provides a mechanism to trace patterns through various abstraction levels. We use a feedback control framework as an illustrative example to show how the tool can be used to develop pattern-oriented designs for application-specific systems.

A hierarchy of COTS certification criteria

At the same time as we recognize that generic forms of software reuse have fallen short of their expectations (in terms of gains in process productivity, product quality, and time to market), we also find that specialized forms of software reuse, such as commercial-off-the-shelf (COTS) based development and product-line engineering (PLE), have a great deal of potential in practice. To reap the benefits of practicing these two specialized forms of software reuse, COTS components can be used in product lines to streamline the development process. However, acquiring commercial components for a product line carries several risks. Testing and certification techniques are essentially required to assess the suitability of a COTS component for integration in a product-line architecture. The National Product Line Asset Center (NPLACE) is confronted with the problem of developing certification and suitability testing criteria for several COTS components in the market. In this paper, we develop a hierarchical reference model to guide the development of COTS certification criteria. We use an example of a database management system (DBMS) to illustrate the applicability of the model.

POD: a composition environment for pattern-oriented design

Object oriented design patterns have been proposed as an approach to encapsulate good quality design experiences that are proven useful in successful projects. A design pattern abstracts a solution structure that is mostly described in terms of a set of collaborating classes or objects. Composing these design structures to develop application designs is a tedious task that involves integration of patterns. We envisage that a tool-support for developing designs using patterns will facilitate the integration process. We describe a design environment for visual composition of design patterns for the purpose of developing pattern oriented designs. The tool makes the notion of pattern interfaces explicit and integrates patterns at the architecture level. It supports three hierarchical traceable pattern-level design models. The internal details of the pattern structure are hidden at high design levels (pattern views) and are traced to lower design levels (class views). Current visual modeling tools do not explicitly support the concepts of pattern views and pattern interfaces. The proposed tool facilitates the process of designing applications using patterns as design components and provides a mechanism to trace patterns through various levels of abstraction. We use an illustrative example to show how the tool can be used to develop pattern oriented designs.

A Case Study in Software Reuse

We report on a term project to conduct domain engineering followed by application engineering for a specific set of applications. We discuss some of the observations we have made on this project, as well some of the lessons we have learned.

An object-oriented framework for feedback control applications

We propose a reusable framework for a known engineering problem: feedback control systems. Feedback systems are commonly described in terms of block diagrams and have different implementations according to the software system designer. The proposed framework is constructed using software design patterns as its building blocks. The Unified Modeling Language (UML) notation is used for specifying the framework class and collaboration diagrams. The framework is represented in the design level to be reused as an initial step in designing feedback control applications. An instantiation of the framework in a sample application is illustrated to show the flexibility and simplicity of using the framework.