Software Reengineering

Context:
With the acknowledged benefits of microservices architectures, such as scalability, flexibility, improved maintenance, and deployment, legacy software systems are increasingly being reengineered into microservices. Recently, a plethora of methods, techniques, tools, and evaluation criteria for reengineering software systems into microservices have been proposed without being systematized.

Objectives:
The objective of this work is to conduct an in-depth systematic literature review to identify and analyze methods, techniques, and tools for reengineering software systems into microservices and the ways for evaluating such reengineering initiatives and their results.

Methods:
A systematic literature review of works on reengineering software systems into microservices was performed, yielding 117 primary studies. The review focused on addressing key research questions concerning the evolution of microservices reengineering, methodologies employed, tools available, and the challenges faced in the reengineering process. We used a taxonomy development method to systematize knowledge in these areas.

Results:
The analysis revealed multiple reengineering approaches: static, dynamic, hybrid, and artifact-driven. Significant evaluation criteria identified include coupling, cohesion, and modularity. Key paradigms for microservices reengineering, such as domain-driven design and interface analysis, were identified and discussed. The study also highlights that incremental and iterative transitions are favored in practice.

Conclusion:
This study provides a structured overview of the current state of research on reengineering software systems into microservices. It highlights challenges in existing reengineering methodologies. Future directions include validating behavioral equivalence of original and reengineered systems, automating microservices generation, and refining database layer partitioning. The findings emphasize the need for further work to enhance the reengineering process and evaluation of the transition between monolithic and microservices architectures.

Malware is a threat to information security and poses a security threat to harm networks or computers. Not only the effects of malware can generate damage to systems, they can also destroy a country when for example, its defense system is affected by malware. This paper takes a look at different machine learning techniques that can be used to predict a system's probability of getting hit by various families of malware, based on different properties of that system. Given a dataset of these properties and the machine infections, the proposed solution is to use a fusion framework, namely LightGBM +MSVM, to build a model that predicts whether a system will soon be hit with malware.The evaluation is carried out through classification evaluation indexes such as accuracy, precision, recall, F1-score.

The paper deals with the formation and transformation of stakeholder requirements for the information system throughout the entire life cycle. It is shown how the seamless architecture provides traceability of requirements from the level of the business process, to the functional and logical architectures of systems, to the selection of criteria and identification of microservices. It is shown how maintaining the traceability of requirements in the presence of business, functional and logical architecture models can reduce the cost of planning complex functional and load testing of systems, as well as ensure the interaction of operation, maintenance services and contractors that form the entire system, maintain its integrity during the life cycle.

La reingeniería de sistemas heredados tiene por finalidad reestructurar o transformar viejos sistemas en aplicaciones más fáciles de mantener, con entornos más agradables e integradas en nuevas plataformas de hardware/software. Tratamos de dar una visión general de lo que es la reingeniería de software y cuáles son las actitudes que se pueden tomar a la hora de modernizar un sistema legado que se ha quedado obsoleto en cuanto a operatividad, aspecto y software de base sobre el que se ejecuta, pero de probada eficiencia y que mantiene su funcionalidad. Mostramos las características de un proceso de desarrollo que se adapta a este tipo de aplicaciones, verificado, mediante el caso de estudio, la transformación de una aplicación escrita en un lenguaje imperativo, no estructurado, a un nuevo lenguaje visual y orientado a objetos, describiendo las diversas fases de la metodología aplicadas a un caso concreto.

The modern business environment requires organizations to be flexible and open to change if they are to gain and retain their competitive age. Competitive business environment needs to modernize existing legacy system in to self-adaptive ones. Reengineering presents an approach to transfer a legacy system towards an evolvable system. Software reengineering is a leading system evolution technique which helps in effective cost control, quality improvements and time and risk reduction. However successful improvement of legacy system through reengineering requires portfolio analysis of legacy application around various quality and functional parameters some of which includes reliability and modularity of the functions, level of usability and maintainability as well as policy and standards of software architecture and availability of required documents. Portfolio analysis around these parameters will help to examine the legacy application on quality and functional gaps within the application [1]. In this paper we identify and measure risk factors related to quality and functional aspect of legacy system. Paper analyzes a variety of risk components related to quality and functional dimensions of legacy application. Identification and development of various metrics and important measures to compute impact value of individual risk component is also addressed. Existing quality and functional level of legacy system are considered to identify and categories risk components. The impact of various technical issues such as inconsistency between architecture of legacy and target system, unmodularised legacy system architecture, unavailability of required design documents, high degree of coupling between modules of legacy system has been covered in the paper..

The realization of modern business, activities and projects poses increasing demands and challenges to project managers. Therefore, modern project management practices are inconceivable without the help of project management software. This paper describes and compares the most commonly used project management software with emphasis on the need for careful selection based on the required software features and other criteria such as software price, necessary implementation time and education of future users and an example of Microsoft Project application in project planning.

