Education & Training

  • Ph.D. Degree 2015

    Ph.D. in Computer Science - Software Engineering

    Université de Montpellier, France

  • Master Degree 2011

    Computer Science

    Jordan University of Science and Technology, Jordan, Excellent, 93.4% (Ranked 1st)

  • Bachelor Degree 2009

    Computer Science

    Irbid National University, Jordan, Excellent, 93.9% (Ranked 1st)

  • Diploma Degree (75 credit hours) 2006

    Computer Technology

    Alhuson University College, Albalqa Applied University, Jordan

Filter by type:

Sort by year:

Codifying Hidden Dependencies in Legacy J2EE Applications

Geoffrey Hecht, Hafedh Mili, Ghizlane El-Boussaidi, Anis Boubaker, Manel Abdellatif, Yann-Gael Guéhéneuc, Anas Shatnawi, Jean Privat, and Naouel Moha
ConferencePapers Proceedings of the 25th Asia-Pacific Software Engineering Conference (APSEC), December 2018., 2018-12-04

Abstract

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.

State of the Practice in Service Identification for SOA Migration in Industry (Best Paper Award)

Manel Abdellatif, Geoffrey Hecht, Hafedh Mili, Ghizlane El Boussaidi, Naouel Moha, Anas Shatnawi, Jean Privat, Yann-Gael Guéhéneuc
ConferencePapers Proceedings of the 16th International Conference on Service-Oriented Computing ICSOC 2018, Hangzhou, China, November 12-15, 2018, 2018-11-12

Abstract

The migration of legacy software systems to Service Oriented Architectures (SOA) has become a mainstream trend for modernizing enterprise software systems. A key step in SOA migration is the identification of services in the target application, but it is a challenging one to the extent that the potential services (1) embody reusable functionalities, (2) can be developed in a cost-effective manner, and (3) should be easy to maintain. In this paper, we report on state of the practice of SOA migration in industry. We surveyed 45 practitioners of legacy-to-SOA migration to understand how migration, in general, and service identification (SI), in particular are done. Key findings include: (1) reducing maintenance costs is a key driver in SOA migration, (2) domain knowledge and source code of legacy applications are most often used respectively in a hybrid top-down and bottom-up approach for SI, (3) industrial SI methods focus on domain services–as opposed to technical services, (4) there is very little automation of SI in industry, and (5) RESTful services and microservices are the most frequent target architectures. We conclude with a set of recommendations and best practices.

(Under submission) ReSIde: Reusable Service Identification from Software Families

Anas Shatnawi, Abdelhak Seriai, Houari Sahraoui, Tewfik Ziadi
JounalPapers Submitted on Oct 17, 2018 to the Journal of Systems and Software JSS , 2018-10-17

Abstract

(Under submission) Extraction of Software Product Line Architectures from Many System Variants

Anas Shatnawi, Djamel Seriai and Houari Sahraoui
BookChapters Submitted on Oct 10, 2018 to the Springer Handbook entitled "Re-engineering Software Intensive Systems into Software Product Lines", 2018-10-10

Abstract

Re-Factored Operational Support Systems for the Next Generation Platform as a Service

Paul Veitch, Adam Broadbent, Steven Van Rossem, Bessem Sayadi, Lionel Natarianni, Bilal Al Jammal, Laurent Roullet, Angelos Mimidis, Eder Ollora, Jose Soler, Sebastien Pinniterre, Michele Paolino, Ignacio Labrador, Aurora Ramos, X. Du, M. Flouris, Leonard
ConferencePapers The 5G Cloud Native Design Workshop, co-located with the IEEE 5G World Forum (5G-WF), Santa Clara, California, United State. 2018., 2018-10-01

Abstract

