Continuous software engineering promotes the use of a release-small, release-often deployment model, with a key focus on the shift-left approach, where quality is assessed as early as possible in the software development life-cycle. To effectively implement this shift-left strategy, developers need tools and techniques that can provide early warnings when a module may be entering a failure-prone state following certain edits. In this paper, we propose a fault-proneness detection framework that analyzes the evolution of quality and technical debt metrics as a system progresses from one commit to the next. This framework can be applied in real-time, as code is committed. Specifically, a metrics vector defines the state of each commit. Commit sequences then form a commit state transition model, which can be analyzed to identify transition paths most likely to lead to an imminent bug-inducing commit. Our approach has shown promising results when evaluated using the SonarQube Technical Debt open-source dataset.

Continuous software engineering advocates a release-small, release-often process model, where new functionality is added to a system very frequently and in small increments. In such a process model, it is important to be able to identify as early as possible, and every time a change is introduced, whether the system has entered a state where faults are more likely to occur. In this paper, we present a method that is based on process, quality, and source code metrics to evaluate the likelihood that an imminent bug inducing commit is highly probable. More specifically, the method analyzes the correlations, and the rate of change of selected structural and quality metrics. The findings from the SonarQube Technical Debt open-source dataset indicate that before bug inducing commits, metrics which otherwise are not corelated, suddenly exhibit a high correlation or high rate of metric value change. This metric behavior can then be used as a predictor for a imminent bug inducing commit. The technique is programing language agnostic, as it is based on metrics which are extracted without the use of specialized parsers, and can be applied to forewarn developers that a file, or a collection of files, has entered a state where faults are highly probable.

We witness a paradigm shift where entities such as software applications, people, businesses and service providers increasingly interact in virtual rather than physical environments, such as social media, social commerce, and the metaverses. A key issue that emerges in such environments is how one entity can trust another. Here, the concept of trust is considered as a meta-requirement, that is, the level of belief a service requestor has that a service provider will provide the service in a way that meets the requestor’s expectations. We refer to the service offering entities as service providers (SPs) and the service requesting entities as service clients (SCs). In this paper, we propose a technique that allows for evaluating trust and assigning reputation to various service providers by considering first their ability to fulfill their clients’ expectations or policies, and second the reputation other service clients have, when acting as recommenders for the aforementioned service providers. In this work, service clients and service providers are considered as virtual entities that coordinate with each other, and may include physical users, avatars, micro-services, software agents, smart contracts or any other distributed inter-networked resource, without making any assumptions as to what a service client or a service provider entity is as long as it participates in an interaction.

Tahvildari, L. and Kontogiannis, K. (2004), Improving design quality using meta-pattern transformations: a metric-based approach. J Softw Maint Evol: Res Pract, 16: 331–361. https://doi.org/10.1002/smr.299 In the online version, the corresponding author's surname was incorrect. It should read as “Tahvildari” We apologize for this error.

The emergence of smart contracts in blockchain environments allows for a wide spectrum of transaction oriented trusted applications to be developed. The majority of smart contracts are implemented as scripts written in specialized machine interpretable languages such as Solidity. However recent efforts allow for more general purpose languages such as GoLang and JavaScript to be used. It is therefore evident, that smart contract applications will quickly become more complex, and an interesting question that arises is how we can ensure that the smart contract code achieves and complies with the required goals and policies set by the system's stakeholders. In this short paper we outline a model-based approach for the automatic generation and deployment of smart contract code by using extended goal models to capture the tasks and policies set by various stakeholders, and by applying a code generator to produce Solidity code that corresponds to the model.

As microservices become one of the predominant architectural styles for distributed enterprise computing, there is a need to devise frameworks which allow for the goal driven composition and coordination of such highly granular service components. Even though a number of service composition and orchestration techniques have been proposed over the past decade, these do not take into account stakeholders’ intents as well as data, control, and temporal interdependencies between actions microservices can perform. In this paper, we present extensions to goal models with respect to data, logical and temporal dependencies exhibited between tasks and actions among microservices, and we propose a framework based on a graph transformation approach which, when applied to the extended goal models, can yield service invocation plans that achieve the desired requirements and constraints denoted by the specific goal models being considered.

Since its inception, Service Orientation allowed for distributed clients to invoke remote operations utilizing standardized protocols, programming paradigms and architectures. Furthermore, the problem of compiling complex service compositions, based on contextual information and user preferences, has been also extensively investigated by the research community. However, these techniques are mostly used within a single, or within coupled service domains that utilize predefined orchestration and composition service flows. In this paper, we propose an approach whereby service providers can specify complex service tasks as collections of goal model templates that can be instantiated and customized by the invoking clients. A reasoning process evaluates whether instantiated goals can be fulfilled based on the clients selections and consequently generates service flows that are compliant to the goal model and to the clients preferences. The major difference from existing context aware service computing frameworks is the introduction of a reasoning process that allows for the evaluation of various and possibly synergetic client goals and the on-time initiation and enactment of goal compliant service compositions. A proof of concept prototype has been implemented utilizing SOA technologies for service invocation and flow control.

