The migration of legacy software systems to aservice-oriented architecture(SOA) is one of the main strategies for modernising such systems. The success of modernising a legacy system to a SOA highly depends on the used service identification approach where the goal is to identify reusable functionalities that could become services. In this paper, we perform a comparative analysis of service identification approaches proposed by academia and industry. We show that there is a gap between academia and industry in the used approaches to identify services from legacy systems. We extract from the comparative analysis several recommendations about the inputs, processes, and outputs that a service identification approach should have. Based on these recommendations, we proposeServiceMiner, a bottom-up service identification approach, which relies on source-code analysis, because other sources of information may be unavailable or out of sync with the actual code.ServiceMinerrelies on a categorisation of service types and code-level patterns characterising types of services. We evaluateServiceMineron four case studies. We also compare our results to those of three state-of-the-art approaches. We show thatServiceMineridentifies architecturally-significant services with, on average, 78% precision, 76% recall, and 77% F-measure.

In today's digital economy, organisations build soft-ware systems to support their Collaborative Business Processes (CBPs). Building such systems is a diligent and time-consuming task that requires both business and technical skills. Service-Oriented Architecture (SOA) offers design principals based on the service concept to help align CBPs with their supporting systems while helping organisations achieve their business goals. This paper aims to design a model-driven method that bridges the gap between CBPs and the systems that support them. Its objective is two-fold: i) design SOA-based software solutions that support CBPs expressed in BPMN and ii) build a set of goal models that link each service to the collaborative activity it automates and the business goals it satisfies.

Abstract Robotic Process Automation (RPA) is an emerging software technology for automating business processes. RPA uses software robots to perform repetitive and error‐prone tasks previously done by human actors quickly and accurately. These robots mimic humans by interacting with existing software applications through user interfaces (UI). The goal of RPA is to relieve employees from repetitive and tedious tasks to increase productivity and to provide better service quality. Yet, despite all the RPA benefits, most organizations fail to adopt RPA. One of the main reasons for the lack of adoption is that organizations are unable to effectively identify the processes that are suitable for RPA. This paper proposes a new method, called Rule‐based robotic process analysis (RRPA), that assists process automation practitioners to classify business processes according to their suitability for RPA. The RRPA method computes a suitability score for RPA using a combination of two RPA goals: (i) the RPA feasibility, which assesses the extent to which the process or the activity lends itself to automation with RPA and (ii) the RPA relevance, which assesses whether the RPA automation is worthwhile. We tested the RRPA method on a set of 13 processes. The results showed that the method is effective at 82.05% and efficient at 76.19%.

Typical object-oriented (OO) systems implement several functional features that are interwoven into class hierarchies. In the absence of aspect-oriented techniques to develop and compose these features, developers resort to object-oriented design and programming idioms to separate features as well as possible. Given a legacy OO system, discovering existing functional features helps understand the design of the system and extract these features to ease their maintenance and reuse. We want to discover candidate functional features in OO systems. We first define functional features and then discuss the footprints that such features are likely to leave in an OO system. We identify three such footprints: (1) multiple inheritance, (2) delegation, and (3) ad-hoc. We develop a set of algorithms for identifying such footprints in OO code and implemented them for the Java language using Eclipse JDT. In this article, we present the algorithms, and the results of applying the corresponding tools on five open-source systems: FreeMind, JavaWebMail, JHotDraw, JReversePro, and Lucene. Our experimental results show that: (1) the different algorithms can identify interesting and useful candidate functional features in OO systems, (2) they can identify opportunities for refactoring, and (3) they are complementary and could help developers.

Customer experience management (CEM) denotes a set of practices, processes, and tools that aim to personalise a customer’s interactions with a company, throughout a purchasing process, around the customer’s needs and desires. The customer journey is the process by which a customer interacts with a company to achieve a goal. The complexity of the purchasing process depends on the nature of the product (cartoon of milk vs. house) and on the different paths (journey) pursued by the customers throughout the purchasing process. In this paper, we propose an approach for modeling and personalising purchasing processes by marketing analysts using a Purchasing Scenario Specification Tool (PSST). The tool enables marketing analysts to select relevant process steps and interactions to handle the different encounters of the company with their customers. We rely on Case Management Model and Notation (CMMN) to represent the purchasing processes: 1) to allow marketing analysts to add and remove interactions (tasks and events in CMMN) and 2) to get a flexible process that enables company to track and interact with the different journeys pursued by their customers throughout a same purchasing process. To make the modeling easier for the marketing analyst, PSST uses a simplified notation close to CMMN. We illustrate the approach with two examples of use cases of modeling and personalising purchasing processes having different levels of complexity.