Platform-As-A-Service (PaaS) systems offer customers a rich environment in which to build, deploy, and run applications. Today’s PaaS offerings are tailored mainly to the needs of web and mobile applications developers, and involve a fairly rigid stack of components and features. The vision of the H2020 5GPPP Phase 2 Next Generation Platform-as-a-Service (NGPaaS) project is to enable “build-to-order” customized PaaSes, tailored to the needs of a wide range of use cases with telco-grade 5G characteristics. This paper sets out the salient and innovative features of NGPaaS and explores the impacts on Operational Support Systems and Business Support Systems (OSS/BSS), moving from fixed centralized stacks to a much more flexible and modular distributed architecture.

Model-Based Monitoring for IoTs Smart Cities Applications

Matteo Orrú, Marco Mobilio, Anas Shatnawi, Oliviero Riganelli, Alessandro Tundo, Leonardo Mariani
ConferencePapers 4th Italian Conference on ICT for Smart Cities & Communities (I-CiTies 2018), L'Aquila, Italy, Sept. 19-21, 2018, 2018-09-19

Abstract

Smart Cities are future urban aggregations, where a multitude of heterogeneous systems and IoT devices interact to provide a safer, more efficient, and greener environment. The vision of smart cities is adapting accordingly to the evolution of software and IoT based services. The current trend is not to have a big comprehensive system, but a plethora of small, well integrated systems that interact one with each other. Monitoring these kinds of systems is challenging for a number of reasons.

Dev-for-Operations and Multi-sided Platform for Next Generation Platform as a Service

Bela Berde, Steven Van Rossem, Aurora Ramos, Matteo Orrù, Anas Shatnawi
ConferencePapers The 12th European Conference on Network and Communications (EuCNC18). Ljubljana, Slovenia. 2018., 2018-06-18

Abstract

This paper presents two new challenges for the Telco ecosystem transformation in the era of cloud-native microservice-based architectures. (1) Development-for-Operations (Dev-for-Operations) impacts not only the overall workflow for deploying a Platform as a Service (PaaS) in an open foundry environment, but also the Telco business as well as operational models to achieve an economy of scope and an economy of scale. (2) For that purpose, we construct an integrative platform business model in the form of a Multi-Sided Platform (MSP) for building Telco PaaSes. The proposed MSP based architecture enables a multi-organizational ecosystem with increased automation possibilities for Telco-grade service creation and operation. The paper describes how the Dev-for-Operations and MSP lift constraints and offers an effective way for next-generation PaaS building, while mutually reinforcing each other in the Next Generation Platform as a Service (NGPaaS) framework.

Identifying Software Components from Object-Oriented APIs Based on Dynamic Analysis

Anas Shatnawi, Hudhaifa Shatnawi, Aymen Saied, Zakarea Al Shara, Houari Sahraoui, Abdelhak Seriai
ConferencePapers IEEE International Conference on Program Comprehension (ICPC18, co-located with ICSE). Gothenburg, Sweden. 2018., 2018-05-28

Abstract

The reuse at the component level is generally more effective than the one at the object-oriented class level. This is due to the granularity level where components expose their functionalities at an abstract level compared to the fine-grained object-oriented classes. Moreover, components clearly define their dependencies through their provided and required interfaces in an explicit way that facilitates the understanding of how to reuse these components. Therefore, several component identification approaches have been proposed to identify components based on the analysis object-oriented software applications. Nevertheless, most of the existing component identification approaches did not consider co-usage dependencies between API classes to identify classes/methods that can be reused to implement a specific scenario. In this paper, we propose an approach to identify reusable software components in object-oriented APIs, based on the interactions between client applications and the targeted API. As we are dealing with actual clients using the API, dynamic analysis allows to better capture the instances of API usage. Approaches using static analysis are usually limited by the difficulty of handling dynamic features such as polymorphism and class loading. We evaluate our approach by applying it to three Java APIs with eight client applications from the DaCapo benchmark. DaCapo provides a set of pre-defined usage scenarios. The results show that our component identification approach has a very high precision.

CloudHealth: A Model-Driven Approach to Watch the Health of Cloud Services

