Do developers postpone fixing Technical Debt (TD) in software systems? TD is a metaphor that refers to short-term decisions in software development that may affect the cost of the software development life cycle. The bad smell is an imperfect solution in the software system that negatively impacts the internal software quality and maintainability. In this paper, we will study five open-source software projects (OSSPs) that have several releases and also estimate the numbers of architecture smells (ASs), design smells (DSs), and code smells (CSs) for every release. Designite will be used to detect smells. We describe a case study conducted to explore the following: (1) What is the average smells density for architecture, design, and code smells in an OSSP? (2) Does the density of each smell type increase over multiple releases? (3) What percentage of each smell-type density is eliminated by refactoring? We collected around 2 million LOC from five OSSPs that have multiple releases from the GitHub repository to statistically analyze the software concerning the smells as indicators of TD. We find 36% of Architecture Technical Debt (ATD) is Cyclic Dependency, while 33% of Design Debt (DD) is Cyclically-dependent Modularization. More than 70% of Code Debt (CD) is Magic Number. Even though the developers do refactoring between releases, the TD density in general increases. On average, by refactoring, developers remove around 48%, 16%, and 22% from the introduced ATD, DD, and CD from their next release, respectively.

Paying-off the Architectural Technical Debt by refactoring the flawed code is important to control the debt and to keep it as low as possible. Project Managers tend to delay paying off this debt because they face difficulties in comparing the cost of the refactoring against the benefits gained. These managers need to estimate the cost and the efforts required to conduct these refactoring activities as well as to decide which flaws have higher priority to be refactored. Our research is based on a dataset used by other researchers that study the technical debt. It includes more than 18,000 refactoring operations performed on 33 apache java projects. We applied the COCOMO II:2000 model to calculate the refactoring cost in person-months units per release. Furthermore, we investigated the correlation between the refactoring efforts and two static code metrics of the refactored code. The research revealed a weak correlation between the refactoring efforts and the size of the project, and a moderate correlation with the code complexity. Finally, we applied the DesigniteJava tool to verify our research results. From the analysis we found a significant correlation between the ranking of the architecture smells and the ranking of refactoring efforts for each package. Using machine learning practices, we took the architecture smells level and the code metrics of each release as an input to predict the levels of the refactoring effort of the next release. We calculated the results using our model and found that we can predict the ‘High’ and ‘Very High’ levels, the most significant levels from managers’ perspective, with [Formula: see text] accuracy.

Software systems nowadays are complex and difficult to maintain due to the necessity of continuous change and adaptation. One of the challenges in software maintenance is keeping requirements traceability up to date automatically. The process of generating requirements traceability is time-consuming and error-prone. Currently, most available tools do not support the automated recovery of traceability links. In some situations, companies accumulate the history of changes from past maintenance experiences. In this paper, we consider requirements traceability recovery as a multi objective search problem in which we seek to assign each requirement to one or many software elements (code elements, API documentation, and comments) by taking into account the recency of change, the frequency of change, and the semantic similarity between the description of the requirement and the software element. We use the Non-dominated Sorting Genetic Algorithm (NSGA-II) to find the best compromise between these three objectives. We report the results of our experiments on three open source projects.

Software design is a process of trading off competing objectives. If the user objective space is rich, then we should use optimizers that can fully exploit that richness. For example, this study configures software product lines (expressed as feature maps) using various search-based software engineering methods. As we increase the number of optimization objectives, we find that methods in widespread use (e.g. NSGA-II, SPEA2) perform much worse than IBEA (Indicator-Based Evolutionary Algorithm). IBEA works best since it makes most use of user preference knowledge. Hence it does better on the standard measures (hypervolume and spread) but it also generates far more products with 0% violations of domain constraints. Our conclusion is that we need to change our methods for search-based software engineering, particularly when studying complex decision spaces.

This paper presents “Smartphone Energizer”, a novel technique for context-aware computation offloading for smartphones. Previous techniques to the offloading problem were based on a narrow set of contextual information, which made the amount of energy saving varies unexpectedly based on the context in which the application is running. Smartphone Energizer uses the benefit of supervised learning with a rich set of contextual information such as application, device, network, and user characteristics to optimize both the energy consumption and execution time of Smartphone's applications in a variety of contextual situations. In our evaluation, we show that Smartphone Energizer predicts both energy consumption and execution time in different contexts with error less than 9%, which in turn helped in taking the right offloading decision and saving energy by 40% to 56% and execution time by 43% to 58%.

