• 2
  • 162
  • About
    Top co-authors
    Projects (2)
    The project investigates job schedulers for mobile Grids, i.e. Grids where mobile devices such as smartphones and tablets offer hardware resources to execute both CPU and data-intensive jobs. To this end, several heuristics, ranging from adapted versions of traditional heuristics (Min-Min, Min-Max, etc.) to more elaborated techniques (GAs, Swarm Intelligence) will be explored.
    Research Items (162)
    In the last years, Web Services have become the technological choice to materialize the Service-Oriented Computing paradigm. However, a broad use of Web Services requires efficient approaches to allow service consumption from within applications. Currently, developers are compelled to search for suitable services mainly by manually exploring Web catalogs, which usually show poorly relevant information, than to provide the adequate "glue-code" for their assembly. This implies a large effort into discovering, selecting and adapting services. To overcome these challenges, this paper presents a novel Web Service Selection Method. We have defined an Interface Compatibility procedure to assess structural-semantic aspects from functional specifications - in the form of WSDL documents - of candidate Web Services. Two different semantic basis have been used to define and implement the approach: WordNet, a widely known lexical dictionary of the English language; and DISCO, a database which indexes co-occurrences of terms in very large text collections. We performed a set of experiments to evaluate the approach regarding the underlying semantic basis and against third-party approaches with a data-set of real-life Web Services. Promising results have been obtained in terms of well-known metrics of the Information Retrieval field.
    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 - e.g., for services interfaces in WSDL (Web Service Description Language). Like any other software artifact, WSDL documents have several inherent attributes (e.g., size or complexity) that can be measured. We present an approach to prevent a high complexity on services interfaces (WSDLs), to ease consumers to reason about services' offered functionality. Mostly, WSDLs are automatically derived from object-oriented (OO) source code, with a likely impact on complexity. Thereby, we study the statistical relationships between a recent metric suite of service interface complexity (proposed by Basci & Misra) and the well-known Chidamber & Kemerer's OO metric suite (applied to service implementations), on a data-set of 154 real-world services. First, a theoretical validation of Baski & Misra's suite (using Weyuker's properties) is presented, to prove the ability to measure complexity in WSDL documents. Then, after finding high correlation between both metric suites, we have conducted a series of experiments to analyze how certain refactorings on services' source codes prior to derive WSDLs might reduce complexity. In this way, our approach exploits OO metrics as development-time indicators, to guide software developers towards obtaining less complex service interfaces.
    To expose software as Web-accesible services, Web Service technologies demand developers to implement certain sofware artifacts, such as the service description using WSDL. Therefore, developers usually use automatic tools to perform this task, which take as input a code written in a programming language -e.g. Java- and generate the necessary artifacts for invoking it remotely. However, as a result of tool flaws and some bad coding practices, the description of the resulting Web Services might contain anti-patterns that difficult their discovery and use. In earlier work we proposed a tool-supported, code-first approach named Gapidt to develop Web Services in Java while early reducing the presence of anti-patterns in their descriptions through code refactorings. Bad coding practices, which potentially reduce the textual and structural information of generated WSDL documents, are automatically detected and informed to the developer by means of the GAnalyzer module so he/she can fix the service code. Moreover, developer provided information, such as service parameter names and operation comments, as well as re-utilization of data-type definitions, are exploited by the GMapper module upon generating WSDL documents. This paper focuses on a comprehensive experimental evaluation of the approach oriented at prospective users to assess expected discoverability gains and usage considerations taking into account various relevant service publishing technologies. In addition, we introduce a detailed comparison of Gapidt with a similar approach from the literature. The results show that Gapidt outperforms its competitor in terms of discoverability while improves Web Service description quality (better documentation and data-models). The Web Service discoverability levels of Gapidt outperforms that of third-party tools, either when using the GAnalyzer plus the GMapper, or only the GMapper.
    SOA and Web Services allow to easily expose business functions to build larger distributed systems. However, legacy systems – mostly in COBOL – are left aside unless applying a migration approach. Main approaches are: direct and indirect migration. The former implies to wrap COBOL programs with a thin layer of a Web Service oriented language/platform. The latter needs reengineering COBOL functions to a modern language/platform. In a previous work, we presented an intermediate approach based on direct migration where developed Web Services are later refactored to improve their interfaces quality. Refactorings mainly capture good practices inherent to indirect migration. In this paper, we measure the complexity of Web Services’ interfaces generated by the three approaches. Both comprehension and interoperability can be affected according to the service interface complexity level. We apply a metric suite (by Baski & Misra) to measure complexity on services interfaces – i.e., WSDL documents. Migrations of two real COBOL systems upon the three approaches were compared on the complexity level of the generated WSDL documents.
    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 capabilities and how to interact with 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 ontology-based semantic readability metric to focus on WSDL documents by using WordNet as a lightweight concept hierarchy. We have validated our approach by performing both qualitative and quantitative experiments. The first one consists of 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. The second experiment compares our approach with two ontology-based approaches. The third experiment compares the readability values of a dataset of real-life service descriptions before and after rewriting them. The resultsshowed the effectiveness of our approach to assess readability of Web Services interfaces.
    The growing popularity of massively accessed Web applications that store and analyze large amounts of data, being Facebook, Twitter and Google Search some prominent examples of such applications, have posed new requirements that greatly challenge traditional RDBMS. In response to this reality, a new way of creating and manipulating data stores, known as NoSQL databases, has arisen. This paper reviews implementations of NoSQL databases in order to provide an understanding of current tools and their uses. First, NoSQL databases are compared with traditional RDBMS and important concepts are explained. Only databases allowing to persist data and distribute them along different computing nodes are within the scope of this review. Moreover, NoSQL databases are divided into different types: Key-Value, Wide-Column, Document-oriented and Graph-oriented. In each case, a comparison of available databases is carried out based on their most important features.
    Sparse-matrix operations are commonplace in computational science, and novel solutions for speeding-up them are essential for numerous applications. SMArtOp is a software for efficiently dividing and distributing the processing of large-scale sparse-matrix arithmetic operations. This software relies on both the distinctive characteristics of each type of arithmetic operation and the particular matrices involved to split the operations into parallel and simpler tasks. Experimental evaluation showed the speeding-up and resource consumption advantages of the proposed software, in comparison to other linear-algebra libraries.
    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 ever-growing 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 social-like 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 millions 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.
    Large-scale graphs have become ubiquitous in social media. Computer-based recommendations in these huge graphs pose challenges in terms of algorithm design and resource usage efficiency when processing recommendations in distributed computing environments. Moreover, recommendation algorithms for graphs, particularly link prediction algorithms, have different requirements depending of the way the underlying graph is traversed. Path-based algorithms usually perform traversals in different directions to build a large ranking of vertices to recommend, whereas random walk-based algorithms build an initial subgraph and perform several iterations on those vertices to compute the final ranking. In this work, we propose a distributed graph processing framework called Distributed Partitioned Merge (DPM), which supports both types of algorithms and we compare its performance and resource usage w.r.t. two relevant frameworks, namely Fork-Join and Pregel. In our experiments, we show that in most tests DPM outperforms both Pregel and Fork-Join in terms of recommendation time, with a minor penalization in network usage in some scenarios.
    In the last years, Web Services have become the technological choice to materialize the Service-Oriented Computing paradigm. However, a broad use of Web Services requires efficient approaches to allow service consumption from within applications. Currently, developers are compelled to search for suitable services mainly by manually exploring Web catalogs, which usually show poorly relevant information, than to provide the adequate "glue-code" for their assembly. This implies a large effort into discovering, selecting and adapting services. To overcome these challenges, this paper presents a novel Web Service Selection Method. We have defined an Interface Compatibility procedure to assess structural-semantic aspects from functional specifications - in the form of WSDL documents - of candidate Web Services. Two different semantic basis have been used to define and implement the approach: WordNet, a widely known lexical dictionary of the English language; and DISCO, a database which indexes co-occurrences of terms in very large text collections. We performed a set of experiments to evaluate the approach regarding the underlying semantic basis and against third-party approaches with a data-set of real-life Web Services. Promising results have been obtained in terms of well-known metrics of the Information Retrieval field.
    Service-Oriented Computing promotes building applications by consuming and reusing Web Services. However, the selection of adequate Web Services given a client application is still a major challenge. The effort of assessing and adapting candidate services could be overwhelming due to the “impedance” of Web Service interfaces expected by clients versus the actual interfaces of retrieved Web Services. In this work, we present a novel structural-semantic approach to help developers in the retrieval and selection of services from a service registry. The approach is based on a comprehensive structural scheme for service Interface Compatibility analysis, and WordNet as the semantic support to assess identifiers of operations and parameters. We also empirically analyze, compare and contrast the performance of three service selection methods: a pure structural approach, a pure semantic approach, and the structural-semantic (hybrid) approach proposed in this work. The experimental analysis was performed with two data-sets of real-world Web Services and a service discovery support already published in the literature. Results show that our hybrid service selection approach improved effectiveness in terms of retrievability of Web Services compared to the other approaches.
    The profusion of mobile devices over the world and their evolved computational capabilities promote their inclusion as resource providers in traditional Grid environments. However, their efficient exploitation requires adapting current schedulers to operate with computing capabilities limited by energy supply and mobile devices that cannot be assumed to be dedicated, among other concerns. We propose a two-phase scheduling approach for running CPU-intensive jobs on mobile devices that combines novel energy-aware criteria with job stealing techniques. The approach was evaluated through an event-based simulator that uses battery consumption profiles extracted from real mobile devices. CPU usage derived from non-Grid processes was also modelled. For evaluating the first phase we compared the number of finalized jobs by all energy-aware criteria, while for the second phase we analyzed the performance boost introduced by job stealing. While the best first phase criteria finalized up to 90 % of submitted jobs, job stealing increased this percentage by up to 9 %.
    Web Services are influencing most IT-based industries as the basic building block of business infrastructures. A Web Service has an interface described in a machine-processable format (specifically WSDL). Service providers expose their services by publishing the corresponding 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 – attending to their semantics by using WordNet as the underlying concept hierarchy. In addition, we propose a set of best practices to be used during the development of WSDL documents to improve their readability. To validate our proposals, we performed both qualitative and quantitative experiments. A controlled survey with a group of (human) service consumers showed that software engineers required less time and effort to analyze WSDL documents with higher readability values. Other experiment compares readability values of a dataset of real-life WSDL documents from the industry before and after modifying them to adhere to the readability best practices proposed in this paper. We detected a significant readability improvement for WSDL documents written according to the best practices. In another experiment, we applied existing readability metrics for natural language texts detecting their unsuitability to the Web Service context.Lastly, we analyzed the readability best practices identifying their useful applicability to the industry.
    Resource-intensive agricultural simulation applications have increased the need for gridification tools –i.e., software to transform and scale up the applications using Grid infrastructures–. Previous research has proposed JASAG, a generic gridification tool for agricultural applications, through which the performance of a whole-farm simulation application called Simugan improved considerably. However, JASAG still lacks proper support for efficiently exploiting Grid storage resources, causing significant delays for assembling and summarizing the generated data. In this application note, two different data processing techniques in the context of JASAG are presented to tackle this problem. Simugan was again employed to validate the benefits of these techniques. Experiments using data processing techniques show that the execution time of Simugan was accelerated by a factor of up to 34.34.
    Matrix computations are both fundamental and ubiquitous in computational science, and as a result, they are frequently used in numerous disciplines of scientific computing and engineering. Due to the high computational complexity of matrix operations, which makes them critical to the performance of a large number of applications, their efficient execution in distributed environments becomes a crucial issue. This work proposes a novel approach for distributing sparse matrix arithmetic operations on computer clusters aiming at speeding-up the processing of high-dimensional matrices. The approach focuses on how to split such operations into independent parallel tasks by considering the intrinsic characteristics that distinguish each type of operation and the particular matrices involved. The approach was applied to the most commonly used arithmetic operations between matrices. The performance of the presented approach was evaluated considering a high-dimensional text feature selection approach and two real-world datasets. Experimental evaluation showed that the proposed approach helped to significantly reduce the computing times of big-scale matrix operations, when compared to serial and multi-thread implementations as well as several linear algebra software libraries.
    Multi-label classification (MLC) is a supervised learning problem in which a particular example can be associated with a set of labels instead of a single one as in traditional classification. Many real-world applications, such as Web page classification or resource tagging on the Social Web, are challenging for existing MLC algorithms, because the label space grows exponentially as instance space increases. Under the problem transformation approach, the most common alternative for MLC, multi-label problems are transformed into several single label problems, whose outputs are then aggregated into a prediction to the whole classification problem. Feature selection techniques become crucial in large-scale MLC problems to help reducing dimensionality. However, the impact of feature selection in multi-label setting has not been as extensively studied as in the case of single-label data. In this paper, we present an empirical evaluation of feature selection techniques in the context of the three main problem transformation MLC methods: Binary Relevance, Pair-wise and Label power-set. Experimentation was performed across a number of benchmark datasets for multi-label classification exhibiting varied characteristics, which allows observing the behavior of techniques and assessing their impact according to multiple metrics.
    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.
    Web Service discovery and selection deals with the retrieval of the most suitable Web Service, given a required functionality. Addressing an effective solution remains difficult when only functional descriptions of services are available. The Artificial Intelligence (AI) field have contributed significantly to support the Web Services lifecycle. In this paper, we propose an extension of a previous approach that applied Case-Based Reasoning (CBR) for Web Service Selection, in which Web Services are behaviorally tested for conformance of a given required functionality.
    Web Service discovery and selection deal with the retrieval of the most suitable Web Service, given a required functionality. Addressing an effective solution remains difficult when only functional descriptions of services are available. In this paper, we propose a solution by applying Case-based Reasoning, in which the resemblance between a pair of cases is quantified through a similarity function. We show the feasibility of applying Case-based Reasoning for Web Service discovery and selection, by introducing a novel case representation, learning heuristics and three different similarity functions. We also experimentally validate our proposal with a dataset of 62 real-life Web Services, achieving competitive values in terms of well-known Information Retrieval metrics.
    Mobile devices are the most popular kind of computational device in the world. These devices have more limited resources than personal computers and battery consumption is always under user's eye since mobile devices rely on their battery as energy supply. On the other hand, nowadays most applications are developed using object-oriented paradigm, which has some inherent features, like object creation, that consume important amounts of energy in the context of mobile development. These features are responsible for offering maintainability and flexibility, among other software quality-related advantages. Then, this chapter aims to present an analysis to evaluate the trade-off between object-oriented design purity and battery consumption. As a result, developers can design mobile applications taking into account these two issues, giving priority to object design quality and/or energy efficiency as needed.
    Today’s scientific applications usually take considerable time to run, and hence parallel computing environments, such as Grids and data centers/Clouds, have emerged. Indeed, traditionally, much research in high-performance computing has been conducted with the goal of executing such applications as fast as possible. However, energy has recently been recognized as another crucial goal to consider, because of its negative economic and ecological implications. Energy-driven solutions in these environments are mostly focused on the hardware and middleware layers, but little efforts target the application level. We revisit a catalog of primitives commonly used in object oriented-based scientific programming, or micro-benchmarks, to identify energy-friendly variants of the same primitive. Based on this, we refactor three existing scientific applications, resulting in energy improvements ranging from 2.58 to 96.74 %.
    The problem of inferring missing relationships between people in online social networks such as Facebook, Google+ and Twitter is currently being given much attention due to its enormous applicability. To this end, link prediction algorithms which operate on graph data have been considered. However, the relentless increase of the size of such networks calls for distributed processing models able to cope with the associated big amounts of data. In this paper, we study the suitability of three models (Fork-Join, Pregel and DPM) for scaling up a common class of such algorithms, i.e. random walk-based. Broadly, Fork-Join and Pregel promote two rather different ways of creating and handling parallel sub-computations, while DPM is a model combining the best of both. Experiments performed with the Twitter graph and two classical random walk-based algorithms named HITS and SALSA show that DPM outperforms Fork-Join and Pregel by [30–40]% and [10–20]% respectively in terms of recommendation time.
    In the last years, Web Service composition has undoubtedly become the most promising way to integrate business-to-business applications. However, the industry and the academia often disagree on materializing current solutions, which are based on either SOAP Web Services or semantic Web Services. Besides, any service composition mechanism entails multiple and complex factors such as adaptability, scalability and lightweightness. Recently, RESTful services have shown their potential to compose reliable and visible Web-scale applications based on the so-called mashups. In this paper, we survey a comprehensive set of RESTful composition approaches, i.e., the most promising in their area, totaling 29 approaches. Then, we propose two sets of features to analyze, characterize and compare such approaches: features inherent to SOAP services composition approaches and RESTful services composition features. Lastly, we discuss research challenges and open research problems in the area.
    Given the relentless growing number of mobile devices, researchers have pointed out that distributed computing environments, such as clusters or even computational Grids, could increase the available resources by scavenging devices' capabilities. However, this negatively impacts on their batteries. We study centralized job schedulers that aim at exploiting clusters of mobile resources with rather stable devices in terms of connection time. These schedulers outperform a previous centralized scheduler, finishing up to 30% more jobs with the same amount of energy. We also show that the schedulers perform competitively compared to schedulers based on job stealing, which are more difficult to implement and consume more network resources and hence energy.
    Searching and understanding Web Services is challenging mainly because service developers tend to disregard the importance of the exposed service APIs. In many situations these APIs are defined using WSDL documents, which are written in an XML dialect. Service developers can opt between manually writing these documents or inferring them from service implementations. This work is focused on the later methodology and provides techniques and tools for generating WSDL documents avoiding well-known bad practices (e.g., lack of textual comments or representative names) that compromise Web Service API quality. Our experiments show that by using our approach the obtained WSDL documents are more likely to be free from these undesirable practices so they better describe service functionality. In addition, these experiments show that the WSDL documents generated using our approach also have other important quality-related features, such as less redundant data-type definitions and better defined data-types. Experiments have been performed by comparing our proposal against WSDL generation tools/approaches from both the industry and the academy.
    The creation of new and better recommendation algorithms for social networks is currently receiving much attention owing to the increasing need for new tools to assist users. The volume of available social data as well as experimental datasets force recommendation algorithms to scale to many computers. Given that social networks can be modelled as graphs, a distributed graph-oriented support able to exploit computer clusters arises as a necessity. In this work, we propose an architecture, called Lightweight-Massive Graph Processing Architecture, which simplifies the design of graph-based recommendation algorithms on clusters of computers, and a Java implementation for this architecture composed of two parts: Graphly, an API offering operations to access graphs; and jLiME, a framework that supports the distribution of algorithm code and graph data. The motivation behind the creation of this architecture is to allow users to define recommendation algorithms through the API and then customize their execution using job distribution strategies, without modifying the original algorithm. Thus, algorithms can be programmed and evaluated without the burden of thinking about distribution and parallel concerns, while still supporting environment-level tuning of the distributed execution. To validate the proposal, the current implementation of the architecture was tested using a followee recommendation algorithm for Twitter as case study. These experiments illustrate the graph API, quantitatively evaluate different job distribution strategies w.r.t. recommendation time and resource usage, and demonstrate the importance of providing non-invasive tuning for recommendation algorithms.
    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.
    Feature modeling has been widely used in domain engineering for the development and configuration of software product lines. A feature model represents the set of possible products or configurations to apply in a given context. Recently, this formalism has been applied to the runtime (re-)configuration of systems with high variability and running in changing contexts. These systems must adapt by updating their component assembly configuration at runtime, while minimizing the impact of such changes on the quality of service. For this reason the selection of a good system configuration is seen as an optimization problem based on quality attribute criteria. We propose an approach for system adaptation based on the specification, measurement and optimization of quality attribute properties on feature models. Furthermore, we describe its integration into a platform for supporting the self-adaptation of component-based systems. Feature models are annotated with quality attribute properties and metrics, and then an efficient algorithm is used to deal with the optimization problem. Results and conclusions Two performance properties –frame processing time and reconfiguration time– are estimated with our model against measurements obtained from the running system to show the accuracy of metrics on feature models for estimating quality attribute properties. The results show evidence that these metrics are reasonably accurate for measuring performance properties on a realistic component-based computer vision system.
    Web Service composition is becoming the most promising way for business-to-business systems integration. However, current mechanisms for service composition entail a trade-off on multiple and complex factors. Thereby, existing solutions based on business Web Services, semantic Web Services, or the recent RESTful services, lack of a standardized adoption. This paper gives an overview of current approaches according to a set of features. Moreover, related core problems and future directions of service composition mechanisms are pointed out.
    The Computer Science (CS) community has been discussing, for some time now, the role of conferences as publication venues. In this regard, computer scientists claim to have a long-standing tradition in publishing their research results in conferences, which are also recognized as being different to events in other disciplines. This practice, however, contrasts with journal driven publication practices which are the prevailing academic standard. Consequently, the assessment of the quality of CS conferences with respect to journals is a recurrent topic of discussion within evaluation boards in charge of judging researchers’ performance. Even when agreements are feasible inside the discipline, they are often subject to the scrutiny in the context of multi-disciplinary evaluation boards—usually ruled by standard bibliometrics—in which CS researchers compete for obtaining scholarships, positions and funding. The Argentinian CS community is not an exception in this respect. In this paper, we present a study of the publication practices of the Argentinian CS community, their evolution over time and, more importantly, the impact they achieved in terms of citations. The findings of this study are good basis for understanding the publishing practices of our community, promoting future discussions as well as supporting the community positions regarding these issues.
    This work improves a novel Service Selection Method for the development of Service-Oriented Applications in the context of the Service-Oriented Computing (SOC) paradigm. We have defined a Semantic-Structural Scheme to assess Web Services on Interface Compatibility exploring the available information from WSDL documents. The structural information involves data types from return, parameters and exceptions. The semantic information concerns identifiers from parameters and operation names. The lexical database WordNet is used as a semantic basis. Two appraisal values were defined: compatibility gap and adaptability gap. The former is centered on functional aspects. The latter explains the adaptation effort to a successful integration. We validated those appraisals values through different experiments with a data-set of 465 real-life Web Services and measured the results using three metrics from the Information Retrieval field.
    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.
    An Enterprise Desktop Grid (EDG) is a low cost platform that gathers desktop computers spread over different institutions. This platform uses desktop computers idle time to run grid applications. We argue that computers in these environments have a predictable productivity that affects a grid application execution time. In this paper, we propose a system called PFS for computer productivity forecasting that improves grid applications performance. We simulated 157 500 applications and compared the performance achieved by our proposal against two recent strategies. Our experiments show that a grid scheduler based on PFS runs applications faster than schedulers based on other selection strategies.
    Friend recommendation algorithms in large-scale social networks such as Facebook or Twitter usually require the exploration of huge user graphs. In current solutions for parallelizing graph algorithms, the burden of dealing with distributed concerns falls on algorithm developers. In this paper, a simple yet powerful programming interface (API) to implement distributed graph traversal algorithms is presented. A case study on implementing a followee recommendation algorithm for Twitter using the API is described. This case study not only illustrates the simplicity offered by the API for developing algorithms, but also how different aspects of the distributed solutions can be treated and experimented without altering the algorithm code. Experiments evaluating the performance of different job scheduling strategies illustrate the flexibility or our approach.
    Previous research of our own [34] has shown that by avoiding certain bad specification practices, or WSDL anti-patterns, contract-first Web Service descriptions expressed in WSDL can be greatly improved in terms of understandability and retrievability. The former means the capability of a human discoverer to effectively reason about a Web Service functionality just by inspecting its associated WSDL description. The latter means correctly retrieving a relevant Web Service by a syntactic service registry upon a meaningful user's query. However, code-first service construction dominates in the industry due to its simplicity. This paper proposes an approach to avoid WSDL anti-patterns in code-first Web Services. We also evaluate the approach in terms of services understandability and retrievability, deeply discuss the experimental results, and delineate some guidelines to help code-first Web Service developers in dealing with the trade-off that arise between these two dimensions. Certainly, our approach allows services to be more understandable, due to anti-pattern remotion, and retrievable as measured by classical Information Retrieval metrics.
    The results of botnet detection methods are usually presented without any comparison. Although it is generally accepted that more comparisons with third-party methods may help to improve the area, few papers could do it. Among the factors that prevent a comparison are the difficulties to share a dataset, the lack of a good dataset, the absence of a proper description of the methods and the lack of a comparison methodology. This paper compares the output of three different botnet detection methods by executing them over a new, real, labeled and large botnet dataset. This dataset includes botnet, normal and background traffic. The results of our two methods (BClus and CAMNEP) and BotHunter were compared using a methodology and a novel error metric designed for botnet detections methods. We conclude that comparing methods indeed helps to better estimate how good the methods are, to improve the algorithms, to build better datasets and to build a comparison methodology.
    Feature modeling has been widely used in domain engineering for the development and configuration of software products. A feature model represents the set of possible configurations to apply in a given context. Recently, this formalism was applied to the runtime (re-)configuration of systems with high variability and context changes, in which the selection of the best candidate configuration is seen as an optimization problem based on quality criteria. To this end, we propose an approach for the specification, measurement and optimization of runtime quality attributes based on feature models, and furthermore, we describe its integration into a component-based architecture for supporting dynamically adaptive systems. Feature models are annotated with quality-attribute properties and metrics, and then an efficient and flexible algorithm is used to deal with the optimization problem. We report on some examples of adaptation and quality-attribute scenarios in the context of a video surveillance domain, in order to illustrate the pros and cons of our approach.
    The development of mobile applications that combine Web Services from different providers --also referred as mashup applications-- is growing as a consequence of the ubiquity of bandwidth connections and the increasing number of available Web Services. In this context, providing higher maintainability to Web Service applications is a worth of matter, because of the dynamic nature of the Web. EasySOC (1) solves this problem by decoupling mashups from application components. However, mobile devices have energy constraints because of the limitations in the current battery capacities. This work proposes a model that builds on the benefits of the EasySOC approach and improves this latter by assisting developers to select Web Service combinations that reduce energy consumption. We evaluated the feasibility of the model through a case study in which we compare the estimations provided by the model against real energy measurements. The results indicated that our model had an efficacy of 81% for the analyzed case study.
    This is the bidirectional argus NetFlow file containing the traffic of the Capture 1 described in the paper. It has Botnet, Normal and Background labels. For more information see
    An evolutionary process that is currently taking place in the software industry is the shift from developing applications from scratch to discovering and assembling services published in the Internet. This has given birth to a new computing paradigm called service-oriented computing (SOC). We investigated whether simplifying and automating tasks inherent to SOC-based development, while exploiting systems engineering students' experience in earlier paradigms, namely object orientation, reduce the cognitive effort needed to learn SOC. The study involved 38 undergraduate students plus 7 postgraduate students from 4 universities, which attended a course about SOC development models and technologies. Then, they were asked to develop a real-life service-oriented application using two alternatives, namely existing SOC libraries and a software support of our own named EasySOC. EasySOC promotes using common object-oriented design patterns to structure service-oriented applications, facilitates service discovery, and hides many technological details from users. The students were surveyed about their perception on both alternatives using a Likert-based questionnaire. Results show that the students, who had no previous experience in service-oriented notions before the experiment, perceived that EasySOC allows focusing on essential aspects of the paradigm while concealing accidental aspects, and provides adequate support and guidance to bridge the gap. Comput Appl Eng Educ © 2011 Wiley Periodicals, Inc.
    Although producing high quality WSDL documents is a key factor in a Web Service system success, previous works have shown that WSDL document quality, in terms of readability and discoverability, is often disregarded by service developers. One of the main causes of this is that developers do not write the WSDL documents directly. Instead, these documents are automatically generated from service implementations, which are called code-first Web Services. This work presents a novel tool for assisting Java code-first Web Service development that spots potential issues that might lead to low quality WSDL documents. The approach was empirically evaluated using 81 open-source Web Service implementations. The evaluation shows that the WSDL documents generated using our tool can be more easily retrieved from Web Service registries by users. This indirectly implies that these WSDL documents have a better quality than the ones generated using alternative tools.
    Multi-label classification techniques have been developed for problems where objects can be associated to several disjoint labels, such as the scientific topics covered by a paper. However, these techniques tend to be computationally complex, which makes it difficult to use them in practice. Therefore, they might be unsuitable for large problems. This paper presents an approach to accelerate a well-know multi-label classification technique, called Binary Relevance, by using small computational clusters. In this classification technique, the training times grow linearly with the number of labels. In particular, this work aims at reducing the times required for training a Binary Relevance classifier. This approach was tested using 7 data-sets with 81 associated labels and more than a quarter million training instances. Experimental results shown a linear increment on the speed-up when computational nodes are added to the cluster.
    Arithmetic operations on matrices are frequently used in scientific computing areas. They usually become a performance bottleneck due to their high complexity. In this context, the parallel processing of matrix operations in distributed environments arises as an important field of study. This work presents several strategies for distributing sparse matrix arithmetic operations on computer clusters, focusing on the intrinsic characteristics of the operations and the matrices involved. The performance of the proposed strategies for determining the number of parallel tasks to be executed on the computer cluster was evaluated considering a high-dimensional feature selection approach. Additionally, the performance of two alternatives for efficiently representing big-scale sparse matrices was tested. Experimental results showed that the proposed strategies significantly reduce the computing time of matrix operations, outperforming computations based on serial and multi-thread implementations.
    Botnets are an important security problem on the Internet. They continuously evolve their structure, protocols and attacks. This survey analyzes and compares the most important efforts carried out in a network-based detection area. It accomplishes four tasks: first, the comparison of previous surveys and the proposal of four new dimensions to analyze their classification schemes; second, a new classification and comparison of network-based botnet detection proposals, which includes the definition of 20 desired properties of every botnet detection paper; third, an extensive comparison between the most representative detection proposals; and fourth, the description of the most important problems and highlights in the area. We conclude that the area has achieved great advances so far, but there are still many open problems. Copyright © 2013 John Wiley & Sons, Ltd.
    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.
    Software cognitive complexity refers to how demanding the mental process of performing tasks such as coding, testing, debugging, or modifying source code is. Achieving low levels of cognitive complexity is crucial for ensuring high levels of software maintainability, which is one of the most rewardful software quality attributes. Therefore, in order to control and ensure software maintainability, it is first necessary to accurately quantify software cognitive complexity. In this line, this paper presents a software metric to assess cognitive complexity in Object-Oriented (OO) systems, and particularly those developed in the Java language, which is very popular among OO programming languages. The proposed metric is based on a characterization of basic control structures present in Java systems. Several algorithms to compute the metric and their materialization in the Eclipse IDE are also introduced. Finally, a theoretical validation of the metric against a framework specially designed to validate software complexity metrics is presented, and the applicability of the tool is shown by illustrating the metric in the context of ten real world Java projects and relevant metrics from the well-known Chidamber-Kemerer metric suite.
    This a a pcap dataset with the network traffic of one real infected computer. See the paper for more details.
    This a a pcap dataset with the network traffic of one real infected computer. See the paper for more details.
    This a a pcap dataset with the network traffic of one real infected computer. See the paper for more details.
    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.
    Undoubtedly, the Service-Oriented Computing (SOC) is not an incipient computing paradigm anymore, while Web Services technologies is now a very mature stack of technologies. Both have been steadily gaining maturity as their adoption in the software industry grew. Accordingly, several metric suites for assessing different quality attributes of Web Services have been recently proposed. In particular, researchers have focused on measuring services interfaces descriptions, which like any other software artifact, have a measurable size, complexity and quality. This paper presents a study that assesses human perception of some recent services interfaces complexity metrics (Basci and Misra’s metrics suite). Empirical evidence suggests that a service interface that it is not complex for a software application, in terms of time and space required to analyze it, will not be necessarily well designed, in terms of best practices for designing Web Services. A Likert-based questionnaire was used to gather individuals opinions about this topic.
    Because of the increasing availability of multi-core machines, clusters, Grids, and combinations of these there is now plenty of computational power, but today's programmers are not fully prepared to exploit parallelism. In particular, Java has helped in handling the heterogeneity of such environments. However, there is a lot of ground to cover regarding facilities to easily and elegantly parallelizing applications. One path to this end seems to be the synthesis of semi-automatic parallelism and Parallelism as a Concern (PaaC). The former allows users to be mostly unaware of parallel exploitation problems and at the same time manually optimize parallelized applications whenever necessary, while the latter allows applications to be separated from parallel-related code. In this paper, we present EasyFJP, an approach that implicitly exploits parallelism in Java applications based on the concept of fork-join synchronization pattern, a simple but effective abstraction for creating and coordinating parallel tasks. In addition, EasyFJP lets users to explicitly optimize applications through policies, or user-provided rules to dynamically regulate task granularity. Finally, EasyFJP relies on PaaC by means of source code generation techniques to wire applications and parallel-specific code together. Experiments with real-world applications on an emulated Grid and a cluster evidence that EasyFJP delivers competitive performance compared to state-of-the-art Java parallel programming tools.
    Service-Oriented Computing SOC promotes structuring applications via coarse-grained, remote components called services. To materialise SOC, web services is the most common choice. A web service comprises an implementation and a description using the Web Services Description Language WSDL. Web services are often built by first implementing their behaviour and then generating its WSDL document via automatic tools. However, bad design practices already present in a service implementation may end up affecting the quality of its WSDL document. For web services to be reusable, good WSDL designs are crucial. Previously, Mateos et al. show that there is a high correlation between Object-Oriented OO metrics from service implementations and the occurrences of 'anti-patterns' in WSDL documents. In this follow-up paper, these results are extended to all the existing WSDL generation tools. A detailed analysis of the impact of OO metric-driven code refactorings on the quality of WSDL documents is also reported.
    Legacy Systems have become a challenge for many enterprises, which have been migrating its legacy systems towards new computational environments because of interoperability issues with modern technologies, high maintenance costs, and hiring expert staff who possess high legacy technologies background. In order to find a strategy to solve legacy systems concerns, several approaches and experiences were created for the last years. This paper presents a strengths and weaknesses analysis of 18 migration approaches.
    Mobile devices have evolved from simple electronic agendas and mobile phones to small computers with great computational capabilities. In addition, there are more than 2 billion mobile devices around the world. Taking these facts into account, mobile devices are a potential source of computational resources for clusters and computational Grids. In this work, we present an analysis of different schedulers based on job stealing for mobile computational Grids. These job stealing techniques have been designed to consider energy consumption and battery status. As a result of this work, we present empirical evidence showing that energy-aware job stealing is more efficient than traditional random stealing in this context. In particular, our results show that mobile Grids using energy-aware job stealing might finish up to 11% more jobs than when using random stealing, and up to 24% more jobs than when not using any job stealing technique. This means that using energy-aware job stealing increases the energy efficiency of mobile computational Grids because it increases the number of jobs that can be executed using the same amount of energy.
    Service Oriented Architecture (SOA) and Web Services are the current trend to integrate large and distributed systems, which is a common situation in both the business and government worlds. However, within these worlds, systems are commonly written in COBOL because they were developed several decades ago. Therefore, migration of COBOL systems into a service-oriented architectures becomes a necessity. Two main approaches are used to migrate COBOL systems to SOA systems: direct and indirect migration. Direct migration implies wrapping the current COBOL routines of a system with a software layer developed under a newer platform that can be used to offer Web Services. In contrast, indirect migration requires re-designing and re-implementing the COBOL routines functionality using a newer platform as well. In this chapter, we propose a novel migration approach, which takes the best of the two previous approaches. To assess the advantages and disadvantages of these approaches, this chapter presents a case study from a government agency COBOL system that has been migrated to a Web Services-based system using the three approaches. As a result of having these migration attempts, we present the trade-off between direct and indirect migration the resulting service interfaces quality and the migration costs. These results also show that this new migration approach offers a good balance to the above trade-off, which makes the approach applicable to similar COBOL migration scenarios.
    Service-oriented computing promotes building applications by consuming reusable services. However, facing the selection of adequate services for a specific application still is a major challenge. Even with a reduced set of candidate services, the effort of assessing candidates could be overwhelming. We have defined an approach to assist developers in the selection of services, which mainly comprises an assessment process for service interface compatibility. This assessment process is based on a comprehensive structural scheme for service interfaces matching. The scheme allows developers to gain knowledge on likely services' interactions and their required adaptations to achieve a successful integration. We evaluated the performance of the interface compatibility analysis with a data set of 453 services and two different service discovery registries. The experiments show an improvement of up to 15% in precision and up to 8% in the DCG usefulness metric, with regard to the previous results obtained using only textual (syntactical) information.
    In a previous article, the authors demonstrated that effectively discovering Web services helps developers avoid several common design errors in Web Service Description Language (WSDL) documents. Their proposed guidelines are unfortunately applicable only when publishers follow the top-down, or contract-first, method of building services, which isn't very popular due to its inherent costs. Here, they present an approach for preventing such errors when using a counterpart method-namely, bottom-up or code-first-and measure the approach's impact on service discovery. The rationale behind the study is that because code-first service interfaces are automatically generated by tools that-given a service implementation-deterministically map programming language constructs onto WSDL elements, the measurable properties of service implementations could influence resulting service interfaces.
    Over the last years, several techniques to evaluatemodifiability of software architectureshave been developed. One of such techniques is change impact analysis (CIA), which aids developers in assessing the effects of change scenarios on architectural modules. However, CIA does not take into account the pattern structures behind those modules. In architectural frameworks, such as the Enterprise Java Beans (EJB) architecture, the use of patterns is a key practice to achieve modifiability goals. Although patterns can be easily understood individually, when an application combines several pattern instances the analysis is not straightforward. In practice, many EJB designsare assessed in an ad-hoc manner and relying on the developers' experience. A way of dealing with this problem is through the integration of modifiabiliy analysis models and patterns. We propose a knowledge-based approach that explicitly links the EJB patterns to a scenario-based analysis for multi-tier architectures. Specifically, we have developed a modifiability reasoning framework that reifies the EJB patterns present in a given design solution and, for a set of predetermined scenarios, the reasoning framework identifies which architectural elements can be affected by the scenarios. The reasoning framework outputs metrics for each of the scenarios regarding specific EJB tiers. The main contribution of this approach is that assists developers to evaluate EJB alternatives, providing quantitativeinformation about the modifiability implications of their decisions. A preliminary evaluation has shown that the the reasoning framework is viable to analyze EJB designs.
    There is a good consensus on the strategic value of Service Oriented Architecture (SOA) as a way of structuring systems, and a common trend is to migrate legacy applications that use outdated technologies and architectures to SOA. We study the effects in the resulting Web Service interfaces of applying two traditional migration approaches combined with common ways of building services, namely direct migration with code-first and indirect migration with contract-first. The migrated system was a 35-year-old COBOL system of a government agency that serves several millions of users. In addition, we provide a deep explanation of the trade-offs involved in following either combinations. Results confirm that the “fast and cheap” approach to move into SOA, which is commonplace in the industry, may deliver poor service interfaces, and interface quality is also subject to the tools supporting the migration process.
    The relentlessly increasing importance and application of Information and Communication Technologies (ICTs) in Agriculture have given birth to a new field called e-Agriculture, which focus on improving agricultural and rural development through a variety of technologies. In this sense, Agricultural Information Systems (AISs) are distributed sources of information that exploit ICTs to make agricultural processes and decision making more efficient. In order to integrate AISs and therefore build added value AISs, Web Service technologies seem to be the right path towards heterogeneous systems integration. However, there is still uncertain which is the best implementation approach to integrate Web Service-enabled AISs and mobile devices, i.e., the remote information accessors by excellence in rural areas. We comparatively explore the outcomes of employing either Simple Object Access Protocol (SOAP) or REpresentational State Transfer (REST) approaches in a Web Service-enabled whole-farm simulator accessed from Android-powered smartphones. Memory usage was 24% lower in SOAP, but even older and lower-end smartphones have enough RAM to avoid detrimental effects on performance. REST-based approaches broadly incur in less byte transferred compared to SOAP, which has huge implications on costs. That is particularly important when the Internet is accessed via GPRS or 3G protocols and pay-per-byte data plans as in most of Latin America rural areas. However, when unlimited data usage became less costly and more available in such areas, SOAP might be preferred due to the higher maturity of both the protocol and the available developer environments.
    Information diffusion has been studied between and within biosphere, microblogs, social networks, citation networks and other domains, where the network structure is present. These studies have turned to be useful for acquiring intrinsic knowledge for strategic decision making in related areas, for example, planning online campaigns in case of microblogs and blogosphere. In the context of data-centric Web services, information exchange patterns will reveal practical heuristics for efficient Web services selection and composition. For example, by possible knowledge that there is information flow between Web services of textit{Financial Analysis Services} and textit{Enterprise Resource Planning Services}, as outlined by our experimental results, the potential applications, which interact with textit{Financial Analysis} services, can be adjusted to take advantage of textit{Enterprise Resource Planning} services as well. In this paper we present a method for analyzing information diffusion between categories of data-centric Web services. The method operates on a Web services network constructed by linking interface descriptions of categorized Web services. The proposed method is evaluated on a case study of global Web services. The results indicate high potential of the proposed model in understanding interactions between categories of Web services.
    Legacy system migration to Service-oriented Architectures (SOA) has been identified as the right path to the modernization of enterprise solutions needing agility to respond to changes and high levels of interoperability. However, one of the main challenges of migrating to SOA is finding an appropriate balance between migration effort and the quality of resulting service interfaces. This paper describes an approach to assist software analysts in the definition of produced services, which bases on the fact that poorly designed service interfaces may be due to bad design and implementation decisions present in the legacy system. Besides automatically detecting common design pitfalls, the approach suggests refactorings to correct them. Resulting services have been compared with those that resulted from migrating a real system by following two classic approaches.
    We are facing a hardware revolution given by the increasing availability of multicore computers, clusters, Grids, and combinations of these. Consequently, there is plenty of computational power, but today’s programmers are not fully prepared to exploit parallelism and distribution. Particularly, Java has helped in handling the heterogeneity of such environments, but there is a lack of facilities to easily and elegantly parallelizing applications. One path to this end seems to be the synthesis of semi-automatic parallelism and Parallelism as a Concern (PaaC). We briefly survey relevant Java-based parallel development tools, identify their drawbacks, and discuss some insights of an ongoing approach for mitigating them.
    The Service-Oriented Computing paradigm enables the construction of distributed systems by assembling loosely coupled pieces of software called services, which have clear interfaces to their functionalities. Service interface descriptions have many aspects, such as complexity and quality, all of which can be measured. This paper presents empirical evidence showing that services interfaces maintainability can be predicted by applying traditional software metrics in service implementations. A total of 11 source code level metrics and 5 service interface metrics have been statistically correlated using 154 real world services.
    In this paper, we propose a suite of cognitive metrics for evaluating complexity of object-oriented (OO) codes. The proposed metric suite evaluates several important features of OO languages. Specifically, the proposed metrics are to measure method complexity, message complexity (coupling), attributes complexity and class complexity. We propose also a code complexity by considering the complexity due to inheritance for the whole system. All these proposed metrics (except attribute complexity) use the cognitive aspect of the code in terms of cognitive weight. All the metrics have critically examined through theoretical and empirical validation processes.
    Previous efforts towards simplifying Web Service discovery have shown that avoiding some well-known WSDL specification anti-patterns yield quite good results in making more discoverable services. The anti-patterns, however, have been studied with contract-first Web Services, a service construction methodology that is much less popular in the software industry compared to code-first. We study a number of source code refactorings that can be applied at service development time to reduce the presence of anti-patterns in code-first WSDL documents. The cornerstone of these refactorings is a statistical correlation between common object-oriented (OO) metrics and the anti-patterns computed by using a data-set of real Web Services. We quantify the impact of the refactorings on Web Service discovery and show that more clear WSDL documents are generated and service discovery is greatly improved.
    Grid Computing allows scientists and engineers to run compute intensive experiments that were unfeasible not so long ago. On the downside, for users not proficient in distributed technologies, programming for Grids is difficult, tedious, time-consuming and error-prone. Then, disciplinary users typically waste precious time that could be instead invested into analyzing results. In a previous paper, we introduced BYG (Mateos et al., 2011) [28], a Java-based software that automatically parallelizes sequential applications by directly modifying their compiled codes. In addition, BYG is designed to harness Grid resources by reusing existing Grid platforms and schedulers. In its current shape, however, BYG lacks support for some state-of-the-art Grid schedulers and mechanisms for introducing application-dependent optimizations to parallelized codes. In this paper, we present several extensions to BYG aimed at overcoming these problems and thus improving its applicability and delivered efficiency. We also report experiments by using traditional computational kernels and real-life applications to show the positive practical implications of the proposed extensions.
    This year the concept of “Semantic Web” celebrates its tenth anniversary since it was coined by prominent researchers Tim Berners-Lee, James Hendler and Ora Lassila. To date, there are many technologies to describe, in a machine-understandable way, information and services available in the Web. An incipient research area is focused on solving the issues related to building applications for truly exploiting semantically-described resources. In this paper, we present an approach to upgrade a software application into a Semantic Web-enabled one. The approach builds on the Aspect-Oriented Programming (AOP) paradigm to allow developers to incorporate ontology management capabilities into an ordinary object-oriented application without modifying its source code. The paper also discusses related works and presents case studies.
    Historically, software engineers have conceived metric suites as valu-able tools to estimate the quality of their software artifacts. Recently, a fresh computing paradigm called Service-Oriented Computing (SOC) has emerged at the crossing of massively distributed and heterogeneous software. This paper presents a statistical correlation analysis showing that classic software engineer-ing metrics can be used to predict the complexity and quality of WSDL docu-ments, the cornerstone software artifact when materializing this novel comput-ing paradigm with Web-based technologies. For the experiments, 154 real world WSDL documents have been employed.
    Service Oriented Architecture (SOA) and Web Services are the current trend to integrate large and distributed systems, which is a common situation in both the business and government worlds. However, within these worlds, systems are commonly written in COBOL because they were developed several decades ago. Therefore, migration of COBOL systems into service-oriented architectures becomes a necessity. Two main approaches are used to migrate COBOL systems to SOA systems: Direct and indirect migration. Direct migration implies wrapping the current COBOL routines of a system with a software layer developed under a newer platform that can be used to offer Web Services. In contrast, indirect migration requires re-designing and re-implementing the COBOL routines' functionality using a newer platform as well. In this chapter, the authors propose a novel migration approach, which takes the best of the two previous approaches. To assess the advantages and disadvantages of these approaches, this chapter presents a case study from a government agency COBOL system that has been migrated to a Web services-based system using the three approaches. As a result of having these migration attempts, the authors present the trade-off between direct and indirect migration, the resulting service interfaces quality, and the migration costs. These results also show that this new migration approach offers a good balance to the above trade-off, which makes the approach applicable to similar COBOL migration scenarios.
    Smartphones are a new kind of mobile devices that allow users to take their office anywhere and anytime with them. The number of smartphones is rapidly growing. Most of the time their capabilities are underused, therefore several authors have studied how to exploit smartphones for assisting scientific computing. Yet, as far as we know, there is no study aimed at determining whether smartphones can do a significant contribution to this area as resource providers. This paper shows that smartphones are not that slow when compared to standard mobile devices, such as notebooks. Furthermore, a notebook running on battery only performed 8 times more work than a low-end smartphone before their batteries run out. However, the low-end smartphone is 145 times slower than the notebook, and the smartphone battery has less capacity than the notebook battery. Since smartphones can execute large amount of work running on battery, we think that smartphones can have a major role in building the next-generation HPC infrastructures.
    An Enterprise Desktop Grid (EDG) is a low cost platform that scavenges idle desktop computers to run Grid applications. Since EDGs use idle computer time, it is important to estimate the expected computer availability. Based on this estimation, a scheduling system is able to select those computers with more expected availability to run applications. As a consequence, an overall performance improvement is achieved. Different techniques have been proposed to predict the computer state for an instant of time, but this information is not enough. A prediction model provides a sequence of computer states for different instants of time. The problem is how to identify computer behavior having as input this sequence of states. We identify the need of providing a architecture to model and evaluate desktop computer behavior. Thus, a scheduling system is able to compare and select resources that run applications faster. Experiments have shown that programs run up to 8 times faster when the scheduler selects a computer suggested by our proposal.
    The Service-Oriented Computing (SOC) paradigm has gained a lot of attention in the software industry since SOC represents a novel way of architecting distributed applications. SOC is mostly materialized via Web Services, which allow developers to expose their application as building blocks for other applications by defining a clear and public interface. Although conceptually and technologically mature, SOC still lacks adequate development support from a methodological point of view. We present the EasySOC project: a catalog of guidelines to build service-oriented applications and services. This catalog synthesizes best SOC development practices that arise as a result of several years of research in fundamental SOC-related topics, namely WSDL-based technical specification, Web Service discovery and Web Service outsourcing. In addition, we describe a plug-in for the Eclipse IDE that has been implemented to simplify the utilization of the guidelines. We believe that the practical nature of the guidelines, the empirical evidence that supports them, and the availability of IDE-integrated tools that enforces them will help software practitioners to rapidly exploit our ideas for building real SOC applications.
    Service-Oriented Computing allows building applications by reusing web-accessible services. However, current approaches still involve a large effort both at discovery of services and their successful integration. This paper presents a novel approach to assist developers at discovery, selection and integration of services. In particular, the paper focuses on the selection method that involves two main evaluations on candidate services to achieve a concrete decision upon the most appropriate service. Initially, a syntactic Interface Compatibiliy assessment characterizes the list of candidate services according to a calculated syntactic distance to then proceed with a Behavior Compatibility evaluation that is based on a blackbox testing framework. The usefulness of the selection method is highlighted through a series of case studies.
    The vision of a worldwide computing network of services that Service Oriented Computing paradigm and its most popular materialization, namely Web Service technologies, promote is a victim of its own success. As the number of publicly available services grows, discovering proper services is similar to finding a needle in a haystack. Different approaches aim at making discovery more accurate and even automatic. However they impose heavy modifications over current Web Service infrastructures and require developers to invest much effort into publishing and describing their services and needs. So far, the acceptance of this paradigm is mainly limited by the high costs associated with connecting service providers and consumers. This paper presents WSQBE+, an approach to make Web Service publication and discovery easier. WSQBE+ combines open standards and popular best practices for using external Web services with text-mining and machine learning techniques. We describe our approach and empirically evaluate it in terms of retrieval effectiveness and processing time, by using a data-set of 391 public services.
    Computational Grids deliver the necessary computational infrastructure to perform resource-intensive computations such as the ones that solve the problems scientists are facing today. Exploiting Computational Grids comes at the expense of explicitly adapting the ordinary software implementing scientific problems to take advantage of Grid resources, which unavoidably requires knowledge on Grid programming. The recent notion of "gridifying" ordinary applications, which is based on semi-automatically deriving a Grid-aware version from the compiled code of a sequential application, promises users to be relieved from the requirement of manual usage of Grid APIs within their source codes. In this paper, we describe a novel gridification tool that allows users to easily parallelize Java applications on Grids. Extensive experiments with two real-world applications -ray tracing and sequence alignment- suggest that our approach provides a convenient balance between ease of gridification and Grid resource exploitation compared to manually using Grid APIs for gridifying ordinary applications.
    Once a big repository of static data, the Web has been gradually evolved into a worldwide network of information and services known as the Semantic Web. This environment allows programs to autonomously interact with Web-accessible information and services. In this sense, mobile agent technology could help in efficiently exploiting this relatively new Web in a fully automated way, since Semantic Web resources are described in a computer-understandable way. In this paper, we present SWAM, a platform for building and deploying Prolog-based intelligent mobile agents on the Semantic Web. The article also reports examples and experimental results in order to illustrate as well as to assess the benefits of SWAM.
    Mobile device capabilities have been steadily increasing in the past years. Therefore, mobile Grids potential benefits have encouraged research on this topic. Researchers have identified several issues, such as energy consumption and limited resources, that steam from using mobile devices because they are small computers that run on battery and can move outside of the wireless coverage area. This paper analyses these issues discusses proposed solutions to them in the different Grid abstraction levels from Grid fabric layer to Grid user application layer. Finally, we propose a taxonomy that considers the use of mobile devices and discuss future research opportunities.
    Discovering services acquires importance as Service-Oriented Computing SOC becomes an adopted paradigm. SOC's most popular materializations, namely Web Services technologies, have different challenges related to service discovery and, in turn, many approaches have been proposed. As these approaches are different, one solution may be better than another according to certain requirements. In consequence, choosing a service discovery system is a hard task. To alleviate this task, this paper proposes eight criteria, based on the requirements for discovering services within common service-oriented environments, allowing the characterization of discovery systems. These criteria cover functional and non-functional aspects of approaches to service discovery. The results of the characterization of 22 contemporary approaches and potential research directions for the area are also shown.
    Service-Oriented Computing (SOC) allows developers to structure applications as a set of reusable services. Web Services expose their functionality by using Web Service Description Language (WSDL). We found that there is a high correlation between well-known object-oriented metrics taken in the code implementing services and the occurrences of ‘anti-patterns’ in their WSDLs. We show that some simple refactorings performed early when developing Web Services can greatly improve the quality of WSDL documents. Then, the contribution of this work is a practical approach to guide practitioners in obtaining better WSDL designs that aligns with the technologies and techniques commonly used in the industry for building services.
    Moving from mainframe systems to a service-oriented architecture (SOA) using Web services is an attractive but daunting task. The bottom-up or direct migration approach enables the effective modernization of legacy systems to Web services. Conversely, bringing migration into fruition with the top-down or indirect-migration approach is more difficult, but it achieves better migration results. Employing both approaches on the same large enterprise system is uncommon, which leaves no room for comparison. This article describes the migration processes, costs, and outcomes of applying both approaches on a real Cobol system.
    Different development methods have been proposed for enabling the construction of software with the Service-Oriented Computing (SOC) paradigm. Service-oriented applications invoke services that developers must first discover, engage, and in time potentially replace with newer versions or even alternative services from different providers. Hence, the widely agreed development methodology involves three main activities, including service discovery, service incorporation into applications, and service replacement. EasySOC is a very recent approach for developing service-oriented applications that decreases the costs of building this kind of applications, by simplifying discovery, integration and replacement of services. This paper reports some experiments evidencing the effort needed to start producing service–oriented applications with EasySOC. Results show that users non experienced in SOC development perceive that EasySOC is convenient and easy to adopt.
    Exploiting Grids intuitively requires developers to alter their applications, which calls for expertise on Grid programming. Gridification tools address this problem by semi-automatically making user applications to be Grid-aware. However, most of these tools produce monolithic Grid applications in which common tuning mechanisms (e.g. parallelism) are not applicable, and do not reuse existing Grid middleware services. We propose BYG (BYtecode Gridifier), a gridification tool that relies on novel bytecode rewriting techniques to parallelize and easily execute existing applications via Grid middlewares. Experiments performed by using several computing intensive applications on a cluster and a simulated wide-area Grid suggest that our techniques are effective while staying competitive compared to programmatically using such services for gridifying applications.
    Mobile agents have been successfully used for building massively distributed systems. In spite of the advantages the paradigm has shown, mobile agents are still somewhat underrated and hard to develop. Consequently, we proposed the Reactive Mobility by Failure (RMF) mobility model [1] for simplifying mobile agent adoption and development. RMF enables the developer to non-intrusively delegate certain decisions about agent mobility to the underlying executing middleware. However, in its current shape, the model is not able to consider application-specific context, which may be helpful for making better decisions about mobility regarding execution performance and network usage. In this paper, we describe an extension of RMF aimed at improving the efficiency of RMF-based applications by allowing the programmer to tailor RMF according to his application requirements. In essence, the contribution of this paper is to show that it is possible to automate some mobility decisions via RMF, while keeping high levels of flexibility -the points of a mobile agent code at which the developer is allowed to use mobility- and performance through the addition of custom mobility decisions. We have developed a Prolog-based prototype of our extended RMF model to enable the rapid implementation of mobile applications. Experimental results showing the advantages of the approach with respect to related approaches are also reported.
    Mostly e-business and e-applications rely on the Service Oriented Computing paradigm and its most popular implementation, namely Web Services. When properly implemented and described, Web Services can be dynamically discovered and reused using Internet technologies, pushing interoperability to unprecedented levels. However, poorly described Web Services are rather difficult to be discovered, understood, and reused. This paper presents heuristics for automatically detecting common pitfalls that should be avoided when creating Web Service descriptions. Experimental results with ca. 400 realworld Web Services, empirically show the feasibility of the proposed heuristics. © 2010 IFIP International Federation for Information Processing.
    Service-Oriented Computing (SOC) is a new paradigm that replaces the traditional way to develop distributed software with a combination of discovery, engagement and reuse of third-party services. Web Service technologies are currently the most adopted alternative for implementing the SOC paradigm. However, Web Service discovery presents many challenges that, in the end, hinder service reuse. This paper reports frequent practices present in a body of public services that attempt to prevent the discovery of any service. In addition, we have studied how to solve the discoverability problems that these bad practices cause. Accordingly, this paper presents a novel catalog of eight Web Service discoverability anti-patterns. We conducted a comparative analysis of the retrieval effectiveness of three discovery systems by using the original body of Web Services versus their corrected version. This experiment shows that the removal of the identified anti-patterns eases the discovery process by allowing the employed discovery systems to rank more relevant services before non-relevant ones, with the same queries. Moreover, we conducted a survey to collect the opinions from 26 individuals about whether the improved descriptions are more intelligible than the original ones. This experiment provides more evidence of the importance of correcting the observed problems.
    Top co-authors