Positions

Education & Training

  • Ph.D Degree 2015

    Computer Science - Software Engineering

    Université de Montpellier, France

  • Master's Degree 2011

    Computer Science, Excellent, 93.4% (Ranked 1st)

    Jordan University of Science and Technology, Jordan

  • Bachelor’s Degree 2009

    Computer Science, Excellent, 93.9% (Ranked 1st)

    Irbid National University, Jordan

  • Diploma Degree (75 credit hours) 2006

    Computer Technology

    Alhuson University College, Albalqa Applied University, Jordan

Honors, Awards and Grants

Projects

  • 2018
    Reengineering Software Variants to Software Product Lines
  • 2017 - 2018
    CloudHealth: Monitoring as a Service Approach
  • 2015 - 2017
    Architectural Migration of JEE Web Applications into Service-Oriented Architecture
  • 2012 - 2015
    Supporting Software Reuse by Reverse Engineering of Software Architectures and Components based on the Analysis of Object-Oriented APIs and Product Variants
  • 2009 - 2012
    Holodeck: a Cross-Platform Game Engine for Building Portable Games

Projects

  • Reengineering Software Variants to Software Product Lines

    Position Held:
    Postdoctoral Researcher
    Funded By:
    Cowrkers:
    Tewfik Ziadi, Xhevahire Tërnava
    Duration:
    Jun 2018 - Present
  • CloudHealth: Monitoring as a Service Approach

    Position Held:
    Postdoc Researcher
    Funded By:
    Cowrkers:
    Prof Leonardo Mariani (team leader), Dr. Riganelli Oliviero, Dr. Mobilio Marco, Dr. Matteo Orrù and other researchers from 12 European partners from 7 EU countries.
    Duration:
    Sep 2017 - May 2018

    NGPaaS envisages 5G as: a build-to-order platform, with components, features and performance tailored to a particular use case; developed through a “Dev-for-Operations” model that extends the IT industry’s DevOps approach to support a multi-sided platform between operators, vendors and verticals; and with revised Operational and Business Support Systems (OSS/BSS) to reflect the new parameters and highly dynamic environment. NGPaaS can enable 5G to become central to a cooperative future with cloud developers, by removing the technological silos between the telco and IT industries. NGPaaS builds on 5G-PPP phase 1 projects and lays the foundation for large-scale phase 3 deployments and industrial usage, through a stepped validation of several Telco, IoT/vertical and combined scenarios culminating in a live test in Paris-Saclay campus that can incorporate innovative SMEs selected for showcasing NGPaaS’ s operational, service and business benefits.

    In the context of NGPaaS, our team at University of Milano-Bicocca manages the contribution of the operational framework that is a key engineering part of the PaaS. It handles the lifecycle management aspects of services and the underlying infrastructure. This is an important aspect of maintaining a continued service without any outages that may cause financial penalties due to non-compliance of contractual or service elements. As such the services offered by an operational framework are largely inwards focused, ensuring that the PaaS is operating as expected.

    We outline the key responsibilities of the operational framework including ensuring the reliability of the system and ensuring that the lifecycle of the service and the underlying platform is maintained. We studied the state of the art techniques and then determined how these can be carried forward and implemented in the overall operational framework that will be developed in NGPaaS.

    We identify the different operational framework elements that NGPaaS will incorporate into the different PaaSes that it will develop. The operational framework has many synergies with the business logic layer and also needs to be linked with many of the core services. This is due to the fact that the operational framework is normally responsible for the life-cycle management of services that exist on a platform. Although they do not offer outward facing business value, the services offered by operational frameworks allow for continued and sustained business practices, which help assure compliance with the contractual terms set out on what the infrastructure and services should be doing. This information that is usually decided in the business logic layer as part of the availability and requirements will feed through into the operational framework as a series of configuration options.

    To enable a useful and efficient operational framework requires monitoring of the infrastructure and the services. A combination of the configuration and the monitoring information allow introspective checks and for remedial actions to be carried out by the operational framework. This also requires that the operational framework can perform orchestration tasks as a delegated action or have communication through APIs to the orchestration framework in order to take the actions needed.

    In addition to monitoring, we describe some of the reliability metrics that can be gathered and detail a root cause analysis framework that helps to identify the sources of failures that can then be actioned. Certain types of failures are more destructive and/or have a greater chance of occurring, so it is important to weigh up the costs of mitigating such risks and balance them according to the business demands. To this effect, we also detail how high availability systems can be enabled by providing examples of working and industrial solutions. We then describe the upgradeability of the underlying infrastructure and the services by looking at a platform from one of the partners as an example of a distributed, upgradeable platform. We take inspiration from this work to help design an upgradeable and updateable system that can have both the services and the platform on which those services run, be able to continue to operate while being upgraded.

    By combining all the tools and techniques mentioned above, we will offer a framework that is upgradeable, configurable and will allow operators to decide the level of fault tolerance and reliability that is required in the overall NGPaaS platform.

  • Architectural Migration of JEE Web Applications into Service-Oriented Architecture

    Position Held:
    Postdoc Researcher
    Cowrkers:
    Prof. Hafedh Mili, Prof. Yann-Gael Gueheneuc, Prof. Jean Privat, Prof. Naouel Moha, Prof. Ghizlane El Boussaidi, Manel Abdellatif (Ph.D. student)
    Duration:
    Dec 2015 - Aug 2017

    Service-orientation views applications as orchestrations of independent software services that (1) implement functions that are reusable across many applications or application domains, (2) can be distributed and invoked remotely, and (3) are exposed such that their interfaces (a) abstract the specificities of their implementation technology and (b) allow any client, regardless of its implementation technology, to invoke them.

    An organization that applies service-oriented development can develop new applications (1) by performing a high-level decomposition of the functions of the applications into coarse functional blocks, (2) by mapping those functional blocks to available services, (3) by implementing the functional blocks that have no corresponding services, and (4) by implementing the process that orchestrates all the services. The more services we have available, the more productive and effective is service-oriented development.

    Therefore, an organization may also want to re-engineer its legacy applications to use service-oriented development (1) by mining the existing applications for reusable functions that could qualify as services, (2) by packaging these functions as services to enable their (re)use, and (3) by rewriting some existing applications to (re)use the newly-identified services. Indeed, while service identification and packaging is useful for future application development, they do little for existing applications. Therefore, refactoring existing applications into service-oriented applications is also important to modernize legacy applications and ease future maintenance.

    We choose legacy JEE applications as the input of the re-engineering effort for many reasons. First, we chose not to have to deal with language or language paradigm issues, and focus on architectural issues. Thus, we needed a legacy whose programming language(s) can support the SOA style. Second, we chose JEE in particular, as opposed to plain Java applications, because JEE applications embody the range of complexities that we are likely to encounter in enterprise applications. Indeed, JEE applications are multi-tier, multi-language, rely on external configuration files to link the pieces together, and rely on frameworks and containers during runtime to connect the pieces together. As such, they illustrate the range of complexities one is likely to encounter in recent legacy enterprise applications. Finally, we chose JEE because the technology has been in use since 1999, and is quite popular for enterprise applications.

    Validation and impact:

    We suppose that industrial and scientific communities will get the benefits of this contribution to re-engineer their JEE applications to SOA.

    Dissemination:

    Results of this project was published in 4 conference papers (MSR 2017, CIEL 2017, ICSOC2018, APSEC2018) and 6 technical report (as LATECE reports) and some other papers under the process of publication.

  • Supporting Software Reuse by Reverse Engineering of Software Architectures and Components based on the Analysis of Object-Oriented APIs and Product Variants

    Position Held:
    Ph.D. Researcher
    Cowrkers:
    Prof. Abdelhak Seriai, Prof. Houari Sahraoui
    Duration:
    Sep 2012 - Jun 2015

    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.

    Validation and impact:

    The results of this project were used for another research (as a continuity) by Zakarea Alshara for his Ph.D. thesis. We worked on code transformation of the identified components to be confirmed with existing component models. Also, our tool was used by another Ph.D. student (Seza Adjoyan) for identifying services from object-oriented legacy software. Furthermore, we have got requests about the implementation tool from international researchers as they intend to compare their approaches with ours.

    The project was validated, as my Ph.D. thesis by the jury composed of Prof. Franck Barbier (University of Pau), Prof. Jean-Michel Bruel (University of Toulouse), Prof. Flávio Oquendo (University of Brittany) and Dr Abdelkader Gouaich (University of Montpellier).

    Dissemination:

    As results of this project, we published 2 journal papers in JSS and 7 conference papers (1 ECSA 2016, 2 ICSR 2015, GPCE 2015, 1 SEKE 2014, 1 IRI 2013).

  • Holodeck: a Cross-Platform Game Engine for Building Portable Games

    Position Held:
    Software Developer
    Funded By:
    Organization:
    Cowrkers:
    Hudhaifa Shatnawi (team leader), Zakarea Alshara, Arafat Alomari, Barakat Daradkeh
    Duration:
    Jun 2009 - Jun 2012

    Holodeck is an industrial cross-platform game engine developed at Maysalward R&D. It is composed of a set of tools and API’s used for game development inspired from the "Write Once, Run Anywhere" concept. It addresses challenges related to build portable games for different environments (JavaME, Android, BlackBerry, GWT, JavaFX, Desktop and Web).

    Validation and impact:

    Holodeck provides a sufficient support to the activities of the development team at Maysalward. For example, the ability to derive executable files for different handsets and platforms can be done based on one source code.

    Dissemination:

    Holodeck is a privet product accessed only by the development team at Maysalward. However, more information can be existed at http://hudhaifas.blogspot.ca/p/holodeck-game-engine.html.

