DOI: 10.3897/jucs.161668

Authors: Dung Hai Dinh, Quan Nguyen Minh Tran, Quang Huan Dong, Nicole Ondrusch

Abstract: This study explores the application of predictive modeling to the TensorFlow project, a prominent open-source machine learning library. Our research aims to develop and validate predictive models that can accurately forecast issue closures, thereby enhancing project management decisions. We systematically collect data from the TensorFlow GitHub repository through data crawling using a self-built python script, focusing on key metrics such as commit history, issue tracking, and contributor metrics. The data comprises 120,000 commit messages and 25,053 issue tickets. We apply descriptive analytics to identify insights into the project's development dynamics and implement nineteen models using various machine learning techniques, including linear regression, ridge regression, and ensemble methods. The final model, based on Lasso regression, achieves high accuracy with the lowest Mean Squared Error (MSE), the Average Cross-Validation MSE and highest R-squared value compared to other models. The final model also utilizes advanced feature engineering techniques, such as lagged features and cyclical time transformations, which help enhance the model's performance. Applied time-aware validation shows the need to further refine the evaluation design to enhance temporal modeling.

HTML

PDF

DOI: 10.3897/jucs.76528

Authors: Jing Qiu, Feng Dong, Guanglu Sun

Abstract: Disassembly is the basis of static analysis of binary code and is used in malicious code detection, vulnerability mining, software optimization, etc. Disassembly of arbitrary suspicious code blocks (e.g., for suspicious traffic packets intercepted by the network) is a difficult task. Traditional disassembly methods require manual specification of the starting address and cannot automate the disassembly of arbitrary code blocks. In this paper, we propose a disassembly method based on code extension selection network by combining traditional linear sweep and recursive traversal methods. First, each byte of a code block is used as the disassembly start address, and all disassembly results (control flow graphs) are combined into a single flow graph. Then a graph attention network is trained to pick the correct subgraph (control flow graph) as the final result. In the experiment, the compiler-generated executable file, as well as the executable file generated by hand-written assembly code, the data file and the byte sequence intercepted by the code segment were tested, and the disassembly accuracy was 93%, which can effectively distinguish the code from the data.

HTML

XML

PDF

DOI: 10.3897/jucs.66857

Authors: Sébastien Martinez, Christophe Gransart, Olivier Stienne, Virginie Deniau, Philippe Bon

Abstract: Because stopping a service to apply updates raises issues, Dynamic Software Updating studies the application of updates on programs without disrupting the services they provide. This is acheived using specific mechanisms operating updating tasks such as the modification of the program state. To acheive transparency, Dynamic Software Updating systems use pre-selected and pre-configured mechanisms. Developers provide patches that are transparently converted to dynamic updates. The cost of such transparency is often that applied patches cannot modify the general semantic of the updated program. Allowing dynamic modification of the general semantic of a running program is rarely considered.In the context of protection of communications between moving vehicles and uncontrolled infrastructure, SoREn (Security REconfigurable Engine) is designed to be dynamically reconfigurable. Its semantics can transparently be modified at runtime to change the security policy it enforces. Administrators can supply new policies to trigger a reconfiguration, without developing new components. This paper details and discusses the design of SoREn, its meta-model linked to cybersecurity business concepts and its automatic reconfiguration calculator allowing transparent application of reconfigurations.

HTML

XML

PDF

DOI: 10.3897/jucs.72475

Authors: Ricardo Perez-Castillo, Mario Piattini

Abstract: Today, there is no company that does not attempt to control or assure software quality in a greater or lesser extent. Software quality has been mainly studied from the perspectives of the software product and the software process. However, there is no thorough research about how code quality is affected by the software development projects’ contexts. This study analyses how the evolution of the development effort (i.e., the number of developers and their contributions) influences the code quality (i.e., the number of bugs, code smells, cloning, etc). This paper presents a multiple case study that analyses 13 open-source projects from GitHub and SonarCloud, and retrieves more than 95,000 commits and more than 25,000 quality measures. The insights are that more developers or higher number of commits does not necessary influence worse quality levels. After applying a clustering algorithm, it is detected an inverse correlation in some cases where specific efforts were made to improve code quality. The size of commits and the relative weight of developers in their teams might also affect measures like complexity or cloning. Project managers can therefore understand the mentioned relationships and consequently make better decisions based on the information retrieved from code repositories.

HTML