Rapid Serial Visual Presentation is an effective approach for browsing and searching large amounts of data. By presenting subsequent images at high frequency, we utilize the perceptual abilities of the human visual system to rapidly process certain visual features. While this concept is successfully used in video and image browsing, we demonstrate how it can be applied to dynamic graph visualization. In this paper, we introduce a visualization technique for time-varying graphs that is scalable with respect to the number of time steps. The graph visualization is based on the Parallel Edge Splatting technique, which employs a space-efficient display of a sequence of dynamically changing graphs. To illustrate the usefulness of our approach we analyzed method call graphs recorded during the execution of the open source software system JHotDraw. Furthermore, we studied a time-varying social network representing researchers and their dynamic communication structure while attending the ACM Hypertext 2009 conference.

La reingeniería de sistemas heredados tiene por finalidad reestructurar o transformar viejos sistemas en aplicaciones más fáciles de mantener, con entornos más agradables e integradas en nuevas plataformas de hardware/software. Tratamos de dar una visión general de lo que es la reingeniería de software y cuáles son las actitudes que se pueden tomar a la hora de modernizar un sistema legado que se ha quedado obsoleto en cuanto a operatividad, aspecto y software de base sobre el que se ejecuta, pero de probada eficiencia y que mantiene su funcionalidad. Mostramos las características de un proceso de desarrollo que se adapta a este tipo de aplicaciones, verificado, mediante el caso de estudio, la transformación de una aplicación escrita en un lenguaje imperativo, no estructurado, a un nuevo lenguaje visual y orientado a objetos, describiendo las diversas fases de la metodología aplicadas a un caso concreto.

This is a PDF file of an article that has undergone enhancements after acceptance, such as the addition of a cover page and metadata, and formatting for readability, but it is not yet the definitive version of record. This version will undergo additional copyediting, typesetting and review before it is published in its final form, but we are providing this version to give early visibility of the article. Please note that, during the production process, errors may be discovered which could affect the content, and all legal disclaimers that apply to the journal pertain.

The agility inherent to today's business promotes the definition of software architectures where the business entities are decoupled into modules and/or services. However, there are advantages in having a rich domain model, where domain entities are tightly connected, because it fosters an initial quick development. On the other hand, the split of the business logic into modules and/or services, its encapsulation through well-defined interfaces and the introduction of inter-service communication introduces a cost in terms of performance. In this paper we analyze the stepwise migrating of a monolith, using a rich domain object, into a microservice architecture, where a modular monolith architecture is used as an intermediate step. The impact on the migration effort and on performance is measured for both steps. Current state of the art analyses the migration of monolith systems to a microservices architecture, but we observed that migration effort and performance issues are alrea...

Software code clones (CC) in software programs are degrading the performance of software systems. many code clones detection (CCD) methods proposed in the literature detect only individual cloned types efficiently. This paper proposes a collaborative code clones detection (CCCD) method by utilizing lexical, syntactic, semantic and structural features for effectively identifying all types of clones including type-4. Initially, a large variance mapper (LV-mapper) is utilized to identify clone pairs (CPs). Then CPs are converted into lexical features by directly applying Word2vec. The synonyms of CPs are obtained using the WordNet tool and converted as semantic features by Word2vec.Additionally, code size metrics (CZM) and object oriented metrics (OOM) are additionally measured as structural features of a program's code blocks (CBs). The syntactic features are extracted through the abstract syntax tree (AST) from the source code. Finally, the joint feature vector is generated by combining all the features together. In order to detect CCs in any new software, the joint feature vector of known clone type source codes is generated first (training set) and then the joint feature vector of unknown clone types source codes is generated next. The Euclidean distances between training and testing of joint feature vectors determine the clone type of test features. Finally, the experimental outcome demonstrates that the proposed CCCD technique has an accuracy of 87.8%, 92.3% and 95.5% for the dataset Apache Maven 3.8.3, Appache ant 1.10.12 and Opennlp-master 1.9.1, respectively, compared to the existing LV-CCD, ES-CCD, TBCNN-CCD and CPVDetector methods.

Among the many challenges faced by businesses that maintain legacy software systems is the integration of those systems with external data sources, which are often other software systems developed and maintained by otherwise unrelated entities. Leveraging service oriented-architecture (SOA) provides a method by which the business value of a legacy system can be extended without the expensive alternative of reengineering or of complete replacement of the software. This paper describes a particular implementation that used a SOA approach to enhance and extend the functionality of a mature, complex multi-channel commerce enterprise system. The implementation linked the legacy enterprise system of a multi-channel merchant with that of an international shipping company that provides a service for electronic shipping label requests. The goal was to further automate the process of shipping and tracking of purchased products returned by customers of the merchant.

