• Authors: Nikolaos Nikolaidis, Apostolos Ampatzoglou, Alexander Chatzigeorgiou, Sofia Tsekeridou & Avraam Piperidis
• Location: PROFES 2022: Product-Focused Software Process Improvement pp 265–281

Abstract:

Service-Oriented Architectures (SOA) have become a standard for developing software applications, including but not limited to cloud-based ones and enterprise systems. When using SOA, the software engineers organize the desired functionality into self-contained and independent services, that are invoked through end-points (API calls). At the maintenance phase, the tickets (bugs, functional updates, new features, etc.) usually correspond to specific services. Therefore, for maintenance-related estimates it makes sense to use as unit of analysis the service-per se, rather than the complete project (too coarse-grained analysis) or a specific class (too fine-grained analysis). Currently, some of the most emergent maintenance estimates are related to Technical Debt (TD), i.e., the additional maintenance cost incurred due to code or design inefficiencies. In the literature, there is no established way on how to quantify TD at the service level. To this end, in this paper, we present a novel methodology to measure the TD of each service considering the underlying code that supports the corresponding endpoint. The proposed methodology relies on the method call graph, initiated by the service end-point, and traverses all methods that provide the service functionality. To evaluate the usefulness of this approach, we have conducted an industrial study, validating the methodology (and the accompanying tool) with respect to usefulness, obtained benefits, and usability.

• Authors: TBD
• Location: Profes 2022
• Link: TBD

Abstract: TBD

• Authors: Nikolaos Nikolaidis, Dimitrios Zisis, Apostolos Ampatzoglou, Nikolaos Mittas, and Alexander Chatzigeorgiou
• Location: 6th International Workshop on Machine Learning Techniques for Software Quality Evaluation (MaLTeSQuE 2022)
• Link: will come soon

Abstract: Refactorings constitute the most direct and comprehensible ap-proach for addressing software quality issues, stemming directly from identified code smells. Nevertheless, despite their popularity in both the research and industrial communities: (a) the effect of a refactoring is not guaranteed to be successful; and (b) the plethora of available refactoring opportunities does not allow their compre-hensive application. Thus, there is a need of guidance, on when to apply a refactoring opportunity, and when the development team shall postpone it. The notion of interest, forms one of the major pil-lars of the Technical Debt metaphor expressing the additional maintenance effort that will be required because of the accumulated debt. To assess the benefits of refactorings and guide when a refac-toring should take place, we first present the results of an empirical study assessing and quantifying the impact of various refactorings on Technical Debt Interest (building a real-world training set) and use machine learning approaches for guiding the application of fu-ture refactorings. To estimate interest, we rely on the FITTED framework, which for each object-oriented class assesses its dis-tance from the best-quality peer; whereas the refactorings that are applied throughout the history of a software project are extracted with the RefactoringMiner tool. The dataset of this study involves 4,166 refactorings applied across 26,058 revisions of 10 Apache projects. The results suggest that the majority of refactorings reduce Technical Debt interest; however, considering all refactoring appli-cations, it cannot be claimed that the mean impact differs from zero, confirming the results of previous studies highlighting mixed ef-fects from the application of refactorings. To alleviate this problem, we have built an adequately accurate (~70%) model for the predic-tion of whether or not a refactoring should take place, in order to reduce Technical Debt interest.

• Authors: Elvira Maria Arvanitou, Pigi Argyriadou, Georgia Koutsou, Apostolos Ampatzoglou
• Location: 48th Euromicro Conference on Software Engineering and Advanced Applications (SEAA’ 22)