XML

PDF

DOI: 10.3217/jucs-023-08-0769

Authors: Arthur Pinto, Ricardo Terra, Eduardo Guerra

Abstract: As software evolves, developers usually introduce deviations from the planned architecture, due to unawareness, conflicting requirements, technical difficulties, deadlines, etc. This occurs in systems with an explicit division of responsibility between groups of classes, such as modules and layers. Although there are architectural conformance tools to identify architectural violations, these tools are underused and detected violations are rarely corrected. To address these shortcomings, this article introduces an architectural conformance process into continuous integration. Thus, the conformance process is triggered by every code integration and, when no violations are detected, the code is integrated into the repository. The implemented tool, called ArchCI, supports the proposed solution using DCL (Dependency Constraint Language) as underlying conformance technique and Jenkins as the Continuous Integration server. We also evaluated the applicability of our proposed solution in a real-world Java project where we incrementally introduced 44 constraints through six releases. As the result, our process was able to detect 42 violations, which have always been fixed before the ensuing release.

HTML

XML

PDF

DOI: 10.3217/jucs-023-02-0129

Authors: Egon Börger, Klaus-Dieter Schewe

Abstract: Up to recently the majority of applications of the Abstract State Machines method for design and verification of computational systems used the shared variable approach. However in particular with distributed systems only various forms of communication may be available to share information. We define communicating ASMs by using instead of shared locations an explicit, abstract concept of Sending/Receiving messages which can be added to existing ASM execution engines. We aim to provide a definition which is a conservative extension of traditional ASMs, uniformly captures synchronous and asynchronous communication and is not bound to any specific message passing mechanism but can be instantiated to the major communication concepts in the literature. We illustrate the concept by an application to synchronous and asynchronous networks of communicating processes.

HTML

XML

PDF

DOI: 10.3217/jucs-022-12-1509

Authors: Eduardo Herranz, Ricardo Colomo-Palacios, Antonio Seco, Mary-Luz Sánchez-Gordón

Abstract: One of the main reasons for failure in Software Process Improvement (SPI) initiatives is the lack of motivation of the professionals involved. Therefore, motivation should be encouraged throughout the software process. Gamification allows us to define mechanisms that motivate people to develop specific tasks. A gamification framework was adapted to the particularities of an organization and software professionals to encourage motivation. Thus, it permitted to facilitate the adoption of SPI improvements and a higher success rate. The objective of this research was to validate the framework presented and increase the actual implementation of gamification in organizations. To achieve this goal, a qualitative research methodology was employed through interviews that involved a total of 29 experts in gamification and SPI. The results of this study confirm the validity of the framework presented, its relevance in the field of SPI and its alignment with the standard practices of gamification implementation within organizations.

HTML

XML

PDF

DOI: 10.3217/jucs-020-06-0885

Authors: Eduardo Herranz, Ricardo Colomo-Palacios, Antonio Seco, Murat Yilmaz

Abstract: For any Software Process Improvement (SPI) initiative to succeed human factors, in particular, motivation and commitment of the people involved should be kept in mind. In fact, Organizational Change Management (OCM) has been identified as an essential knowledge area for any SPI initiative. However, enough attention is still not given to the human factors and therefore, the high degree of failures in the SPI initiatives is directly linked to a lack of commitment and motivation. Gamification discipline allows us to define mechanisms that drive people's motivation and commitment towards the development of tasks in order to encourage and accelerate the acceptance of an SPI initiative. In this paper, a gamification framework oriented to both organization needs and software practitioners groups involved in an SPI initiative is defined. This framework tries to take advantage of the transverse nature of gamification in order to apply its Critical Success Factors (CSF) to the organizational change management of an SPI. Gamification framework guidelines have been validated by some qualitative methods. Results show some limitations that threaten the reliability of this validation. These require further empirical validation of a software organization.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0746

Authors: Flavio Medeiros, Márcio Ribeiro, Rohit Gheyi, Baldoino Fonseca

