Abstract In the context of software engineering, product software quality measures how well a software artifact is designed and coded. Software products must satisfy nonfunctional properties (eg, reliability, usability, understandability, and maintainability), in order to make maintenance and evolution sustainable in the long period. Software evolution is an issue of interest for the malware writers, too, for 2 reasons. First, to evade detection with the minimum effort, malware writers use to produce “variants,” which are obtained by applying little changes to existing malware. Morevoer, recent studies demonstrated that malware is increasingly improving evasion strategies and infection mechanisms and is using more and more complex payloads. This suggests that malware writers are devoting relevant efforts and skills for producing high‐quality software. For this reason, we wonder whether malware writers are devoting effort to improve the structural quality of their code, too, as it happens in the development of goodware. To investigate this question, we (1) characterize a dataset containing about 20 000 Android applications, divided into goodware and malware ones, relying on the Android API version they require, and (2) compute software quality metrics, divided into 4 categories (ie, dimensional, complexity, object‐oriented, and Android‐oriented metrics) for apps belonging to each population. We then identify evolution trends of these metrics in malware and goodware. The results of our study demonstrate that goodware and malicious applications exhibit similar evolution trends for some of the quality indicators, suggesting that malware writers care about the overall quality of their code. Code quality could be considered an indirect measure of how many and how fast variants of existing malware will be released in the wild.

Android represents the most widespread mobile environment. This increasing diffusion is the reason why attackers are attracted to develop malware targeting this platform. Malware writers usually use code obfuscation techniques in order to evade the current antimalware detection and to generate new malware variants. These techniques make code programs harder to understand and they change the signature of the application making ineffective the signature extraction work. We propose a method based on formal methods able to identify whether a mobile application is obfuscated. In this preliminary work we identify one of the most widespread obfuscation technique: the code reordering. We test our method on a real-world dataset composed by Android trusted and ransomware samples, obtaining encouraging results.

Recent experiments demonstrated the effectiveness of pair programming in terms of quality and productivity. Growing interest towards global software development is fostering the design of suitable methods and tools for distributing software processes, at any level of detail, from entire subprocesses up to a single activity. Consequently, people placed in different locations could also share programming tasks and related practices, such as pair programming. Unfortunately, distribution might seriously compromise the success of pair programming, due to communication and collaboration issues. We have performed an experiment in order to investigate the impact of distribution on pair programming when performing maintenance tasks. An interesting conjecture stems from the experiment: under certain conditions, distributed pair's components tend to dismiss from each other, stopping the collaborative work. This can be a very expensive risk factor to keep into account when planning tasks of distributed pair programming.

We present an approach based on queuing theory and stochastic simulation to help planning, managing, and controlling the project staffing and the resulting service level in distributed multiphase maintenance processes. Data from a Y2K massive maintenance intervention on a large COBOL/JCL financial software system were used to simulate and study different service center configurations for a geographically distributed software maintenance project. In particular, a monolithic configuration corresponding to the customer's point-of-view and more fine-grained configurations, accounting for different process phases as well as for rework, were studied. The queuing theory and stochastic simulation provided a means to assess staffing, evaluate service level, and assess the likelihood to meet the project deadline while executing the project. It turned out to be an effective staffing tool for managers, provided that it is complemented with other project-management tools, in order to prioritize activities, avoid conflicts, and check the availability of resources.

The use of workflow technology to provide automated support to the management and execution of software engineering processes has become of great interest for large software companies that nowadays are moving towards the new model of "virtual" organizations. Therefore, workflow systems that allow co-operation among team members in a distributed environment are now a primary concern. In this paper we present a new workflow management system, named FlowManager, which has all the potential to be used in such application domain. FlowManager, in fact, will be a component of a larger European GENESIS project (Generalized Environment for Process Management in Cooperative Software Engineering), whose objective is to develop a non-invasive and open source environment for modeling software engineering processes and managing co-operation among geographically distributed teams.

