An approach providing automatic support in the assignment of concepts to documents recovered by reverse engineering Web applications is presented. Web pages composing Web applications usually include relevant textual information from the domain of the application, while different editing formats are used for emphasising to the end users the various concepts provided by the pages. The proposed concept assignment approach exploits both the textual information contained in the Web pages, and the editing formal used to display it in order to identify automatically a set of candidate concepts describing a Web page or a set of pages. These concepts can be used by maintainers involved in the task of assigning a meaning to software artefacts recovered by reverse engineering the Web applications. Validation experiments carried out with Web applications selected from the real world showed the validity of the proposed approach. The experimental results are presented in the paper.

The growing market request for Web applications is forcing software industries to produce applications under the pressure of a short time-to-market and a strong competition, with the consequence that low quality and poor documented software is often produced. Maintaining, evolving or comprehending these applications are not straightforward tasks, and reverse engineering processes should be defined and validated to support them. In this paper a reverse engineering approach for reconstructing an object-oriented conceptual model of the application domain of a Web application is presented. The proposed approach defines a process that reconstructs the model in three steps. In each step, heuristic criteria exploiting source code analysis are used for the identification of objects and their relationships. Tools for implementing this method have been produced, and experiments for validating it have been carried out with the support of case studies. Experimental results showed the feasibility and the effectiveness of the proposed approach.

The rapid diffusion of Internet and open standard technologies is producing a significant growth of the demand of Web sites and Web applications with more and more strict requirements of usability, reliability, interoperability and security. While several methodological and technological proposals for developing Web applications are coining both from industry and academia, there is a general lack of methods and tools to carry out the key processes that significantly impact the quality of a Web application (WA), such as the validation & verification (V&V), and quality assurance. Some open issues in the field of Web application testing are addressed in this paper. The paper exploits an object-oriented model of a WA as a test model, and proposes a definition of the unit level for testing the WA. Based on this model, a method to test the single units of a WA and for the integration testing is proposed. Moreover, in order to experiment with the proposed technique and strategy, an integrated platform of tools comprising a Web application analyzer, a repository, a test case generator and a test case executor, has been developed and is presented in the paper. A case study, carried out with the aim of assessing the effectiveness of the proposed method and tools, produced interesting and encouraging results.

Several reverse engineering methods for recovering objects from legacy systems have been proposed in the literature, but most of them neglect to identify the relationships among the objects, or recover only a part of them. The paper describes a method for recovering an OO (object oriented) model together with the objects and relationships among them. The proposed approach integrates the results of reverse engineering of both the procedural code and the persistent data stores of the system, and exploits a number of heuristic criteria to obtain a class diagram. A preliminary experiment carried out to validate the method on a COBOL medium-sized system yielded encouraging results.

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.

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.>

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 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.>

Abstract In a distributed system based on Transputer components there is one clock for each processing element, and the definition of the global system time requires the choice of a hardware or software synchronization method. This paper describes the RING_SYNC algorithm, based on a ring‐structured synchronization scheme. RING_SYNC has no provision for fault tolerance, but it introduces little overhead, thanks to the optimization of both the number of messages exchanged at sync time and the resynchronization frequency. The implementation of the algorithm together with the tests performed for measuring the synchronization error and their results are discussed extensively, and some typical applications are pointed out.

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.