In many object oriented software, there are recurring patterns of classes. With the help of these patterns specific design problem can be solved and object oriented design become more flexible and reusable. Design Pattern existence improve the program understanding and software maintenance. Hence a reliable design pattern mining is required. Graph Matching algorithms are useful and very general form of pattern matching to find the realistic use in several areas. In this paper we are reviewing the different graph matching algorithms to detect design patterns.

This paper discusses aspects of the redocumentation of legacy systems and proposes a model oriented approach to generating documentation, which is to produce models from existing systems and to generate the documentation based on the models. Since the software models can bridge the gap of a legacy system and an evolved system, the generated documentation covers all the information of system evolution. A prototype software redocumentation tool is presented to semi-automate this process and a case study of a system in IBM assembler is used for experiments with the approach and the prototype tool.

Berger-Levrault is an international company that developed applications in GWT for more than 10 years. However, GWT is no longer actively maintained, with only one major update since 2015. To avoid being stuck with legacy technology, the company decided to migrate its applications to Angular. However, because of the size of the applications (more than 500 web pages per application), rewriting from scratch is not desirable. To ease the migration, we designed a semi-automated migration approach that helps developers migrate applications' front-end from GWT to Angular and a tool that performs the migration. In this paper, we present our approach and tool. We validated the approach on concrete application migration and compared its benefits to redeveloping the application manually. We report that the semi-automated migration offers an effort reduction over a manual migration. Finally, we present recommendations for future migration projects.

Code clone is a serious problem in software and has the potential to software defects, maintenance overhead, and licensing violations. Therefore, clone detection is important for reducing maintenance effort and improving code quality during software evolution. A variety of clone detection techniques have been proposed to identify similar code in software. However, few of them can efficiently detect semantic clones (functionally similar code without any syntactic resemblance). Recently, several deep learning based clone detectors are proposed to detect semantic clones. However, these approaches have high cost in data labelling and model training. In this paper, we propose a novel approach that leverages word embedding and ensemble learning techniques to detect semantic clones. Our evaluation on a commonly used clone benchmark, BigCloneBench, shows that our approach significantly improves the precision and recall of semantic clone detection, in comparison to a token-based clone detect...

Code Clone detection (CCD) appears to be a prominent research field in a software side. Previously many machine learning (ML) techniques have been developed. These approaches always rely on generic, handcrafted features too represent code snippets. So, multi-label (code clone) classification (MLC) will be a major problem which probably demands for distinct evaluation criteria. So, the Deep Learning (DL) model have been efficiently developed for the CCD. But still, this DL algorithm is typically lacks to consider the hidden correlation of the labels when solving MLC
issues in order to enhance prediction accuracy. In addition, extricating the concealed correlation is a difficult task in CCD. Hence, in this article, DL based Cost-Responsive Reweighted Loss Function (DL-CRRLF) Model is proposed to handle the hidden correlation of MLC for efficient detection performance. In the training phase, the MLC algorithm utilizes the training data set which includes samples (non-semantic, semantic, and structure-based features of one code snippet) with labels (clone type) in order to learn the classifier. The trained classifier maps a feature vector to an estimated label vector which is similar to the ground truth vectors. The evaluation criteria are used to determine the closeness of label vectors. The evaluation criteria in Cost-Responsive Reweighted Loss Function are used in this process to assess the similarity between a predicted vector and a ground truth vector. This loss function is the ensemble of Hamming loss,F1 score,Accuracy score and Rank loss. In the testing phase, test samples are selected from the similar distribution as the training dataset in order to effectively detect multi-label code clones. Finally, the experimental outcome demonstrates that the proposed DL-CRRLF technique has an accuracy of 92%, 93% and 91% for the dataset Apache Maven 3.8.3, Appache ant 1.10.12 and Opennlp-master 1.9.1, respectively recognizing protein homologies compared to the conventional techniques.

Software code clones (CC) in software programs are degrading the performance of software systems. many code clones detection (CCD) methods proposed in the literature detect only individual cloned types efficiently. This paper proposes a collaborative code clones detection (CCCD) method by utilizing lexical, syntactic, semantic and structural features for effectively identifying all types of clones including type-4. Initially, a large variance mapper (LV-mapper) is utilized to identify clone pairs (CPs). Then CPs are converted into lexical features by directly applying Word2vec. The synonyms of CPs are obtained using the WordNet tool and converted as semantic features by Word2vec.Additionally, code size metrics (CZM) and object oriented metrics (OOM) are additionally measured as structural features of a program's code blocks (CBs). The syntactic features are extracted through the abstract syntax tree (AST) from the source code. Finally, the joint feature vector is generated by combining all the features together. In order to detect CCs in any new software, the joint feature vector of known clone type source codes is generated first (training set) and then the joint feature vector of unknown clone types source codes is generated next. The Euclidean distances between training and testing of joint feature vectors determine the clone type of test features. Finally, the experimental outcome demonstrates that the proposed CCCD technique has an accuracy of 87.8%, 92.3% and 95.5% for the dataset Apache Maven 3.8.3, Appache ant 1.10.12 and Opennlp-master 1.9.1, respectively, compared to the existing LV-CCD, ES-CCD, TBCNN-CCD and CPVDetector methods.