Software evolution in a cooperative environment, where a pool of maintainers/developers contribute to the overall system changes, is challenging due to several factors, such as the poor communication among individuals and the high number of produced changes. Conflicting or contradictory changes, unforeseen or unexpected dependencies may result in a non working system. We propose a strategy aimed to reduce the risk of conflicting changes in a maintenance cooperative environment. To evaluate the feasibility of our approach and to attempt to estimate the size of the code to be scrutinised per single changed line, we developed a number of tools and tested our approach on release 30 of DDD software system. The preliminary results are encouraging. Potentially impacted LOCS per single changed LOC is on the average less than 4.

We present an experiment in identifying coarse-grained persistent objects in a legacy system of an Italian public organisation. Object methods are searched for at the program level driven by the minimisation of the coupling between objects. This strategy is useful in incremental migration projects requiring the identification of largely independent subsystems needing low re-engineering and decoupling costs to be first encapsulated in different wrappers and then selectively replaced. The aim of the experiment was to evaluate the feasibility of this approach when applied to large software systems. The work presented in this paper is part of the project PROGRESS, a research project on process and software re-engineering in Italian public organisations carried out by Italian universities and research centres.

Constructing code analyzers may be costly and error prone if inadequate technologies and tools are used. If they are written in a conventional programming language, for instance, several thousand lines of code may be required even for relatively simple analyses. One way of facilitating the development of code analyzers is to define a very high-level domain-oriented language and implement an application generator that creates the analyzers from the specification of the analyses they are intended to perform. This paper presents a system for developing code analyzers that uses a database to store both a no-loss fine-grained intermediate representation and the results of the analyses. The system uses an algebraic representation, called F(p), as the user-visible intermediate representation. Analyzers are specified in a declarative language, called F(p)-l, which enables an analysis to be specified in the form of a traversal of an algebraic expression, with access to, and storage of, the database information the algebraic expression indices. A foreign language interface allows the analyzers to be embedded in C programs. This is useful for implementing the user interface of an analyzer, for example, or to facilitate interoperation of the generated analyzers with pre-existing tools. The paper evaluates the strengths and limitations of the proposed system, and compares it to other related approaches.

This study is based on the Structured Process Model formalism previously proposed by the same authors, and describes some techniques for scheduling an execution plan which conforms to the chosen process but adapts to all the potential changes in the value of specific variables of the project. The executive plan is generated by means of Incremental Refinements. Each increment is the consequence of one or more decisions taken by the manager. All the contingencies which can occur during the execution of the project are classified in a finite number of types of events which form the basis for the definition of all the transition laws between the possible states of the process. Naturally, the manager's decisions, and therefore the composition of the increment, take into account the changes in the value of the variables of the process and of the process model itself. In addition, the study proposes the handling of fuzzy activities, by means of which the problems of recycles and reprocessing are solved. These activities also provide a better management of the execution times of the project.