Abstract: Developers use the C Preprocessor (CPP) to handle portability and variability in program families of different sizes and domains. However, despite the widely use of the CPP in practice, it is often criticised due to its negative impact on code quality and maintainability, tool development, and its error-prone characteristics. In particular, developers aggravate these problems when using incomplete annotations, i.e., directives encompassing only parts of syntactical units. In a previous work, we performed an empirical study on 41 C program family releases and found that almost 90% of syntax errors occur in incomplete annotations. There are some refactorings to remove incomplete annotations proposed in the literature. However, they clone code and increase Lines of Code (LOC). To avoid incomplete annotations and their intrinsic problems, in this article we propose a catalogue of refactorings that converts incomplete annotations into complete ones without cloning code. We implement an Eclipse plug-in to help developers applying our refactorings automatically. To evaluate our catalogue, we performed a study to analyse questions related to code cloning, LOC, and number of directives. To answer our research questions, we analyse releases of 12 C program families of different domains ranging from 4.9 thousand to 1.5 million LOC. The results show that our catalogue can remove all incomplete annotations without cloning code, and increasing only in 0.04% the LOC and in 2.10% the number of directives.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0615

Authors: Paola Accioly, Paulo Borba, Rodrigo Bonifacio

Abstract: SPL testing has been considered a challenging task, mainly due to the diversity of products that might be generated from an SPL. To deal with this problem, techniques for specifying and deriving product specific functional test cases have been proposed. However, there is little empirical evidence of the benefits and drawbacks of these techniques. To provide this kind of evidence, in a previous work we conducted an empirical study that compared two design techniques for black-box manual testing, a generic technique that we have observed in an industrial test execution environment, and a product specific technique whose functional test cases could be derived using any SPL approach that considers variations in functional tests. Besides revisiting the first study, here we present a second study that reinforce our findings and brings new insights to our investigation. Both studies indicate that specific test cases improve test execution productivity and quality.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0587

Authors: Felype Ferreira, Rohit Gheyi, Paulo Borba, Gustavo Soares

Abstract: Developers evolve software product lines (SPLs) manually or using typical program refactoring tools. However, when evolving an SPL to introduce new features or to improve its design, it is important to make sure that the behavior of existing products is not affected. Typical program refactorings cannot guarantee that because the SPL context goes beyond code and other kinds of core assets, and involves additional artifacts such as feature models and configuration knowledge. Besides that, we typically have to deal with a set of alternative assets that do not constitute a well-formed program in an SPL. As a result, manual changes and existing program refactoring tools may introduce behavioral changes or invalidate existing product configurations. To reduce such risks, we propose approaches and implement four tools for making product line evolution safer. These tools check if SPL transformations preserve the behavior of the original SPL products. They implement different and practical approximations of refinement notions from a theory for safely evolving SPLs. Besides specifying the algorithms of each approach, we compare them with respect to soundness, performance and code coverage in 35 evolution scenarios of an SPL with 32 KLOC.

HTML

XML

PDF

DOI: 10.3217/jucs-018-19-2706

Authors: Anuradha Mathrani, David Parsons, Sanjay Mathrani

Abstract: Offshore software development (OSD) is a leading business sector in the global IT marketplace, and vendors in different countries are opening software development centres to take advantage of new business opportunities. However, software development is both a technical and a social process in which various software modules are integrated, requiring ongoing interaction and synchronisation of activities between distributed stakeholders. Knowledge management (KM) strategies are applied to create knowledge consistent with client requirements, project specific features and chosen design methodologies. Building on existing KM theories with empirical evidence from ten case studies in the Asia Pacific region, within two country contexts (New Zealand and India), this research reveals the KM initiatives for enabling knowledge transfer in the OSD process at the operational, design and strategic level. The paper offers insights on how software vendors build organisational knowledge repositories as they streamline distributed tasks in different country contexts. Country-specific contexts reveal that New Zealand vendors are engaged more in project and product management and have further outsourced software development tasks to other low cost countries. The Indian vendors are involved in software construction, development of technical specialist skills and use of more formal processes. These findings emphasise implications of various sociological, cultural and technical perspectives of KM initiatives in OSD.

HTML

XML

PDF

DOI: 10.3217/jucs-017-05-0684

Authors: Rohit Gheyi, Tiago Massoni, Paulo Borba

Abstract: A feature model (FM) defines the valid combinations of features, whose combinations correspond to a program in a Software Product Line (SPL). FMs may evolve, for instance, during refactoring activities. Developers may use a catalog of refactorings as support. However, the catalog is incomplete in principle. Additionally, it is non-trivial to propose correct refactorings. To our knowledge, no previous analysis technique for FMs is used for checking properties of general FM refactorings (a transformation that can be applied to a number of FMs) containing a representative number of features. We propose an efficient encoding of FMs in the Alloy formal specification language. Based on this encoding, we show how the Alloy Analyzer tool, which performs analysis on Alloy models, can be used to automatically check whether encoded general and specific FM refactorings are correct. Our approach can analyze general transformations automatically to a significant scale in a few seconds. In order to evaluate the analysis performance of our encoding, we evaluated in automatically generated FMs ranging from 500 to 2,000 features. Furthermore, we analyze the soundness of general transformations.