The International Symposium on Web Systems Evolution (WSE) is regarded as one of the premier conferences by the software evolution and maintenance community in its domain. As a symposium, an important focus of WSE is to enable stimulating discussions and interactions of researchers, ranging from the software maintenance and evolution community to the Web engineering and service-oriented computing community, from both academia and industry, while also providing a platform for presenting high-quality research papers. To give a visual impression of the topics covered by WSE from 2001 to 2011, Figure 1 shows a tag cloud constructed from the 170 paper titles published in the corresponding proceedings. The first edition of WSE was held in 1999 as “1st International Workshop on Web Site Evolution”, and since its sixth instantiation in 2005, it is held as a symposium. Since its third instantiation in 2001, WSE is sponsored by the IEEE Computer Society and co-located with the International Conference on Software Maintenance (ICSM). Accounting for the rapid evolution and expanding scope of research topics that surround the Web, WSE's name was changed from Web Site Evolution to Web Systems Evolution in 2009. Web Systems Evolution covers an increasingly wide range of topics that address methodologies, techniques, and tools with respect to the architecture, design, evolution, maintenance, testing, and assessment of Web-related systems, applications, and sites. Information about WSE, including previous and upcoming events, can be found at its dedicated Web site at http://www.websiteevolution.org/. Furthermore, for interested readers, the history and topics of WSE have been summarized in papers at WSE's 5 1 and 10 2 years anniversaries. This special issue presents four extended and revised papers from WSE 2010. The selected papers cover several active research topics that also represent current challenges that researchers are tackling. This special issue is an outcome of the 12th IEEE International Symposium on Web Systems Evolution (WSE 2010) that was held on September 17–18, 2010 in Timişoara, Romania, and co-located with the 26th International Conference on Software Maintenance. WSE has had associated special issues for several years now, which have been published at the following journals: Wiley's Journal of Software Maintenance and Evolution (JSME) for WSE 2002 3 and WSE 2006 4, Rinton's Journal of Web Engineering (JWE) for WSE 2007 5, and Springer's Software Tools for Technology Transfer (STTT) for WSE 2008 6 and WSE 2009 7. Twenty-five technical papers (both full and short ones), from countries around the world, were submitted to WSE 2010. Each paper was reviewed at least by four members of the Program Committee, and nine full papers and six short papers were accepted for presentation at the Symposium and inclusion in the proceedings, published by the IEEE Computer Society. The WSE 2010 technical program also included a keynote speech by Carl Worms on ‘Web Services in a Global Bank – an Enterprise Architecture Perspective’ 8 and a panel on ‘Research Directions in Web Systems Evolution IV: Migrating to the Cloud’ 9. Figure 2 shows a tag cloud generated from the titles and abstracts of all papers (including keynote and panel) from WSE 2010. Contrasting the tag clouds in Figures 1 and 2, one can see – not surprisingly – that there are Web-related themes that are a stable backbone of WSE: Web sites, applications, services, evolution, models/modeling, testing, tools, and so on. However, the increasingly diverse research around the Web is reflected by WSE 2010 with additional or more prominent themes such as interfaces, architecture, scripts, quality, requirements, autonomic/adaptation, haptic, and malware/attack. In contrast, WSE 2010 de-emphasized topics such as migrating, clustering, and accessibility. After the symposium, five papers were selected by the program chairs for submission to this special issue. The selection was based on the original assessments of members of the WSE 2010 program committee that had reviewed the submitted papers and on the presentations given at the symposium. The authors of the selected papers were asked to submit a significantly revised and extended version of their papers, and each of these papers was extensively reviewed by some of the members of the WSE 2010 program committee and the program chairs. The final selection of the papers in this issue was not easy, but after an extensive reviewing process – there were at least three reviewers and at least two reviewing rounds for each paper – four papers were ultimately accepted. In the following, we briefly introduce these papers and, where applicable, place them in context with other WSE publications. The first two papers advance longstanding research topics of WSE (design recovery and quality models), whereas the other two papers – which tackle the issues of service composition mining, and the comparison and evaluation of software architectures for web applications – are newer topics for WSE in the areas of process recovery and autonomic computing. The paper by Bernardi et al., ‘Web Applications Design Recovery and Evolution with RE-UWA’, presents a methodology and accompanying tools to support the evolution of Web applications. The methodology consists of two phases: the first phase enables the reverse engineering of an existing Web application, whereas the second phase enables forward engineering of the Web application to improve upon it in some form, depending on the particular goals of the evolution effort. The reverse engineering phase constructs a conceptual model of the Web application with semi-automatic tools such as clustering and clone detection that are realized on top of the Eclipse platform. The reverse engineering phase and its associated tools are validated with four real-world Web sites. The conceptual model of each site was analyzed manually, without tool support as well as with tool support. The authors conclude that the validation ‘showed that the approach is feasible and valid’. Reverse engineering of Web sites and Web applications has been an active research stream at WSE. Generally, reverse engineering requires tool support (automatic or semi-automatic) to be effective. Consequently, the evaluation of a proposed reverse engineering technique needs an accompanying research tool that demonstrates the technique's feasibility. Examples of early efforts of techniques and tools that have been published at WSE 2001 include work by Hassan and Holt 10 as well as Martin and Martin 11. These approaches confirmed that it is feasible to apply and adapt existing software engineering techniques to the domain of the Web. Examples of more specialized techniques and tools published over the years at WSE are by Estivenart et al. 12, Gui et al. 13, and Sneed 14. Bernardi and Distante, co-authors of this special issue's paper, have presented at WSE 2008 earlier work related to the their methodology's reverse engineering phase 15 and have continued their work on the forward engineering phase with a publication at WSE 2011 16. The paper by Vaucher et al., ‘Automated Evaluation of Web Site Navigability: an Empirical Validation of Multi-level Quality Models’, presents a quality model for Web sites with the aim to assess a site's navigability and to possibly improve upon its usability. Quality models can provide an estimate of how users would assess a Web site without incurring the significant efforts and high costs that are typically associated with extensive user surveys. The quality model is composed of a page model that addresses navigability within a Web page, a composition model that addresses navigability between different pages, and a site model that summarizes the navigability of the whole site. These models are cascaded suitably. A key concern for such a quality model is its own quality in terms of predictive power, or as the authors phrase it, ‘a quality model is as useful as its capacity to reproduce the judgment of a human’. To address this concern, 30 Web sites were evaluated manually by 21 subjects that had to perform a number of tasks. These human judgments were then correlated to the quality model, which showed that the model could indeed ‘predict the perception of navigability by [the] subjects’. In summary, the authors present a quality model for navigability that improves upon the state of the art and that has been validated empirically. Usability of Web sites has been an active research stream at WSE that can be traced back to a paper at WSE 2000 by Boldyreff et al., which proposed to establish dedicated metrics for evaluating Web sites 17. At WSE 2005, a paper was published by Signore that proposes a quality model to assess Web sites on the basis of five dimensions, including navigability as one dimension 18. In the same year, a paper, which introduces the MiLE+ methodology for evaluating Web site usability, by Triacca et al. 19 appeared. Part of MiLE+ is a so-called technical inspection by a human expert that, among other criteria, checks for navigability. At WSE 2008, Martin 20 proposed to assess usability by logging user activities. Last but not least, usability is an important concern for making the Web more accessible for persons with disabilities and low Web literacy. For instance, at WSE 2007, Cesarano et al. 21 focused on usability for the blinds, which have different usability requirements, including navigability, because they listen to content in a one-dimensional voice stream. Further references to accessibility research at WSE can be found at a dedicated overview paper 22. The paper by Upadhyaya et al., ‘An Approach for Mining Service Composition Patterns from Execution Logs’, presents an approach to automatically identify patterns of service composition by analyzing the execution logs of various applications. First, the execution logs are collected and pre-processed to extract the service invocation events. Then, a set of associated services that frequently appear together in many execution instances are identified to generate candidate service sets and to select the one with the highest frequency as the intermediate pattern service set from which the final pattern service set is constructed. The control flow among the services in the pattern is then recovered by combining the execution flows from all execution instances to obtain the overall execution flows of the service composition pattern and to infer the control-flow structures (e.g., sequential and parallel) from it. This allows to identify structurally similar patterns (i.e., patterns whose control flow is present in the control flow of another one). Finally, functionally similar patterns are identified and represented at a higher level of abstraction, regardless of the concrete services that they were recovered from. The functional similarity among services is measured by the similarity in the names of the operations and of the input and output parameters between the involved services. The authors carried out a case study to validate the approach and conclude that the proposed approach can effectively detect service composition patterns. Web services and the evolution of (Web) applications towards Web services has been another one of the outstanding issues of more recent editions of WSE. The issue of mining of Web services in existing applications was dealt with by Aversano et al. 23 at WSE 2008, whereas at WSE 2009, an approach to compose Web services was presented by Jafarpour et al. 24. However, the main issue related to Web services addressed by WSE over the years has been the migration of existing applications towards Web services. WSE 2002 is the first edition where we can find research dealing with that by Lavery et al. 25, Litoiu 26, and Tilley et al. 27. Sneed has been one of the authors that made a large contribution on the issue of Web services with several papers presented at WSE addressing the migration towards Web services [28, 14], testing of Web services 29, and the complexity and quality assessment of Web service interfaces 30. Other contributions on the migration towards Web services have been made by Bhallamudi et al. 31, Marchetto et al. 32, and Yang et al. 33. Xu et al. 34 address the testing of Web services, whereas the issue of synchronization among multiple service versions is dealt with by Wang et al. 35. The paper by Litoiu and Barna, ‘A Performance Evaluation Framework for Web Applications’, presents a formal framework, called Software Performance for Autonomic Computing (SPAC), which supports a software engineer designing a Web application in the task of choosing from many possible architecture styles the one most suitable with respect to performance requirements. The proposed framework allows to compare and rank software architectures in the presence of complex performance requirements. SPAC considers and acts on the base of the performance requirements, the software architecture alternatives, and a performance model of the system along with its workloads. The framework produces a list of ranked architecture alternatives that is obtained by solving the performance models associated with each of the architectures, matching the actual performance metrics computed from the solved models against the performance requirements, and aggregating the results of the matching. The framework can be used both at design and run time. It introduces an architecture performance specification language, a solver and an optimization technique, that quantifies a software architecture in light of the performance attributes. The tool OPERA (Optimization Performance Evaluation and Resource Allocation) was developed to support the framework's application. Finally, the authors present and discuss a case study to validate that the proposed framework selects the most appropriate architecture with regard to performance requirements and architecture characteristics. The topic of this paper is quite new for WSE; indeed, just two papers were presented in previous editions about the evaluation or comparison of architectures for Web applications. Both were presented at WSE 2003: one by Smith et al. 36, and the other one by Sun et al. 37. Our thanks go to the members of the WSE 2010 program committee and in particular to the reviewers for this special issue, who provided us with in-depth, high-quality reviews. Many thanks to Scott Tilley for his invaluable help when organizing WSE 2010 and to Alice Wood and Gerardo Canfora for their support when preparing this special issue. Holger M. Kienle holds a PhD degree from the University of Victoria, Canada (2006), a Diploma in Computer Science from the University of Stuttgart, Germany (1999), and a Master of Science degree in Computer Science from the University of Massachusetts Dartmouth (1995). He received a Research Fellowship (1997–1998) from the University of California Santa Barbara and a fellowship from IBM Canada CAS, (2003–2005). For 2 years, he was a part-time researcher with Mälardalen University's PROGRESS center (2010–2011). He is a part-time Postdoc at the Computer Science Department at the University of Victoria, Canada (Prof. Hausi Müller). He has made scientific contributions in the areas of reverse engineering and component-based development. He was general chair for WSE 2011, program co-chair for WSE 2010, and co-organizer of the WASDeTT workshop series. He has served on the program committees of several conferences (CSMR, ICSM, WCRE, and WSE) and workshops (SEAMS and RELAW). Giuseppe Di Lucca is an associate professor of Software Engineering at the Department of ‘Ingegneria’ of the University of Sannio. He received the Laurea degree in Electronic Engineering from the University of Naples ‘Federico II’, Italy, in 1987 and the PhD degree in Electronic Engineering and Computer Science from the same University in 1992. Since 1987, he has been a researcher in the field of software engineering, and his list of publications contains more than 100 papers published in journals, conference proceedings, and book chapters. His main research interests include software engineering, software maintenance, software testing, reverse engineering, software reuse, software re-engineering, software migration, aspect oriented software development, and web engineering. He was program co-chair for WSE 2010 and serves both as a member of the program and organizing committees of conferences and as a reviewer of papers submitted to some of the main journals and magazines in the field of software engineering, software maintenance, and program comprehension. Kostas Kontogiannis is an associate professor at the Department of Electrical and Computer Engineering at the National Technical University of Athens, Greece, where he is leading the Software Engineering group. Prior to joining his current position, he served as a tenured associate professor at the Department of Electrical and Computer Engineering as at the University of Waterloo, Canada. Kostas received a BSc degree in Mathematics from the University of Patras, Greece, an MSc degree in Computer Science from Katholieke Universiteit Leuven, Belgium, and a PhD degree in Computer Science from McGill University, Canada. Kostas is working in the areas of software analysis, software evolution, model driven engineering, and software systems integration. He has been the recipient of three IBM University Partnership Awards and a Canada Foundation for Innovation (CFI) Award. Kostas is a faculty fellow at the IBM Center for Advanced Studies in IBM Toronto Laboratory.