Filter by type:

Sort by year:

From GWT to Angular: An Experiment Report on Migrating a Legacy Web Application

Benoit Verhaeghe, Anas Shatnawi, Abderrahmane Seriai, Anne Etien, Nicolas Anquetil, Mustapha Derras, Stephane Ducasse
Jounal Papers IEEE Software, 2021-11-01

Abstract

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

Migrating GUI behavior: from GWT to Angular

Benoît Verhaeghe, Anas Shatnawi, Abderrahmane Seriai, Nicolas Anquetil, Anne Etien, Stéphane Ducasse, Mustapha Derras
Conference Papers International Conference on Software Maintenance and Evolution (ICSME), 2021-09-27

Abstract

In a collaboration with Berger-Levrault, a major IT company, we are working on the migration of GWT applications to Angular. We focus on the GUI aspect of this migration which requires a framework switch (GWT to Angular) and a programming language switch (Java to TypeScript). Previous work identified that the GUI can be split into the UI structure and the GUI behavioral code. GUI behavioral code is the code executed when the user interacts with the UI. Although the migration of UI structure has already been studied, the migration of the GUI behavioral code has not. To help developers during the migration of their applications, we propose a generic approach in four steps that uses a meta-model to represent the GUI behavioral code. This approach includes a separation of the GUI behavioral code into events (caller code) and the code executed when an event is fired (called code). We present the approach and its implementation for a real industrial case study. The application comprises 470 Java (GWT) classes representing 56 web pages. We give examples of the migrated code. We evaluate the quality of the generated code with standard tools (SonarQube, codelizer) and compare it to another Java to TypeScript converter. The results show that our code has 53% fewer warnings and rule violations for SonarQube, and 99% fewer for codelizer.