Safety-critical systems are highly heterogeneous, combining different characteristics. Effectively designing such systems requires a complex modelling approach that deals with diverse components (e.g., mechanical, electronic, software)—each having its own underlying domain theories and vocabularies—as well as with various aspects of the same component (e.g., function, structure, behaviour). Furthermore, the regulated nature of such systems prescribes the objectives for their design verification and validation. This paper proposeschecsdm, a systematic approach, based on Model-Driven Engineering (MDE), for assisting engineering teams in ensuring consistency of heterogeneous design of safety-critical systems. The approach is developed as a genericmethodologyand atool framework, that can be applied to various design scenarios involving different modelling languages and different design guidelines. The methodology comprises an iterative three-phased process. The first phase,elicitation, aims at specifying requirements of the heterogeneous design scenario. Using the proposed tool framework, the second phase,codification, consists in building a particular tool set that supports the heterogeneous design scenario and helps engineers in flagging consistency errors for review and eventual correction. The third phase,operation, applies the tool set to actual system designs. Empirical evaluation of the work is presented through two executions of thechecsdmapproach for the specific cases of a design scenario involving a mix of UML, Simulink and Stateflow, and a design scenario involving a mix of AADL, Simulink and Stateflow. Theoperationphase of the first case was performed over three avionics systems and the identified inconsistencies in the design models of these systems were compared to the results of a fully manual verification carried out by professional engineers. The evaluation also includes an assessment workshop with industrial practitioners to examine their perceptions about the approach. The empirical validation indicates the feasibility and “cost-effectiveness” of the approach. Inconsistencies were identified in the three avionics systems with a greater recall rate over the manual verification. The assessment workshop shows the practitioners found the approach easy to understand and gave an overall likelihood of adoption within the context of their work.

J2EE applications tend to be multi-tier and multi-language applications. They rely on the J2EE platform and containers that offer infrastructure and architectural services to ensure distributed, secure, safe, and scalable executions. These mechanisms hide many program dependencies, which helps development but hinders maintenance, evolution, and re-engineering of J2EE applications. In this paper, we study (i) the J2EE specifications to extract a declarative specification of the dependencies that are inherent in the services offered and that are not visible in the user code that uses them. Then, we introduce (ii) a codification of the dependencies into rules, and (iii) a tool that supports the specification of those dependencies and their detection in J2EE applications. We validate our approach and tool on a sample of 10 J2EE applications. We also compare our tool against JRipples, a state-of-the-art tool for change-impact analysis tasks. Results show that our tool adds, on average, 15% more call dependencies, which would have been missed otherwise. On change impact analysis tasks, our tool outperforms JRipples in all 10 applications, especially for the early iterations of change propagation exploration.

Summary We present a case study inmodel‐driven developmentof ane‐tourism portalthat we chose to develop throughgenerationfrom adomain modelencoded as anontology. We present (1) the requirements of e‐tourism portal, which dictated its high‐level design; (2) the principles behind our implementation strategy, including the use of adomain ontologyas a starting model within the context of a model‐driven transformational approach; (3) the ontology development process and the code generation strategy used; and (4) the lessons learned. In particular, we compare our experiences to those reported in the model‐driven engineering (MDE) literature along 3 dimensions, ie, (1) the impact of MDE on the development process, (2) the choice of the modeling approach, and (3) the impact of code generation on design and code quality and testing. Overall, our experiences corroboratedsomeof thetheoretical claimsandmanyof thepractical experienceswith MDE. Key findings include (1) model‐driven development makes maintenance, not development, more efficient; (2) it does require a higher skill level than traditional development; (3) clients and managers need to be educated into whatincrementalitymeans in agenerative approach; (4) UML is neither necessary nor sufficient to handle the required representational flexibility; (5) it is difficult to build models that are good for both human consumption and code generation; and (6) it is difficult to generate code that is, simultaneously, efficient, pretty, and easy to maintain. We conclude by summarizing the findings of the paper.

Program dependency artifacts such as call graphs help support a number of software engineering tasks such as software mining, program understanding, debugging, feature location, software maintenance and evolution. Java Enterprise Edition (JEE) applications represent a significant part of the recent legacy applications, and we are interested in modernizing them. This modernization involves, among other things, analyzing dependencies between their various components/tiers. JEE applications tend to be multilanguage, rely on JEE container services, and make extensive use of late binding techniques-all of which makes finding such dependencies difficult. In this paper, we describe some of these difficulties and how we addressed them to build a dependency call graph. We developed our tool called DeJEE (Dependencies in JEE) as an Eclipse plug-in. We applied DeJEE on two open-source JEE applications: Java PetStore and JSP Blog. The results show that DeJEE is able to identify different types of JEE dependencies.