Software product lines are hard to configure. Techniques that work for medium sized product lines fail for much larger product lines such as the Linux kernel with 6000+ features. This paper presents simple heuristics that help the Indicator-Based Evolutionary Algorithm (IBEA) in finding sound and optimum configurations of very large variability models in the presence of competing objectives. We employ a combination of static and evolutionary learning of model structure, in addition to utilizing a pre-computed solution used as a “seed” in the midst of a randomly-generated initial population. The seed solution works like a single straw that is enough to break the camel's back -given that it is a feature-rich seed. We show promising results where we can find 30 sound solutions for configuring upward of 6000 features within 30 minutes.

Teeth classification is an important component in building an Automated Dental Identification System (ADIS) as part of creating a data structure that guides tooth-to-tooth matching. This aids in avoiding illogical comparisons that both inefficiently consume the limited computational resources and mislead decision-making. We tackle this problem by using low computational-cost, appearance-based Orthogonal Locality Preserving Projection (OLPP) algorithm to assign an initial class, i.e. molar or premolar to the teeth in bitewing dental images. After this initial classification, we use a string matching technique, based on teeth neighborhood rules, to validate initial teeth-classes and thus assign each tooth a number corresponding to its location in the dental chart. On a large dataset of bitewing films that contain 622 teeth, the proposed approach achieves classification accuracy of 89% and teeth class validation enhances the overall teeth classification accuracy to 92%.

Teeth segmentation is one of the important components in building an Automated Dental Identification System (ADIS). The extraction of the teeth from their corresponding dental radiographs is called teeth segmentation. Dental radiographs may suffer from poor teeth image quality, low contrast and uneven exposure that complicate the task of teeth segmentation. To achieve a good performance in segmentation, the teeth images are preprocessed by a two-step thresholding technique, which starts with an iterative thresholding followed by an adaptive thresholding to binarize the teeth images. Then, we propose to adapt the seam carving technique on the binary images, using both horizontal and vertical seams, to separate each individual tooth. The proposed method is evaluated experimentally and compared to other algorithms. The results show that our new approach achieves the lowest failure rate among all existing methods, and the highest optimality among all of the fully automated approaches reported in the literature.