Anas Shatnawi, Matteo Orru, Marco Mobilio, Oliviero Riganelli and Leonardo Mariani
ConferencePapers The 1st International Workshop on Software Health (SoHeal 2018, co-located with ICSE). Gothenburg, Sweden. 2018., 2018-05-27

Abstract

Cloud systems are complex and large systems where services provided by different operators must coexist and eventually cooperate. In such a complex environment, controlling the health of both the whole environment and the individual services is extremely important to timely and effectively react to misbehaviours, unexpected events, and failures. Although there are solutions to monitor cloud systems at different granularity levels, how to relate the many KPIs that can be collected about the health of the system and how health information can be properly reported to operators are open questions. This paper reports the early results we achieved in the challenge of monitoring the health of cloud systems. In particular we present CloudHealth, a model-based health monitoring approach that can be used by operators to watch specific quality attributes. The CloudHealth Monitoring Model describes how to operationalize high level monitoring goals by dividing them into subgoals, deriving metrics for the subgoals, and using probes to collect the metrics. We use the CloudHealth Monitoring Model to control the probes that must be deployed on the target system, the KPIs that are dynamically collected, and the visualization of the data in dashboards.

NGPaaS Use Cases and Design Principles

NGPaaS Partners
Reports Internal Report 2.1 in Next Generation Platform as a Service: http://ngpaas.eu. 2017., 2017-12-01

Abstract

Initial Design of Operational Framework of NGPaaS

NGPaaS Partners
Reports Internal Report 4.3 in Next Generation Platform as a Service: http://ngpaas.eu. 2017., 2017-12-01

Abstract

Reverse Engineering Reusable Software Components from Object-Oriented APIs

Anas Shatnawi, Abdelhak Seriai, Houari Sahraoui and Zakarea Al Shara
JounalPapers SHATNAWI, Anas, SERIAI, Abdelhak-Djamel, SAHRAOUI, Houari, et al. Reverse engineering reusable software components from object-oriented APIs. Journal of Systems and Software, 2017, vol. 131, p. 442-460., 2017-09-01

Abstract

Object-oriented Application Programing Interfaces (APIs) support software reuse by providing pre-implemented functionalities. Due to the huge number of included classes, reusing and understanding large APIs is a complex task. Otherwise, software components are accepted to be more reusable and understandable entities than object-oriented ones. Thus, in this paper, we propose an approach for reengineering object-oriented APIs into component-based ones. We mine components as a group of classes based on the frequency they are used together and their ability to form a quality-centric component. To validate our approach, we experimented on 100 Java applications that used four APIs.

Recovering Software Product Line Architecture of a Family of Object-Oriented Product Variants

Anas Shatnawi, Abdelhak Seriai and Houari Sahraou
JounalPapers The Journal of Systems and Software (JSS), 2017-09-01

Abstract

Software Product Line Engineering (SPLE) aims at applying a pre-planned systematic reuse of large-grained software artifacts to increase the software productivity and reduce the development cost. The idea of SPLE is to analyze the business domain of a family of products to identify the common and the variable parts between the products. However, it is common for companies to develop, in an ad-hoc manner (e.g. clone and own), a set of products that share common services and differ in terms of others. Thus, many recent research contributions are proposed to re-engineer existing product variants to a software product line. These contributions are mostly focused on managing the variability at the requirement level. Very few contributions address the variability at the architectural level despite its major importance. Starting from this observation, we propose an approach to reverse engineer the architecture of a set of product variants. Our goal is to identify the variability and dependencies among architectural-element variants. Our work relies on formal concept analysis to analyze the variability. To validate the proposed approach, we evaluated on two families of open-source product variants; Mobile Media and Health Watcher. The results of precision and recall metrics of the recovered architectural variability and dependencies are 81%, 91%, 67% and 100%, respectively.

Software Library Investment Metrics: a New Approach, Issues and Recommendations