Abstract: Despite the attention that Technical Debt has attracted over the last years, the quantification of TD Interest still remains rather vague (and abstract). TD Interest quantification is hindered by various factors that introduce a lot of uncertainty, such as: identifying the parts of the system that will be maintained , quantifying the load of maintenance, as well as the size of the maintenance penalty, due to the existence of TD. In this study, we aim to shed light on the current approaches for quantifying TD Interest by exploring existing literature within the TD and Maintenance communities. To achieve this goal, we performed a systematic mapping study on Scopus and explored: (a) the existing approaches for quantifying TD Interest; (b) the existing approaches for estimating Maintenance Cost; and (c) the factors that must be taken into account for their quantification. The broad search process has returned more than 1,000 articles, out of which only 25 provide well-defined mathematical formulas / equations for the quantification of TD Interest or Maintenance Cost (only 6 of them are explicitly for TD Interest). The results suggest that despite their similarities, the quantification of TD Interest presents additional challenges compared to Maintenance Cost Estimation, constituting (at least for the time being) the accurate quantification of TD Interest an open and distant to solve research problem. Regarding the factors that need to be considered for such an endeavor, based on the literature: size, complexity, and business parameters are those that are more actively associated to TD Interest quantification.

• Authors: Zakieh Alizadehsani, Daniel Feitosa, Theodore Maikantis Apostolos Ampatzoglou
• Location: 48th Euromicro Conference on Software Engineering and Advanced Applications (SEAA’ 22)

Abstract: Developing software based on services is one of the most emerging programming paradigms in software development. Service-based software development relies on the composition of services (i.e., pieces of code already built and deployed in the cloud) through orchestrated API calls. Black-box reuse can play a prominent role when using this programming paradigm, in the sense that identifying and reusing already existing/deployed services can save substantial development effort. According to the literature, identifying reusable assets (i.e., components, classes, or services) is more successful and efficient when the discovery process is domain-specific. To facilitate domain-specific service discovery, we propose a service classification approach that can categorize services to an application domain, given only the service description. To validate the accuracy of our classification approach, we have trained a machine-learning model on thousands of open-source services and tested it on 67 services developed within two companies employing service-based software development. The study results suggest that the classification algorithm can perform adequately in a test set that does not overlap with the training set; thus, being (with some confidence) transferable to other industrial cases. Additionally, we expand the body of knowledge on software categorization by highlighting sets of domains that consist ‘grey-zones’ in service classification.

• Authors: Apostolos Ichtsis, Nikolaos Mittas, Apostolos Ampatzoglou, Alexander Chatzigeorgiou
• Location: 5th International Conference on Technical Debt (TechDEBT’ 22)

Abstract: Technical Debt estimation relies heavily on the use of static analysis tools looking for violations of pre-defined rules. Largely, Technical Debt principal is attributed to the presence of low-level code smells, unavoidably tying the effort for fixing the problems with mere coding inefficiencies. At the same time, despite their simple definition, the detection of most code smells is non-trivial and subjective, rendering the assessment of Technical Debt principal dubious. To this end, we have revisited the literature on code smell detection approaches backed by tools and developed an Eclipse plugin that incorporates six code smell detection approaches. The combined application of various smell detectors can increase the certainty of identifying actual code smells that matter to the development team. We also conduct a case study to investigate the agreement among the employed code smell detectors. To our surprise the level of agreement is quite low even for relatively simple code smells threating the validity of existing TD analysis tools and calling for increased attention to the precise specification of code and design level issues.

• Authors: Elvira Maria Arvanitou; Apostolos Ampatzoglou; Stamatia Bibi; Alexander Chatzigeorgiou; Ignatios Deligiannis;
• Location: IEEE Access (Volume 10)

