Introducing Energy Efficiency into SQALE

Energy Efficiency is becoming a key factor in software development, given the sharp growth of IT systems and their impact on worldwide energy consumption. We do believe that a quality process infrastructure should be able to consider the Energy Efficiency of a system since its early development: for this reason we propose to introduce Energy Efficiency into the existing quality models. We selected the SQALE model and we tailored it inserting Energy Efficiency as a sub-characteristic of efficiency. We also propose a set of six source code specific requirements for the Java language starting from guidelines currently suggested in the literature. We experienced two major challenges: the identification of measurable, automatically detectable requirements, and the lack of empirical validation on the guidelines currently present in the literature and in the industrial state of the practice as well. We describe an experiment plan to validate the six requirements and evaluate the impact of their violation on Energy Efficiency, which has been partially proved by preliminary results on C code. Having Energy Efficiency in a quality model and well verified code requirements to measure it, will enable a quality process that precisely assesses and monitors the impact of software on energy consumptio

A Testability Analysis Framework for Non-Functional Properties

This paper presents background, the basic steps and an example for a testability analysis framework for non-functional properties

Understanding Class-level Testability Through Dynamic Analysis

It is generally acknowledged that software testing is both challenging and time-consuming. Understanding the factors that may positively or negatively affect testing effort will point to possibilities for reducing this effort. Consequently there is a significant body of research that has investigated relationships between static code properties and testability. The work reported in this paper complements this body of research by providing an empirical evaluation of the degree of association between runtime properties and class-level testability in object-oriented (OO) systems. The motivation for the use of dynamic code properties comes from the success of such metrics in providing a more complete insight into the multiple dimensions of software quality. In particular, we investigate the potential relationships between the runtime characteristics of production code, represented by Dynamic Coupling and Key Classes, and internal class-level testability. Testability of a class is consider ed here at the level of unit tests and two different measures are used to characterise those unit tests. The selected measures relate to test scope and structure: one is intended to measure the unit test size, represented by test lines of code, and the other is designed to reflect the intended design, represented by the number of test cases. In this research we found that Dynamic Coupling and Key Classes have significant correlations with class-level testability measures. We therefore suggest that these properties could be used as indicators of class-level testability. These results enhance our current knowledge and should help researchers in the area to build on previous results regarding factors believed to be related to testability and testing. Our results should also benefit practitioners in future class testability planning and maintenance activities

Component Integration Metrics and Their Evaluation

Software Engineering (SE) has been described as the discipline devoted to the design, development, and use of computer software, covering not only the technical aspects of building software systems, but also management issues develops highly complex software. The crisis in SE, due to the lack of well-defined formal processes, has led to poorly designed products with high maintenance costs and whose behavior becomes unpredictable. Component Based Software Engineering (CBSE) is currently a preferred approach to system design to overcome the crisis of SE, since it promotes software re-use, facilitates adaptability and faster system development. A component provides a function or a set of related functions, which forms a reusable program building block that can be combined with other components to form an application. A component with qualities such as, reusability, testability, modularity, complexity, proper to communicate and stability reduces maintenance costs. The components thus integrated, should be able to interoperate so that an operational application that results in reduced maintenance costs can be composed with minimal effort. Metrics are used to measure a component\u27s quality factor and there are no good metrics available to validate their effectiveness, when components are integrated. Currently, the success of projects based on the CBSE methodology relies on experts who assess software components; however, their evaluation process involves parameters that may not be measured in practice. Existing traditional metrics are inappropriate since CBSE is aimed at improving interoperability and re-usability. Size metrics based on lines of code are not applicable as component sizes may not be known a priori. Furthermore, complexities that arise due to varying nature of facets and interfaces are not addressed by traditional metrics. This thesis addresses the evaluation of a series of metrics based on complexity, criticality and dynamic behavior, in order that component integration performance can be assessed. Three suites of metrics defined by various authors have been considered for evaluation so that one could choose the best metrics to measure an integrated environment. A suite of metrics proposed by Narasimhan and Hendradjaya are classified based on the attributes of: complexity, criticality and dynamic aspects. These metrics use graph-based connectivity to represent a system of integrated components. While the complexity metrics consider the packing density of integrated components and the interaction density among the components, criticality metrics reveal the extent of binding within each component in the system. Dynamic metrics have also been collected during the execution of an application and aid the process involved in testing and maintenance. Metric related data sets have been from several benchmark programs using instrumentation programs and key inferences have been obtained; these inferences include a systematic evaluation of quality of the various metrics. Two new metrics have also been provided towards assessing the stability of the application: one metric, namely CRIT instability, calculates the instability of each component, while the second new metric, namely CRIT inheritance,counts the number of components whose children exceeds a threshold value. Both these metrics are useful to assess the stability of the application and, in addition, to determine the components in a given application that needs to be redesigned. Future work will focus on the development of a metric evaluation suite to assess the system\u27s stability as a whole, considering the role of each component in an application