Mohammad Shatnawi, Ismail Hmeidi and Anas Shatnawi
JounalPapers Shatnawi, M., Hmeidi, I., Shatnawi, A., Software Library Investment Metrics: a New Approach, Issues and Recommendations, (2017) International Review on Computers and Software (IRECOS), 12 (2), pp. 84-92. doi:https://doi.org/10.15866/irecos.v12i2.12228, 2017-08-01

Abstract

Software quality is considered as one of the most highly interacting aspects in software engineering. It has many dimensions that vary depending on the users' requirements and their points of view. Thus, the varying dimensions lead to complications in measuring and defining the software quality appropriately. The use of libraries increases software quality more than using generic programming as these libraries are prepared and tested in advance. Moreover, these libraries reduce the effort spent in the designing, testing and the maintaining processes. In this research, a new model is introduced to calculate the saved effort that results from using libraries instead of generic programming in testing, coding, and productivity processes. The proposed model consists of three metrics. These metrics are the library investment ratio, the library investment level, and program simplicity. An experimental analysis has been done onto ten software products to compare the outcomes of the model with reuse percent. The outcomes show that the model gives better results than reuse percent, because the model is deepening in the source code more than the reuse percent does. Also, the model has a better effect on the improvement of software quality and productivity, rather than reuse percent.

Toward Service Identification To Support Legacy Object-Oriented Software Systems Migration To SOA

Manel Abdellatif, Anas Shatnawi, Yann-Gael Geheneuc, Hafedh Mili and Jean Privat
ConferencePapers 6ème Conférence en IngénieriE du Logiciel (CIEL 2017). Montpellier, France. 2017., 2017-06-15

Abstract

The migration of legacy software systems to Service Oriented Architecture (SOA) is a challenging task. On the one hand, legacy software systems, by their very definition, have architecture, design, and implementation problems. On the other hand, SOA is different from legacy architectures. One of the main challenges in modernizing legacy software systems is the identification of potential services with significant value. We want to support the migration of legacy object-oriented software systems to SOA. We base our support on software re-engineering techniques to extract from legacy software systems useful information for the service identification (SI) process. We aim (1) to provide good practices for SI through a taxonomy of SI approaches in the literature; (2) to propose an automatic SI technique based on re-engineering techniques. We built a taxonomy of SI approaches and drew a general classification of the different techniques in terms of the used inputs, the applied SI processes, the obtained outputs, and the applicability of the techniques. We also collected and evaluated several re-engineering tools used in SI research and several open-source applications migrated to SOA. The results of our analysis showed that there is no fully-automated SI approach in the literature. This motivates us to propose patterns for the identification process as a first step and then investigate how we can automatically identify potential services from legacy object-oriented software systems analysis based on those patterns and other heuristics.

Analyzing Program Dependencies in Java EE Applications

– Anas Shatnawi, Hafedh Mili, Ghizlane El Boussaidi, Anis Boubaker, Yann-Gael Gueheneuc, Naouel Moha, Jean Privat, Manel Abdellatif
ConferencePapers International Conference on Mining Software Repositories (MSR 2017). Buenos Aires, Argentina. 2017., 2017-05-27

Abstract

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.

Reengineering Service-Oriented Architectures: Issues and Research Directions

Hafedh Mili, Ghizlane El Boussaidi, Anas Shatnawi, Jean Privat, Manel Abdellatif, Yann-Gael Gueheneuc, Naouel Moha
TechnicalPapers Technical Report, LATECE Laboratory, University of Quebec at Montreal, Montreal, Quebec, Canada. 2017., 2017-05-01

Abstract