Analyzing the run time behavior of large software systems is a difficult and challenging task. Log analysis has been proposed as a possible solution. However, such an analysis poses unique challenges, mostly due to the volume and diversity of the logged data that is collected, thus making this analysis often intractable for practical purposes. In this paper, we present a log analysis technique that aims to compute a smaller, compared to the original, collection of events that relate to a given analysis objective. The technique is based on computing a similarity score between the logged events and a collection of significant events that we refer to as beacons. The major novelties of the proposed technique are that it is domain independent and that it does not require the use of a pre-existing training data set. The technique has been evaluated against the DARPA Intrusion Detection Evaluation 1999 and the KDD 1999 data sets with promising results.

Model Transformation is considered an important enabling factor for Model Driven Development. Transformations can be applied not only for the generation of new models from existing ones, but also for the consistent co-evolution of software artifacts that pertain to various phases of software lifecycle such as requirement models, design documents and source code. Furthermore, it is often common in practical scenarios to apply such transformations repeatedly and frequently; an activity that can take a significant amount of time and resources, especially when the affected models are complex and highly interdependent. In this paper, we discuss a novel approach for deriving incremental model transformations by the partial evaluation of original model transformation programs. Partial evaluation involves pre-computing parts of the transformation program based on known model dependencies and the type of the applied model change. Such pre-evaluation allows for significant reduction of transformation time in large and complex model repositories. To evaluate the approach, we have implemented QvtMix, a prototype partial evaluator for the Query, View and Transformation Operational Mappings (QVT-OM) language. The experiments indicate that the proposed technique can be used for significantly improving the performance of repetitive applications of model transformations.

