Exact or nearly similar code fragments in a software system's source code are referred to as code clones. It is often the case that updates (i.e., changes) to a code clone will need to be propagated to its related code clones to preserve their similarity and to maintain source code consistency. When there is a delay in propagating the changes (possibly because the developer is unaware of the related cloned code), the system might behave incorrectly. A delay in propagating a change is referred to as `late propagation,' and a number of studies have investigated this phenomenon. However, these studies did not investigate the intensity of late propagation nor how late propagation differs by clone type. In this research, we investigate late propagation separately for each of the three clone types (Type 1, Type 2, and Type 3). According to our experimental results on thousands of revisions of eight diverse subject systems written in two programming languages, late propagation occurs more frequently in Type 3 clones compared with the other two clone types. More importantly, there is a higher probability that Type 3 clones will experience buggy late propagations compared with the other two clone types. Also, we discovered that block clones are more involved in late propagation than method clones. Refactoring and tracking of Similarity Preserving Change Pattern (SPCP) clones (i.e., the clone fragments that evolve following a SPCP) can help us minimize the occurrences of late propagation in clones.

As software-based systems become more pervasive, there is a need to construct systems that in addition to meeting their functional requirements also adhere to their non-functional requirements, specifically those requirements that impact reliability, safety and security. The stated requirements all make a strong case for High Assurance Systems Engineering. Both academia and industry continue to seek new techniques and tools to develop systems that ensure their systems meet the highest assurance standards. In this special issue on High Assurance Systems Engineering, seven papers are presented that investigate problems in the areas of reliability, safety and security. The first paper ‘‘An Empirical Exploration of Distortion in Fault Injection Experiments’’ by Erik van der Kouwe, Cristiano Giuffrida and Andrew S. Tanenbaum investigates whether fault injection experiments faithfully represents the fault model designed by the user. Most software researchers and practitioners accept the fact that there will always be bugs present in software, except for trivial programs; therefore the focus for highly reliable systems should also be on the mechanisms that contain faults and recover from them. This paper makes a case for carefully evaluating whether activated faults, when using a fault injection technique, match the user’s fault model of the software and identifying which parameters impact the activation of faults from the fault model. The second paper ‘‘Accelerating Temporal Verification of Simulink Diagrams Using Satisfiability Modulo Theories’’ by Petr Bauch, Vojtech Havel and Jiri Barnat explores the process of model checking for Simulink diagrams by developing a hybrid approach that involves the explicit and symbolic representations of sets. The approach takes into account

Debugging--the process of identifying, localizing and fixing bugs--is a key activity in software development . Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of methods, models and tools for debugging concurrent and multicore software have been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve. This suggests the need for a classification, and an up-to-date comprehensive overview of the area. This paper presents the results of a systematic mapping study in the field of debugging of concurrent and multicore software in the last decade (2005---2014). The study is guided by two objectives: (1) to summarize the recent publication trends and (2) to clarify current research gaps in the field. Through a multi-stage selection process, we identified 145 relevant papers. Based on these, we summarize the publication trend in the field by showing distribution of publications with respect to year, publication venues, representation of academia and industry, and active research institutes. We also identify research gaps in the field based on attributes such as types of concurrency bugs, types of debugging processes, types of research and research contributions. The main observations from the study are that during the years 2005---2014: (1) there is no focal conference or venue to publish papers in this area; hence, a large variety of conferences and journal venues (90) are used to publish relevant papers in this area; (2) in terms of publication contribution, academia was more active in this area than industry; (3) most publications in the field address the data race bug; (4) bug identification is the most common stage of debugging addressed by articles in the period; (5) there are six types of research approaches found, with solution proposals being the most common one; and (6) the published papers essentially focus on four different types of contributions, with "methods" being the most common type. We can further conclude that there are still quite a number of aspects that are not sufficiently covered in the field, most notably including (1) exploring correction and fixing bugs in terms of debugging process; (2) order violation, suspension and starvation in terms of concurrency bugs; (3) validation and evaluation research in the matter of research type; (4) metric in terms of research contribution. It is clear that the concurrent, parallel and multicore software community needs broader studies in debugging. This systematic mapping study can help direct such efforts.

Developers need to comprehend a program before modifying it. In such cases, developers use cues to establish the relevance of a piece of information with a task. Being familiar with different kinds of cues will help the developers to comprehend a program faster. But unlike the experienced developers, novice developers fail to recognize the relevant cues, because (a) there are many cues and (b) they might be unfamiliar with the artifacts. However, not much is known about the developers' choice of cue. Hence, we conducted two independent studies to understand the kind of cues used by the developers and how a tool influences their cue selection. First, from our user study on two common comprehension tasks, we found that developers actively seek the cues and their cue source choices are similar but task dependent. In our second exploratory study, we investigated whether an integrated development environment (IDE) influences a developer's cue choices. By observing their interaction history while fixing bugs in Eclipse IDE, we found that the IDE's influence on their cue choices was not statistically significant. Finally, as a case in point, we propose a novel task-specific program summarization approach to aid novice developers in comprehending an unfamiliar program. Our approach used developers cue choices to synthesize the summaries. A comparison of the synthesized summaries with the summaries recorded by the developers shows both had similar content. This promising result encourages us to explore task-specific cue models, which can aid novice developers to accomplish complex comprehension tasks faster.