Abstract: DevOps is an emerging software development methodology, that differs from more traditional approaches due to the closer involvement of the customer and the adoption of “ continuous -*” (e.g., integration, deployment, delivery, etc.) practices. The vast research on DevOps (including numerous secondary studies) published in a short timeframe, and the diversity of the authors’ research backgrounds (e.g., from a Dev or an Ops perspective), has inevitably produced a long list of investigated topics, which use inconsistent terminology. The goal of this study is to analyze literature reviews on DevOps with respect to: (a) the research topics in DevOps; (b) the terms that are mapped to each topic; and (c) the consistency of terminology. To achieve this goal, we have performed a tertiary study, i.e., a systematic mapping study that uses as primary studies “ Systematic Literature Reviews ” and “ Mapping Studies ”. For Data Extraction, Analysis, and Synthesis (DEAS) we propose a novel approach relying on thematic analysis, statistical analysis, and meta-analysis. The results unveiled 7 core topics on DevOps research, out of which DevOps features and DevOps practices are dominant ones. Additionally, as expected various terminology ambiguities have been identified, most between features as practices, as well as, between challenges faced before adopting DevOps and while applying DevOps. The main contribution of this study is the disambiguation of the mapping of terms to topics. Along this process, we highlight both inconsistencies—attempting to resolve ambiguities, as well as topics and terms with high levels of consistency; aiding researchers and practitioners.

• Authors: Panagiotis Kotsikoris, Theodore Chaikalis, Apostolos Ampatzoglou, Alexander Chatzigeorgiou
• Location: 17th International Conference on the Evaluation of Novel Approaches to Software Engineering (ENASE ‘22)

Abstract: The last decade marked undeniably the leading role of web services and the establishment of service-oriented architectures. Indeed, it is nowadays hard to find a contemporary software application that does not use at least one third-party web service. The main driver for this paradigm shift, lies in the benefits that decoupled, cloud-based services bring to software development, operation and maintenance as well as at the seamless deployment, integration and scalability features those modern public clouds provide.

• Authors: Elvira Maria Arvanitou, Nikolaos Nikolaidis, Apostolos Ampatzoglou, Alexander Chatzigeorgiou
• Location: 17th International Conference on the Evaluation of Novel Approaches to Software Engineering (ENASE ‘22)

Abstract: Scientific software development refers to a specific branch of software engineering that targets the development of scientific applications. Such applications are usually developed by non-expert software engineers (e.g., natural scientists, biologists, etc.) and pertain to special challenges. One such challenge (stemming from the lack of proper software engineering background) is the low structural quality of the end software-also known as Technical Debt-leading to long debugging and maintenance cycles. To contribute towards understanding the software engineering practices that are used in scientific software development, and investigating whether their application can lead to preventing structural quality decay (also known as Technical Debt prevention); in this study, we seek insights from professional scientific software developers, through a questionnaire based empirical setup. The results of our work suggest that several practices (e.g., Reuse and Proper Testing) can prevent the introduction of Technical Debt in software development projects. On the other hand, other practices seem as either improper for TD prevention (e.g., Parallel / Distributed Programming), whereas others as non-applicable to the branch of scientific software development (e.g., Refactorings or Use of IDEs). The results of this study prove useful for the training plan of scientists before joining development teams, as well as for senior scientists that act as project managers in such projects.

• Authors: Dimitrios Tsoukalas, Alexander Chatzigeorgiou, Apostolos Ampatzoglou, Nikolaos Mittas
  
• Location: 5th International Conference on Technical Debt (TechDEBT’ 22)

Abstract: To date, the identification and quantification of Technical Debt (TD) rely heavily on a few sophisticated tools that check for violations of certain predefined rules, usually through static analysis. Different tools result in divergent TD estimates calling into question the reliability of findings derived by a single tool. To alleviate this issue, we present a tool that employs machine learning on a dataset built upon the convergence of three widely-adopted TD Assessment tools to automatically assess the class-level TD for any arbitrary Java project. The proposed tool is able to classify software classes as high-TD or not, by synthesizing source code and repository activity information retrieved by employing four popular open source analyzers. The classification results are combined with proper visualization techniques, to enable the identification of classes that are more likely to be problematic. To demonstrate the proposed tool and evaluate its usefulness, a case study is conducted based on a real-world open-source software project. The proposed tool is expected to facilitate TD management activities and enable further experimentation through its use in an academic or industrial setting.
Video: https://youtu.be/umgXU8u7lIA
Running Instance: http://160.40.52.130:3000/tdclassifier
Source Code: https://gitlab.seis.iti.gr/root/td-classifier.git

