This work investigates whether the development methodology affects some metrics that are related to the quality of the generated code. Trying to characterize the development methodology using software metrics could be beneficial to developers who use agile approaches extensively. Therefore, this study sheds light on the metrics that might be highly affected by following agile approaches. The values of these metrics need to be tracked, because they might result in a quality-related issue, such as error-proneness, for example. The proposed approach employs different feature selection and classification methods, which include artificial neural networks. We used 11 object-oriented systems of various sizes and functionalities. Five of the used systems were developed using agile approaches, while the rest were developed using non-agile methodologies. The classes and methods of the used systems were represented by a set of metrics that shows some complexity, cohesion, and coupling features of the systems. The generated metrics are used as features to classify between the two different types of the development methodologies using a feed-forward artificial neural network. The obtained high classification accuracy shows the strong relationship between the used metrics and the type of the followed development process. Copyright © 2015 John Wiley & Sons, Ltd.

This study introduces a novel image encryption system based on diffusion and confusion processes in which the image information is hidden inside the complex details of fractal images. A simplified encryption technique is, first, presented using a single‐fractal image and statistical analysis is performed. A general encryption system utilising multiple fractal images is, then, introduced to improve the performance and increase the encryption key up to hundreds of bits. This improvement is achieved through several parameters: feedback delay, multiplexing and independent horizontal or vertical shifts. The effect of each parameter is studied separately and, then, they are combined to illustrate their influence on the encryption quality. The encryption quality is evaluated using different analysis techniques such as correlation coefficients, differential attack measures, histogram distributions, key sensitivity analysis and the National Institute of Standards and Technology (NIST) statistical test suite. The obtained results show great potential compared to other techniques.

The detection of function clones in software systems is valuable for the code adaptation and error checking maintenance activities. This paper presents an efficient metrics-based data mining clone detection approach. First, metrics are collected for all functions in the software system. A data mining algorithm, fractal clustering, is then utilized to partition the software system into a relatively small number of clusters. Each of the resulting clusters encapsulates functions that are within a specific proximity of each other in the metrics space. Finally, clone classes, rather than pairs, are easily extracted from the resulting clusters. For large software systems, the approach is very space efficient and linear in the size of the data set. Evaluation is performed using medium and large open source software systems. In this evaluation, the effect of the chosen metrics on the detection precision is investigated.

This paper investigates the use of entropies as measures of software information content. Several entropies, including the well-known Shannon entropy, are characterized by their mathematical properties. Based on these characterizations, the entropies, which are suitable for measuring software systems, are rigorously chosen. By treating a software system as an information source, the function calls in procedural systems or method invocations in object-oriented systems resemble the emission of symbols from an information source. Thus, the probabilities, required for computing the entropies, are obtained using an empirical distribution of function calls or method invocations. Application of the suggested measures on procedural and object-oriented programs is further explained using two small examples. Because a. rigorous definition of information measures does not guarantee their usefulness in practice, an evaluation case study is performed In particular, the aim of this study is to practically evaluate the intuitiveness and scalability of the measures on a real software system totaling about 460000 lines of code. In addition to being intuitive and meaningful, the case study results highlight differences between the information measures. Thus, the family of measures presented can satisfy different measurement requirements.

This paper studies the effects of two different program decomposition techniques on knowledge-based program understanding. The first technique generates events which encapsulate program parts that are interdependent with respect to data flow. The second technique is program slicing. Both techniques are briefly described and the resulting slices and events are compared. An understanding of a program is formed by matching its events or slices against previously designed knowledge base plans. In order to have a detailed insight into the design and utilization of the knowledge base, we perform a two-phase case study. The first phase uses the decomposition results of a set of 65 loops to construct two different knowledge bases; one for recognizing loop events and the other for recognizing loop slices. This phase of the case study demonstrates the different design decisions made during the construction of the two knowledge bases. The second phase of the case study utilizes the previously designed plans in analyzing a set of 92 loops extracted from five randomly selected programs. Finally, the results of comparing the two decomposition techniques are summarized

The paper evaluates a recently presented knowledge-based program understanding approach that generates first order predicate logic annotations of loops. An initial and partial evaluation of this approach was performed on an existing program of reasonable size. Plans in the knowledge base were designed by performing an analysis of the existing program. As a result, the previous study did not demonstrate that the knowledge base generated for a given program is generally usable beyond that program. An extensive evaluation of the analysis approach is performed. Plans developed during the initial evaluation stage are used to analyze a set of 92 loops in five randomly selected Pascal programs. Results concerning the analyzed loops and utilization of the existing plans are given and discussed. These results generally show a good usability of the knowledge base beyond the original program.

The paper presents a knowledge-based analysis approach that generates first order predicate logic annotations of loops. A classification of loops according to their complexity levels is presented. Based on this taxonomy, variations on the basic analysis approach that best fit each of the different classes are described. In general, mechanical annotation of loops is performed by first decomposing them using data flow analysis. This decomposition encapsulates closely related statements in events, that can be analyzed individually. Specifications of the resulting loop events are then obtained by utilizing patterns, called plans, stored in a knowledge base. Finally, a consistent and rigorous functional abstraction of the whole loop is synthesized from the specifications of its individual events. To test the analysis techniques and to assess their effectiveness, a case study was performed on an existing program of reasonable size. Results concerning the analyzed loops and the plans designed for them are given.

An overview of a knowledge-based approach which helps in the mechanical documentation and understanding of computer programs is given. This approach performs mechanical annotation of loops by first decomposing them into fragments, called events. It then recognizes the high-level concepts, represented by the events, based on patterns, called plans, stored in a knowledge-base. The design and utilization of the plans are described in detail, and how to generalize their structure is discussed. The generalized tree structure can facilitate plan recognition and reduce the size of the knowledge-base. A case study on a real program of some practical importance, containing a set of 77 loops, has been performed. Results concerning the plans designed for this case study are given.>

The problems related to the analysis and reengineering of existing software in order to reuse it are discussed. The authors introduce a process model for component extraction and focus on the problem of analyzing and qualifying software components which are candidates for reuse. A prototype tool for supporting the extraction of reusable components is presented. One of the components of this tool aids in understanding programs and is based on the functional model of correctness. It can assist software engineers in the process of finding correct formal specifications for programs. A detailed description of this component and an example to demonstrate a possible operational scenario are given.>