Using application understanding to support impact analysis

Impact analysis - determining the potential effects of changes on a software system - plays an important role in software engineering tasks such as maintenance, regression testing, and debugging. In previous work, two new dynamic impact analysis techniques, CoverageImpact and PathImpact, were presented. These techniques perform impact analysis based on data gathered about program behavior relative to specific inputs, such as inputs gathered from field data, operational profile data, or test-suite executions. Due to various characteristics of the algorithms they employ, CoverageImpact and PathImpact are expected to differ in terms of cost and precision; however, there have been no studies to date examining the extent to which such differences may emerge in practice. Since cost-precision tradeoffs may play an important role in technique selection and further research, we wished to examine these tradeoffs. We therefore designed and performed an empirical study, comparing the execution and space costs of the techniques, as well as the precisions of the impact analysis results that they report. This paper presents the results of this study.

The framework is made to provide tools to develop the integrated modular avionics (IMA) applications, which could be launched on the target platform LynxOs-178 without modifying their source code. The framework usage helps students to form skills for developing modern modules of the avionics. In addition, students obtain deeper knowledge for the development of competencies in the field of technical creativity by using of the framework. The article describes the architecture and implementation of the Linux OS framework for ARINC653 compliant OS application development. The proposed approach reduces ARINC-653 application development costs and gives a unified tool to implement OS vendor independent code that meets specification. To achieve import substitution free and open-source Linux OS is used as an environment for developing IMA applications. The proposed framework is applicable for using as the tool to develop IMA applications and as the tool for development of the following competencies: the ability to master techniques of using software to solve practical problems, the ability to develop components of hardware and software systems and databases, using modern tools and programming techniques, the ability to match hardware and software tools in the information and automated systems, the readiness to apply the fundamentals of informatics and programming to designing, constructing and testing of software products, the readiness to apply basic methods and tools of software development, knowledge of various technologies of software development.

Aspect-oriented Component Engineering uses early aspects to better categorize and reason about provided and required services of individual components in software systems. Our earlier work on AOCE demonstrated an increase in the reusability and understandability of software components and systems via its usage of early requirements and design-phase aspects but lacked adequate tool support. We describe a novel design tool called Aspect-Oriented UML (AO-UML) that can be used to efficiently capture and manage early aspects for software development using the Aspect-oriented Component Engineering methodology. The key benefits of our tool are its use throughout the development lifecycle and its ability to support and take advantage of Aspect-Oriented Component Engineering's features and capabilities.

The literature reports that source code lexicon plays a paramount role in program comprehension, especially when software documentation is scarce, outdated or simply not available. In source code, a significant proportion of vocabulary can be either acronyms and-or abbreviations or concatenation of terms that can not be identified using consistent mechanisms such as naming conventions. It is, therefore, essential to disambiguate concepts conveyed by identifiers to support program comprehension and reap the full benefit of Information Retrieval-based techniques (e.g., feature location and traceability) whose linguistic information (i.e., source code identifiers and comments) used across all software artifacts (e.g., requirements, design, change requests, tests, and source code) must be consistent. To this aim, we propose source code vocabulary normalization approaches that exploit contextual information to align the vocabulary found in the source code with that found in other software artifacts. We were inspired in the choice of context levels by prior works and by our findings. Normalization consists of two tasks: splitting and expansion of source code identifiers. We also investigate the effect of source code vocabulary normalization approaches on software maintenance tasks. Results of our evaluation show that our contextual-aware techniques are accurate and efficient in terms of computation time than state of the art alternatives. In addition, our findings reveal that feature location techniques can benefit from vocabulary normalization approaches when no dynamic information is available.

Monitoring and measuring industrial software processes are necessary for understanding processes and establishing baselines for process improvement. In this paper we monitor and measure the capability of experienced software developers to predict software change caused by new requirements to an existing software system (i.e. impact analysis) at different levels of granularity. The study shows a general underprediction and that the accuracy of the prediction deteriorated with increasing level of detail. The results were non-intuitive for the practitioners participating in the study and therefore important to consider when revising current processes and cost models based on such estimates. The study is a good example of how software industry can co-operate with university researchers in monitoring, measuring and evaluation of current practices. The results will be used by the organization as a baseline for further studies of subsequent releases of the product. Copyright © 1998 John Wiley & Sons, Ltd.