• Authors: Theodore Maikantis, Theodore Chaikalis, Apostolos Ampatzoglou, Alexander Chatzigeorgiou
• Location:  PCI 2021. 25th Pan-Hellenic Conference on Informatics

Abstract: Nowadays the majority of cloud applications are developed based on the Service-Oriented Architecture (SOA) paradigm. Large-scale applications are structured as a collection of well-integrated services that are deployed in public, private or hybrid cloud. Despite the inherent benefits that service-based cloud development provides, the process is far from trivial, in the sense that it requires the software engineer to be (at least) comfortable with the use of various technologies in the long cloud development toolchain: programming in various languages, testing tools, build / CI tools, repositories, deployment mechanisms, etc. In this paper, we propose an approach and corresponding toolkit (termed SmartCLIDE-as part of the results of an EU-funded research project) for facilitating SOA-based software development for the cloud, by extending a well-known cloud IDE from Eclipse. The approach aims at shortening the toolchain for cloud development, hiding the process complexity and lowering the required level of knowledge from software engineers. The approach and tool underwent an initial validation from professional cloud software developers. The results underline the potential of such an automation approach, as well as the usability of the research prototype, opening further research opportunities and providing benefits for practitioners.

• Authors: David Berrocal-Macías, Zakieh Alizadeh-Sani, Francisco Pinto-Santos, Alfonso González-Briones, Pablo Chamoso, Juan M. Corchado
• Location: PAAMS 2021 : 19th International Conference on Practical Applications of Agents and Multi-Agent Systems

Abstract:

The great development of the internet and all its associated systems has led to the growth of multiple and diverse capabilities in the field of software development.

One such development was the emergence of code repositories that allow developers to share their projects, as well as allowing other developers to contribute to the growth and improvement of those projects. However, there has been such a growth in the use of these systems that there are multiple works with very similar names and themes that it is not easy to find a repository that completely adapts to the developer’s needs quickly.

This process of searching and researching for repositories that fit the initial needs has become a complex task. Due to the complexity of this process, developers need tools that allow them to process a large amount of information that can be downloaded and analysed programmatically. This complexity can be solved by approaches such as big data and scraping.

This paper presents the design of a data ingestion system for libraries, components and repositories in a multi-agent programming environment.

• Authors: Francisco Pinto-Santos, Zakieh Alizadeh-Sani, David Alonso, Alfonso González-Briones, Pablo Chamoso, Juan M. Corchado
• Location: PAAMS 2021 : 19th International Conference on Practical Applications of Agents and Multi-Agent Systems

Abstract:

Today, the paradigm of multi-agent systems has earned a place in the field of software engineering thanks to its versatility to adapt to various domains. However, the construction of these systems is complex, which leads to additional costs in the implementation process. In recent years, however, several frameworks have emerged to simplify this task by providing functionalities that these systems need as a basis, or even tools to generate code related to this paradigm.  These tools are based on a single framework, protocol and language, which sets many limits to the code generation capacity of these tools.

Therefore, this paper proposes a tool for code generation of complete multi-agent systems, focused on the elimination of the restrictions of programming language, framework, communication protocol, etc. through the use of model-driven and template-driven development.

• Authors: Zakieh Alizadeh-Sani, Pablo Plaza Martínez, Guillermo Hernández González, Alfonso González-Briones, Pablo Chamoso, Juan M. Corchado
• Location: PAAMS 2021 : 19th International Conference on Practical Applications of Agents and Multi-Agent Systems

Abstract:

Reusing software is a promising way to reduce software development costs. Nowadays, applications compose available web services to build new software products. In this context, service composition faces the challenge of proper service selection. This paper presents a model for classifying web services. The service dataset has been collected from the well-known public service registry called ProgrammableWeb.