Code cloning (CC) is the process of copying and reconfiguring a code fragment and using it in another part of a software project. This clones increases the running overhead of the software. As a result, Code Clone Detection (CCD) has become an active research area in software development research. The detection of Large-Variance Code Clones (LV-CCs) is very difficult when the lines of codes (LOCs) in the source code are very large. The distance metrics have been used in LV-CC detection by calculating the distance between training feature sets of source codes and testing feature sets of source codes. However, threshold selection for detecting clones is a challenging issue in distance-based LV-CC detection. To solve this, a Collaborative CCD using Deep Learning (CCCD-DL) is developed in this paper by utilising lexical, syntactic, semantic and structural features for identifying all types of clones together. A lexical feature is extracted from Clone Pairs (CPs) identified by LV-Mapper. Syntactic and semantic features are identified by the Abstract Syntax Tree (AST) and Control Flow Graph (CFG). The structural features are extracted by code size metrics (CZMs) and object-oriented metrics (OOMs). All features are coordinated and fed into the input layer of DNN. The hidden layer then transforms the inputs into the neural vertices in the multi-classification stage using linear transformation preceded by suppressing nonlinearity. This process can generate a complicated and non-hypothetical prototype with a weight matrix for fitting the training sequence. Thus, the feed-forward step has been successfully completed. This model then uses back-propagation in the following element to modify the weight matrix based on the training set. Finally, a softmax layer converts the clone detection task into a classification process. The results of the experiments show that the proposed method solves distance-based problems more quickly and effectively than the traditional methods for the CCD.

Code fragments are reused by software developers through copying pasting with or without slight modifications. As a consequence in software systems, code sections also include very similar sections known as code clones. Code cloning can be harmful in software evolution and maintenance. Additionally, duplicated fragments will greatly increase the amount of work required when adapting or improving code. Various software engineering processes including software evaluation analysis, code quality analysis, plagiarism detection, program understanding, aspect mining, copyright infringement investigation, code compaction and Bug detection can necessitate the extraction of code fragments that are semantically or syntactically identical, making clone detection an important and valuable software analysis process. Various clone detection methods have been proposed over the last decade. In this article, an adequate comprehension of the text, token, tree, Program Dependency Graph (PDG) and machine learning based clone detection techniques. Also, their benefits and limitations are analyzed in a tabular form. Based on the analysis, future direction towards the clone detection is suggested for better software development. IndexTerms-Software development, clone code, clone code detection, duplicated fragments.

In the last couple of years, we have seen a growing interest in the Lisp programming language and its various dialects, including Common Lisp, Scheme, ISLISP, Dylan, and so on. Several user group meetings, workshops and conferences have been organized in recent years, with great success. Especially in Europe, but also elsewhere, Lisp is gaining momentum. With the European Lisp Symposium, we aim to start a series of annual events that is especially suitable for novel research results, but also for insights and lessons learned from practical applications and education perspectives, all involving Lisp dialects. For this yearʼs symposium, we have received 15 submissions, and after a careful review process, the program committee selected seven of them for presentation at the main track of the symposium. Furthermore, we have received seven additional submissions for a work-inprogress track, which describe ongoing work that is not ready for publication yet. Those work-in-progress papers will be discussed at the symposium using a writersʼ workshop format for giving feedback to the authors in a dedicated session. This volume contains the papers accepted for both the main track and the work-in-progress session. Some of the papers of the main track are selected for further review after the symposium and will be considered for publication in a future special issue of the Journal of Universal Computer Science (J.UCS). The success of the 1st European Lisp Symposium was only possible because of the great efforts of many people. I would especially like to thank the local organizer Robert Strandh for providing the facilities of the University of Bordeaux 1 and the local organization team for taking care of the many important details that are necessary to run such an event.