Service-orientation views applications as orchestrations of independent software services that (1) implement functions that are reusable across many applications, (2) can be invoked remotely, and (3) are packaged to decouple potential callers from their implementation technology. As such, it enables organizations to develop quality applications faster than without services. Legacy applications are not service-oriented. Yet, they implement many reusable functions that could be exposed as services. Organizations face three main issues when re-engineering legacy application to (re)use services: (1) to mine their existing applications for reusable functions that can become services, (2) to package those functions into services, and (3) to refactor legacy applications to invoke those services to ease future maintenance. In this paper, we explore these three issues and propose research directions to address them. We choose to focus on the service-oriented re-engineering of recent legacy object-oriented applications, and more specifically, on JEE applications, for several reasons. First, we wanted to focus on architectural challenges, and thus we choose to not have to deal with programming language difference between source and target system. We chose JEE applications, in particular, because they embody the range of complexities that one can encounter in recent legacy applications, namely, multi-language systems, multi-tier applications, the reliance on external configuration files, and the reliance on frameworks and container services during runtime. These characteristics pose unique challenges for the three issues mentioned above.

A Static Program Slicing Approach for Output Stream Objects in JEE Applications

Anas Shatnawi, Hafedh Mili, Jean Privat, Manel Abdellatif, Yann-Gael Gueheneuc, Naouel Moha, and Ghizlane El Boussaidi
TechnicalPapers Technical Report, LATECE Laboratory, University of Quebec at Montreal, Montreal, Quebec, Canada. 2017., 2017-05-01

Abstract

In this paper, we propose a program slicing approach for the output stream object in JEE applications. Our approach is based on extracting a dependency call graph from KDM models of JEE applications. Then, it applies breath-first search algorithm to identify the program slice as a graph reachability problem. The proposed approach is implemented as an extension of our DeJEE tool.

Codification of Dependencies Related to JSP Tag Libraries in JEE Applications

Anas Shatnawi, Hafedh Mili, Jean Privat, Manel Abdellatif, Yann-Gael Gueheneuc, Naouel Moha, and Ghizlane El Boussaidi
TechnicalPapers Technical Report, LATECE Laboratory, University of Quebec at Montreal, Montreal, Quebec, Canada. 2017., 2017-04-01

Abstract

JSP custom tag libraries aim to improve the code reusability and quality. However, the use of custom tag libraries makes analyzing program dependencies difficult for several reasons. We identified five reasons that are: (1) we need to visit and to parse several files that have different syntaxes to understand the semantic of each custom tag, (2) implicit dependencies of callback methods related to the Web container services, (3) there are many different ways used to develop custom tags, (4) the reliance on different meta-model in the implementation of tag libraries, and (5) the use of multilanguage code in the output stream defined in tag handlers.
In this paper, we discuss these problems and provide strategies to solve them, in order to codify program elements and related dependencies of JSP custom tag libraries. We implement these solutions in terms of a set of tools that can be used to identify a KDM model including the program elements and their related dependencies of JSP custom tag libraries.

Materializing Architecture Recovered from OO Source Code in Component-Based Languages

Zakarea Al Shara, Abdelhak Seriai, Chouki Tibermacine, Hinde Bouziane, Christophe Dony and Anas Shatnawi
ConferencePapers 10th European Conference on Software Architecture (ECSA 16), 2016-12-02

Abstract

In the literature of software engineering, many approaches have been proposed for the recovery of software architectures. These approaches propose to group classes into highly-cohesive and loosely-coupled clusters considered as architectural components. The recovered architecture plays mainly a documentation role, as high-level design views that enhance software understandability. In addition, architecture recovery can be considered as an intermediate step for migration to component-based platforms. This migration allows to fully benefit from all advantages brought by software component concept. For that, the recovered clusters should not be considered as simple packaging and deployment units. They should be treated as real components: true structural and behavior units that are instantiable from component descriptors and connected together to materialize the architecture of the software. In this paper, we propose an approach for revealing component descriptors, component instances and component-based architecture to materialize the recovered architecture of an object-oriented software in component-based languages. We applied our solution onto two well known component-based languages, OSGi and SOFA.

Identifying KDM Model of JSP Pages