HTML

XML

PDF

DOI: 10.3217/jucs-015-11-2166

Authors: Ronan Barrett, Claus Pahl

Abstract: Distributed systems are being constructed by composing a number of discrete com-ponents. This practice is particularly prevalent within the Web service domain in the form of service process orchestration and choreography. Often, enterprise systems are built from manyexisting discrete applications such as legacy applications exposed using Web service interfaces. There are a number of architectural configurations or distribution patterns, which express how acomposed system is to be deployed in a distributed environment. However, the amount of code required to realise these distribution patterns is considerable. In this paper, we propose a distri-bution pattern-driven approach to service composition and architecting. We develop, based on a catalog of patterns, a UML-compliant framework, which takes existing Web service interfacesas its input and generates executable Web service compositions based on a distribution pattern chosen by the software architect.

HTML

XML

PDF

DOI: 10.3217/jucs-015-07-1472

Authors: Francisco Jurado, Ana Molina, Miguel Redondo, Manuel Ortega Cantero, Adam Giemza, Lars Bollen, H. Hoppe

Abstract: Learning to program is an important subject for students of Computer Science. Mentoring these students is a time-consuming and complex task. In this paper, we present a learning and tutoring environment that integrates task/solution delivery, assessment support and tutor’s annotations, by extending Eclipse to a "Real World Integrated Development Environment". We will present a distributed system that uses Tuple Space architecture to integrate Eclipse with an evaluation module and a hand-writing annotation feature.

HTML

XML

PDF

DOI: 10.3217/jucs-014-22-3737

Authors: Gio Wiederhold

Abstract: The investments needed to bring a software project to the market are substantial and can extend over several years. Managing software development requires not only technical expertise, but communication with funders and economists. This paper presents methods to estimate a parameter which captures the effective investment time, lag. The lag parameter is useful in assessing progress towards the goal of having a quality product, while scheduling resources, assessing the risk, considering options, capitalization of investments, and predicting taxation consequences. The paper presents the lag estimation methods for a new product, for additional versions of a product, and for complete product replacement.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3573

Authors: Rohit Gheyi, Tiago Massoni, Paulo Borba

Abstract: Software Product Lines (SPL) may be adopted by either bootstrapping existing software products into a SPL, or extending an existing SPL to encompass an additional software product. Program refactorings are usually applied for carrying out those tasks. The notion of SPL refactoring is an extension of the traditional definition of refactoring; it involves not only program refactorings, but also Feature Model (FM) refactorings, in order to improve configurability. However, FM refactorings are hard to define, due to the incompleteness of the refactoring catalogs developed as of today. In this paper, we propose a complete, sound catalog of algebraic laws, making up special FM refactorings that preserve configurability. This catalog is also defined as minimal, as one law cannot be derived from another one in the same catalog. In addition, a theory for FMs is presented, in the context of a theorem prover.

HTML

XML

PDF

DOI: 10.3217/jucs-014-14-2343

Authors: Botond Virginas, Marian Ursu, Edward Tsang, Gilbert Owusu, Chris Voudouris

Abstract: This paper considers the problem of resource allocation in the service industries approached from an agent-based perspective. Agent technologies seem to be well suited to this domain by providing a distributed environment, are network centric, semi-autonomous and collaborative and can communicate with each other to achieve better optimisation with little human intervention. The paper describes the context of this solution, a general power model and several pathways with corresponding example implementations with results and discussion The novelty of the solution resides in the fact that it is a natural and versatile formulation that combines an agent-based model with various artificial intelligence and operations research techniques such as rule-based expressions of allocation strategies and multi-criteria optimisation expressions of allocation objectives.

HTML

XML

PDF

DOI: 10.3217/jucs-014-13-2212

Authors: Miguel Pérez-Toledano, Amparo Navasa, Juan-Manuel Murillo-Rodríguez, Carlos Canal