Workflow management systems (WfMS) are vital
tools that enhance productivity and efficiency by
automating and streamlining business processes across
various industries. With the increasing need for operational
optimization, selecting the most suitable WfMS becomes
crucial for organizations. This research paper presents a
comprehensive comparative analysis of different workflow
management systems, aiming to assist decision-makers in
understanding their strengths, weaknesses, and applicability
across diverse organizational contexts. The study evaluates
a range of WfMS, including traditional on premise systems,
cloud-based solutions, and open-source platforms. The
evaluation criteria encompass user experience,
customization, integration, automation, security, scalability,
extant of usage, industry/domain application and size of
company. The analysis is based on an extensive review of
literature, case studies, and interviews with industry experts.
The findings provide valuable insights into the comparative
performance of various workflow management systems,
outlining their specific advantages and limitations. This
research aims to guide organizations in selecting an
appropriate WfMS that aligns with their unique
requirements, facilitating improved process automation and
overall operational effectiveness. The outcomes of this study
contribute to the existing body of knowledge and provide
practical recommendations for WfMS selection and
implementation.

Large software systems need to be modified to remain useful. Changes can be more easily performed when their design has been carefully documented. This paper presents an approach to quickly find design patterns that have been implemented into a software system. The devised solution greatly reduces the performed checks by organising the search for a design pattern as tree traversals, where candidate classes are carefully positioned into trees. By automatically tagging classes with design pattern roles we make it easier for developers to reason with large software systems. Our approach can provide documentation that lets developers understand the role each class is playing, assess the quality of the code, have assistance for refactoring and enhancing the functionalities of the software system.

The constant apparition of new technologies challenging and disrupting the way to develop software pushes dayby-day software migration to become more and more common. Despite the "normality" of software migration, it is a problem that had ruined more than one company in the past. It is no wonder that different methods to migrate software have been the driver of many efforts and the centre of many discussions for years, resulting in multiple solutions and strategies to accomplish the desired migration. However, there is a lack of efforts on how software reengineering can be used to assess the process of planning by measuring and predicting the cost of a migration. In this article, we present Alce, a software migration assessment and prediction tool under development in the context of a collaboration with Berger-Levrault, for migrating Microsoft Access applications. We present a simple use case that represents most of the usages we had given to the tool during the analysis and reporting of two different applications to be migrated, to assess the extremely hard task of planning a software migration. We present as well a second use for task definition and prioritisation in the process of library migration. We discuss future features based on the interaction with one of the project managers, and finally, we discuss the lack of software reengineering tools usage in the context of software migration.

Software migration has been a research subject for a long time. Major research and industrial implementations have been conducted, shaping not only the techniques available nowadays, but also a good part of Software evolution jargon. To understand systematically the literature and grasp the major concepts is challenging and time consuming. Even more, research evolves, and it does based on the assumption that there is a single meaning that we all share redounding in the pollution of words with multiple and many times opposite meanings. In our quest to understand, share and contribute scientifically in this domain, we recognise this situation as a problem. To tackle down this problem we propose a taxonomy on the subject as a theoretical framework grounded on a systematic literature review. In this study we contribute a bottom-up taxonomy that links from the object of a migration to

HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci-entific research documents, whether they are pub-lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers. L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et a ̀ la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés. Copyright

HAL is a multidisciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers. L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Les technologies logicielles ne cessent d'évoluer pour faciliter le développement, le déploiement et la maintenance d'applications dans différents domaines. En parallèle, ces applications évoluent en continu pour garantir une bonne qualité de service et deviennent de plus en plus complexes. Cette évolution implique souvent des coûts de développement et de maintenance de plus en plus importants, auxquels peut s'ajouter une augmentation des coûts de déploiement sur des infrastructures d'exécution récentes comme le cloud. Réduire ces coûts et améliorer la qualité de ces applications sont actuellement des objectifs centraux du domaine du génie logiciel. Récemment, les microservices sont apparus comme un exemple de technologie ou style architectural favorisant l'atteinte de ces objectifs.Alors que les microservices peuvent être utilisés pour développer de nouvelles applications, il existe des applications monolithiques (i.e., monolithes) cons-truites comme une seule u...

In the Forward Engineering phase, the designer modifies the database conceptual schema and produces a logical and physical schema contaiming some "spurious" relations dictated by design tricks and DBMS's limitations. Therefore the rebuilding of the database conceptual schema from the physical database structure is a fundamental issue in the re-engineering and design recovery processes. Some proposed methodologies try to get the necessary information from the schema and from the content of the database, paying little attention to the analysis of the usage that the programs make of the data, while this can bethought as the most reliable source of information. In this paper we present an approach to the reverse engineering based on the identification of schema, primary key, SQL and procedural indicators that lead to the assertion of Prolog facts and, by some heuristic rules, to the rebuilding of the conceptual schema.

