publications

2021

1. A taxonomy of service identification approaches for legacy software systems modernization

   Abdellatif, Manel, Shatnawi, Anas, Mili, Hafedh, Moha, Naouel, Boussaidi, Ghizlane El, Hecht, Geoffrey, Privat, Jean, and Guéhéneuc, Yann-Gaël

   Journal of Systems and Software 2021

   Abs

   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.

2. Optimization of Java Virtual Machine Flags Using Feature Model and Genetic Algorithm

   Canales, Felipe, Hecht, Geoffrey, and Bergel, Alexandre

   In Companion of the ACM/SPEC International Conference on Performance Engineering 2021

   Abs PDF

   Optimizing the Java Virtual Machine (JVM) options in order to get the best performance out of a program for production is a challenging and time-consuming task. HotSpot, the Oracle’s open-source Java VM implementation offers more than 500 options, called flags, that can be used to tune the JVM’s compiler, garbage collector (GC), heap size and much more. In addition to being numerous, these flags are sometimes poorly documented and create a need of benchmarking to ensure that the flags and their associated values deliver the best performance and stability for a particular program to execute.Auto-tuning approaches have already been proposed in order to mitigate this burden. However, in spite of increasingly sophisticated search techniques allowing for powerful optimizations, these approaches take little account of the underlying complexities of JVM flags. Indeed, dependencies and incompatibilities between flags are non-trivial to express, which if not taken into account may lead to invalid or spurious flag configurations that should not be considered by the auto-tuner.In this paper, we propose a novel model, inspired by the feature model used in Software Product Line, which takes the complexity of JVM’s flags into account. We then demonstrate the usefulness of this model, using it as an input of a Genetic Algorithm (GA) to optimize the execution times of DaCapo Benchmarks.

3. Quantifying the adoption of Kotlin on Android stores: Insight from the bytecode

   Hecht, Geoffrey, and Bergel, Alexandre

   In IEEE/ACM 8th International Conference on Mobile Software Engineering and Systems (MobileSoft) 2021

   Abs PDF

   Android apps have been traditionally built using Java since the inception of Android. However, Google announced Kotlin as an official supported language for the Android platform in May 2017. Since then, the popularity of Kotlin for Android projects has steadily increased, to the point that Google announced in 2019 that “Android development will be Kotlin-first” with nearly 60% of the top 1,000 Android apps containing Kotlin code. Yet, the transition from Java to Kotlin seems gradual and most applications still partially use Java. Outside open-source apps, little is known about the real proportion of code written in Kotlin inside apps. This paper supports a better understanding of the adoption of Kotlin in the Android ecosystem. We propose an approach to identify the language, Java or Kotlin, in which a class bytecode of an Android Package Kit (APK) originate from. We applied our model on more than 200k closed-source APKs from app stores and found that (i) most of the apps classes are still written in Java, indicating a mitigated adoption of Kotlin in less popular apps, (ii) the penetration of Kotlin is steadily increasing since 2017. We believe our insights are valuable to assess the adoption of Kotlin at large.

4. Quality Histories of Past Extract Method Refactorings

   Taqui, Abel Mamani, Sandoval, Juan Pablo, Hecht, Geoffrey, and Bergel, Alexandre

   In International Conference on Computational Science and Its Applications 2021

   Abs PDF

   Modern programming environments offer the Extract Method refactoring as a way to improve software quality by moving a source code fragment into a new method. This refactoring comes with an immediate positive feedback by shortening the refactored method. It can also increase code re-usage and encourage developers to remove code clones. The impact of refactorings on the software quality has been the topic of many research efforts. However, these refactorings are usually studied in groups. Therefore the metrics evaluated and the observation are not tailored to a specific refactoring, thus hiding a valuable insight on how practitioners use a refactoring in particular. In this paper, we conduct an assessment of the quality impact resulting from the Extract Method refactoring. Our results statistically confirm the tendency of the Extract Method to improve complexity and slightly worsen cohesion, respectively in 46% and 70% of the refactoring. In addition, we observe that the Extract Method favors re-use and reduces occurrences of code clones in 56% of the extracted methods. However, our results also show that some specific cases are contrary to the previously mentioned trends and that it is therefore necessary to study refactorings at a low granularity.