Models are a useful tool to increase the developer's productivity and satisfaction when performing maintenance tasks. However, in order to maximise these advantages, the right selection of notations must be made. Unfortunately, the software engineering field lacks a body of empirical evidence that supports such selection. A suboptimal decision in this regard may have negative consequences over the maintenance process. The aim of the study was to compare a textual and a graphical notation with respect to the efficiency, effectiveness and satisfaction of junior software developers while performing analysability and modifiability tasks on two different applications. We have carried out a quasi-experiment with 86 third-year students of the Computer Engineering degree at the University of Alicante. Subjects were randomly classified into two groups, and each group performed 20 maintenance tasks with a textual and a graphical notation. We measured and compared the efficiency, effectiveness and satisfaction of subjects assigned to each treatment. The analysed data show that only the actual analysability coverage (AACov) and the actual modifiability efficiency (AMEffc) are affected by the type of notation used, regardless of the application. In both cases, subjects using the textual notation performed significantly better, although the effect size was low to moderate (AACov $$\eta ^2=0.106$$ź2=0.106, AMEffc $$\eta ^2=0.187$$ź2=0.187). This is a pilot study, and it has been conducted to enhance the design of future studies in this area. Thus, it should be replicated to extend our conclusions to other subject profiles, different textual and graphical notations, and application types.

Risk orientation in testing is an important means to balance quality, time-to-market, and cost of software. Especially for small and medium enterprises (SME) under high competitive and economic pressure, risk orientation can help to focus testing activities on critical areas of a software product. Although several risk-based approaches to testing are available, the topic has so far not been investigated in the context of SME, where risks are often associated with business critical issues. This article fills the gap and explores the state of risk orientation in the testing processes of SME. Furthermore, it compares the state of risk-based testing in SME to the situation in large enterprises. The article is based on a multiple case study conducted with five SME. A previous study on risk-based testing in large enterprises is used as reference for investigating the differences between risk orientation in SME and large enterprises. The findings of our study show that a strong business focus, the use of informal risk concepts, as well as the application of risk knowledge to reduce testing cost and time are key differences of risk-based testing in SME compared to large enterprises.

Software plays a crucial role in modern societies. Not only do people rely on it for their daily operations or business, but also for their lives as well. For this reason, correct and consistent behavior of software systems is a fundamental and critical part of end-user expectations. Additionally, businesses require cost-effective production, maintenance, and operation of their systems. Thus, the demand for high-quality and maintainable software is increasing, setting it as a differentiator for the success or failure of a software product, as well as a dominating factor for the commercial success of companies. The main questions that arise concern how quality is measured and communicated to stakeholders. What, where, and when we assess and assure quality are also open issues. Many views have been expressed about software quality attributes including maintainability, security, evolvability, portability, robustness, reliability, usability, and efficiency. Some of these have been formulated in standards such as ISO/IEC 25010 (SQuaRE) and CMMI. However, the debate about quality and maintainability between software producers, vendors, and users continues, while organizations need the ability to evaluate the software systems they use or develop from multiple viewpoints. So, is ‘‘software quality in the eye of the beholder’’? This special section on Software Quality and Maintainability presents original work and relates experiences on issues pertaining to software quality and maintainability. Moreover, the theme of this special section opens discussion of how to investigate quality issues in the maintenance of software systems. Out of 15 full-paper submissions for this issue, four papers were selected. The accepted papers address a range of topics related to software quality, including code refactoring, API

Test suite reduction strategies aim to produce a smaller and representative suite that presents the same coverage as the original one but is more cost-effective. In the model-based testing (MBT) context, reduction is crucial since automatic generation algorithms may blindly produce several similar test cases. In order to define the degree of similarity between test cases, researchers have investigated a number of distance functions. However, there is still little or no knowledge on whether and how they influence on the performance of reduction strategies, particularly when considering MBT practices. This paper investigates the effectiveness of distance functions in the scope of a MBT reduction strategy based on the similarity degree of test cases. We discuss six distance functions and apply them to three empirical studies. The first two studies are controlled experiments focusing on two real-world applications (and real faults) and ten synthetic specifications automatically generated from the configuration of each application (and faults randomly generated). In the third study, we also apply the reduction strategy to two subsequent versions of an industrial application by considering real faults detected. Results show that the choice of a distance function has little influence on the size of the reduced test suite. However, as reduced suites are different depending on the distance function applied, the choice can significantly affect the fault coverage. Moreover, it can also affect the stability of the reduction strategy regarding coverage of different sets of faults on different executions.