Mobile software application development process must be matured enough to handle the challenges (especially market related) associated with the development of high quality mobile software development. Ever increasing number of both mobile users and mobile applications had presented software engineers with the challenge of satisfying billions of users with high quality software applications to be delivered within deadline and budgets. Always there had been a lot of pressure to develop complex software categorized by thousands of requirements, under resource constrained environment. Requirement prioritization is one of the activities undertaken by software engineer to deliver partial software product to its customers such that most important requirements are implemented in the earliest releases. During next releases some changed and pending requirements are implemented, an activity that generates ripple effects. Such ripple effects need to be tested by executing modified source code against test cases of previous releases (regression testing). Regression testing is a very effortful activity that requires a software tester to select test cases that have high fault detection capability, execute the modified code against selected test cases and performing debugging. This regression testing activity can be lowered to the maximum extend by considering dependencies between requirements during the time of requirement prioritization. Thus requirement prioritization will be carried out not only against aspects like cost, time, risks, business values etc but against dependencies also. The aim is to implement almost all dependent highest priority requirements in current release so that implementation of new requirements is unlikely to have ripple effects. Changes in requirements might not be related to variable usage and definition and might not involve a change in functionality. In such cases there is no need to select already executed test cases of previous versions. Module dependencies can lead to test case selections of previous versions if changes of requirement lead to ripple effects. This paper aims to implement highest priority requirements such that regression testing is performed to minimum thereby improving development process of mobile applications. The proposed technique had been successfully evaluated on Android based notification software application that meets the specification of Aakash tablets.

A software component is an assembly unit that can be deployed independently in any software system. Since the source code and development documents of software components cannot be obtained, the vulnerability testing for software components is a challenge for component users. Explicit and implicit vulnerabilities are two common security vulnerabilities in the components. In this paper, in order to detect security vulnerabilities in the component under test effectively, a mining approach for component abnormal information based on monitor log is proposed. For explicit vulnerability, the monitor log is mined with the improved apriori algorithm, and the risk coefficient of each method in component is calculated with the frequent item sets algorithm based on the mining results. For implicit vulnerability, all the method execution sequences in monitor log should be extracted and stored into a database to establish the method sequence database. The vulnerability testing report will be obtained by mining the method sequence database with the improved generalised sequential patterns (GSP) algorithm after data preprocessing. An empirical study based on the proposed method is conducted, and the experimental results show that the approach to mine component abnormal information can effectively detect security exceptions of the component under test.

Approaches that support software maintenance need to be evaluated and compared against existing ones, in order to demonstrate their usefulness in practice. However, oftentimes the lack of well-established sets of benchmarks leads to situations where these approaches are evaluated using different datasets, which results in biased comparisons. In this data paper we describe and make publicly available a set of benchmarks from six Java applications, which can be used in the evaluation of various software engineering (SE) tasks, such as feature location and impact analysis. These datasets consist of textual description of change requests, the locations in the source code where they were implemented, and execution traces. Four of the benchmarks were already used in several SE research papers, and two of them are new. In addition, we describe in detail the methodology used for generating these benchmarks and provide a suite of tools in order to encourage other researchers to validate our datasets and generate new benchmarks for other subject software systems. Our online appendix: http://www.cs.wm.edu/semeru/data/msr13/.

Unforeseen safety and security failures in complex software-intensive systems arise due to hidden dependencies between system components and artifacts. These stem from stakeholder misunderstanding of system artifact and component interactions. In most systems, artifacts are defined and described, and components are designed, implemented, and combined by engineers in multiple disciplines. Also, artifacts are described in places separated by hundreds of pages or files and in different domain and description languages, including natural, graphical, and domain-specific languages. Hence, it is of primary importance, but also currently extremely difficult, to discover these hidden dependencies. To help engineers find these dependencies, and hence better foresee erroneous interactions, an approach that enables and promotes a holistic, hierarchical, and incremental description of a system is needed. In this article, we introduce EXMPLRAD. EXMPLRAD is a human-centered language that enables the description and integration of informal and formal requirements, architectural and design descriptions, source code, and configuration artifacts, and their relationships in a format that resembles code. A holistic system model described using EXMPLRAD enables the creation and application of methods for the automatic discovery of hidden dependencies. We demonstrate this with a case study that analyzes the seL4 microkernel's Inter- Process Communication subsystem including the modeling of its requirements, architecture, and source code in C.

The autonomic computing paradigm addresses the operational challenges presented by increasingly complex software systems by proposing that they be composed of many autonomous components, each responsible for the runtime reconfiguration of its own dedicated hardware and software components. Consequently, regulation of the whole software system becomes an emergent property of local adaptation and learning carried out by these autonomous system elements. Designing appropriate local adaptation policies for the components of such systems remains a major challenge. This is particularly true where the system’s scale and dynamism compromise the efficiency of a central executive and/or prevent components from pooling information to achieve a shared, accurate evidence base for their negotiations and decisions. In this paper, we investigate how a self-regulatory system response may arise spontaneously from local interactions between autonomic system elements tasked with adaptively consuming/providing computational resources or services when the demand for such resources is continually changing. We demonstrate that system performance is not maximized when all system components are able to freely share information with one another. Rather, maximum efficiency is achieved when individual components have only limited knowledge of their peers. Under these conditions, the system self-organizes into appropriate community structures. By maintaining information flow at the level of communities, the system is able to remain stable enough to efficiently satisfy service demand in resource-limited environments, and thus minimize any unnecessary reconfiguration whilst remaining sufficiently adaptive to be able to reconfigure when service demand changes.