5. VR-Based User Interactions to Exploit InfiniteSpace in Programming Activities

   Segura, Víctor, Merino, Leonel, Hecht, Geoffrey, and Bergel, Alexandre

   In 40th International Conference of the Chilean Computer Science Society (SCCC) 2021

   Abs

   Virtual reality (VR) devices have now become a commodity, and as such, VR is percolating the traditional working environment of software programmers. Current approaches to use VR as the medium to immerse software programmers essentially project classical IDE windows in the virtual environment: the very same VSCode or IntelliJ window is seen through the VR device. As a consequence, the same constraints imposed by a physical screen are found in the VR environment, thus representing a missed opportunity. VRIDE is a new VR-based environment for object-oriented programming to let software developers carry out their activity in a full VR-based immersed environment. VRIDE innovates by offering four interactions designed to exploit the infinite space proposed by the VR environment. Our interactions disrupts the traditional mapping of windows from desktop to VR by supporting dedicated actions for navigation, inspection, and space management. Our prototype illustrates the feasibility of having a virtual environment for software programmers.

2020

1. Vision: Alleviating Android Developer Burden on Obfuscation

   Hecht, Geoffrey, Neverov, Cyprien, and Bergel, Alexandre

   In Proceedings of the IEEE/ACM 7th International Conference on Mobile Software Engineering and Systems 2020

   Abs PDF

   Mobile applications (apps) have gained an increasing importance in the field of software engineering as they are becoming one of the most widely used type of software. In the Android ecosystem, obfuscation tools are available to optimize, reduce the size and protect the intellectual properties of apps. However, despite the clear advantages provided by obfuscation most apps do not use it, often because of the difficulties induced by the usage of obfuscation which requires writing rules to keep a usable app. In this paper, we identify the concrete challenges encountered by app developers who wish to use obfuscation in their apps. In addition, we propose an approach using crowdsourcing to automatically generate rules, when static analysis is not sufficient. With the knowledge gained from hundreds of projects, we hope to lighten the burden on developers when writing rules.

2018

1. State of the practice in service identification for soa migration in industry

   Abdellatif, Manel, Hecht, Geoffrey, Mili, Hafedh, Elboussaidi, Ghizlane, Moha, Naouel, Shatnawi, Anas, Privat, Jean, and Guéhéneuc, Yann-Gaël

   In International Conference on Service-Oriented Computing 2018

   Abs PDF

   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.

2. Codifying Hidden Dependencies in Legacy J2EE Applications

   Hecht, Geoffrey, Mili, Hafedh, El-Boussaidi, Ghizlane, Boubaker, Anis, Abdellatif, Manel, Guéhéneuc, Yann-Gaël, Shatnawi, Anas, Privat, Jean, and Moha, Naouel

   In 2018 25th Asia-Pacific Software Engineering Conference (APSEC) 2018

   Abs PDF

   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.

2017

1. Investigating the energy impact of Android smells

   Carette, Antonin, Younes, Mehdi Adel Ait, Hecht, Geoffrey, Moha, Naouel, and Rouvoy, Romain

   In 2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER) 2017

   Abs PDF

   Android code smells are bad implementation practices within Android applications (or apps) that may lead to poor software quality. These code smells are known to degrade the performance of apps and to have an impact on energy consumption. However, few studies have assessed the positive impact on energy consumption when correcting code smells. In this paper, we therefore propose a tooled and reproducible approach, called HOT-PEPPER, to automatically correct code smells and evaluate their impact on energy consumption. Currently, HOT-PEPPER is able to automatically correct three types of Android-specific code smells: Internal Getter/Setter, Member Ignoring Method, and HashMap Usage. HOT-PEPPER derives four versions of the apps by correcting each detected smell independently, and all of them at once. HOT-PEPPER is able to report on the energy consumption of each app version with a single user scenario test. Our empirical study on five open-source Android apps shows that correcting the three aforementioned Android code smells effectively and significantly reduces the energy consumption of apps. In particular, we observed a global reduction in energy consumption by 4,83% in one app when the three code smells are corrected. We also take advantage of the flexibility of HOT-PEPPER to investigate the impact of three picture smells (bad picture format, compression, and bitmap format) in sample apps. We observed that the usage of optimised JPG pictures with the Android default bitmap format is the most energy efficient combination in Android apps. We believe that developers can benefit from our approach and results to guide their refactoring, and thus improve the energy consumption of their mobile apps.