The results were obtained by breaking service classification into a two-step process. First, Natural Language Processing(NLP) pre-processed web service data have clustered by the Agglomerative hierarchical clustering algorithm. Second, several supervised learning algorithms have been applied to determine service categories.

The findings show that the hybrid approach using the combination of hierarchical clustering and SVM provides acceptable results in comparison with other unsupervised/supervised combinations.

• • Authors: Angeliki-Agathi Tsintzira, Elvira-Maria Arvanitou, Apostolos Ampatzoglou, Alexander Chatzigeorgiou (University of Macedonia)
  • Location: Sept. 2020 –  13th International Conference on the Quality of Information and Communications Technology (QUATIC 2020).

Abstract: Technical Debt Management (TDM) is a fast-growing field that in the last years has attracted the attention of both academia and industry. TDM is a complex process, in the sense that it relies on multiple and heterogeneous data sources (e.g., source code, feature requests, bugs, developers’ activity, etc.), which cannot be straightforwardly synthesized; leading the community to use mostly qualitative empirical methods. However, empirical studies that involve expert judgment are inherently biased, compared to automated or semi-automated approaches. To overcome this limitation, the broader (not TDM) software engineering community has started to employ machine learning (ML) technologies. Our goal is to investigate the opportunity of applying ML technologies for TDM, through a Systematic Literature Review (SLR) on the application of ML to software engineering problems (since ML applications on TDM are limited).

Thus, we have performed a broader scope study, i.e., on machine learning for software engineering, and then synthesize the results so as to achieve our high-level goal (i.e., possible application of ML in TDM). Therefore, we have conducted a literature review, by browsing the research corpus published in five high-quality SE journals, with the goal of cataloging: (a) the software engineering practices in which ML is used; (b) the machine learning technologies that are used for solving them; and (c) the intersection of the two: developing a problem solution mapping. The results are useful to both academics and industry, since the former can identify possible gaps, and interesting future research directions, whereas the later can obtain benefits by adopting ML technologies.

• Authors: Elvira Maria Arvanitou; Apostolos Ampatzoglou; Stamatia Bibi; Alexander Chatzigeorgiou; Ignatios Deligiannis;
• Location: IEEE Access (Volume 10)

Abstract: DevOps is an emerging software development methodology, that differs from more traditional approaches due to the closer involvement of the customer and the adoption of “ continuous -*” (e.g., integration, deployment, delivery, etc.) practices. The vast research on DevOps (including numerous secondary studies) published in a short timeframe, and the diversity of the authors’ research backgrounds (e.g., from a Dev or an Ops perspective), has inevitably produced a long list of investigated topics, which use inconsistent terminology. The goal of this study is to analyze literature reviews on DevOps with respect to: (a) the research topics in DevOps; (b) the terms that are mapped to each topic; and (c) the consistency of terminology. To achieve this goal, we have performed a tertiary study, i.e., a systematic mapping study that uses as primary studies “ Systematic Literature Reviews ” and “ Mapping Studies ”. For Data Extraction, Analysis, and Synthesis (DEAS) we propose a novel approach relying on thematic analysis, statistical analysis, and meta-analysis. The results unveiled 7 core topics on DevOps research, out of which DevOps features and DevOps practices are dominant ones. Additionally, as expected various terminology ambiguities have been identified, most between features as practices, as well as, between challenges faced before adopting DevOps and while applying DevOps. The main contribution of this study is the disambiguation of the mapping of terms to topics. Along this process, we highlight both inconsistencies—attempting to resolve ambiguities, as well as topics and terms with high levels of consistency; aiding researchers and practitioners.

SmartCLIDE offers services to accelerate the creation and deployment of Cloud solutions by providing the ability for non-programmers to construct applications and new services using smart automation. One of the backend services provided by SmartCLIDE is runtime monitoring and verification (RMV) which in conjunction with automated testing is applied to assure the quality of the created services. In this paper we describe the objectives of RMV, and provide an overview of the approach and the benefits.