Is Requirements Similarity a Good Proxy for Software Similarity? An Empirical Investigation in Industry (Best Paper Runner-up Award)

M Abbas, A Ferrari, A Shatnawi, E Paul
Conference Papers The 27th International Working Conference on Requirement Engineering REFSQ 2021, 2021-04-12

Abstract

requirements can be used as proxies to retrieve similar software. When a new requirement is proposed by a stakeholder, natural language processing (NLP)-based similarity metrics can be exploited to retrieve existing requirements, and in turn identify previously developed code. [Question/problem] Several NLP approaches for similarity computation are available, and there is little empirical evidence on the adoption of an effective technique in recommender systems specifically oriented to requirements-based code reuse. [Principal ideas/results] This study compares different state-of-the-art NLP approaches and correlates the similarity among requirements with the similarity of their source code. The evaluation is conducted on real-world requirements from two industrial projects in the railway domain. Results show that requirements similarity computed with the traditional tf-idf approach has the highest correlation with the actual software similarity in the considered context. Furthermore, results indicate a moderate positive correlation with Spearman's rank correlation coefficient of more than 0.5. [Contribution] Our work is among the first ones to explore the relationship between requirements similarity and software similarity. In addition, we also identify a suitable approach for computing requirements similarity that reflects software similarity well in an industrial context. This can be useful not only in recommender systems but also in other requirements engineering tasks in which similarity computation is relevant, such as tracing and categorization.