Problem diagnosis in large software systems is a challenging and complex task. The sheer complexity and size of the logged data make it often difficult for human operators and administrators to perform problem diagnosis and root cause analysis. A challenge in this area is to provide the necessary means, tools, and techniques for the operators to focus their attention to specific parts of the logged data reducing thus the complexity of the diagnostic process. In this paper, we propose a framework for filtering logs according to specific analysis goals and diagnostic hypotheses set by the user or by an automated process. More specifically, the proposed framework uses annotated goal trees to model the constraints and the conditions by which the functionality of a particular system is being delivered. Next, a transformation process maps such constraints and conditions to a collection of queries that can be either applied to a relational database that stores the logged data or use Latent Semantic Indexing to identify the most relevant log entries for the given query. The results of such queries provide a subset of the logged data that is compliant with the goal tree and can be used by a diagnostic SAT-solver based algorithm. Experimental results show that the filtering process can reduce the time and complexity of the diagnosis when applied to multi-tier heterogeneous service oriented systems.

The main goal of this workshop is to provide an opportunity for participants to present current work and have a lively discussion of open issues for the maintenance and evolution of service-oriented systems. The dialog will include both short-term research issues such as reengineering processes and long-term issues such as evolution patterns for service-oriented systems.

Software maintenance and reengineering are vital software engineering activities for facilitating the evolution of large software systems. However, software maintenance is not only to be considered for existing systems, but also for new systems, where software models and artefacts evolve as part of iterative and incremental development processes. The Conference on Software Maintenance and Reengineering is the premier European forum to discuss the theory and practice of software maintenance, reengineering, and evolution of software systems. CSMR promotes fruitful discussion and exchange of experiences among researchers and practitioners about the development of maintainable systems, and their evolution, migration and reengineering. This special issue comprises extended versions of three papers, presented at CSMR 2008. The 12th CSMR focused on ‘Developing evolvable systems’. The need for systems to evolve in shorter timescales and with increased quality necessitates developing maintainable and evolvable systems. Defining, achieving, and assessing ‘evolvability’, as well as issues related to processes for developing evolvable software systems are open challenges. The CSMR 2008 technical program covered a wide range of current research activities in software maintenance and reengineering, as well as industrial and academic experience reports. It included keynote talks on future trends in Software Reengineering by John Mylopoulos (University of Toronto) on ‘Software Agents’ and by Jürgen Ebert (University of Koblenz-Landau) on the serious use of ‘Metamodels in Reengineering’. The topics on technical sessions showed the current trends in our field. These include: Supporting Evolution, Code Analysis, Reverse Engineering, Reengineering and Reuse, Aspect Orientation, and Ontologies. The program was complemented by tool demonstrations, industrial reports, a doctoral symposium, and four workshops. Papers were submitted from 26 countries covering all inhabited continents. Out of 87 submitted papers, 24 full papers were selected for presentation at CSMR 08. The authors of six selected papers, based on their suitability and quality as indicated by the reviewers, were invited to submit extended versions of their papers which went through a rigorous review process involving at least three reviewers. Eventually, three papers were selected for this special issue. Dynamic Update of Java Applications—Balancing Change Flexibility vs. Programming Transparency by Alan Gregersen and Bo Jørgensen deals with the dynamic change of software behaviour. The paper presents and discusses an approach to dynamically updating running Java applications while guaranteeing type and thread safety. Splitting a Large Software Repository for Easing Future Software Evolution—An Industrial Experience Report by Marco Glorie, Andy Zaidman, Arie van Deursen, and Lennart Hofland presents lessons learned in improving the maintainability of huge industrial software systems. The paper discusses the feasibility of using formal concept analysis and cluster analysis to split software repositories in industrial scale settings. An Evaluation of Code Similarity Identification for the Grow-and-Prune Model by Thilo Mende, Rainer Koschke, and Felix Beckwermert addresses incremental software evolution and quality improvement of software systems. This paper presents and evaluates the use of clone detection techniques and similarity measures to merge code clones which had originated in deliberated copying that requires additional refactoring.