Customised code analysis tools for the maintenance and evolution of existing software systems can be created by storing program information in a database, and using an application generator to translate the high-level specifications of the analyses the tools are intended to perform. We present a high-level domain-specific language for the specification of program analysis tools that exploit an algebraic program representation called F(p). The algebraic representation is a compact program view which describes the static composition of the control structures and the set of the resulting potential executions. Operands of the algebraic expression (that represent the program's constructs) are used as indexes to access information stored in the database. The specification language provides facilities for the traversal of the program representation and access to the associated information in the database. The program model and the analysis results are integrated into a unique conceptual model, thus simplifying the reuse of the results of an analysis and the integration of the tools.

We present a new program slicing process for identifying and extracting code fragments implementing functional abstractions. The process is driven by the specification of the function to be isolated, given in terms of a precondition and a postcondition. Symbolic execution techniques are used to abstract the preconditions for the execution of program statements and predicates. The recovered conditions are then compared with the precondition and the postcondition of the functional abstraction. The statements whose preconditions are equivalent to the pre and postconditions of the specification are candidate to be the entry and exit points of the slice implementing the abstraction. Once the slicing criterion has been identified the slice is isolated using algorithms based on dependence graphs. The process has been specialized for programs written in the C language. Both symbolic execution and program slicing are performed by exploiting the Combined C Graph (CCG), a fine-grained dependence based program representation that can be used for most software maintenance tasks. The work described in this paper is part of RE2, a research project aiming to explore reverse engineering and re-engineering techniques for reusing software components from existing systems.

The identification of abstractions within existing software systems is an important problem to be solved to facilitate program comprehension and the construction of a set of reusable artifacts. In particular, of interest is the identification of object-like features in procedural programs. Existing techniques and algorithms achieve some level of success but do not, in general, always precisely identify a coherent set of objects. The identified objects tend to contain spurious methods that are only tenuously related to the object and require a great deal of human effort and understanding to unravel. This paper presents an improved algorithm that overcomes these drawbacks and enables the precise identification of objects with less human intervention and understanding by exploiting simple statistical techniques. The algorithm is applied to several sample programs and the results are compared with existing algorithms. Finally, the application of the algorithm to a real medium-size system is described and discussed. The algorithm was developed as part of the RE2 project in which the identification of object-like features in existing systems is the basis for a re-engineering process aimed at populating a repository of reusable assets.

One of the greatest difficulties of setting up a software maintenance workbench is the definition of an internal representation of programs from which different external representations can be automatically constructed. This is because many techniques and tools exist that support and automate individual maintenance activities, and each of these techniques and tools operates on its own specific representation of the program. This paper presents our program representation, called F(p), and shows how it can be used as an index to access program information. This allows many existing representations to be derived from F(p). The paper presents two novel algorithms to derive two existing program representations, namely the control dependence graph and the sets of uses that can be reached from each variable definition (which provide the additional information needed to draw the program dependence graph).

We present the results of a case study in identifying and isolating reusable functions from C programs. The work exploits and specializes to programs written in C the theoretical framework of specification driven program slicing, a new program slicing process for isolating code fragments implementing functional abstractions. The specification of the function to be isolated, given in terms of a precondition and a postcondition, is used to identify a suitable slicing criterion. The preconditions for the execution of program statements and predicates are abstracted by using symbolic execution and compared with the conditions of the specification. The statements whose preconditions are equivalent to the pre and postconditions of the functional abstraction are candidates for entry and exit points of the slice implementing the abstraction. Once the slicing criterion has been identified, the slice can be isolated using algorithms based on control flow graphs and dependence graphs.

Abstract The destiny of legacy software is a relevant economic problem. Many companies are experiencing the friction that legacy systems oppose to the change and growth of their business. Nevertheless, these systems cannot be simply discarded and replaced with new ones developed according to the new organization requirements. Existing systems record a great deal of knowledge and expertise used to set up solutions to real problems in different application domains and it is imperative that this knowledge must not be lost, partly because it may not be recorded anywhere else than in the code. This paper discusses the problems related to the modularization of legacy systems, with the emphasis being placed on the automation of code scavenging. It is argued that a balance must be struck between the modularization of legacy code, and the production of reusable, easy‐to‐evolve modules. The paper provides a framework for examining system modularization methods and identifies a set of attributes that define their quality. An overview of modularization techniques is presented, and an evaluation is made to assess their strength and identify and understand their major limitations. Finally, an attempt is made to identify techniques and tools that are nature enough to be transferred from research laboratories to industry.

The paper is a summary of a third party re-engineering project aiming to adjust a legacy system to the new quality standard established by the customer. The quality standard is defined in the form of a set of metrics each associated with a range of acceptable values. A set of 100 programs has been restructured and modularised to meet the quality requirements. When possible, automated tools have been used in order to reduce the costs, standardise the results, and ease the transfer of techniques and methodologies to the customer. The re-engineered programs have replaced the original versions in the customer production environment. Their quality, and in particular their understandability and maintainability, is considerably increased as confirmed by the customer's technical personnel. The work described is a preliminary step towards the definition of a larger re-engineering project to bring the customer's software portfolio into line with the new quality standard.>

This paper presents algorithms for isolating reusable functions in large monolithic programs. The functions to be isolated are specified in terms of either pre-conditions or binding conditions, and these are mapped onto predicates on program's variables. Code components whose execution is triggered and/or bound by these predicates are then isolated. Each component is a candidate to implement a reusable function. The algorithms exploit a representation of the subject program in the form of a program dependence graph. This work forms part of RE/sup 2/, a research project that addresses the wider issue of software reuse. RE/sup 2/ project aims to promote the reuse of software through the exploration of reverse engineering and re-engineering techniques to identify and extract reusable software components from existing systems.>

This paper presents the results of research within the RE/sup 2/ project of a refinement of two existing methods for identifying reusable abstract data types. These methods are based on the relationships existing between the user defined types and procedure-like components that use them in their headings and on direct dominance trees and strong direct dominance trees that are refinements of the call directed graph of a program. It shows how these methods can be used to give a more precise set of reusable abstract data types. The method is then applied to a program and the results are compared with the existing method.>

Some features of software create considerable problems as regards the management of its construction processes, which therefore requires suitable models. In the studies published up to now on this subject, various problems have remained unsolved, particularly the readability of the numerous independent components for each activity in the process, the help required by the manager for handling projects and the need to adapt models to risks and the software development environment. The model proposed in this paper offers a solution to these problems. The innovative aspects of the approach described are the location of all pertinent information in the products of the model in order to improve management, and a formal definition which makes it possible to control the internal coherence of the plan automatically using a flexible notation which is compatible with the knowledge of all participants in the production process.

Abstract Initial research in reuse was in the designing and implementation of reusable software. This research, although fruitful, did not address the area of extracting reusable components from existing software. In this paper the term reuse is used to mean the ‘reuse of existing source code’. A process called ‘reuse re‐engineering’ is defined and this, together with techniques from reverse‐engineering, form a new method for achieving reuse. A reference paradigm is established to implement the reuse re‐engineering process. This process is divided into five sequential phases, each characterized by the objects it produces. These phases are: candidature, election, qualification, classification and storage, and search and display. This paper concentrates on the first three phases because they produce reusable modules from existing systems. In selecting candidates for reuse, different abstractions have to be applied, namely functional abstraction (algorithms) and data abstractions (data structures and data types). This paper presents a formalized approach to each of these abstractions. The approach proposed in this paper aims to promote reuse in industrial software production environments.

The results of a case study in identifying and extracting reusable abstract data types from C programs are presented. Reuse re-engineering processes already established in the RE/sup 2/ project are applied. The method for identifying abstract data types uses an interconnection graph called a variable-reference graph, and coincidental and spurious connections within the graph are resolved using a statistical technique. A prototype tool is described which demonstrates the feasibility of the method. The tool is used to analyze a C program, and a number of abstract data types are identified and used in the maintenance of the original program. The validity of the method is assessed by a simple manual analysis of the source code. The resulting reusable components are then specified using the formal notation Z.>

The first step in a software reuse reengineering process is to analyze the structural characteristics of the existing software so as to produce software component sets, each of which is a candidate for clustering and reengineering into a reusable module. This step is founded on one or more candidature criteria and the cost of the following steps depends on their quality. The notions of completeness and adequacy as applied to candidature criteria are introduced, the need for an adequacy validation process before they are applied on a software system is outlined. An adequate validation process founded on the assignment of a concept to the candidate modules is proposed, and the results of an application of this process are described and discussed.>

Abstract Parallel programs are intrinsically non‐deterministic, and therefore the techniques of cyclical debugging that are commonly used for sequential programs are not suitable for parallel ones. This paper proposes a method to reproduce Occam program behaviour. Saving information on the timer values input by the program and the guards selected at run‐time on alternative commands allows program replay, i.e. it makes it possible to re‐execute the program deterministically with the same inputs following the same instruction path. This enables the software developer to use tools such as debuggers and intrusive monitors to help identify program faults. After discussing possible implementations of the proposed technique, IRD (an interactive replay debugger for Occam programs) is described. Finally, the use of the IRD in a sample debug session is presented as an example.

A typographic error in rule 10 in the above-titled paper (see ibid., vol.18, no.12, p.1053-64, Dec. 1992), is corrected.>

The authors model the different points of view on a software structure as distinct conceptual models. The mapping among models of the same software structure is made through the assumption of design decisions. This mapping is represented as a graph, the model dependency descriptor, which connects components of source models with those in the target models. A traceability relation is set between components by producing the transitive closure of the model dependency descriptor. The traceability relation which is proposed links objects and also tracks decisions having a role in the transformation. A traceability support system incorporates a number of design databases and implements the model dependency descriptor. Its use enables the management of systems which were developed by using different design methods and different programming environments, and the capturing of the assumptions set during both development and maintenance.>

With reference to the setting up of software reuse reengineering processes this paper describes the high level organizational paradigm adopted in the reuse reengineering project RE/sup 2/. In particular the paper outlines: the key role of reverse engineering in a reuse reengineering process; and the need to define a module 'Template' in order to implement reusable modules in languages which do not have an ad hoc construct. Finally, with reference to TurboPascal the paper describes the template adopted in RE/sup 2/.>

Abstract Starting from the need for formalization and models to represent and repeat reverse‐engineering activities, this paper presents a proposal in the field of data flow analysis. In particular, the authors propose a formal model for a practical approach to the reconstruction of intermodular data flow associated with the structure charts of a Pascal software system. Specific matrices extracted straight from code are presented and matrix calculation is then exploited to obtain a final matrix containing all the information needed for the reconstruction of the data flow. Finally, this flow is reconstructed by means of transformations on the elements in this matrix.

Difficulties arising in the use of documents produced by reverse engineering tools are analyzed. With reference to intermodular data flow analysis for Pascal software systems, an interactive and evolutionary tool is proposed. The tool is based on the production of intermodular data flow information by static analysis of code, its representation in a Prolog program dictionary, and a Prolog abstractor that allows the specific queries to be answered.>

Some of the reasons for difficulties arising in the use of design documents produced by reverse engineering tools are analyzed. With reference to intermodular dataflow analysis for Pascal software systems, an interactive tool is proposed to more effectively help the maintainer. The tool is based on: the production of intermodular dataflow information by static analysis of the code; their representation in a Prolog program dictionary; and a Prolog abstractor that allows specific queries of maintainers to be answered. A logic-based approach to the design and implementation of an interactive tool which analyzes the intermodularal data flow of a program is discussed.>

Abstract The paper proposes an algebraic representation of program modules, calledF(p), and illustrates the algorithms that useF(p)to generate program graph models for measurement, documentation and testing activities. The representation refers to procedural languages, D‐structured programs and one‐in/one‐out modules but its definition can be extended to programs structured in terms of an arbitrary set of one‐in/one‐out legal control structures. Since it is possible to produceF(p)directly from the program code using reverse engineering techniques, the algorithms proposed are of considerable interest for the setting up of tools supporting the program comprehension phase, which is a fundamental first step in any maintenance operation.

The authors outline the important role that actual and (mainly) potential intermodular dependencies play in the maintenance phase of a software product. They discuss the problem with reference to Pascal systems and they show how reverse engineering and static code analysis enable the identification of the actual and potential intermodular data flow and relationships. Some constraints are proposed to prevent an uncontrollable proliferation of data binding among modules and their reciprocal calls. To achieve the consistency of the programs with respect to the adopted constraints, the intermodular dependency knowledge, as produced by reverse engineering, is used to restructure both data and module declarations.>

The methodology used to define a reverse engineering process that has been employed in an enhancement maintenance operation on a Pascal software system is described. Attention is focused on the methodology used to produce, from code, a hierarchy of data-flow diagrams (DFDs) at different levels of abstraction. DFDs are produced in the high-level design phase of a software production process using transform analysis. It is shown that DFD production by reverse engineering is useful in maintenance, not only for the software comprehension phase, but also for suggesting and supporting restructuring activities during the development of maintenance operations.>

A post-maintenance testing strategy based on path-change analysis is presented. This analysis is based on an underlying algebraic representation of the design and/or code of the program to be tested, and is characterized by the ease with which the modified, cancelled, and new paths produced by maintenance operations are identified by elementary algebraic operations. The methodologies and techniques illustrated, and the tools supporting them, are part of the post-maintenance testing subsystem of an integrated maintenance environment.>

This paper concerns the conversion from non-structured to equivalent structured programs. For this aim the conversion rules of one-in/one-out structures into the Dijkstra traditional structures are described. This approach allows both the application of complexity measurement methods for structured programs and an easier program maintenance. The suggested conversion rules have been implemented by a proper integrated system of software tools.