This paper analyzes and evaluates different software project management tools that help the team to plan, manage, optimize resources, and monitor the project progress. The ICT industry in Bangladesh has immense prospects in driving the country's economy, and it has grown by 28%-40% annually since 2010 each year. But though we have huge benefits over low development costs, clients of the developed country are not very satisfied with the quality of the software. So in this paper, we are proposing an open source-based project management tool that will serve small to medium-sized software firms at no cost. The software firms will maintain the software engineering best practices by using the software. As "openness" becomes one of society's hallmarks in the 21st century and extends into innovation, research, and standardssetting, an open-source system has become an integral part of the business. Because of the speed and the scale at which it has happened, open-source is central to strategy today. But we do not have any cloud access in an Open-source system. For that reason, in this paper, we also have tried to propose the same tool with more options in the Software as a Service (SaaS) environment.

Cloud" computing-a relatively recent term, defines the paths ahead in computer science world. Being built on de cades of research it utilizes all recent achievements in virtualization, distributed computing, utility computing, and networking. It implies a service oriented architecture through offering software and platforms as services, reduced information technology overhead for the end-user, great flexibility, reduced total cost of ownership, on de mand services and many other things. This paper is a brief survey based on r eadings of "cloud" computing and it tries to address related research topics, challenges ahead and possible applications.

Software migration has been a research subject for a long time. Major research and industrial implementations were conducted, shaping not only the techniques available nowadays, but also a good part of Software evolution jargon. To understand systematically the literature and grasp the major concepts is challenging and time-consuming. Even more, research evolves, and it does based on the assumption that many words (such as migration) have a single well-known meaning that we all share. Since since these words meanings are rarely explicit, and their usage heterogeneous, these words end up polluted with multiple and many times opposite or incompatible meanings. In our quest to understand, share and contribute in this domain, we recognize this situation

Application Programming Interfaces (API) provide reusable functionality to aid developers in the development process. The features provided by these APIs might change over time as the API evolves. To allow API consumers to peacefully transition from older obsolete features to new features, API producers make use of the deprecation mechanism that allows them to indicate to the consumer that a feature should no longer be used. The Java language designers noticed that no one was taking these deprecation warnings seriously and continued using outdated features. Due to this, they decided to change the implementation of this feature in Java 9. We question as to what extent this issue exists and whether the Java language designers have a case. We start by identifying the various ways in which an API consumer can react to deprecation. Following this we benchmark the frequency of the reaction patterns by creating a dataset consisting of data mined from 50 API consumers totalling 297,254 GitHub based projects and 1,322,612,567 type-checked method invocations. We see that predominantly consumers do not react to deprecation and we try to explain this behavior by surveying API consumers and by analyzing if the API's deprecation policy has an impact on the consumers' decision to react.

Application Programming Interfaces (APIs) are a tremendous resource-that is, when they are stable. Several studies have shown that this is unfortunately not the case. Of those, a large-scale study of API changes in the Pharo Smalltalk ecosystem documented several findings about API deprecations and their impact on API clients. We extend this study, by analyzing clients of both popular third-party Java APIs and the JDK API. This results in a dataset consisting of more than 25,000 clients of five popular Java APIs on GitHub, and 60 clients of the JDK API from Maven Central. This work addresses several shortcomings of the previous study, namely: a study of several distinct API clients in a popular, statically-typed language, with more accurate version information. We compare and contrast our findings with the previous study and highlight new ones, particularly on the API client update practices and the startling similarities between reaction behavior in Smalltalk and Java. We make a comparison between reaction behavior for third-party APIs and JDK APIs, given that language APIs are a peculiar case in terms of widespread usage, documentation, and support from IDEs. Furthermore, we investigate the connection between reaction patterns of a client and the deprecation policy adopted by the API used.

In software development life cycle, software maintenance is among the critical phases. It is a post-implementation activity that requires rigorous human efforts. For any software developer, maintaining software for a longer period is the primary objective. This objective can be accomplished if good quality software is developed. Maintainability is one of the vital characteristics of software maintenance. Maintainability enables developers to keep the system alive for a longer period of time at a limited cost. Software Maintainability can be enhanced using reengineering. The proposed research validates improvement in the quality of the reengineered software system. The quality of the software is analyzed using a coupling, cohesion, inheritance, and other essential design metrics. The observed improvement in the software design is 62.1%. The execution time of the software is also reduced by 6.5%. Reduction in the cost of maintenance is also another important outcome of this research. ...