Anas Shatnawi, Hafedh Mili, Jean Privat, Manel Abdellatif, Yann-Gael Gueheneuc, Naouel Moha, and Ghizlane El Boussaidi
TechnicalPapers Technical Report, LATECE Laboratory, University of Quebec at Montreal, Montreal, Quebec, Canada. 2017., 2016-08-30

Abstract

In this report, we propose our approach that identifies a KDM model of JSP pages. Our approach is based on two main steps. The first one aims to reduce the problem space by translating JSP pages into Java Servlets where we can use existing tools to identify a KDM model. The second step aims to complete the resulting KDM model by identifying dependencies of JSP tags that are not codified by the translation step.

How to Implement Dependencies in Server Pages of JEE Web Applications

Anas Shatnawi, Hafedh Mili, Jean Privat, Manel Abdellatif, Yann-Gael Gueheneuc, Naouel Moha, and Ghizlane El Boussaidi
TechnicalPapers Technical Report, LATECE Laboratory, University of Quebec at Montreal, Montreal, Quebec, Canada. 2017., 2016-05-01

Abstract

Java Enterprise Edition (JEE) applications are implemented in terms of a set of components developed based on several JEE technologies includ- ing, but not limited to, Servlet, JSP, JSF, EJB, JavaBeans. These JEE technologies rely on a varied set of communication mechanisms to commu- nicate between each others. Examples of these communication mechanisms are HTTP requests, Remote Method Invocation (RMI), Java DateBase Connectivity (JDBC), etc. These communication mechanisms represent program dependencies between JEE components. However, one communi- cation mechanism can be implemented following different implementation ways by different JEE technologies. Therefore, to be able to detect related dependencies, we identify these implementation ways used by a set of JEE technologies. In this technical report, we focus on the Web tier technologies that are Servlets, JSPs and JSFs. Also, we present how these technologies access the JavaBeans and Manage Beans components.

What Should You Know Before Developing a Service Identification Approach

Anas Shatnawi, Hafedh Mili, Jean Privat, Manel Abdellatif, Yann-Gael Gueheneuc, Naouel Moha, and Ghizlane El Boussaidi
TechnicalPapers Technical Report, LATECE Laboratory, University of Quebec at Montreal, Montreal, Quebec, Canada. 2017., 2016-04-01

Abstract

In this paper, we answer a set of research questions that are required to develop service identification approach based on the analysis of object- oriented software. Such research questions are: (1) what is a service, (2) how are services different from software components, (3) what are types of services, (4) what are existing service identification approaches that consider service types into account, and (5) how to identify services based on the object-oriented source code with respect to their types. Our methodology is based on performing a literature review to identify the answers of these research questions. Also, we propose a taxonomy of service types.

Migrating Large Object-oriented Applications into Component-based ones: Instantiation and Inheritance Transformation

Zakarea Al Shara, Abdelhak Seriai, Chouki Tibermacine, Hinde Bouziane, Christophe Dony and Anas Shatnawi
ConferencePapers 14th International Conference on Generative Programming: Concepts & Experience (GPCE 15), 2015-10-26

Abstract

In the literature of software engineering, many approaches have been proposed for the recovery of software architectures. These approaches propose to group classes into highly-cohesive and loosely-coupled clusters considered as architectural components. The recovered architecture plays mainly a documentation role, as high-level design views that enhance software understandability. In addition, architecture recovery can be considered as an intermediate step for migration to component-based platforms. This migration allows to fully benefit from all advantages brought by software component concept. For that, the recovered clusters should not be considered as simple packaging and deployment units. They should be treated as real components: true structural and behavior units that are instantiable from component descriptors and connected together to materialize the architecture of the software. In this paper, we propose an approach for revealing component descriptors, component instances and component-based architecture to materialize the recovered architecture of an object-oriented software in component-based languages. We applied our solution onto two well known component-based languages, OSGi and SOFA.

Supporting Reuse by Reverse Engineering Software Architectures and Components from Object-Oriented Product Variants and APIs