The component-based nature of large industrial software systems that consist of a number of diverse collaborating applications, pose significant challenges with respect to system maintenance, monitoring, auditing, and diagnosing. In this context, a monitoring and diagnostic system interprets log data to recognize patterns of significant events that conform to specific threat models. Threat models have been used by the software industry for analyzing and documenting a systempsilas risks in order to understand a systempsilas threat profile. In this paper, we propose a framework whereby patterns of significant events are represented as expressions of a specialized monitoring language that are used to annotate specific threat models. An approximate matching technique that is based on the Viterbi algorithm is then used to identify whether system generated events, fit the given patterns. The technique has been applied and evaluated considering threat models and monitoring policies in logs that have been obtained from multi-user MS-Windows based systems.

The main goal of this workshop is to provide an opportunity for participants to present current work and have a lively discussion of open issues for the maintenance and evolution of service-oriented systems. The dialog will include both short-term research issues such as reengineering processes and long-term issues such as evolution patterns for service-oriented systems. The current version of a SOA research agenda will be used as a starting point for discussion.

The main goal of this working session is to provide an opportunity for participants to present current work and have a lively discussion of open issues for the maintenance and evolution of SOA-based systems. The dialog will include both business issues (e.g., organizational changes in the context of migrating to an SOA environment) and technical issues (e.g., analyzing the reuse potential of legacy components in an SOA environment). A draft version of a research agenda will be used as a starting point for obtaining feedback from researchers and practitioners active in this area.