A survey on software testability

Context: Software testability is the degree to which a software system or a unit under test supports its own testing. To predict and improve software testability, a large number of techniques and metrics have been proposed by both practitioners and researchers in the last several decades. Reviewing and getting an overview of the entire state-of-the-art and state-of-the-practice in this area is often challenging for a practitioner or a new researcher. Objective: Our objective is to summarize the body of knowledge in this area and to benefit the readers (both practitioners and researchers) in preparing, measuring and improving software testability. Method: To address the above need, the authors conducted a survey in the form of a systematic literature mapping (classification) to find out what we as a community know about this topic. After compiling an initial pool of 303 papers, and applying a set of inclusion/exclusion criteria, our final pool included 208 papers. Results: The area of software testability has been comprehensively studied by researchers and practitioners. Approaches for measurement of testability and improvement of testability are the most-frequently addressed in the papers. The two most often mentioned factors affecting testability are observability and controllability. Common ways to improve testability are testability transformation, improving observability, adding assertions, and improving controllability. Conclusion: This paper serves for both researchers and practitioners as an "index" to the vast body of knowledge in the area of testability. The results could help practitioners measure and improve software testability in their projects

A SOFTWARE TESTING ASSESSMENT TO MANAGE PROJECT TESTABILITY

The demand for testing services is, to a large extend a ?derived demand? influenced directly by the manner in which prior developed activities are undertaken. The early stages of a structured software development life cycle (SDLC) project can often run behind schedule, shrinking the time available for performing adequate testing especially when software release deadlines have to be met. This situation fosters the need to influence pre-testing activities and manage the testing effort efficiently. Our research examines how to measure testability of a SDLC project before testing begins. It builds on the ?design for testability? perspective by introducing a ?manage for testability? perspective. Software testability focuses on whether the activities of the SDLC process are progressing in ways that enable the testing team to find software product defects if they exist. To address this challenge, we develop a software testing assessment. This assessment is designed to provide testing managers with information needed to: (1) influence pre-testing activities in ways that ultimately increase testing efficiency and effectiveness, and (2) plan testing resources to optimize efficient and effective testing. We developed specific software testing assessment measures through interviews with key informants. We present data collected for the measures for large-scale structured software development projects to illustrate the assessment?s usefulness and application

A research review of quality assessment for software

Measures were recommended to assess the quality of software submitted to the AdaNet program. The quality factors that are important to software reuse are explored and methods of evaluating those factors are discussed. Quality factors important to software reuse are: correctness, reliability, verifiability, understandability, modifiability, and certifiability. Certifiability is included because the documentation of many factors about a software component such as its efficiency, portability, and development history, constitute a class for factors important to some users, not important at all to other, and impossible for AdaNet to distinguish between a priori. The quality factors may be assessed in different ways. There are a few quantitative measures which have been shown to indicate software quality. However, it is believed that there exists many factors that indicate quality and have not been empirically validated due to their subjective nature. These subjective factors are characterized by the way in which they support the software engineering principles of abstraction, information hiding, modularity, localization, confirmability, uniformity, and completeness

Testability Assessment Model for Object Oriented Software based on Internal and External Quality Factors

Software testability is coming out to be most frequent talked about subject then the underrated and unpopular quality factor it used to be in past few years. The correct and timely assessment of testability can lead to improvisation of software testing process. Though many researchers and quality controllers have proved its importance, but still the research has not gained much momentum in emphasizing the need of making testability analysis necessary during all software development phases. In this paper we review and analyse the factors affecting testability estimation of object oriented software systems during design and analysis phase of development life cycle. These factors are then linked together in the form of new assessment model for object oriented software testability. The proposed model will be evaluated using analytical hierarchical process (AHP)