Anas Shatnawi
Books Ph.D. Thesis, 147 pages, LIRMM, University of Montpellier, France, 2015-06-29

Abstract

It is widely recognized that software quality and productivity can be significantly improved by applying a systematic reuse approach. In this context, Component-Based Software Engineering (CBSE) and Software Product Line Engineering (SPLE) are considered as two important systematic reuse paradigms. CBSE aims at composing software systems based on pre-built software components and SPLE aims at building new products by managing commonalty and variability of a family of similar software. However, building components and SPL artifacts from scratch is a costly task. In this context, our dissertation proposes three contributions to reduce this cost. Firstly, we propose an approach that aims at mining reusable components from a set of similar object-oriented software product variants. The idea is to analyze the commonality and the variability of product variants, in order to identify pieces of code that may form reusable components. Our motivation behind the analysis of several existing product variants is that components mined from these variants are more reusable for the development of new software products than those mined from single ones. The experimental evaluation shows that the reusability of the components mined using our approach is better than those mined from single software. Secondly, we propose an approach that aims at restructuring object-oriented APIs as component-based ones. This approach exploits specificity of API entities by statically analyzing the source code of both APIs and their software clients to identify groups of API classes that are able to form components. Our assumption is based on the probability of classes to be reused together by API clients on the one hand, and on the structural dependencies between classes on the other hand. The experimental evaluation shows that structuring object-oriented APIs as component-based ones improves the reusability and the understandability of these APIs. Finally, we propose an approach that automatically recovers the component-based architecture of a set of object-oriented software product variants. Our contribution is twofold: the identification of the architectural component variability and the identification of the configuration variability. The configuration variability is based on the identification of dependencies between the architectural elements using formal concept analysis. The experimental evaluation shows that our approach is able to identify the architectural variability.

Mining Software Components from Object-Oriented APIs

Anas Shatnawi, Abdelhak Seriai, Houari Sahraoui and Zakarea Al Shara
ConferencePapers 14th International Conference on Software Reuse (ICSR 2015), 2015-01-04

Abstract

Object-oriented Application Programing Interfaces (APIs) support software reuse by providing pre-implemented functionalities. Due to the huge number of included classes, reusing and understanding large APIs is a complex task. Otherwise, software components are admitted to be more reusable and understandable entities than object-oriented ones. Thus, in this paper, we propose an approach for reengineering object- oriented APIs into component-based ones. We mine components as a group of classes based on the frequency they are used together and their ability to form a quality-centric component. To validate our approach, we experimented on 100 Java applications that used Android APIs.

Recovering Architectural Variability of a Family of Product Variants

Anas Shatnawi, Abdelhak Seriai and Houari Sahraou
ConferencePapers 14th International Conference on Software Reuse (ICSR 2015), 2015-01-04

Abstract

A Software Product Line (SPL) aims at applying a pre-planned systematic reuse of large-grained software artifacts to increase the software productivity and reduce the development cost. The idea of SPL is to analyze the business domain of a family of products to identify the common and the variable parts between the products. However, it is common for companies to develop, in an ad-hoc manner (e.g. clone
and own), a set of products that share common functionalities and differ in terms of others. Thus, many recent research contributions are proposed to re-engineer existing product variants to a SPL. Nevertheless, these contributions are mostly focused on managing the variability at the requirement level. Very few contributions address the variability at the architectural level despite its major importance. Starting from this observation, we propose, in this paper, an approach to reverse engineer the architecture of a set of product variants. Our goal is to identify the variability and dependencies among architectural-element variants at the architectural level. Our work relies on Formal Concept Analysis (FCA) to analyze the variability. To validate the proposed approach, we experimented on two families of open-source product variants; Mobile Media and Health Watcher. The results show that our approach is able to identify the architectural variability and the dependencies.

Service Identification Based on Quality Metrics - Object-Oriented Legacy System Migration Towards SOA