During the last decade, the number of software applications that have been deployed as a collection of components implemented in different programming languages and paradigms has increased considerably. When such applications are maintained, traditional program comprehension and reengineering techniques may not be adequate. In this context, this working session aims to stimulate discussion around key issues relating to the comprehension, reengineering, and maintenance of multi-language software applications. Such issues include, but are not limited to, the formalization, management, exploration, and presentation of multi-language program dependencies, as well as the development of practical toolsets for automating and easing the comprehension and maintenance of multi-language software.

The migration to Web services has the potential of providing significant value to keeping legacy systems and components operational in a networked environment, a number of critical issues still need to be addressed. These issues can be classified in three categories; a) program comprehension and analysis issues; b) legacy system migration issues and; c) technology and standards issues. This paper discusses and debates approaches for addressing these issues. The paper's objective is twofold. First, is to explore the current state of the art in methods, tools and technologies that can assist in carrying out the required work and to identify a taxonomy of current approaches as well as, their strengths and weaknesses. The second objective is to identify open issues and research opportunities in the area of migrating legacy systems in Web enabled environments

Software evolution is an iterative and incremental process that encompasses the modification and alteration of software models at different levels of abstraction. These modifications are usually performed independently, but the objects to which they are applied to, are in most cases mutually dependent. Inconsistencies and drift among related artifacts may be created if the effects of an alteration are not properly identified, recorded, and propagated in other dependent models. For large systems, it is possible that there is a considerable number of such model dependencies, for which manual extraction is not feasible. In this paper, we introduce an approach for automating the identification and encoding of dependence relations among software models and their elements. The proposed dependency extraction technique first uses association rules to map types between models at different levels of abstraction. Formal concept analysis is then used to identify clusters of model elements that pertain to similar or associated concepts. Model elements that cluster together are considered related by a dependency relation. The technique is used to synchronize business process specifications with the underlying J2EE source code models.

This paper proposes an architectural framework for integrating services within an enterprise and accessing them from mobile devices in a pervasive-computing environment. Present network environments are prone to failures from disconnections and device crashes. Being able to maintain service transaction while moving to different locations and wireless networks (known as service roaming), is currently a major objective in pervasive and mobile computing research. This paper presents a framework (called m-Roam) that allows for mobile clients to perform service invocation and roaming. The framework addresses this problem by introducing a proxy-based architecture so that invocation context and transaction state can be maintained or updated accordingly, while the user roams in different locations.

Software evolution encompasses all activities related to engineering software, from its inception to retirement. Propagating change across software models that are altered due to maintenance activities is a first step towards maintaining consistency between architectural design, and implementation models. Model synchronization techniques initially presented within the context of model driven architecture provide an instrument for achieving change trace-ability and consistency. We present a framework whereby software artifacts at different levels of abstraction such as architecture diagrams, object models, and abstract syntax trees are represented by graph-based MOF compliant models that can be synchronized using model transformations. In such a framework model dependencies are implicitly encoded using transformation rules and an equivalence relation is used to evaluate when two models become synchronized.