Abstract: One focus of current software development is the re-use of components in the construction of systems. Software Adaptation facilitates the consequent need to adapt these components to the new environment by employing adaptors which are obtained automatically and hence with a certain guarantee of suitability, from formal descriptions of the interface behaviour. One appropriate technique for Software Adaptation is Aspect-Oriented Programming (AOP) which makes use of aspects to facilitate the dynamic adaptation of components transparently and non-intrusively. However, owing to the way that aspects are integrated, these can unexpectedly modify the functionality of the system, and consequently completely alter its semantics. It is hence necessary to study the final behaviour of the system to ensure its correctness after adding aspects for its adaptation. This study must go beyond just detecting problems at the protocol level, to analyze the potential semantic problems. This is the main focus of the present communication. We start from the Unified Modeling Language (UML 2.0) specification of both the initial system and the aspects. This specification is validated by generating an algebraic Calculus of Communicating Systems (CCS) description of the system. Next, extended (finite) state machines are automatically generated to verify, simulate, and test the modeled system's behaviour. The result of that process can also be compared with the behaviour of the new running system. To facilitate this task, we propose grouping components so as to centre the study on the points actually affected by the behaviour of the aspects.

HTML

XML

PDF

DOI: 10.3217/jucs-014-13-2110

Authors: Stephen Kell

Abstract: Software adaptation techniques appear in many disparate areas of research literature, and under many guises. This paper enables a clear and uniform understanding of the related research, in three ways. Firstly, it surveys a broad range of relevant research, describing and contrasting the approaches of each using a uniform terminological and conceptual vocabulary. Secondly, it identifies and discusses three commonly advocated principles within this work: component models, first-class connection and loose coupling. Thirdly, it identifies and compares the various modularisation strategies employed by the surveyed work.

HTML

XML

PDF

DOI: 10.3217/jucs-014-08-1256

Authors: Kellyton dos Santos Brito, Vinícius Garcia, Eduardo De Almeida, Silvio Romero de Lemos Meira

Abstract: Nowadays software systems are essential to the environment of most organizations, and their maintenance is a key point to support business dynamics. Thus, reverse engineering legacy systems for knowledge reuse has become a major concern in software industry. This article, based on a survey about reverse engineering tools, discusses a set of functional and non-functional requirements for an effective tool for reverse engineering, and observes that current tools only partly support these requirements. In addition, we define new requirements, based on our group’s experience and industry feedback, and present the architecture and implementation of LIFT: a Legacy InFormation retrieval Tool, developed based on these demands. Furthermore, we discuss the compliance of LIFT with the defined requirements. Finally, we applied the LIFT in a reverse engineering project of a 210KLOC NATURAL/ADABAS system of a financial institution and analyzed its effectiveness and scalability, comparing data with previous similar projects performed by the same institution.

HTML

XML

PDF

DOI: 10.3217/jucs-011-10-1645

Authors: Fei Cao, Barrett Bryant, Rajeev Raje, Andrew Olson, Mikhail Auguston, Wei Zhao, Carol Burt

Abstract: Component-based software composition offers a development approach with reduced time-to-market and cost while achieving enhanced productivity, quality and maintainability. Existent work on the composition paradigm focuses on static composition, which is not sufficient in a distributed environment, in which both constituent components and the assembled distributed system are subject to dynamic adaptation. This paper presents two types of dynamic composition for distributed components: assertive and autonomous over a .NET based Web Services environment. Three case studies are provided to illustrate the use of assertive and autonomous composition.

HTML

XML

PDF

DOI: 10.3217/jucs-010-09-1302

Authors: José Sierra, Alfredo Fernández-Valmayor, Baltasar Fernández-Manjón, Antonio Navarro

Abstract: This paper proposes a document oriented paradigm to the development of content-intensive, document-based applications (e.g. educational and hypermedia applications, and knowledge based systems). According to this paradigm, the main aspects of this kind of applications can be described by means of documents. Afterwards, these documents are marked up using descriptive domain-specific markup languages and applications are produced by the automatic processing of these marked documents. We have used this paradigm to improve the maintenance and portability of content-intensive educational and hypermedia applications. ADDS (Approach to Document-based Development of Software) is an approach to software development based on the document oriented paradigm. A key feature of ADDS is that formulation of domain-specific markup languages is a dynamic and eminently pragmatic activity, and markup languages evolve according to the authoring needs of the different participants in the development process (domain experts and developers). The evolutionary nature of markup languages in ADDS leads to OADDS (Operationalization in ADDS), the proposed operationalization model for the incremental development of modular markup language processors. Finally, the document-oriented paradigm can also be applied in the construction of OADDS processors that are also described using marked documents. This paper presents our ADDS approach, including the operationalization model and its implementation as an object-oriented framework. The application of our document-oriented paradigm to the construction of OADDS processors is also presented.

