Service-Oriented Architecture has been widely adopted in software development because of its properties of addressing distributed and heterogeneous environments. At the same time, the highly-demanding flexibility and capacity of adaptation in software projects introduce a process of constant code modifications and complexity growth. Thus, developers quickly make mistakes such as code duplication or unnecessary code, negatively impacting quality attributes such as performance and maintainability. Those modifications are usually conducted by refactoring, which significantly improves software quality. In this context, we aim to compare manual service groupings and automatic groupings that allow analyzing, evaluating, and validating clustering techniques applied to improve service cohesion and fragmentation in SOA-driven software projects. Concerning quantifying the quality of our clustering solutions, we relied on external quality metrics, which measure how well the clustering results match some prior knowledge (manual service groupings by real developers in our case) about the data. Additionally, we have performed improvements in existing clustering techniques of previous work, VizSOC, reaching a 20% gain regarding the metrics mentioned above. Moreover, we added an implementation of the COBWEB clustering algorithm to expand our research, yielding fruitful results.

Within the main goals of Dew Computing is improving users’ experience via on-premise nearby computers while reducing to the minimum the dependency on remote infrastructures. Moreover, smartphones are one of the commonest, most affordable and versatile personal devices exploited by end users everyday, which can in turn be employed as on-premise computers themselves. Nowadays the market offers smartphones with varied capabilities. Hence, studying their software and hardware properties is crucial to Dew computing since they help Dew researchers and app developers to get the most out of these devices. Studies frequently involve the configuration of real smartphones to obtain profile data from the execution of custom codes (benchmarks or profiling routines) under certain conditions (device charging or discharging, initial battery level, baseline CPU usage, display state, etc.). The purposes of such data capturing procedures range from describing component behavior (e.g., battery depletion rate) to determining computing power, in order to build holistic device capabilities rankings. However, few to none supports exist to automate this tedious procedure. For this reason, we present Motrol 2.0, a hardware/software platform that allow Dew researchers and developers to automate benchmarking and profiling tests on Android-based smartphones.

Mobile grid computing has been a popular topic for researchers due to mobile and IoT devices’ ubiquity and their evergrowing processing potential. While many scheduling algorithms for harnessing these resources exist in the literature for standard grid computing scenarios, surprisingly, there is little insight into this matter in the context of hybrid‐powered computing resources, typically found in Dew and Edge computing environments. This paper proposes new algorithms aware of devices’ power source for scheduling tasks in hybrid environments, i.e., where the battery‐ and non‐battery‐powered devices cooperate. We simulated hybrid Dew/Edge environments by extending DewSim, a simulator that models battery‐driven devices’ battery behavior using battery traces profiled from real mobile devices. We compared the throughput and job completion achieved by algorithms proposed in this paper using as a baseline a previously developed algorithm that considers computing resources but only from battery‐dependent devices called Enhanced Simple Energy‐Aware Schedule (E‐SEAS). The obtained results in the simulation reveal that our proposed algorithms can obtain up to a 90% increment in overall throughput and around 95% of completed jobs in hybrid environments compared to E‐SEAS. Finally, we show that incorporating these characteristics gives more awareness of the type of resources present and can enable the algorithms to manage resources more efficiently in more hybrid environments than other algorithms found in the literature.

Summary Dew computing is an emerging computing paradigm, which aims at minimizing the dependency over existing internetwork back‐haul, ie, being dependent on processing resources offered by remote servers. Smartphones and tablets ubiquity and powerful computing hardware motivated researchers to investigate the way of providing Dew computing services by exploiting the aggregated capabilities of devices in a vicinity, a smart device cluster. Consequently, research on resource management is necessary to learn how to scavenge resources from such a cluster, deal with devices heterogeneity, limitations, and dynamic resource availability. Simulation is commonly practiced for studying resource management in other distributed computing research fields, specially due to the complexity involved in the set up of experiments. However, a free‐to‐use purpose specific toolkit for studying smart device clusters do not exist or have been documented. Current simulation efforts do not allow researchers to faithfully represent key singularities of such environment, which are energy depletion and nondedicated nature of computing resources. We propose a trace‐based toolkit built on modular software artifacts to speed up research in resource management techniques in Dew environments. A trace‐driven methodology is adopted to assure practical value of simulated scenarios. The toolkit comprises a device profiler application for Android to capture generic battery and CPU traces from real devices, a profile mixer to create user interaction baseline traces through generic ones, and an extensible engine to simulate the execution of workloads configurable via text files. Verification and validation tests were run to show correctness and reliability of our simulation approach.