The modern business environment requires organizations to be flexible and open to change if they are to gain and retain their competitive age. Competitive business environment needs to modernize existing legacy system in to self-adaptive ones. Reengineering presents an approach to transfer a legacy system towards an evolvable system. Software reengineering is a leading system evolution technique which helps in effective cost control, quality improvements and time and risk reduction. However successful improvement of legacy system through reengineering requires portfolio analysis of legacy application around various quality and functional parameters some of which includes reliability and modularity of the functions, level of usability and maintainability as well as policy and standards of software architecture and availability of required documents. Portfolio analysis around these parameters will help to examine the legacy application on quality and functional gaps within the application [1]. In this paper we identify and measure risk factors related to quality and functional aspect of legacy system. Paper analyzes a variety of risk components related to quality and functional dimensions of legacy application. Identification and development of various metrics and important measures to compute impact value of individual risk component is also addressed. Existing quality and functional level of legacy system are considered to identify and categories risk components. The impact of various technical issues such as inconsistency between architecture of legacy and target system, unmodularised legacy system architecture, unavailability of required design documents, high degree of coupling between modules of legacy system has been covered in the paper..

Detection of design pattern methodology is based on match gain between graph vertices. This approach has the combined action power of detection normal, changed version patterns and nearness marking. This approach make use of the fact that patterns reside in one or additional inheritance hierarchies, reducing the dimensions of the graphs to that the algorithm is applied. Finally, the algorithm doesn't suppose any patternspecific heuristic, facilitating the extension to novel style structures. Analysis on 3 open-source comes demonstrated the accuracy and therefore the potency of the proposed methodology.

Documentation is one of the elements of reusability. A good documentation can make the software module more reliable since it makes it easier to understand . Design Patterns are software modules that are proven solutions to common design problems. They improve many qualities of software like Reusability. If better reusability is required for existing software where design patterns are used, then an approach that can detect design pattern in the existing software will be useful. The result of detection approach gives occurrences of specific design pattern in existing software. In this paper we propose a tool DPVO for design pattern detection and a case study in JHotDraw (existing software) with documentation. This documentation provide location (class name) of design pattern in JHotDraw and helpful to improve reusability of this existing software.

Software engineering research now considers that no system is an island, but it is part of an ecosystem involving other systems, developers, users, hardware,. .. When one system (e.g., a framework) evolves, its clients often need to adapt. Client developers might need to adapt to functionalities, client systems might need to be adapted to a new API, client users might need to adapt to a new User Interface. The consequences of such changes are yet unclear, what proportion of the ecosystem might be expected to react, how long might it take for a change to diffuse in the ecosystem, do all clients react in the same way? This paper reports on an exploratory study aimed at observing API evolution and its impact on a large-scale software ecosystem, Pharo, which has about 3,600 distinct systems, more than 2,800 contributors, and six years of evolution. We analyze 118 API changes and answer research questions regarding the magnitude, duration, extension, and consistency of such changes in the ecosystem. The results of this study help to characterize the impact of API evolution in large software ecosystems, and provide the basis to better understand how such impact can be alleviated.

Detection of design pattern methodology is based on match gain between graph vertices. This approach has the combined action power of detection normal, changed version patterns and nearness marking. This approach make use of the fact that patterns reside in one or additional inheritance hierarchies, reducing the dimensions of the graphs to that the algorithm is applied. Finally, the algorithm doesn't suppose any patternspecific heuristic, facilitating the extension to novel style structures. Analysis on 3 open-source comes demonstrated the accuracy and therefore the potency of the proposed methodology.

The present research estimates the efficacy of a legacy program and the areas of its development. The research also intends to put forward as to what extent reengineering of a legacy program has to be done on the basis of the estimation approach. The study has tried to outline the current issues and trends in reengineering of a legacy program from various perspectives. An all-inclusive literature review reveals that a lot of work has already been piled up with legacy system estimation and the reengineering domain, yet the basic assumptions of Complexity, Quality and Effort have not been worked out collectively. Hence the present research underlines this very maxim and studies the reengineering of a legacy program on the paradigms of Quality, Complexity, and Effort Estimation collectively. The findings put forward an equation and reengineering scale which would be highly compatible with present technology for the feasibility of an effective reengineering.

The present research estimates the efficacy of a legacy program and the areas of its development. The research also intends to put forward as to what extent reengineering of a legacy program has to be done on the basis of the estimation approach. The study has tried to outline the current issues and trends in reengineering of a legacy program from various perspectives. An all-inclusive literature review reveals that a lot of work has already been piled up with legacy system estimation and the reengineering domain, yet the basic assumptions of Complexity, Quality and Effort have not been worked out collectively. Hence the present research underlines this very maxim and studies the reengineering of a legacy program on the paradigms of Quality, Complexity, and Effort Estimation collectively. The findings put forward an equation and reengineering scale which would be highly compatible with present technology for the feasibility of an effective reengineering.

Software migration has been a research subject for a long time. Major research and industrial implementations were conducted, shaping not only the techniques available nowadays, but also a good part of Software evolution jargon. To understand systematically the literature and grasp the major concepts is challenging and time-consuming. Even more, research evolves, and it does based on the assumption that many words (such as migration) have a single well-known meaning that we all share. Since since these words meanings are rarely explicit, and their usage heterogeneous, these words end up polluted with multiple and many times opposite or incompatible meanings. In our quest to understand, share and contribute in this domain, we recognize this situation

