Ghizlane El Boussaidi

Business process modeling languages: Sorting through the alphabet soup

Requirements capture is arguably the most important step in software engineering, and yet the most difficult and the least formalized one [Phalp and Shepperd 2000]. Enterprises build information systems to support their business processes. Software engineering research has typically focused on the development process, starting with user requirements—if that—with business modeling often confused with software system modeling [Isoda 2001]. Researchers and practitioners in management information systems have long recognized that understanding the business processes that an information system must support is key to eliciting the needs of its users (see e.g., Eriksson and Penker 2000]), but lacked the tools to model such business processes or to relate such models to software requirements. Researchers and practitioners in business administration have long been interested in modeling the processes of organizations for the purposes of understanding, analyzing, and improving such processes [Hammer and Champy 1993], but their models were often too coarse to be of use to software engineers. The advent of ecommerce and workflow management systems, among other things, has led to a convergence of interests and tools, within the broad IT community, for modeling and enabling business processes. In this article we present an overview of business process modeling languages. We first propose a categorization of the various languages and then describe representative languages from each family.

Reconstructing Architectural Views from Legacy Systems

Modernizing a large legacy system is a demanding and costly process which requires a deep understanding of the systems architecture and its components. However legacy systems are poorly documented and they have often undergone many changes that make them deviate from their initial architectural design. Approaches for reconstructing architectural views from legacy systems and re-documenting the resulting components are of great value in the context of a modernization process. In this paper, we propose an approach that helps constructing distinct architectural views from legacy systems. To do so, we propose various clustering algorithms which are driven by common architectural views and styles. Our approach makes use of the knowledge discovery model which provides a standard machine-independent representation of legacy systems. We implemented and applied the approach in an industrial setting. The preliminary experimentations have shown that the algorithms perform well and produce comprehensive views.

Understanding design patterns — what is the problem?

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 > where MP is a model of the problem solved by the pattern, MS is a model of the solution proposed by the pattern, and T is 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 match MP (call them instances of MP), and when one is found, we apply the transformation T yielding an instance of MS. Easier said than done. Experimentation with an Eclipse Modeling Framework‐based implementation of our approach applied to a number of open‐source software applications 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

On the use of design defect examples to detect model refactoring opportunities

Abstract Design defects are symptoms of design decay, which can lead to several maintenance problems. To detect these defects, most of existing research is based on the definition of rules that represent a combination of software metrics. These rules are sometimes not enough to detect design defects since it is difficult to find the best threshold values; the rules do not take into consideration the programming context, and it is challenging to find the best combination of metrics. As an alternative, we propose in this paper to identify design defects using a genetic algorithm based on the similarity/distance between the system under study and a set of defect examples without the need to define detection rules. We tested our approach on four open-source systems to identify three potential design defects. The results of our experiments confirm the effectiveness of the proposed approach.

Using FCA to suggest refactorings to correct design defects

Design defects are poor design choices resulting in a hard-to-maintain software, hence their detection and correction are key steps of a disciplined software process aimed at yielding high-quality software artifacts. While modern structure- and metric-based techniques enable precise detection of design defects, the correction of the discovered defects, e.g., by means of refactorings, remains a manual, hence error-prone, activity. As many of the refactorings amount to re-distributing class members over a (possibly extended) set of classes, formal concept analysis (FCA) has been successfully applied in the past as a formal framework for refactoring exploration. Here we propose a novel approach for defect removal in object-oriented programs that combines the effectiveness of metrics with the theoretical strength of FCA. A case study of a specific defect, the Blob, drawn from the Azureus project illustrates our approach.

Combining lexical and structural information to reconstruct software layers

ContextThe architectures of existing software systems generally lack documentation or have often drifted from their initial design due to repetitive maintenance operations. To evolve such systems, it is mandatory to reconstruct and document their architectures. Many approaches were proposed to support the architecture recovery process but few of these consider the architectural style of the system under analysis. Moreover, most of existing approaches rely on structural dependencies between entities of the system and do not exploit the semantic information hidden in the source code of these entities. ObjectiveWe propose an approach that exploits both linguistic and structural information to recover the software architecture of Object Oriented (OO) systems. The focus of this paper is the recovery of architectures that comply with the layered style, which is widely used in software systems. MethodIn this work, we (i) recover the responsibilities of the system under study and (ii) assign these responsibilities to different abstraction layers. To do so, we use the linguistic information extracted from the source code to recover clusters corresponding to the responsibilities of the system. Then we assign these clusters to layers using the systems structural information and the layered style constraints. We formulate the recovery of the responsibilities and their assignment to layers as optimization problems that we solve using search-based algorithms. ResultsTo assess the effectiveness of our approach we conducted experiments on four open source systems. The so-obtained layering results yielded higher precision and recall than those generated using a structural-based layering approach. ConclusionOur hybrid lexical-structural approach is effective and shows potential for significant improvement over techniques based only on structural information.

Analyzing program dependencies in Java EE applications

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.

WAVI: A reverse engineering tool for web applications

Web developers face some unique challenges when trying to understand, modify and document the structure of their web applications. The heterogeneity and complexity of the underlying technologies and languages heighten comprehension problems. In particular, JavaScript, as an essential part of the Web ecosystem, is a language that offers a flexibility that can make its code hard to grasp, when it comes to comprehension and documentation tasks. In this paper, we present the first iteration of WAVI (WebAppViewer), a reverse engineering tool that uses static analysis and a filter-based mechanism to retrieve and document the structure of a Web application. WAVI is able to extract elements coming from essential web languages and frameworks such as HTML, JavaScript, CSS and Node.js. The tool makes use of some simple, effective heuristics to accurately retrieve dependency links for files and methods. WAVI also offers the visualisation of the extracted information as force-directed graphs and customized class diagrams. The effectiveness of WAVI is evaluated with experiments that demonstrate that (i) it can resolve JavaScript calls better than a recent technique, and (ii) its visualisation modules are intuitive and scalable.

An approach for classifying design artifacts

Software designers have to deal with a large number of distinct software design artifacts (SDAs), including requirements, patterns, and tactics. This paper proposes a technique that systematizes the classification of SDAs, and a classification scheme (CS) which organizes the SDAs into a matrix, in a manner derived from the Zachman Framework for enterprise architecture. An instantiation of this CS is a traceability matrix called a software-structure map (SSM) that records the SDAs and their relationships. The approach is illustrated through the analysis of the Template Method (TM) design pattern as an example of a SDA. Keywords-software knowledge management, software artifacts, multi-dimension analysis, decision support systems

The Layered Architecture Recovery as a Quadratic Assignment Problem

Software architecture recovery is a bottom-up process that aims at building high-level views that support the understanding of existing software applications. Many approaches have been proposed to support architecture recovery using various techniques. However, very few approaches are driven by the architectural styles that were used to build the systems under analysis. In this paper, we address the problem of recovering layered views of existing software systems. We re-examine the layered style to extract a set of fundamental principles which encompass a set of constraints that a layered system must conform to at design time and during its evolution. These constraints are used to guide the recovery process of layered architectures. In particular, we translate the problem of recovering the layered architecture into a quadratic assignment problem (QAP) based on these constraints, and we solve the QAP using a heuristic search algorithm. In this paper, we introduce the QAP formulation of the layering recovery and we present and discuss the results of the experimentation with the approach on four open source software systems.