A business software application often has two perspectives: the business flow and operation that the application intends to solve, and the source code and its design and flow upon which the application is built. As one changes and evolves, the other needs to be synchronized. This paper addresses an approach to synchronize these two models for effective software maintenance.

Our previous work on improving the quality of object-oriented legacy systems through re-engineering proposed a software transformation framework based on soft-goal inter-dependency graphs (Tahvildari and Kontogiannis, 2002). We considered a class of transformations where a program is transformed into another program in the same language (source-to-source transformations) and that the two programs may differ in specific qualities such as performance and maintainability. This paper defines a decision making process that determines a list of source-code improving transformations among several applicable transformations. The decision-making process is developed on a multi-objective decision analysis technique. This type of technique is necessary as there are a number of different, and sometimes conflicting, criterion among nonfunctional requirements. For the migrant system, the proposed approach uses heuristic estimates to guide the discovery process.

Abstract Improving the design quality of large object‐oriented systems during maintenance and evolution is widely regarded as a high‐priority objective. Furthermore, for such systems that are subject to frequent modifications, detection and correction of design defects may easily become a very complex task that is even not tractable for manual handling. Therefore, the use of automatic or semi‐automatic detection and correction techniques and tools can assist reengineering activities. This paper proposes a framework whereby object‐oriented metrics can be used as indicators for automatically detecting situations for particular transformations to be applied in order to improve specific design quality characteristics. The process is based both on modeling the dependencies between design qualities and source code features, and on analyzing the impact that various transformations have on software metrics that quantify the design qualities being improved. Copyright © 2004 John Wiley & Sons, Ltd.

Over the past years, the reengineering of legacy software systems to object oriented platforms has received significant attention. In this paper, we present a generic re-engineering source code transformation framework to support the incremental migration of such procedural legacy systems to object oriented platforms. First, a source code representation framework that uses a generic domain model for procedural languages allows for the representation of abstract syntax trees as XML documents. Second, a set of transformations allow for the identification of object models in specific parts of the legacy source code. In this way, the migration process is applied incrementally on different parts of the system. A clustering technique is used to decompose a program into a set of smaller components that are suitable for the incremental migration process. Finally, the migration process gradually composes the object models obtained at every stage to generate an amalgamated object model for the whole system. . A case study for the migration of a medium size C system to C++ is discussed as a proof of concept.

This paper presents a graph matching model for the software architecture recovery problem. Because of their expressiveness, the graphs have been widely used for representing both the software system and its high-level view, known as the conceptual architecture. Modeling the recovery process as graph matching is an attempt to identify a sub-optimal transformation from a pattern graph, representing the high-level view of the system, onto a subgraph of the software system graph. A successful match yields a restructured system that conforms to the given pattern graph. A failed match indicates the points where the system violates specific constraints. The pattern graph generation and the incrementality of the recovery process are the important issues to be addressed. The approach is evaluated through case studies using a prototype toolkit that implements the proposed interactive recovery environment.

Abstract In this paper, we present a user‐assisted clustering technique for software architecture recovery based on a proximity measure that we call component association. The component association measure is computed on the shared properties among groups of highly related system entities. In this approach, the software system is modeled as an attributed relational graph with the software constructs (entities) represented as nodes and data/control dependencies represented as edges. The application of data mining techniques on the system graph allows us to generate a component graph where the edges are labeled by the association strength values among the components. An interactive partitioning technique is used to partition a system into cohesive components. Graph visualization tools and cluster quality evaluation metrics are applied by the user to assess and fine tune the partition result. Copyright © 2003 John Wiley & Sons, Ltd.

Reengineering legacy software systems to object oriented platforms has received significant attention over the past few years. In this paper, we propose a goal driven software migration framework that aims to identify and extract a quality object model from a procedural system and to generate quality object oriented code. The framework is composed of analysis tools, transformation rules, and non-functional requirement models for the target migrant system. Specifically, to facilitate the design and development of such goal driven migration framework, source code transformation rules are associated with a degree of belief that they contribute towards enhancing a desired property for the target system. The migration process applies a search algorithm that is guided by the source code analysis to select a transformation sequence that has the highest likelihood of yielding such a target system. The migration of a selected set of gnu AVL libraries to a new object oriented platform is presented as a proof of concept for the proposed technique.