Automating the process of postmortem identification of deceased individuals based on dental characteristics is receiving increased attention. With the large number of victims encountered in mass disasters (e.g., Asian tsunami), automating the identification process would enhance the scalability of this biometric. However, archiving and retrieving dental records from large databases is a challenging task and has received inadequate attention in the literature. This paper concerns itself with the task of efficient fast retrieving dental records from a database in order to assist the forensic expert in identifying deceased individuals in a rapid manner. The proposed method is an appearance-based technique that consolidates the evidence presented by individual teeth in a dental record, i.e., it `moves' from tooth-to-tooth in order to render a record-to-record matching score. The proposed method is shown to reduce the searching time of record-to-record matching by a factor of hundred. Experimental results indicate that the proposed approach requires significantly less time compared to the other approaches suggested in the literature thereby underscoring its relevance in real-time applications.

Identification of deceased individuals based on dental characteristics is receiving increased attention, especially with the large volume of victims encountered in mass disasters. An important problem in automated dental identification is automatic classification of teeth into four classes (molars, premolars, canines, and incisors). An equally important problem is the construction of a dental chart, which is a data structure that guides tooth-to-tooth matching. Dental charts are the key for avoiding illogical comparisons that inefficiently consume the limited computational resources and may mislead decision making. Labeling of the teeth is a challenging task which has received inadequate attention in the literature. We tackle this composite problem using a two-stage approach. The first stage utilizes low computational cost, appearance-based features for assigning an initial class. The second stage applies a string matching technique, based on teeth neighborhood rules, to validate initial teeth-classes and, hence, to assign each tooth a number corresponding to its location in the dental chart. Based on a large test dataset of 507 bitewing and periapical films that contain 2027 teeth, the proposed approach achieves classification accuracy of 87%. Experimental results indicate that the proposed approach works very fast, and achieves high performance compared to other approaches suggested in the literature.

A software product spends more than 65% of its lifecycle in maintenance. Software systems with good maintainability can be easily modified to fix faults. We define maintainability-based risk as a product of two factors: the probability of performing maintenance tasks and the impact of performing these tasks. In this paper, we present a methodology for assessing maintainability-based risk in the context of corrective maintenance. The proposed methodology depends on the architectural artifacts and their evolution through the life cycle of the system. In order to prioritize corrective maintenance tasks, we combine components' maintainability- based risk with the severity of a failure that may happen as a result of unfixed fault. We illustrate the methodology on a case study using UML models.

Development of software systems utilizes only 20%-40% of the overall project cost; the rest is consumed by maintenance. Systems with poor maintainability are difficult to modify and to extend. Maintainability based risk is defined as a product of two factors: the probability of carrying out maintenance tasks and the impact of these tasks. The decision of adopting a single architecture over others should be verified through some pre-implementation analysis. This paper assesses different architectures for process control applications using a maintainability risk analysis. The paper illustrates the methodology using a simple example of a Gas Burner process control system.

Much of the research work on agent design patterns has primarily focused on discovering and documenting patterns. Agent design patterns promise early reuse benefits at the design stage. To reap the benefits of deploying these proven design solutions, we need a methodology to construct agent applications using patterns. The MaSE/POAD methodology is one which aims to provide a systematic development process using pattern. The methodology is a hybrid between the Multiagent System Engineering (MaSE) and Pattern Oriented Analysis and Design (POAD) methodology. This paper presents an agent design pattern framework which could be immersed in the methodology. The framework contains the description of the pattern structure and representation that can be used to model the agents in specific application. The pattern representation is based on the views provided in the MaSE/POAD: task, conversation and structural. Two examples of patterns; Initiatior pattern and Observer pattern are presented to illustrate the framework.

The study of software architectures is gaining importance due to its role in various aspects of software engineering, like product line engineering, componentbased software engineering and other emerging paradigms. With the increasing emphasis on design patterns, the traditional practice of ad-hoc software construction is slowly shifting towards pattern-oriented development. Various architectural attributes like error propagation, change propagation, requirements propagation provide a wealth of information about software architectures. In this paper, we show that change propagation probability (CP) is helpful and effective in assessing the design quality of software architectures. We study two different architectures (one that employs patterns versus one that does not) for the same application. We also analyze and compare the change propagation metric with respect to other coupling-based metrics.

Automating the process of postmortem identification of individuals using dental records is receiving increased attention. Teeth segmentation from dental radiographic films is an essential step for achieving highly automated postmortem identification. In this paper, we offer a mathematical morphology approach to the problem of teeth segmentation. We also propose a grayscale contrast stretching transformation to improve the performance of teeth segmentation. We compare and contrast our approach with other approaches proposed in the literature based on a theoretical and empirical basis. The results show that in addition to its capability of handling bitewing and periapical dental radiographic views, our approach exhibits the lowest failure rate among all approaches studied.

Summary form only given. Software architectures are an emerging discipline in software engineering as they play a central role in many modern software development paradigms. Quantifying software architectures is an important research agenda, as it allows software architects to subjectively assess quality attributes and rationalize architecture-related decisions. In this paper, we discuss the attribute of change propagation probability, which reflects the likelihood that a change that arises in one component of the architecture propagates (i.e. mandates changes) to other components.

Summary form only given. Risk assessment is an integral part of software risk management. There are several methods for risk assessment during various phases of software development and at different levels of abstraction. However, there are very few techniques available for assessing risk at the requirements level and those that are available are highly subjective and are not based on any formal design models. Such techniques are human-intensive and highly error prone. This paper presents a methodology that assesses software risk at the requirements level using Unified Modeling Language (UML) specifications of the software at the early development stages. Each requirement is mapped to a specific operational scenario in UML. We determine the possible failure modes of the scenario and find out the complexity of the scenario in each failure mode. The risk factor of a scenario in a failure mode is obtained by combining the complexity of the failure mode in that scenario and the severity of the failure. The result of applying the methodology on a cardiac pacemaker case study is presented.

Summary form only given. Software metrics have become an integral part of software development and are used during every phase of the software development life cycle. Research in the area of software metrics tends to focus predominantly on static metrics that are obtained by static analysis of the software artifact. But software quality attributes such as performance and reliability depend on the dynamic behavior of the software artifact. Estimating software quality attributes based on dynamic metrics for the software system are more accurate and realistic. The research presented in this paper attempts to narrow the gap between static metrics and dynamic metrics, and lay the foundation for a more systematic approach to estimate the dynamic behavior of a software system early in the software development cycle. Focusing on coupling metrics, we present an empirical study to analyze the relationship between static and dynamic coupling metrics and propose the concept of pseudo dynamic metrics to estimate the dynamic behavior early in the software development lifecycle.

The study of software architectures is gaining importance due to its role in various aspects of software engineering such as product line engineering, component based software engineering and other emerging paradigms. With the increasing emphasis on design patterns, the traditional practice of ad-hoc software construction is slowly shifting towards pattern-oriented development. Various architectural attributes like error propagation, change propagation, and requirements propagation, provide a wealth of information about software architectures. In this paper, we show that change propagation probability (CP) is helpful and effective in assessing the design quality of software architectures. We study two different architectures (one that employs patterns versus one that does not) for the same application. We also analyze and compare change propagation metric with respect to other coupling-based metrics.

Performance is a nonfunctional software attribute that plays a crucial role in wide application domains spreading from safety-critical systems to e-commerce applications. Software risk can be quantified as a combination of the probability that a software system may fail and the severity of the damages caused by the failure. In this paper, we devise a methodology for estimation of performance-based risk factor, which originates from violations, of performance requirements, (namely, performance failures). The methodology elaborates annotated UML diagrams to estimate the performance failure probability and combines it with the failure severity estimate which is obtained using the functional failure analysis. We are thus able to determine risky scenarios as well as risky software components, and the analysis feedback can be used to improve the software design. We illustrate the methodology on an e-commerce case study using step-by step approach, and then provide a brief description of a case study based on large real system.

To assist the analysis software architectures, we have developed a Web-based CASE tool that automates the steps of capturing, modeling, and inspection of software architectures, in order to derive and display the change propagation probabilities.

This paper introduces a reliability model, and a reliability analysis technique for component-based software. The technique is named Scenario-Based Reliability Analysis (SBRA). Using scenarios of component interactions, we construct a probabilistic model named Component-Dependency Graph (CDG). Based on CDG, a reliability analysis algorithm is developed to analyze the reliability of the system as a function of reliabilities of its architectural constituents. An extension of the proposed model and algorithm is also developed for distributed software systems. The proposed approach has the following benefits: 1) It is used to analyze the impact of variations and uncertainties in the reliability of individual components, subsystems, and links between components on the overall reliability estimate of the software system. This is particularly useful when the system is built partially or fully from existing off-the-shelf components; 2) It is suitable for analyzing the reliability of distributed software systems because it incorporates link and delivery channel reliabilities; 3) The technique is used to identify critical components, interfaces, and subsystems; and to investigate the sensitivity of the application reliability to these elements; 4) The approach is applicable early in the development lifecycle, at the architecture level. Early detection of critical architecture elements, those that affect the overall reliability of the system the most, is useful in delegating resources in later development phases.

Recent evidences indicate that most faults in software systems are found in only a few of a system's components [1]. The early identification of these components allows an organization to focus on defect detection activities on high risk components, for example by optimally allocating testing resources [2], or redesigning components that are likely to cause field failures. This paper presents a prototype tool called Architecture-level Risk Assessment Tool (ARAT) based on the risk assessment methodology presented in [3]. The ARAT provides risk assessment based on measures obtained from Unified Modeling Language (UML) artifacts [4]. This tool can be used in the design phase of the software development process. It estimates dynamic metrics [5] and automatically analyzes the quality of the architecture to produce architectural-level software risk assessment [3].

Risk assessment is an essential part in managing software development. Performing risk assessment during the early development phases enhances resource allocation decisions. In order to improve the software development process and the quality of software products, we need to be able to build risk analysis models based on data that can be collected early in the development process. These models will help identify the high-risk components and connectors of the product architecture, so that remedial actions may be taken in order to control and optimize the development process and improve the quality of the product. In this paper, we present a risk assessment methodology which can be used in the early phases of the software life cycle. We use the Unified Modeling Language (UML) and commercial modeling environment Rational Rose Real Time (RoseRT) to obtain UML model statistics. First, for each component and connector in software architecture, a dynamic heuristic risk factor is obtained and severity is assessed based on hazard analysis. Then, a Markov model is constructed to obtain scenarios risk factors. The risk factors of use cases and the overall system risk factor are estimated using the scenarios risk factors. Within our methodology, we also identify critical components and connectors that would require careful analysis, design, implementation, and more testing effort. The risk assessment methodology is applied on a pacemaker case study.

The paper presents a methodology for reliability 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. 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 Failure Mode and Effect Analysis (FMEA) as applied to architecture models. We combine severity and complexity factors to develop heuristic risk factors for the architecture components and connectors. Based on analysis scenarios, we develop a risk assessment model that represents components, connectors, component risk factors, connector risk factors, and probabilities of component interactions. We also develop a risk analysis algorithm that aggregates risk factors of components and connectors to the architectural level. Using the risk aggregation and the risk analysis model, 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 architecture is used to illustrate the application of the methodology. The methodology is used to identify critical components and connectors and to investigate the sensitivity of the architecture risk factor to changes in the heuristic risk factors of the architecture elements.

The importance of early performance assessment grows as software systems increase in terms of size, logical distribution and interaction complexity. Lack of time on the side of software developers, as well as distance between software model notations and performance model representation do not help to build an integrated software process that takes into account, from the early phases of the lifecycle, nonfunctional requirements. We work towards filling this gap by extending the capabilities of a simulative environment developed for the UML notation. Our intent is to introduce new stereotypes representing performance related items, such as resource types and job dispatchers. They allow the software designers to homogeneously represent a software architecture integrated with a running platform as well as parameterized with the resource demand that the components require.

An interactive electronic technical manual (IETM) is a digital package of information that is required for the diagnosis and maintenance of complex weapon systems and both military and commercial equipment. The lack of interoperability within and among IETM systems has become a major challenge to the US DoD IETM community. The initial phase of user-level interoperability support has been undertaken by the development of a Web-based Joint IETM Architecture (JIA). Within this architecture, there is a need to develop a standardized Web-enabled alternative to the IETM database specification. Object-oriented modeling provides the conceptual foundation for assembling the Web-enabled alternative out of Web components using Web technologies such as Java and XML. In this paper, we discuss a UML-based object model to manage the large and complex IETM database specification. We also define a UML extension to capture the semantics of the IETM database architecture.

Simulation of turbulent fluctuations in ship wakes is one of the complex applications of large eddy simulations in computational fluid dynamics (CFD). Ship wake simulation requires extensive computations and large amounts of computer resources. The accuracy of ship wake prediction is limited by the memory of the workstation. We present the parallel implementation of large eddy simulations (LES) of a flat plane wake using a data domain decomposition technique for a cluster environment. We present the results of the implementation executed on a cluster of workstations. Also, we show how the implementation scales up with the number of workstations and that it is possible to obtain better accuracy by increasing the number of workstations in the cluster system. Moreover, we show how we can predict the number of workstations required to execute the simulation for given accuracy level based on the number of grid nodes, or estimate the execution time for a certain cluster.

Because it codifies best practices, and because it supports various forms of software reuse, the discipline of software architecture is emerging as an important branch of software engineering research and practice. Because architectural-level decisions are prone to have a profound impact on finished software products, it is important to apprehend their quality attributes and to quantify them (as much as possible). In this paper, we discuss an information-theoretic approach to the definition and validation of architectural metrics, and illustrate our approach on a sample example.

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.

This paper presents a methodology and an example of risk assessment of functional-requirement specifications for complex real-time software systems. A heuristic risk-assessment technique based on CPN (colored Petri-net) models is presented. This technique is used to classify software functional-requirement specification components according to their relative importance in terms of such factors as severity and complexity. A dynamic complexity measure, based on concurrence in the functional requirements, is introduced. This technique is applied on the Earth Operation Commanding Center (EOC COMMANDING), a large component of the NASA Earth Observing System (EOS) project. Two specification models of the system are considered. Results of applying this technique to both CPN models are presented. The risk assessment methodology in this paper suggests the following conclusions: (i) risk assessment at the functional-requirement specification phase can be used to classify functional requirements in terms of their complexity and severity; (ii) dynamic complexity metrics and the concurrence metric can be important in assessing the risk factors based on the complexity of functional specifications; (iii) the concurrence complexity metric is an important aspect of dynamic complexity; and (iv) CPN models can be used to build an executable specification of the system, which helps the analyst not only to acquire deep understanding of the system but also to study the dynamic behavior of the system by simulating the model.

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.

Software designers are motivated to utilize off-the-shelf software components for rapid application development. Such applications are expected to have high reliability as a result of deploying trusted components. The claims of high reliability need further investigation based on reliability analysis techniques that are applicable to component-based applications. This paper introduces a probabilistic model and a reliability analysis technique that is applicable to high-level designs. The technique is named scenario-based reliability analysis (SBRA). SBRA is specific to component-based software whose analysis is strictly based on execution scenarios. Using scenarios, we construct a probabilistic model named a "component-dependency graph" (CDG). CDGs are directed graphs that represent components, component reliabilities, link and interface reliabilities, transitions and transition probabilities. In CDGs, component interfaces and link reliabilities are treated as first-class elements of the model. Based on CDGs, an algorithm is presented to analyze the reliability of the application as the function of reliabilities of its components and interfaces. A case study illustrates the applicability of the algorithm. The SBRA is used to identify critical components and critical component interfaces, and to investigate the sensitivity of the application reliability to changes in the reliabilities of components and their interfaces.

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.

Scenario based dynamic analysis is an important technique used in the verification of specification models for complex real time systems. One of the important problems facing developers of these systems is conducting risk analysis at early stages of development. Our methodology for risk assessment uses colored Petri net (CPN) models for predicting risk factors of system components, based on severity and complexity measures. CPN models are developed from system requirements specifications, and risk analysis provides guidance for identifying high risk components prior to their actual design and implementation. The analysis of the specification models is performed through scenario based simulations. Even though the set of scenarios used for simulation is very important for the success of risk analysis, the scenarios are chosen in an ad hoc fashion, usually guided by the experience of domain experts. Therefore, it is likely that some important scenarios are overlooked, due to the complexity of the system. We propose a technique that increases the likelihood that high risk scenarios are identified. The technique is based on input domain partitioning. Partitions can be determined from the given CPN model automatically. Predicates, which describe subdomains of the input space, assist users in revealing interesting scenarios. This methodology is applied to the assessment of a commanding component of NASA's Earth Observing System (EOS).

This paper presents an example of risk assessment in complex real-time software systems at the early stages of development. A heuristic risk assessment technique based on colored Petri net (CPN) models is used to classify software according to its relative importance in terms of such factors as severity and complexity. The methodology of this technique is presented in a companion paper (Ammar et al., 1997). This technique is applied on the Earth Operation Commanding Center; a large component of NASA's Earth Observing System (EOS) project. Two specifications of the system are considered: a sequential model and a pipeline model. Results of applying the above technique to both CPN-based models yield different complexity measures. The pipeline model shows clearly a higher risk factor than the sequential model. Whereas using traditional complexity measures, the risk factors were similar in both models.

An algorithm and a methodology for the performability analysis of repairable distributed real-time systems are presented. The planning cycle of a real-time distributed system, which normally consists of several task invocations, is first identified. The performability distribution at the end of the planning cycle is determined by repeated convolutions of performability densities between task invocations. These convolution operations are efficiently carried out using the operational properties of Laguerre coefficients. The algorithm numerically determines both moments and distribution of performability in O(N/sub max//sup 3/), where N/sub max/ is the largest size of the state space between any task invocations. To illustrate the overall methodology, a simplified example of a radar system is analyzed, and the various performability measures are obtained using the algorithm.>

A time-scale decomposition (TSD) algorithm of a class of generalized stochastic Petri net (GSPN) models of systems comprising activities whose duration differ by orders of magnitude is presented. The GSPN model of a system can be decomposed into a hierarchical sequence of aggregated subnets, each of which is valid at a certain time scale. These smaller subnets are solved in isolation and their solutions are combined to get the solution of the whole system. A degradable multiprocessor system which would be intractable using conventional techniques, is analyzed using TSD. The complexity of the TSD algorithm can be orders of magnitude smaller without any significant loss in the accuracy of the result. In general, the error due to aggregation is proportional to the maximum degree of coupling between aggregates. An expression of the error due to aggregation is also given in terms of the ratio of fast and slow transitions in the GSPN model. The algorithm is easy to use and can be easily automated.>

A time-scale decomposition (TSD) algorithm of a class of generalized stochastic Petri net (GSPN) models for performance evaluation of degradable multiprocessor systems is presented. The failure and repair rates in a multiprocessor system are an order of magnitude smaller than the rates of job arrival and completion; therefore, the GSPN models of these systems are decomposed into a hierarchical sequence of aggregated subnets, each of which is valid at a certain time scale. These smaller subnets are involved in isolation, and their solutions are combined to get the solution of the whole system. The algorithm is described step-by-step using a simple example. Then a large degradable multiprocessor system, which is intractable using conventional GSPN solution techniques, is analyzed. The complexity of the TSD algorithm is an order of magnitude smaller.>