Flexible processes emerged to provide flexibility to business process execution. A flexible process is not static and can have several different executions, that is influenced by the current situation. In this context, the decision-making is placed in the hands of any knowledge worker during the execution, who decides which tasks and in which order they will be executed. Two approaches for flexible processes are discussed in this paper: case management and declarative processes. In particular we use the CMMN standard and the ConDec language for the two approaches, respectively. We compare them based on scope, model representation, formal semantics, and limitations. Our goal is to present commonalities and differences between the languages in order to identify potential extensions to make them more complete to attain more flexible process examples.

Organizations build information systems to support their business processes. Some of these business processes are industry or organization-specific, but most are common to many industries and are used as is, modulo a few modifications. Our work tries to capitalize on these similarities to develop a methodology and tools that help business analysts generate organization-specific process models from a catalog of generic business processes. We developed a framework for representing and classifying business processes that supports process variability management by, 1) navigating a repository of generic processes, and 2) automatically generating new process variants around key process variation points. We use business patterns from the Resource Event Agent ontology to identify variation points, and to codify the model transformations inherent in the generation of the process variants. We developed a prototype, showing the computational feasibility of the approach, and validated the relevance of the variation points, and the correctness of corresponding transformations in the context of ERP key processes, showing the conceptual soundness of the approach.

Recovering the architecture of existing software systems remains a challenge and an active research field in software engineering. In this paper, we propose an approach to recover the layered architecture of object oriented software systems. To do so, our approach first recovers clusters corresponding to the various responsibilities of the system; the challenge in this context is to find the appropriate level of granularity of these responsibilities. Then the recovered clusters are assigned to layers using an optimization algorithm that exploits the principles of the layering architectural style. The approach was validated on five Java open source systems.

SUMMARY Design patterns codify proven solutions to recurring design problems. Their proper use within a development context requires that: (i) we understand them; (ii) we ascertain their applicability or relevance to the design problem at hand; and (iii) we apply them faithfully to the problem at hand. We argue that an explicit representation of the design problem solved by a design pattern is key to supporting the three tasks in an integrated fashion. We propose a model‐driven representation of design patterns consisting of triples < MP,MS,T > whereMPis a model of the problem solved by the pattern,MSis a model of the solution proposed by the pattern, andTis a model transformation of an instance of the problem into an instance of the solution. Given an object‐oriented design model, we look for model fragments that matchMP(call them instances ofMP), and when one is found, we apply the transformationTyielding an instance ofMS. Easier said than done. Experimentation with an Eclipse Modeling Framework‐based implementation of our approach applied to a number of open‐source software application's raised fundamental questions about: (i) the nature of design patterns in general, and the ones that lend themselves to our approach, and (ii) our understanding and codification of seemingly simple design patterns. In this paper, we present the principles behind our approach, report on the results of applying the approach to the Gang of Four (GoF) design patterns, and discuss the representability of design problems solved by these patterns. Copyright © 2011 John Wiley & Sons, Ltd.

The separation of concerns (SOC), as a conceptual tool, enables us to manage the complexity of the software systems that we develop. When the idea is taken further to software packaging, greater reuse and maintainability are achieved. One of the methods of SOC is view-oriented programming (VOP) in which an object can change its behaviors and play different roles (views) in their lifecycle. In VOP, an object's response to a message depends on the views currently attached to its core instance. This view-programming suffers from security issues to protect the privileges of each client who needs to access different views of the same object. In a previous article, we introduced a view security model based on changing the signature of each method to authenticate a client privileges to access object views. In this paper, we present the main parts of our views security model without changing each method signature. Java security model is applied to views to support transparent authentication. These issues are discussed through an example.

Legacy OO applications typically implement a number of functional features. In the absence of aspect-oriented development techniques to separately develop and maintain these features, they end up embodied in the same class hierarchies. That embodiement depends on the design technique used to implement them. We identified three such design techniques: a) multiple inheritance– or simulations thereof, b) delegation, and c) what we referred to as adhoc implementation. We are interested in developing techniques for identifying and isolating code fragments that implement distinct functional features. Here, we explore the use of concept analysis to detect ad-hoc implementations of features. We present the principles underlying our overall approach, a concrete method for identifying functional features in legacy code, and the results of preliminary experimentation.