The ubiquity of mobile devices, their strong computational capabilities -frequently underused by the owners- and their close relationship to IoT environments, make them valuable providers of computing power at the edge, i.e. as an aid to deal with remote computing servers high-delay communication. Then, researchers have proposed to take advantage of the connection regularity of groups of mobile devices to fixed wireless networking infrastructures, e.g., access points, to scavenge mobile computing resources. However, among the key concerns to achieve such exploitation in an efficient way is providing new scheduling criteria for computations able to deal with the challenges posed by mobile devices finite energy sources. The value of considering battery-related parameters for ranking devices capabilities against not using them has been hardly investigated in the literature. Then, in this paper, we analyze several job scheduling criteria and provide statistical evidence that support our findings. The experiments are performed via a simulation software that employs energy consumption traces derived from real mobile devices, hence practical utility is ensured.

Given mobile devices ubiquity and capabilities, some researchers now consider them as resource providers of distributed environments called mobile Grids for running resource intensive software. Therefore, job scheduling has to deal with device singularities, such as energy constraints, mobility and unstable connectivity. Many existing schedulers consider at least one of these aspects, but their applicability strongly depends on information that is unavailable or difficult to estimate accurately, like job execution time. Other efforts do not assume knowing job CPU requirements but ignore energy consumption due to data transfer operations, which is not realistic for data-intensive applications. This work, on the contrary, considers the last as non negligible and known by the scheduler. Under these assumptions, we conduct a performance study of several traditional scheduling heuristics adapted to this environment, which are applied with the known information of jobs but evaluated along with job information unknown to the scheduler. Experiments are performed via a simulation software that employs hardware profiles derived from real mobile devices. Our goal is to contribute to better understand both the capabilities and limitations of this kind of schedulers in the incipient area of mobile Grids.

Web Services have become essential to the software industry as they provide reusable, remotely-accessible functionality and data, thus accelerating client application development and relieving users from maintaining the consumed services. Since Web Services-particularly their descriptions-must be discovered before being consumed, many discovery approaches based on classic Information Retrieval techniques, which store and process textual service descriptions, have arisen. These discovery approaches are affected by natural language ambiguity, such as synonymy and homonymy. Such issues are known as term mismatch, since descriptions relevant to a keyword-based query can be retrieved only if they share many words. Recently, Word Embeddings emerged and tried to cope with this problem by representing words in a language as vectors in a continuous vector space. An interesting property of these vectors is that two different words with similar meaning are represented by vectors that are close in the space. Word Embeddings aim at categorising and quantifying words so that semantic relationships can be established through simple vector distance measures. In this paper, we exploit Word Embeddings to find hidden relationships between service descriptions and queries for the case of REST services, a recent alternative to SOAP-oriented services. The results showed improvements over classical service retrieval techniques such as Vector Space Model or Latent Semantic Analysis of up to 20% in Precision, 39% in Recall, 35% in F-Measure and 10% in NDCG.

The Service Oriented Computing (SOC) paradigm promotes building new applications by discovering and then invoking services, i.e., software components accessible through the Internet. Discovering services means inspecting registries where textual descriptions of services functional capabilities are stored. To automate this, existing approaches index descriptions and associate users' queries to relevant services. However, the massive adoption of Web-exposed API development practices, specially in large service ecosystems such as the IoT, is leading to evergrowing registries which challenge the accuracy and speed of such approaches. The recent notion of Social Web Services (SWS), where registries not only store service information but also sociallike relationships between users and services opens the door to new discovery schemes. We investigate an approach to discover SWSs that operates on graphs with user-service relationships and employs lightweight topological metrics to assess service similarity. Then, "socially" similar services, which are determined exploiting explicit relationships and mining implicit relationships in the graph, are clustered via exemplar-based clustering to ultimately aid discovery. Experiments performed with the ProgrammableWeb.com registry, which is at present the largest SWS repository with over 15k services and 140k user-service relationships, show that pure topology-based clustering may represent a promising complement to content-based approaches, which in fact are more time-consuming due to text processing operations.

Large scale multi-label learning, i.e. the problem of determining the associated set of labels for an instance, is gaining relevance in recent years due to the emergence of several real-world applications. Most notably, the exponential growth of the Social Web where a resource can be labeled by mil lions of users using one or more tags, i.e. a resource can be associated to several labels at the same time. A well-known approach for multi-label classification is the Binary Relevance (BR) algorithm which trains a binary classifier for each label independently. However, the serial implementation of BR is not suitable for medium or large datasets due to the time and computational resources required for training. For example, training classifiers for mid-size datasets using MULAN implementation of BR might take several weeks. This paper discusses a parallel implementation of the MULAN BR technique that harnesses the computational power of nowadays multi-core processors. Our implementation presents a speed-up in the training phase of up to 12 times when compared to the original MULAN implementation. In addition, the cross-validation technique of MULAN had huge RAM requirements, making it unusable with large datasets. Therefore, we have overcome this limitation by using compact data structures and taking advantage of disk caching. We have also compared our implementation against scikit-learn, a popular tool for data mining and data analysis, showing significant improvements in speed-up.