Refactoring Monolithic Object-Oriented Source Code to MaterializeMicroservice-Oriented Architecture

Pascal Zaragoza, Abdelhak Seriai, Abderrahmane Seriai, Hinde-Lilia Bouziane, AnasShatnawi, Mustapha Derras
Conference Papers International Conference on Software Technologies ICSOF 2021, 2021-04-10

Abstract

The emergence of the microservice-oriented architecture (MSA) has led to increased maintainability, better readability, and better scalability. All these advantages make migrating a monolithic software towards an MSA an attractive prospect for organizations. The migration process is recognized to be complex and consequently risky and costly. This process is composed of two phases: (1) the microservice-based architecture recovery phase and (2) the transformation (i.e. materialization) phase.  In this paper, we propose a systematic approach to transform an object-oriented monolithic application towards an MS-oriented one by applying a set of transformation pattern. To validate our approach we automated it with our tool MonoToMicro, and applied it on a set of monolithic Java applications to be migrated towards microservices-based ones.

Symptoms-Based Fuzzy-Logic Approach for COVID-19 Diagnosis

Maad Shatnawi, Anas Shatnawi, Zakarea AlShara, Ghaith Husari
Jounal Papers International Journal of Advanced Computer Science and Applications(IJACSA), Volume 12 Issue 4, 2021. , 2021-04-04

Abstract

The coronavirus (COVID-19) pandemic has caused severe adverse effects on the human life and the global economy affecting all communities and individuals due to its rapid spreading, increase in the number of affected cases and creating severe health issues and death cases worldwide. Since no particular treatment has been acknowledged so far for this disease, prompt detection of COVID-19 is essential to control and halt its chain. In this paper, we introduce an intelligent fuzzy inference system for the primary diagnosis of COVID-19. The system infers the likelihood level of COVID-19 infection based on the symptoms that appear on the patient. This proposed inference system can assist physicians in identifying the disease and help individuals to perform self-diagnosis on their own cases.

A taxonomy of service identification approaches for legacy software systems modernization

Manel Abdellatif, Anas Shatnawi, Hafedh Mili, Naouel Moha, Ghizlane El Boussaidi, Geoffrey Hecht, Jean Privat, Yann-Gaël Guéhéneuc
Jounal Papers Journal of Systems and Software JSS, 2021-03-01

Abstract

The success of modernizing legacy software systems to Service-Oriented Architecture (SOA) depends on Service Identification Approaches (SIAs), which identify reusable functionalities that could become services. The literature describes several SIAs. However, the selection of an identification approach that is suitable for a practitioner is difficult because it depends on several factors, including the goal of modernization, the available legacy artifacts, the organization’s development process, the desired output, and the usability of the approach. Accordingly, to select a suitable service identification approach, a practitioner must have a comprehensive view of existing techniques. We report a systematic literature review (SLR) that covers 41 SIAs based on software-systems analyses. Based on this SLR, we create a taxonomy of SIAs and build a multi-layer classification of existing identification approaches. We start from a high-level classification based on the used inputs, the applied processes, the given outputs, and the usability of the SIAs. We then divide each category into a fine-grained taxonomy that helps practitioners in selecting a suitable approach for identifying services in legacy software systems. We build our SLR based on our experience with legacy software modernization, on discussions and experiences working with industrial partners, and analyses of existing SIAs. We validate the correctness and the coverage of our review with industrial experts who modernize(d) legacy software systems to SOA. The results show that our classification conforms to the industrial experts’ experiences. We also show that most of the studied SIAs are still at their infancy. Finally, we identify the main challenges that SIAs need to address, to improve their quality.