In wide-enterprise information system, an object can change its behaviors and play different roles in their lifecycle. Each client program needs to access different pieces/views of the same domain object. Our approach, called distributed view programming, tries to address both problems and in particular, we address delegation problem in view-based systems. At any given point of time, an object offers a different set of behaviors depending of the active views in that time. Therefore, a client/application user may select a subset of existing functionalities of that object. The core object forwards a function call to a view that has to return it to core object. In distributed platforms, there is no need to support delegation in EJB Corba or .Net because the separation of an object and its aspects doesn't exist. We discuss the delegation model and security issues.

Aspect-oriented software development builds upon object-oriented (OO) development by offering additional abstraction boundaries that help us separate different types of requirements into so-called aspects. Given a legacy OO application, it pays to identify existing aspects to help understand the structure of the application and potentially to extract those aspects into separate software modules that can be maintained and reused individually. We are interested in the extraction and repackaging of functional aspects. We first characterize what we mean by functional aspect, and then explore the properties that such aspects are likely to exhibit in a legacy application that integrate such aspects. Next, we present algorithms for extracting such aspects, and the preliminary results we obtained. We conclude by discussing directions for future research.

Design patterns encode proven solutions to recurring design problems. To use a design pattern properly, we need to 1) understand the design problem the pattern resolves, 2) recognize an instance of this problem in the model at hand, and 3) to transform the model to produce the proposed solution. We argue that an explicit representation of the design problem solved by a pattern is key to supporting each one of these tasks. We propose to represent a design pattern using a triple (MP, MS, T) where MP is a model of the design problem solved by the pattern, MS is a model of the solution proposed by it, and T is a rule-based representation of the transformations embodied in the application of the pattern. In this paper, we describe the principles underlying our approach and the current implementation using the Eclipse Modeling FrameworkTMand JRulesTM.

Enterprises build information systems to support their business processes. Some of those business processes are industry or enterprise-specific, but most are common to many industries and are used, modulo a few modifications, in different contexts. To the extent that we can, i) decompose complex business processes into composable generic sub-processes, ii) develop software components that implement such generic processes, and iii) map process specialization and composition operators to corresponding operators on software components, we will be able to develop information systems by modeling the business processes that they are meant to support, and using such models to guide the assembly of the corresponding software components. This is not a new idea, but earlier attempts suffered from the lack of tools, conceptual and otherwise, to perform this mapping. In this paper, we describe the principles underlying our approach and the status of the current implementation in the Eclipse environment.

Abstract Enterprise frameworks are a special class of application frameworks. They are distinguished from other application frameworks in terms of scale and focus. In terms of focus, application frameworks typically cover one particular aspect of an application, either a domain‐dependent aspect (e.g., billing in a web‐based customer‐to‐business ordering system), or a computational infrastructure aspect such as distribution, man‐machine interface, or persistence, etc. Generally, an application framework alone delivers no useful end‐user function. With infrastructure frameworks, we still have to plug in domain functionalities, while with domain frameworks, we need to set‐up the infrastructure. In contrast, enterprise frameworks embody a reference architecture for an entire application, covering both the infrastructure aspects of the application, and much of the domain‐specific functionality. Instantiating an enterprise framework is nothing short of application engineering, where the architecture and many of the components are reusable. While creativity and continual improvement may be the major ingredients for building a good application framework, anything related to enterprise frameworks, be it building, documenting, or instantiating them, is complex and requires careful design and planning. In this paper, we identify the issues involved in building, using, and maintaining enterprise frameworks, both from research and practical perspective. Copyright © 2002 John Wiley & Sons, Ltd.

We propose a model for building object oriented applications based on the composition of application slices or fragments that provide their own overlapping definitions or expectations of the same domain objects. Different slices may implement different functional or implementation concerns, or embody different access rights and privileges to the same domain objects. We call such slices views and we recognize that the behavior embodied in views may be abstracted into generic class-like algebraic structures called viewpoints, from which views for specific domain classes may be generated. We are interested in the problem of distributing view based applications when different sites access different slices of the same domain objects. Specifically, we are interested in the problem of offering different views of the same domain objects to different client programs in a CORBA-like environment. We first discuss the principles behind view programming, and then explore ways in which objects with views may be distributed in a way that support's different sets of functionalities to different client programs. An interesting application of view programming in a distributed context is the selective duplication of object slices.

The Simple Network Management Protocol (SNMP) was introduced in 1988 and is still widely implemented, deployed, and used. SNMPv3 is now in its final stages of standardization. From a practical perspective, we need to consider how telecommunication systems can be extended to consider different versions of SNMP, different applications and different security models. We present an object-oriented implementation of SNMPv3 to create a flexible product architecture. This architecture allows one to easily interface with other modules as required. We also describe network object models and relationships required for the architecture. The implementation uses Java to create modular reusable components. We explain how the architecture using a modular approach can allow interoperability with other SNMP applications. Also, the systems can possibly connect via an API bus to CORBA, JMAPI or WBEM.