HTML

XML

PDF

DOI: 10.3217/jucs-010-04-0428

Authors: Artur Boronat, Jennifer Pérez, Jose Carsí, Isidro Ramos

Abstract: This paper presents an outline of a formal model management framework that provides breakthroughs for legacy systems recovery (RELS) and for data migration (ADAM). To recover a legacy system, we use an algebraic approach by using algebras in order to represent the models and manipulate them. RELS also generates automatically a data migration plan that specifies a data transfer process to save all the legacy knowledge in the new recovered data-base. The data migration solution is also introduced as a support for the O-O conceptual schemas evolution where their persistent layers are stored by means of relational databases, in the ADAM tool. Contents and structure of the data migration plans are specified using an abstract data migration language. Our past experience in both projects has guided us towards the model management research field. We present a case study that illustrates the application of both tools.

HTML

XML

PDF

DOI: 10.3217/jucs-009-07-0641

Authors: Márcio Greyck Batista Dias, Nicolas Anquetil, Käthia De Oliveira

Abstract: Knowledge engineering emerged as a very promising area to help improve software engineering practice. One of its possible applications would be to help in solving the numerous problems that affect the software maintenance activity. Maintainers of legacy systems developed years ago with obsolete techniques and tools, and not documented, need all kinds of knowledge (application domain, programming skills, software engineering techniques, etc.) It is generally assumed that formalizing all this knowledge and recording it would be a worthwhile effort. However, research is still in a early stage and numerous questions need to be answered: What knowledge should be targeted first? Where to find this knowledge? etc. To answer these questions, one needs a precise understanding of what knowledge is at stake here. We, therefore, propose an ontology of the knowledge needed to perform software maintenance. This ontology would be most useful as a framework for future research in knowledge engineering for software maintenance.

HTML

XML

PDF

DOI: 10.3217/jucs-008-01-0097

Authors: Klaus Schmaranz

Abstract: Two of today's most used buzz-words in the context of software development are the terms Componentware and Distributed Object-System. The combination of both ideas is then called a Distributed Component-System, meaning a componentware approach where the components are distributed across the network. Today's approaches fulfill the application developers' needs only partly. Also, most are more or less cumbersome to use. I want to call such part-solutions like e.g. Corba, Enterprise Java­Beans and others first generation distributed component systems. In fact, Corba has a different origin, but for the moment let me consider it to be a first generation componentware system, too. In this paper I want to identify the requirements that have to be fulfilled to design and implement a second generation distributed component system. One main aspect is behind all of the ideas of second generation systems: a good distributed component system is one that the application programmers don't notice. The open-source project Dinopolis is currently in its early implementation phase and can be considered the first second-generation distributed component system according to the requirements that are identified in the following. Therefore the very basic cornerstones of Dinopolis are discussed at the end of this paper.

HTML

XML

PDF

DOI: 10.3217/jucs-004-12-0866

Authors: Lutz Prechelt, Christian Krämer

Abstract: The object-oriented design community has recently begun to collect so-called software design patterns: descriptions of proven solutions common software design problems, packaged in a description that includes a problem, a context, a solution, and its properties. Design pattern information can improve the maintainability of software, but is often absent in program documentation. We present a system called Pat for localizing instances of structural design patterns in existing C ++ software. It relies extensively on a commercial CASE tool and a PROLOG interpreter, resulting in a simple and robust architecture that cannot solve the problem completely, but is industrial-strength, it avoids much of the brittleness that many reverse engineering tools exhibit when applied to realistic software. The contribution of our work is not so much in the engineering value represented by this concrete system, but in its methodological approach. To evaluate Pat, we quantify its performance in terms of precision and recall. We examine four applications, including the popular class libraries zApp and LEDA. Within Pat s restrictions all pattern instances are found, the precision is about 40 percent, and manual filtering of the false positives is relatively easy. Therefore, we consider Pat a good compromise: modest functionality, but high practical stability for recovering design information.

HTML

XML

PDF