In re-engineering object-oriented legacy code, it is frequently useful to introduce a design pattern in order to improve specific nonfunctional requirements (e.g., maintainability enhancement). This paper presents a methodology for the development of a quality-driven re-engineering framework for object-oriented systems. First, a catalogue of design motifs (primitive design pattern transformations) is presented Then, the transformations for the design patterns in the GoF book are defined as a composition of these primitive transformations. Nonfunctional requirements for the migrant system can be encoded using soft-goal interdependency graphs and can be associated with design pattern transformations that are applied for the migration of an object-oriented legacy system.

It has become evident that the benefits of object orientation warrant the design and development of reengineering methods that aim to migrate legacy procedural systems to modern object oriented platforms. However, most research efforts in this direction focus mostly on the extraction of an object model from the legacy procedural code without taking into account quality requirements for the target migrant system. This paper presents a reengineering workbench that allows for quality requirements of the target system to be modeled as soft-goals and software transformations to be applied selectively towards achieving specific quality requirements for the target system. In this context, the migration process is denoted by a sequence of transformations that alter the state of the system being reengineered. A Markov model approach and the Viterbi algorithm are used to identify the optimal sequence of transformations that can be applied at any given state of the migration process. For the evaluation of the proposed workbench, a migration experiment of gnu AVL tree libraries is presented.

With the rapid growth of the Internet and pervasive computing activities, the migration of back-end legacy systems to network centric environments has become a focal point for researchers and practitioners alike. To leverage back-end legacy services into Web-enabled environments, this paper proposes an incremental and iterative migration framework where legacy procedural source code is reengineered into an object-oriented platform. The reengineering framework allows for the representation of the legacy source in the form of XML based annotated abstract syntax trees. Consequently, the extraction of an object-oriented model from the original source code is based on the analysis of source code features in the original system that can be used to identify classes, associations, aggregations, and polymorphic patterns in the new target system.

Recent works by J.F. Sowa (2000) and D. Rayside and G.T. Campbell (2000) demonstrate that there is a strong connection between object-oriented programming and the logical formalism of the syllogism, first set down by Aristotle in the Prior Analytics (1928). In this paper, we develop an understanding of polymorphic method invocations in terms of the syllogism, and apply this understanding to the design of a novel editor for object-oriented programs. This editor is able to display a polymorphic call graph, which is a substantially more difficult problem than displaying a non-polymorphic call graph. We also explore the design space of program analyses related to the syllogism, and find that this space includes Unique Name, Class Hierarchy Analysis, Class Hierarchy Slicing, Class Hierarchy Specialization, and Rapid Type Analysis.

This paper presents a technique for recovering the high level design of legacy software systems based on pattern matching and user defined architectural patterns. Architectural patterns are represented using a description language that is mapped to an attributed relational graph and allows to specify the legacy system components and their data and control flow interactions. Such pattern descriptions are viewed as queries that are applied against an entity-relation graph that represents information extracted from the source code of the software system. A multi-phase branch and bound search algorithm with a forward checking mechanism controls the matching process of the two graphs by which, the query is satisfied and its variables are instantiated. An association based scoring mechanism is used to rank the alternative results generated by the matching process. Experimental results of applying the technique on the Xfig system are also presented.

One of the characteristics of large software systems is that they evolve over time. Evolution patterns include modifications related to the implementation, interfaces and the overall system structure. Consequently, system understanding and maintainability tend to degrade over time unless particular attention is paid to measure, assess and evaluate the effects of the evolution activities. Traditionally, the assessment of evolution activities has focused on the architectural level. However, in many cases it is easier to extract low-level program information from the Abstract Syntax Tree rather than to discover the full architecture of a large legacy system. This paper presents techniques for analyzing the evolution of large systems even in cases where no complete architectural views of the system exist, from information obtained solely from the AST. It presents experimental results by analyzing the evolution patterns across different versions of two popular systems, the Apache Web server and the Bash shell.

Cooperative information systems consist of existing legacy systems integrated in terms of a generic architecture which supports data integration and coordination among the integrated components. The paper presents a proposal for a generic integration architecture named CoopWARE. The architecture is presented in terms of the mechanisms it provides for data integration, and coordination. Data integration is supported by an information repository with an extensible schema, while coordination is facilitated by a rule set and an event-driven rule execution mechanism. In addition, the paper describes implementation and application experiences for the architecture in the context of a three year software engineering project.

Complete automation of design recovery of large systems is a desirable but impractical goal due to complexity and size issues, so current research efforts focus on redocumentation and partial design recovery. Pattern matching lies at the center of any design recovery system. In the context of a larger project to develop an integrated reverse engineering environment, we are developing a framework for performing clone detection, code localization, and plan recognition. This paper discusses a plan localization and selection strategy based on a dynamic programming function that records the matching process and identifies parts of the plan and code fragment that are most "similar". Program features used for matching are currently based on data flow, control flow, and structural properties. The matching model uses a transition network and allows for the detection of insertions and deletions, and it is targeted for legacy C-based systems.>