2. Code Smells in iOS Apps: How Do They Compare to Android?

   Habchi, Sarra, Hecht, Geoffrey, Rouvoy, Romain, and Moha, Naouel

   In 2017 IEEE/ACM 4th International Conference on Mobile Software Engineering and Systems (MOBILESoft) 2017

   Abs PDF

   With billions of app downloads, the Apple App Store and Google Play Store succeeded to conquer mobile devices. However, this success also challenges app developers to publish high-quality apps to keep attracting and satisfying end-users. In particular, taming the ever-growing complexity of mobile apps to cope with maintenance and evolution tasks under such a pressure may lead to bad development choices. While these bad choices, a.k.a. code smells, are widely studied in object-oriented software, their study in the context of mobile apps, and in particular iOS apps, remains in its infancy. Therefore, in this paper, we consider the presence of object-oriented and iOS-specific code smells by analyzing 279 open-source iOS apps. As part of this empirical study, we extended the Paprika toolkit, which was previously designed to analyze Android apps, in order to support the analysis of iOS apps developed in Objective-C or Swift. We report on the results of this analysis as well as a comparison between iOS and Android apps. We comment our findings related to the quality of apps in these two ecosystems. Interestingly, we observed that iOS apps tend to contain the same proportions of code smells regardless of the development language, but they seem to be less prone to code smells compared to Android apps.

2016

1. An Empirical Study of the Performance Impacts of Android Code Smells

   Hecht, Geoffrey, Moha, Naouel, and Rouvoy, Romain

   In IEEE/ACM International Conference on Mobile Software Engineering and Systems (MOBILESoft’16) 2016

   Abs PDF

   Android code smells are bad implementation practices within Android applications (or apps) that may lead to poor software quality, in particular in terms of performance. Yet, performance is a main software quality concern in the development of mobile apps. Correcting Android code smells is thus an important activity to increase the performance of mobile apps and to provide the best experience to mobile end-users while considering the limited constraints of mobile devices (e.g., CPU, memory, battery). However, no empirical study has assessed the positive performance impacts of correcting mobile code smells. In this paper, we therefore conduct an empirical study focusing on the individual and combined performance impacts of three Android performance code smells (namely, Internal Getter/Setter, Member Ignoring Method, and HashMap Usage) on two open source Android apps. To perform this study, we use the Paprika toolkit to detect these three code smells in the analyzed apps, and we derive four versions of the apps by correcting each detected smell independently, and all of them. Then, we evaluate the performance of each version on a common user scenario test. In particular, we evaluate the UI and memory performance using the following metrics: frame time, number of delayed frames, memory usage, and number of garbage collection calls. Our results show that correcting these Android code smells effectively improve the UI and memory performance. In particular, we observe an improvement up to 12.4% on UI metrics when correcting Member Ignoring Method and up to 3.6% on memory-related metrics when correcting the three Android code smells. We believe that developers can benefit from these results to guide their refactoring, and thus improve the quality of their mobile apps.

2. Détection et analyse de l’impact des défauts de code dans les applications mobiles (PhD Thesis)

   Hecht, Geoffrey

   2016

   Abs PDF

   Mobile applications are becoming complex software systems that must be developed quickly and evolve continuously to fit new user requirements and execution contexts. However, addressing these constraints may result in poor low-level design choices, known as code smells. The presence of code smells within software systems may incidentally degrade their quality and performance, and hinder their maintenance and evolution. Thus, it is important to know this smells but also to detect and correct them. While code smells are well-known in object-oriented applications, their study in mobile applications is still in their infancy. Moreover there is a lack of tools to detect and correct them. That is why we present a classification of 17 code smells that may appear in Android applications, as well as a tool to detect and correct code smells on Android. We apply and validate our approach on large amounts of applications (over 3000) in two studies evaluating the presence and evolution of the number of code smells in popular applications. In addition, we also present two approaches to assess the impact of the correction of code smells on performance and energy consumption. These approaches have allowed us to observe that the correction of code smells is beneficial in most cases.