Summary The increasing number of mobile devices with ever‐growing capabilities makes them useful for running scientific applications. However, these applications have high computational demands, whereas mobile devices have limited capabilities when compared with non‐mobile devices. More importantly, mobile devices rely on batteries for their power supply. We initially measure the battery consumption of different versions of known micro‐benchmarks representing common programming primitives found in scientific applications. Then, we analyze the performance of such micro‐benchmarks in CPU‐intensive mobile applications. We apply good programming practices and code refactorings to reduce battery consumption of scientific mobile applications. Our results show the reduction in energy usage from applying these refactorings to three scientific applications, and we consequently propose guidelines for high‐performance computing applications. Our focus is on Android, the dominant mobile operating system. As a long‐term contribution, our results represent one more step in the progress towards hybrid distributed infrastructures comprising fixed and mobile nodes, that is, the so‐called mobile grids. Copyright © 2016 John Wiley & Sons, Ltd.

Web Services have been steadily gaining maturity as their adoption in the software industry grew. Accordingly, metric suites for assessing different quality attributes of Web Service artifacts have been proposed recently. Some researchers have particularly focused on assessing service interface descriptions in WSDL, which like any other software artifact have several inherent attributes (e.g., size or complexity) that can be measured. We study the statistical relationships between some recent service interface complexity metrics (Basci & Misra's metrics suite) and the well-known Chidamber & Kemerer's metric suite applied to service implementations, on a data-set of 154 real-world services. First, to prove the ability of Basci & Misra's suite of measuring the complexity attribute in WSDL documents, a theoretical validation of these metrics using Weyuker's properties is presented. Then, after finding high correlation between both metric suites, we show that refactoring service codes prior to generating the WSDL documents might reduce service interface complexity.

A Web Service has an interface described in a machine-processable format (specifically WSDL). Service providers expose their services by publishing their WSDL documents. Service consumers can learn about service capability and how to interact with the services. Service descriptions (WSDL documents) should be ideally understood easily by service stakeholders so that the process of consuming services is simplified. In this work we present a practical metric to quantify readability in WSDL documents. We adapted and extended an existing semantic readability metric to focus on WSDL documents by using WordNet as the underlying concept hierarchy. Finally, we performed a qualitative experiment: a controlled survey with a group of service consumers. The results showed that consumers (software engineers) required less time and effort to analyze WSDL documents with higher readability values.

Discovery and replacement are two of the main features of Service Oriented Computing. There has been much research on these topics for traditional SOAP-based Web Services, particularly on discovery. Although the original proposal for REST services lacks this feature, some researchers have studied how to perform discovery for REST services using both IR based techniques and semantic techniques. This work presents a novel IR-based discovery approach for REST services described via WADL files. Our approach takes advantage of unsupervised machine learning techniques for improving discovering results. In particular, the approach relies on clustering algorithms, such as K-means or X-means, to reduce the search space for a given query. The experimental results show that using an appropriate clustering technique, our approach achieves nearly 4 times higher F-measure than a traditional IR-based search engine, namely Apache Lucene. Additionally, the paper reports other metrics, such as Recall, Precision, Precision at-10 and Recall at-10, that also point out that the proposed approach outperforms Lucene. Finally, another important contribution is a set of queries and WADL files gathered from the Internet that can be used for evaluating future discovery proposals.

Summary The Grid Computing paradigm aims to create a ‘virtual’ and powerful single computer with many distributed resources to solve resource intensive problems. The term ‘gridification’ involves the process of transforming a conventional application to run in a Grid environment. In that sense, the more automatic this process is, the easier is for developers with low expertise in parallel and distributed computing to take advantage of these resources. To date, many semiautomatic gridifiers were built to support different gridification approaches and application code structures or anatomies. Furthermore, agricultural simulation applications have a particular common anatomy based on biophysical entities, such as animals, crops, and pastures, which are updated by actions, such as growing animals, growing crops, and growing pastures, along simulation execution. However, this anatomy is not fully supported by any of the existing gridifiers. Thus, this paper presents Agricultural Simulation Applications Gridifier (ASAG), a method for easy gridification of agricultural simulation applications, and its Java implementation, named Java ASAG (JASAG). The main design drivers of JASAG are middleware independence, separation of business logic and Grid behavior, and performance increase. An experimental evaluation showing the feasibility of the gridification method and its implementation is also reported, which resulted in speedups of up to 25 by using a real agricultural simulation application. Copyright © 2014 John Wiley & Sons, Ltd.

Web Services represent a number of standard technologies and methodologies that allow developers to build applications under the Service-Oriented Computing paradigm. Within these, the WSDL language is used for representing Web Service interfaces, while code-first remains the de facto standard for building such interfaces. Previous studies with contract-first Web Services have shown that avoiding a specific catalog of bad WSDL specification practices, or anti-patterns, can reward Web Service publishers as service understandability and discoverability are considerably improved. In this paper, we study a number of simple and well-known code service refactorings that early reduce anti-pattern occurrences in WSDL documents. This relationship relies upon a statistical correlation between common OO metrics taken on a service's code and the anti-pattern occurrences in the generated WSDL document. We quantify the effects of the refactorings — which directly modify OO metric values and indirectly alter anti-pattern occurrences — on service discovery. All in all, we show that by applying the studied refactorings, anti-patterns are reduced and Web Service discovery is significantly improved. For the experiments, a dataset of real-world Web Services and an academic service registry have been employed.

Summary Service‐oriented development is challenging mainly because Web service developers tend to disregard the importance of the exposed service APIs, which are specified using Web Service Description Language (WSDL) documents. Methodologically, WSDL documents can be either manually generated or inferred from service implementations using WSDL generation tools. The latter option, called code first, is the most used approach in the industry. However, it is known that there are some bad practices in service implementations or defects in WSDL generation tools that may cause WSDL documents to present WSDL anti‐patterns, which in turn compromise the chances of documents of being discovered and understood. In this paper, we present a software tool that assists developers in obtaining WSDL documents with as few WSDL anti‐patterns as possible. The tool combines text mining and meta‐programming techniques to process service implementations and is developed as an Eclipse plug‐in. An evaluation of the tool by using a data‐set of real service implementations in terms of anti‐pattern avoidance accuracy and discovery performance by using classical Information Retrieval metrics—Precision‐at‐n, Recall and Normalized Discounted Cumulative Gain—is also reported.Copyright © 2014 John Wiley & Sons, Ltd.

SUMMARY The service‐oriented computing (SOC) paradigm has recently gained a lot of attention in the software industry because SOC represents a novel and a fresh way of architecting distributed applications. SOC is usually materialized via web services, which allows developers to structure applications exposing a clear, public interface to their capabilities. Although conceptually and technologically mature, SOC still lacks adequate development support from a methodological point of view. In this paper, we present the EasySOC project, a set of guidelines to simplify the development of service‐oriented applications and services. EasySOC is a synthesized catalog of best SOC development practices that arise as a result of several years of research in fundamental Services Computing topics, that is, Web Service Description Language‐based technical specification, Web Service discovery, and Web Service outsourcing. In addition, we describe a materialization of the guidelines for the Java language, which has been implemented as a plug‐in for the Eclipse IDE. We believe that both the practical nature of the guidelines and the availability of this software that enforces them may help software practitioners to rapidly exploit our ideas for building real SOC applications. Copyright © 2012 John Wiley & Sons, Ltd.

Abstract The benefits of Grids for building massively distributed applications have been broadly acknowledged. However, the high complexity of developing Grid applications compromises the widespread adoption of the paradigm. In a previous paper (Future Gener. Comput. Syst. 2008; 24(2):99–118), we have described JGRIM, a method for easily ‘gridifying’ Java applications, based on non‐invasively injecting Grid functionality into ordinary code through Dependency Injection (DI). DI is similar to the Inversion of Control notion of object‐oriented frameworks and allows external services providing certain functionality to be injected into application components that require these services without affecting the components' implementation. In this paper, we briefly revisit JGRIM and present m‐JGRIM, a novel Java middleware that materializes JGRIM concepts by transforming ordinary applications into entities called Mobile Grid Services, i.e. gridified applications with mobile capabilities that live within a Grid. We also provide an evaluation of the performance of m‐JGRIM. Grid practitioners should find this paper useful in having an assessment of the practical benefits and costs of gridifying applications with the middleware, and a down‐to‐earth description of JGRIM, whose advantages for Grid‐enabling applications from a software engineering perspective have been already evaluated in (Future Gener. Comput. Syst. 2008; 24(2):99–118). Copyright © 2010 John Wiley & Sons, Ltd.

Abstract The Grid shows itself as a globally distributed computing environment, in which hardware and software resources are virtualized to transparently provide applications with vast capabilities. Just like the electrical power grid, the Grid aims at offering a powerful yet easy‐to‐use computing infrastructure to which applications can be easily ‘plugged’ and efficiently executed. Unfortunately, it is still very difficult to Grid‐enable applications, since current tools force users to take into account many details when adapting applications to run on the Grid. In this paper, we survey some of the recent efforts in providing tools for easy gridification of applications and propose several taxonomies to identify approaches followed in the materialization of such tools. We conclude this paper by describing common features among the proposed approaches, and by pointing out open issues and future directions in the research and development of gridification methods. Copyright © 2007 John Wiley & Sons, Ltd.