Environmental sustainability is an important priority in the development of intelligent IoT systems.To maintain the precision of the predictive models used in making decisions, the models should be retrained on fresh data that are continuously collected.Continuous data collection leads to maintaining a large amount of training data over time.To overcome this, we propose a framework of federated learners deployed on the Edge that store training data with a sustainable memory footprint.The results of the evaluation of our approach show that the memory footprint of the training data is not perpetually increasing and that the prediction errors made by the sustainable models are not higher than the prediction errors made by the original models.

Various approaches have been proposed for extracting microservices from the source code of monolithic software systems.The extracted microservices are usually evaluated by using the metrics of the precision and recall.However, the evaluation of the object-oriented design of microservices needs specialized metrics.To bridge this literature gap, we propose the metrics of the completeness, minimality, and structurality to assess the proximity of an extracted design to a ground-truth design.Our evaluation show that our metrics fix the misleading results on the UML quality of microservice designs made by the existing metrics.

Given that cloud servers are usually remotely located from the devices of mobile apps, the end-users of the apps can face delays. The Fog has been introduced to augment the apps with machines located at the network edge close to the end-users. However, edge machines are usually resource constrained. Thus, the execution of online data-analytics on edge machines may not be feasible if the time complexity of the data-analytics algorithm is high. To overcome this, multiple instances of the back-end should be deployed on edge and remote machines. In this case, the research question is how the switching of the app among the instances of the back-end can be dynamically decided based on the response time of the service instances. To answer this, we contribute an AI approach that trains machine-learning models of the response time of service instances. Our approach extends a back-end as a service into an AI self-back-end as a service that self-decides at runtime the right edge/remote instance that achieves the lowest response-time. We evaluate the accuracy and the efficiency of our approach by using real-word machine-learning datasets on an existing auction app.

UML recovery has been a long-standing challenge for the software-engineering community.The complete recovery of UML class relationships needs the employment of both static and dynamic code analyses.However, the dynamic-code analysis is not usually applicable at the design time of programs and especially for incomplete programs in online education.To overcome this restriction, we propose a formally defined set of mappings between UML relationships and object-oriented relationships that are based on static-code analysis exclusively.We evaluate the precision and the recall of our mappings on student projects against ground-truth UML diagrams and against diagrams recovered by existing UML class recovery tools.

Schema integration has been a long-standing challenge for the data-engineering community that has received steady attention over the past three decades. General-purpose integration approaches construct unified schemas that encompass all schema elements. Schema integration has been revisited in the past decade in service-oriented computing since the input/output data-types of service interfaces are heterogeneous XML schemas. However, service integration differs from the traditional integration problem, since it should generalize schemas (mining abstract data-types) instead of unifying all schema elements. To mine well-formed abstract data-types, the fundamental Liskov Substitution Principle (LSP), which generally holds between abstract data-types and their subtypes, should be followed. However, due to the heterogeneity of service data-types, the strict employment of LSP is not usually feasible. On top of that, XML offers a rich type system, based on which data-types are defined via combining type patterns (e.g., composition, aggregation). The existing integration approaches have not dealt with the challenges of a defining subtyping relation between XML type patterns. To address these challenges, we propose a relaxed version of LSP between XML type patterns and an automated generalization process for mining abstract XML data-types. We evaluate the effectiveness and the efficiency of the process on the schemas of two datasets against two representative state-of-the-art approaches.

To avoid the lock-in problem in service-oriented software, existing interface-decoupling mechanisms focus on identifying high-level service mappings, which are not necessarily applicable on translating actual data. Based on the fundamental data-translation process, its successful outcome is guaranteed if mappings are low-level, i.e. they satisfy schema constraints. The problem is that if similar services have been identified based on high-level mappings, then schema constraints may be violated. To overcome this problem, we propose a proactive approach to identify similar services that satisfy schema constraints. In particular, our approach follows a composite workflow (instead of existing hybrid workflows), which determines schema constraints (service documents do not specify them) and estimates service-translation cost (actual cost is not available) as a function of ensured schema-constraints. We compare our approach against a state-of-the-art service-similarity approach on benchmark services and the results show that high service-similarity does not necessarily imply low service-translation cost, the bidirectional nature of service similarity can be misleading, ensured schema-constraints improve service similarity, and estimated translation-cost is very close to actual cost.

Software cohesion concerns the degree to which the elements of a module belong together. Cohesive software is easier to understand, test and maintain. In the context of service-oriented development, cohesion refers to the degree to which the operations of a service interface belong together. In the state of the art, software cohesion is improved based on refactoring methods that rely on information, extracted from the software implementation. This is a main limitation towards using these methods in the case of web services: web services do not expose their implementation; instead all that they export is the web service interface specification. To deal with this problem, we propose an approach that enables the cohesion-driven decomposition of service interfaces, without information on how the services are implemented. Our approach progressively decomposes a given service interface into more cohesive interfaces; the backbone of the approach is a suite of cohesion metrics that rely on information, extracted solely from the specification of the service interface. We validate the approach in 22 real-world services, provided by Amazon and Yahoo. We assess the effectiveness of the proposed approach, concerning the cohesion improvement, and the number of interfaces that result from the decomposition of the examined interfaces. Moreover, we show the usefulness of the approach in a user study, where developers assessed the quality of the produced interfaces.

The state of the art service search engines allow the users to pick the services they need, based on the quality properties, offered by these services. To this end, the users should interact with the search engines based on the quality models that are imposed by the engines. This is a significant restriction towards making the service-oriented paradigm attractive to the general public. In this paper, we propose an approach that allows a user to specify his perception of quality in terms of a simple, user-defined quality model. The proposed approach automatically maps the user-defined quality model to the search engine's quality model. This mapping forms the basis for ordering, grouping and, in general manipulating, the results of the user's service discovery requests.

Several lines of research rely on the concept of service abstractions to enable the organization, the composition and the adaptation of services. However, what is still missing, is a systematic approach for extracting service abstractions out of the vast amount of services that are available all over the Web. To deal with this issue, we propose an approach for mining service abstractions, based on an agglomerative clustering algorithm. Our experimental findings suggest that the approach is promising and can serve as a basis for future research.

A design issue that often appears in real-world services is that their interfaces are not cohesive, i.e., they consist of many and possibly unrelated operations. This issue may complicate the comprehension of the services functionalities and the maintenance of the applications that use them. Currently, the state of the art on case studies that focus on the evaluation of the cohesion of services offered by major service providers is limited, while research efforts on corresponding cohesion metrics are at a quite early stage. In particular, there exist coarse-grained metrics of cohesion lack, which consider that the operations of a service interface are related if the types of certain of their input/output data exactly match. The problem in this approach is that operations which operate on data characterized by similar, but not exactly matching, types are treated as being totally unrelated. Consequently, the aforementioned metrics may overestimate the cohesion lack of service interfaces. In this paper, we undertake a more elaborate approach to evaluate a set of real world services provided by Amazon. Specifically, we propose two fine-grained metrics of cohesion lack, which are defined with respect to the structural similarity of the input/output data types of interface operations. The proposed metrics are formally defined and analytically assessed with respect to fundamental properties of software metrics. Finally we report the results from our case study.

In this paper, we propose a framework that reduces the complexity of service substitution. The framework is based on two substitution relations and corresponding theorems. The proposed relations and theorems allow organizing available services into groups. Then, the complexity of retrieving candidate substitute services for the target service and generating corresponding adapters scales up with the number of available groups, instead of scaling up with the number of available services.