ReSIde: Reusable Service Identification from Software Families

Anas Shatnawi, Abdelhak Seriai, Houari Sahraoui, Tewfik Ziadi, Abderrahmene Seriai
Jounal Papers Journal of Systems and Software, 2020-07-16

Abstract

The clone-and-own approach becomes a common practice to quickly develop Software Product Variants (SPVs) that meet variability in user requirements. However, managing the reuse and maintenance of the cloned codes is a very hard task. Therefore, we aim to analyze SPVs to identify cloned codes and package them using a modern systematic reuse approach like Service-Oriented Architecture (SOA). The objective is to benefit from all the advantages of SOA when creating new SPVs. The development based on services in SOA supports the software reuse and maintenance better than the development based on individual classes in monolithic object-oriented software. Existing service identification approaches identify services based on the analysis of a single software product. These approaches are not able to analyze multiple SPVs to identify reusable services of cloned codes. Identifying services by analyzing several SPVs allows to increase the reusability of identified services. In this paper, we propose ReSIde (Reusable Service Identification): an automated approach that identifies reusable services from a set of object-oriented SPVs. This is based on analyzing the commonality and the variability between SPVs to identify the implementation of reusable functionalities corresponding to cloned codes that can be packaged as reusable services. To validate ReSIde, we have applied it on three product families of different sizes. The results show that the services identified based on the analysis of multiple product variants using ReSIde are more reusable than services identified based on the analysis of singular ones.

Understanding Source Code Variability in Cloned Android Families: an Empirical Study on 75 Families

Anas Shatnawi, Tewfik Ziadi, Mohamed Yassin Mohamadi
Conference Papers Proceedings of the 26th Asia-Pacific Software Engineering Conference, 2019-12-02

Abstract

Software developers rely on the clone-and-own approach to rapidly develop software product variants (PVs) that meet variability in market needs. To improve the comprehension of how PVs are evolved and varied, we analyze the clone-and-own practices applied by developers of these PVs. We perform an empirical study on 75 android families to gain insights about observable phenomena related to the commonality and variability between the source code of PVs of these families.In particular, we study three research questions to identify the commonality and variability related to the organization of source code files, cloning Java methods, and configuration parameters of AndroidManifest.xml files. The results show that cloning packages, Java files and Java methods is a common practice used by developers of all android families. Maintainers should put efforts for managing the diverse implementations (bodies) of the modified cloned methods and it is essential to consider the commonality and variability of configuration parameters.

Codifying Hidden Dependencies in Legacy J2EE Applications (Best Paper Award)

Geoffrey Hecht, Hafedh Mili, Ghizlane El-Boussaidi, Anis Boubaker, Manel Abdellatif, Yann-Gael Guéhéneuc, Anas Shatnawi, Jean Privat, and Naouel Moha
Conference Papers Proceedings of the 25th Asia-Pacific Software Engineering Conference (APSEC), Nara, Japan, 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 Student Paper Award)

Manel Abdellatif, Geoffrey Hecht, Hafedh Mili, Ghizlane El Boussaidi, Naouel Moha, Anas Shatnawi, Jean Privat, Yann-Gael Guéhéneuc
Conference Papers Proceedings of the 16th International Conference on Service-Oriented Computing ICSOC 2018, Hangzhou, China, 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) Extraction of Software Product Line Architectures from Many System Variants

Anas Shatnawi, Djamel Seriai and Houari Sahraoui
Book Chapters 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
Conference Papers 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
Conference Papers 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
Conference Papers 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
Conference Papers 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
Conference Papers 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
Jounal Papers 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
Jounal Papers 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
Jounal Papers 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
Conference Papers 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
Conference Papers 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
Technical Papers 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
Technical Papers 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
Technical Papers 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
Conference Papers 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
Technical Papers 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
Technical Papers 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
Technical Papers 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
Conference Papers 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
Conference Papers 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
Conference Papers 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
Conference Papers 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
Conference Papers 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
Conference Papers 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
Conference Papers 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
Conference Papers World Academy of Science, Engineering and Technology (WASET 2010), Paris, France, 2010-06-28

Abstract