• Authors: Sebastian Scholze
• Location: Eclipse Newsletter, Sept. 2021

Abstract: The SmartCLIDE research project aims to bridge the gap between on-demand business strategies and the lack of qualified software professionals by creating a new cloud native IDE that makes it easier to develop and deploy cloud services. The project is funded by the European Union’s Horizon 2020 research and innovation program, and involves a consortium of 11 partners from Germany, Greece, Luxembourg, Portugal, Spain, and the United Kingdom.

• Authors: Dimitrios Tsoukalas, Nikolaos Mittas, Alexandros Chatzigeorgiou, Dionisis D. Kehagias, Apostolos Ampatzoglou, Theodoros Amanatidis, Lefteris Angelis
• Location: “IEEE Transactions on Software Engineering” journal

Abstract: Technical Debt (TD) is a successful metaphor in conveying the consequences of software inefficiencies and their elimination to both technical and non-technical stakeholders, primarily due to its monetary nature. The identification and quantification of TD rely heavily on the use of a small handful of sophisticated tools that check for violations of certain predefined rules, usually through static analysis. Different tools result in divergent TD estimates calling into question the reliability of findings derived by a single tool. To alleviate this issue we use 18 metrics pertaining to source code, repository activity, issue tracking, refactorings, duplication and commenting rates of each class as features for statistical and Machine Learning models, so as to classify them as High-TD or not. As a benchmark we exploit 18.857 classes obtained from 25 Java projects, whose high levels of TD has been confirmed by three leading tools. The findings indicate that it is feasible to identify TD issues with sufficient accuracy and reasonable effort: a subset of superior classifiers achieved an F₂-measure score of approximately 0.79 with an associated Module Inspection ratio of approximately 0.10. Based on the results a tool prototype for automatically assessing the TD of Java projects has been implemented.

On 3 March 2022, from 14:00 – 16:00 CET, HORIZON CLOUD hosted its March Community event for the European Cloud Community. The two H2020 Cloud Research and Innovation Actions SmartCLIDE and PHYSICS used the webinar to share their project outcomes with the community.

Enjoy it!

The session has been recorded. Check it out: https://youtu.be/VgmiIp7bGEk

On 3 March 2022, from 14:00 – 16:00 CET, HORIZON CLOUD hosted its March Community event for the European Cloud Community. The two H2020 Cloud Research and Innovation Actions SmartCLIDE and PHYSICS used the webinar to share their project outcomes with the community.

After a brief presentation of the project, we can assist to nice demo on the “SmartCLIDE Service Creation and Composition” component followed by a presentation of the “SmartCLIDE Deep Learning Engine” component.

Enjoy it!

The session has been recorded. Check it out!

Sebastian Scholze, ATB

Presented at the Open Research Webinars co-organized by the Eclipse Foundation and OW2, Dec. 15, 2020

Presented at the M9 Review

First public presentation on SmartCLIDE presented during EclipseCon 2020

On 3 March 2022, from 14:00 – 16:00 CET, HORIZON CLOUD hosted its March Community event for the European Cloud Community. The two H2020 Cloud Research and Innovation Actions SmartCLIDE and PHYSICS used the webinar to share their project outcomes with the community.

After a brief presentation of the project, we can assist to nice demo on the “SmartCLIDE Service Creation and Composition” component followed by a presentation of the “SmartCLIDE Deep Learning Engine” component.

Enjoy it!

The session has been recorded. Check it out!

SmartCLIDE was presented at the Open Research Webinar series, December 15, 2020.

This video introduces and summarizes the article Cloud Computing in a nutshell

This video introduces and summarizes the key point of the article AGILE Methodologies and DevOps

A four minutes video presenting SmartCLIDE challenges, objectives, and targets

This poster was originally presented at the FRANSFIERE event.

2-pages introduction to the SmartCLIDE project