In software development life cycle, software maintenance is among the critical phases. It is a postimplementation activity that requires rigorous human efforts. For any software developer, maintaining software for a longer period is the primary objective. This objective can be accomplished if good quality software is developed. Maintainability is one of the vital characteristics of software maintenance. Maintainability enables developers to keep the system alive for a longer period of time at a limited cost. Software Maintainability can be enhanced using reengineering. The proposed research validates improvement in the quality of the reengineered software system. The quality of the software is analyzed using a coupling, cohesion, inheritance, and other essential design metrics. The observed improvement in the software design is 62.1%. The execution time of the software is also reduced by 6.5%. Reduction in the cost of maintenance is also another important outcome of this research. The observed reduction in the maintenance cost is 36.8%. Thus, the main objective of the proposed research is to analyze and validate the quality improvement in the reengineered software. Agile Scrum methodology has been used to perform software reengineering. Design Metrics are measured using the Chidamber and Kemerer Java metric (CKJM) version-9.0 tool. For reengineering implementation, Net Beans 7.3 has been used.
Keywords: Software quality, Software metric, Software Engineering, Reengineering, Software maintainability

Understanding systematically the modernization literature and grasping the major concepts is challenging and timeconsuming. Even more, research evolves, and it does it based on the assumption that many words (such as migration) have a single well-known meaning that we all share. Since these word meanings are rarely explicit, and their usage heterogeneous, these words end up polluted with multiple and many times opposite or incompatible senses. In this context, we ask the following question: What would be a valid theoretical framework that relates and gives meaning to the techniques, technologies and concepts that are required to achieve an iterative incremental migration process successfully?. This article contributes multiple bottom-up taxonomies that cover the various concepts that characterize a modernization: Legacy systems, their decline by decadence and obsolescence, the reasons that drive to recover from this decline, the different families of approaches to recover from decline, how each of these families of solutions instruments their processes and the material relation in between these processes and the features that are recognized as key in software engineering: iterativity, incrementality and validity. For building these taxonomies we propose eleven different research questions to guide the crafting of the taxonomies. To respond to this question we conduct a carefully detailed Systematic Literature Review protocol resulting in the selection of 30 articles. We extract the qualitative data to respond to the research questions by applying the Grounded Theory approach with open codification. The application of the method produced 756 different codes, and an appendix, all this content available online. This article includes more than 20 definitions, arranged in 5 taxonomies, responding to each of the eleven research questions. It also provides the mapping between different taxonomies and the classification of all our readings with the produced taxonomies. After discussing the threats to the validity, the article finishes with the proposal of a few research directions and a conclusion

A significant collection of software assets are used in all high-tech organizations and software business. Today, the major concern is with the maintenance and reuse of software which can be further invested in such a manner that its value may increase with passage of time but not like accountability whose value diminishes with the time. It has been an issue of forceful debate and keen interest for more than two decades for the software engineers to make a choice between the software reengineering and software maintenance. Metric structure which has been discussed in this work can be helpful in calculating the required reengineering cost of system and its various modules. Its authenticity has been proved with the help of a case study. A choice can be made regarding the maintenance, reengineering and retirement need of software or parts of software after obtaining results by these metrics.

Abstract— Software metrics support various reengineering tasks. A set of software metrics can be used to identifying the quality problems with the current system and the prioritization of applications that are candidates for reengineering according to their technical quality and business value. The metrics can be used in the measurements of the costs of changes in the software, if an increase in maintainability is one of the goals of the reengineering process. Also at the conclusion of the re-engineering effort the same metrics can be used to identify the quality of the new system and the return on investment. The collection of metrics on the new system can continue throughout development. To demonstrate, a metric framework has been used for reengineering process. This framework is used in different phases of Rainfall model to make reengineering process easy, economical and efficient. Case study of software has been undertaken to validate this metric framework. KeywordsMaintainabili...

For measuring software quality, majority of approaches focus on metric calculation based on code, which comes very late in the software development life cycle. The proposed approach presents a forward as well as reverse engineering approach that will detect software design patterns in UML model for forward engineering and from Java source code as a part of reverse engineering. Our approach uses structural, behavioral and semantic analysis. We introduce behavioral and semantic analysis that removes false positives from our structural analysis results. We are interested in assessing the quality of the software design by checking whether it conforms to design pattern and calculating package software metrics. Based on these two parameters the quality of the software system can be analyzed. We provide a tool that implements our approach. An XML schema of design pattern(s) which further facilitates to automate the process of design pattern identification given a class diagram with the hel...