The interest behind the use of component based software engineering is to divide an information system in subsystems with less complexity, the reduction of time, faster development, and enhancing the productivity. The software systems are developed by assembling components which are software units that offer a set of services exposed as interfaces. The indispensable role of component-based development is the component model that defines how components can be built and how they can be assembled. A component is intended to provide specific services as the management of the combination and the communication between the system units. The Manager Component is an important and complementary paradigm for the development of software systems. The functionalities that it encapsulates must be related and consistent. The model presented in this paper proposes a component called Manager Software component based on the viewpoint (vision of each system user and actor) by the assembly of Base Component and system components.

User requirements have been changed during development progresses, since they are impossible to define all of software requirements. These requirements change leads to mistakes because the developers cannot completely understand the software structure and behavior, or they cannot discover all parts affected by a change. Therefore, requirement changes have to be managed and assessed to ensure that they are feasible, make economic sense, and contribute to the business needs of the customer organization. We propose requirements change management process on feature-oriented requirements tracing. It is based on value analysis and feature-oriented requirement traceability links. Our approach offers two contributions to the study of requirements change: (1)We define a requirements change tree model to make user requirements change request generalize by feature level. (2)We provide overall process such as change request normalization, change impact analysis, change request alternative design, change request implementation, and change request evaluation. In addition, we especially summarize the results of a case study which is carried out in asset management portal system.

The purpose of the article is to consider the information and analytical support of the cash flows management at the enterprises. It is necessary to investigate the theoretical aspects of the information and analytical support of the cash flows management, taking into account the current conditions of the enterprises. The object of the research is the information and analytical support of the cash flows management at the enterprises. The methods of cognition, synthesis, generalization, systematization, visual methods are used. The concept of "information flow" is considered, which can be considered in three aspects: syntactic, semantic, and pragmatic. The term "information and analytical support" is disclosed from the point of view of scientific concepts of various researchers. It is determined the components of the information and analytical support of the cash flow management. These components include: information, analytical, software and technological support. The sources of the information component of the information and analytical support of the enterprise's cash flow management are determined. It has been proven that the quantity and quality of information determines the effectiveness of the entire management system of the enterprise as a whole and cash flow management, in particular. A systematization of stakeholders interested in receiving data on the company's cash flows is provided. Thus, a component of the cash flow management system is information and analytical support, the main components of which are informational, analytical, software and technological components. To carry out an effective analysis of cash flows, it is necessary to create an information base that includes external and internal information. When studying internal information, it is divided into accounting and non-accounting. The results of the study showed that the need of stakeholders for information about the state of cash flows of financial statements is growing every year, therefore it is important to provide stakeholders with reliable information. The expediency of distinguishing two groups of information users: external and internal has been established. The practical value of the conducted research lies in the further use of information and analytical support in the company's activities.

Identifying defective software components as early as their commit helps to reduce significant software development and maintenance costs. In recent years, several studies propose to use just-in-time (JIT) defect prediction techniques to identify changes that could introduce defects at check-in time. To predict defect introducing changes, JIT defect prediction approaches use change metrics collected from software repositories. These change metrics, however, capture code and code change related information. Information related to the change requests (e.g., clarity of change request and difficulty to implement the change) that could determine the change’s proneness to introducing new defects are not studied. In this study, we propose to augment the publicly available change metrics dataset with six change request- based metrics collected from issue tracking systems. To build the prediction model, we used five machine learning algorithms: AdaBoost, XGBoost, Deep Neural Network, Random Forest and Logistic Regression. The proposed approach is evaluated using a dataset collected from four open source software systems, i.e., Eclipse platform, Eclipse JDT, Bugzilla and Mozilla. The results show that the augmented dataset improves the performance of JIT defect prediction in 19 out of 20 cases. F1-score of JIT defect prediction in the four systems is improved by an average of 4.8%, 3.4%, 1.7%, 1.1% and 1.1% while using AdaBoost, XGBoost, Deep Neural Network, Random Forest and Logistic Regression, respectively.

Feature models are frequently used to capture the knowledge about configurable software systems and product lines. However, feature modeling of large-scale systems is challenging as many models are needed for diverse purposes. For instance, feature models can be used to reflect the perspectives of product management, technical solution architecture, or product configuration. Furthermore, models are required at different levels of granularity. Although numerous approaches and tools are available, it remains hard to define the purpose, scope, and granularity of feature models. In this paper we thus present experiences of developing feature models for two large-scale industrial automation software systems. Specifically, we extended an existing feature modeling tool to support models for different purposes and at multiple levels. We report results on the characteristics and modularity of the feature models, including metrics about model dependencies. We further discuss lessons learned during the modeling process.