2015

1. Detecting antipatterns in android apps

   Hecht, Geoffrey, Rouvoy, Romain, Moha, Naouel, and Duchien, Laurence

   In 2nd ACM international conference on mobile software engineering and systems 2015

   Abs

   Mobile apps are becoming complex software systems that must be developed quickly and evolve continuously to fit new user requirements and execution contexts. However, addressing these constraints may result in poor design choices, known as antipatterns, which may incidentally degrade software quality and performance. Thus, the automatic detection of antipatterns is an important activity that eases both maintenance and evolution tasks. Moreover, it guides developers to refactor their applications and thus, to improve their quality. While antipatterns are well-known in object-oriented applications, their study in mobile applications is still in their infancy. In this paper, we propose a tooled approach, called Paprika, to analyze Android applications and to detect object-oriented and Android-specific antipatterns from binaries of mobile apps. We validate the effectiveness of our approach on a set of popular mobile apps downloaded from the Google Play Store.

2. An Approach to Detect Android Antipatterns

   Hecht, Geoffrey

   In IEEE/ACM 37th IEEE International Conference on Software Engineering 2015

   Abs

   Mobile applications are becoming complex software systems that must be developed quickly and evolve regularly to fit new user requirements and execution contexts. However, addressing these constraints may result in poor design choices, known as antipatterns, which may degrade software quality and performance. Thus, the automatic detection of antipatterns is an important activity that eases the future maintenance and evolution tasks. Moreover, it helps developers to refactor their applications and thus, to improve their quality. While antipatterns are well-known in object-oriented applications, their study in mobile applications is still in their infancy. In this paper, we presents a tooled approach, called Paprika, to analyze Android applications and to detect object-oriented and Android-specific antipatterns from binaries of applications.

3. Tracking the software quality of android applications along their evolution (t)

   Hecht, Geoffrey, Benomar, Omar, Rouvoy, Romain, Moha, Naouel, and Duchien, Laurence

   In 30th IEEE/ACM International Conference on Automated Software Engineering (ASE) 2015

   Abs PDF

   Mobile apps are becoming complex software systems that must be developed quickly and evolve continuously to fit new user requirements and execution contexts. However, addressing these requirements may result in poor design choices, also known as antipatterns, which may incidentally degrade software quality and performance. Thus, the automatic detection and tracking of antipatterns in this apps are important activities in order to ease both maintenance and evolution. Moreover, they guide developers to refactor their applications and thus, to improve their quality. While antipatterns are well-known in object-oriented applications, their study in mobile applications is still in its infancy. In this paper, we analyze the evolution of mobile apps quality on 3, 568 versions of 106 popular Android applications downloaded from the Google Play Store. For this purpose, we use a tooled approach, called PAPRIKA, to identify 3 object-oriented and 4 Android-specific antipatterns from binaries of mobile apps, and to analyze their quality along evolutions.

2014

1. An Empirical Study of the Impact of Cloud Patterns on Quality of Service (QoS)

   Hecht, Geoffrey, Jose-Scheidt, Benjamin, De Figueiredo, Clement, Moha, Naouel, and Khomh, Foutse

   In 2014 IEEE 6th International Conference on Cloud Computing Technology and Science 2014

   Abs PDF

   Cloud patterns are described as good solutions to recurring design problems in a cloud context. These patterns are often inherited from Service Oriented Architectures or Object Oriented Architectures where they are considered good practices. However, there is a lack of studies that assess the benefits of these patterns for cloud applications. In this paper, we conduct an empirical study on a Restful application deployed in the cloud, to investigate the individual and the combined impact of three cloud patterns (i.e., Local Database proxy, Local Sharding-Based Router and Priority Queue Patterns) on Quality of Service (QoS). We measure the QoS using the application’s response time, average, and maximum number of requests processed per seconds. Results show that cloud patterns doesn’t always improve the response time of an application. In the case of the Local Database proxy pattern, the choice of algorithm used to route requests has an impact on response time, as well as the average and maximum number of requests processed per second. Combinations of patterns can significantly affect the QoS of applications. Developers and software architects can make use of these results to guide their design decisions.