Seza Adjoyan, Abdelhak Seriai and Anas Shatnawi
ConferencePapers 26th International Conference on Software Engineering and Knowledge Engineering (SEKE 2014), 2014-08-14

Abstract

Migrating towards Service Oriented Architecture SOA has become a major topic of interest during the recent years. Since emerging service technologies have forced non-service based software systems to become legacy, many efforts and researches have been carried out to enable these legacy systems to survive. In this context, several service identification solutions have been proposed. These approaches are either manual, thus considered expensive, or rely on ad-hoc criteria that fail to identify relevant services. In this paper, within the big picture of migrating object-oriented legacy systems towards SOA, we address automatic service identification from source code based on service quality characteristics. To achieve this, we propose a quality measurement model where characteristics of services are refined to measurable metrics.

Mining Reusable Software Components from Object-Oriented Source Code of a Set of Similar Software

Anas Shatnawi and AD Seriai
ConferencePapers IEEE 14th International Conference on Information Reuse and Integration (IRI 2013), 2013-08-14

Abstract

One of the most important approaches that support software reuse is Component Based Software Engineering (CBSE). Nevertheless the lack of component libraries is one of the major obstacles to widely use CBSE in the industry. To help filling this need, many approaches have been proposed to identify components from existing object-oriented software. These approaches identify components from singular software. Therefore the reusability of these components may be limited. In this paper, we propose an approach to mine reusable components from a set of similar object-oriented software, which were developed in the same domain, ideally by the same developers. Our goal is to enhance the reusability of mined components compared to those mined from single software. In order to validate our approach, we have applied it onto two open source Java applications of different sizes; small and large-scale ones. The results show that the components mined from the analysis of similar software are more reusable than those which are mined from single ones.

A New Framework for Software Library Investment Metrics

Mohammad Shatnawi, Ismail Hmeidi and Anas Shatnawi
ConferencePapers The Second International Conference on Digital Enterprise and Information Systems (DEIS 2013), 2013-03-04

Abstract

Software quality is considered as one of the most important challenges in software engineering. It has many dimensions which differ from users’ point of view that depend on their requirements. Therefore, those dimensions lead to difficulty in measuring and defining the software quality properly. Software quality measurement is the main core of the software quality. Thus, it is necessary to study and develop the software measurements to meet the better quality. The use of libraries increases software quality more than that of using generic programming because these libraries are prepared and tested in advance. In addition, these libraries reduce the effort that is spent in designing, testing, and maintenance processes. In this research, we presented a new model to calculate the saved effort that results from using libraries instead of generic programming in the coding, testing, and productivity processes. The proposed model consists of three metrics that are Library Investment Ratio, Library Investment Level, and Program Simplicity. An empirical analyzes has been applied into ten projects to compare the results of the model with Reuse Percent. The results show that the model has better indication of the improvement of software quality and productivity rather than Reuse Percent.

An Approximation Algorithm for Vertex Cover Problem

Yaser Khamayseh, Wail Mardini and Anas Shatnawi
ConferencePapers International Conference on Computer Networks and Communication Systems (CNCS 2012), 2012-06-01

Abstract

A New Framework for Software Library Investment Metrics

Anas Shatnawi
Books Master Thesis, 64 pages, Jordan University of Science and Technology, Jordan, 2011-12-27

Abstract

A Modified Framework for Labeling Images Based on Human Computation and Robust Technique

Mohammad Shatnawi, Qusai Aduain and Anas Shatnawi
ConferencePapers World Academy of Science, Engineering and Technology (WASET 2010), Paris, France, 2010-06-28

Abstract

  • Present 10

    Project management practices of Scram in real

    Co-supervising 5 Master students to apply project management practices of Scram. The case study is understanding code refactoring and feature identification from source code of software families.

At My Office

Tour 25-26, Office 203

Laboratory of Computer Science of Paris 6 (LIP6)

Sorbonne University

4 Place Jussieu, 75005 Paris, FRANCE