The Simple Network Management Protocol (SNMP) was introduced in 1988 and is still widely implemented, deployed, and used. SNMPv3 is now in its final stages of standardization. From a practical perspective, we need to consider how telecommunication systems can be extended to consider different versions of SNMP, different applications and different security models. We will present an object-oriented implementation of SNMPv3 to create a flexible product architecture. This architecture allows to easily interface with other modules as required. We also describe network object models and relationships required for the architecture. The implementation uses Java to create modular reusable components. We explain how the architecture using a modular approach can allow interoperability with other SNMP applications. Also, the systems can possibly connect via an API bus to CORBA, JMAPI or WBEM.

Software productivity has been steadily increasing over the past 30 years, but not enough to close the gap between the demands placed on the software industry and what the state of the practice can deliver; nothing short of an order of magnitude increase in productivity will extricate the software industry from its perennial crisis. Several decades of intensive research in software engineering and artificial intelligence left few alternatives but software reuse as the (only) realistic approach to bring about the gains of productivity and quality that the software industry needs. In this paper, we discuss the implications of reuse on the production, with an emphasis on the technical challenges. Software reuse involves building software that is reusable by design and building with reusable software. Software reuse includes reusing both the products of previous software projects and the processes deployed to produce them, leading to a wide spectrum of reuse approaches, from the building blocks (reusing products) approach, on one hand, to the generative or reusable processor (reusing processes), on the other. We discuss the implication of such approaches on the organization, control, and method of software development and discuss proposed models for their economic analysis. Software reuse benefits from methodologies and tools to: (1) build more readily reusable software and (2) locate, evaluate, and tailor reusable software, the last being critical for the building blocks approach. Both sets of issues are discussed in this paper, with a focus on application generators and OO development for the first and a thorough discussion of retrieval techniques for software components, component composition (or bottom-up design), and transformational systems for the second. We conclude by highlighting areas that, in our opinion, are worthy of further investigation.>

Existing 00 development methodologies (see e.g.[Rumbaugh9 1 a, Wirfs-Brock90a, Coad9 la]) prescribe that design builds on the basic class structure identified at the analysis level--one aspect of the much vaunted seamless transition--by adding high level (control) and low level (utility)

Inheritance is commonly, exploited by computer programs that deal with hierarchic knowledge and is one instance of the regularity described in this work. Regularity formalizes the observation that hierarchical relationships between concepts reflect relationships between the concepts' properties, and vice versa. Based on the regularity in a knowledge base, an expansion procedure can compute what the attributes of concepts should be when those attributes haven't been previously discovered. In tangled hierarchies where a concept has several parents, a true-false model of property values cannot capture the complexity of the relationships among property values. Fuzzy representations of regularity and expansion correct this failure. The fuzzy sets framework takes into account the normative nature of property values. A theorem is presented that relates a parameter of the fuzzy expansion algorithm to the reliability of expansion. A computer program that implements expansion has been applied to several medical knowledge bases. The experimental results show that expansion is reliable.>

Motivated by the properties of spreading activation and conceptual distance, the authors propose a metric, called distance, on the power set of nodes in a semantic net. Distance is the average minimum path length over all pairwise combinations of nodes between two subsets of nodes. Distance can be successfully used to assess the conceptual distance between sets of concepts when used on a semantic net of hierarchical relations. When other kinds of relationships, like 'cause', are used, distance must be amended but then can again be effective. The judgements of distance significantly correlate with the distance judgements that people make and help to determine whether one semantic net is better or worse than another. The authors focus on the mathematical characteristics of distance that presents novel cases and interpretations. Experiments in which distance is applied to pairs of concepts and to sets of concepts in a hierarchical knowledge base show the power of hierarchical relations in representing information about the conceptual distance between concepts.>

An investigation is reported of ways to take advantage of the semantics in thesauri to improve: (1) indexing by providing descriptions of documents as sets of terms from the thesaurus; and (2) retrieval by assessing the relevance of documents to a query. Thesauri need to be updated to account for the evolution of the field they cover. Accordingly, various augmentation algorithms and methods to assess the usefulness of these augmentations are being studied. The augmentations consist of merging two existing thesauri. By keeping a consistent level of complexity among the structure manipulated by the merging algorithm, the reasoning method, and the evaluation procedure, an improvement of the performance of the merged thesaurus on both document indexing and retrieval is demonstrated.>