Search

Performance testing modeling is a relative new research field. Researches investigating how to apply models to document performance testing information essentially started to be reported in the last decade. Motivated by the lack of a standard to represent performance testing information, our research group, in collaboration with an IT company, proposed a UML approach and lately a Domain-Specific Language (DSL) to support performance testing modeling. The goal of this paper is to show how we support our partner company on the decision process to replace UML by a DSL, hence we designed and conducted an experimental study to provide evidence about the benefits and drawbacks when using UML or DSL for modeling performance testing. In this paper, we report an in vitro experiment, where the subjects designed UML models and DSL models, for the purpose of evaluation with respect to the effort and suitability, from the perspective of the performance testers and the performance engineers in the context of industry and academia for modeling performance testing. Our results indicate that, for performance modeling, effort using a DSL was lower than using UML. Our statistical analysis showed that the results were valid, i.e., that to design performance testing models using our DSL is better than using UML.

There is an increasing number of web data that consists of text and structured data, such as the combination of Wikipedia pages and DBpedia data. To issue queries to such data, we must choose one of the following: (1) submit keyword queries against textual data or (2) submit structured queries written in structured query languages such as SQL and SPARQL against structured data. This paper proposes MorphingAssist, a tool to assist users to gradually transform keywords into structured queries. A feature of our method is to use a hybrid query language that allows a variety of mixtures of keyword and structured query components in a query so that every intermediate step of transformation produces meaningful queries. However, assisting users to transform queries in such a way is a challenge. This paper explains how MorphingAssist generates and shows such hints to the user to facilitate his/her transforming simple keyword queries into more precise queries.

The presentation of multimedia content requires devices with proper computational resources to guarantee intermedia synchronization requirements. When a multimedia system is executed in resource-constrained devices, some synchronization mismatches may occur. This problem becomes harder to solve when considering support for features like user interaction, systemic resilience, and distributed multimedia processing. This paper discusses the separation of concerns between multimedia presentation orchestration and multimedia content decoding and rendering. A multimedia system architecture and its implementation are also presented in this paper, where the separation of concerns goes beyond modularization by being deeply realized as process isolation. This design decision not only assures improved system resilience to the proposed solution but also enables it to be applied in distributed multimedia processing/presentations. Experiments carried out have indicated that the presentation orchestration does not require much resource, and may be run on lightweight devices. On the other hand, multimedia decoding/rendering is suitable to run on devices that are more resourceful.

Designing modern web applications involves a wide spectrum of choices when it comes to deciding where the different tiers of application and framework code that constitute these distributed applications should be placed. These system design choices affect programmer productivity, ease of deployment, security, and performance, particularly with respect to latency and scalability. In this paper, we propose and evaluate a design choice in which not only all application logic executes server-side, but most presentation logic as well. The client browser is reduced to a rendering and I/O engine, similar to a "thin client" or "dumb terminal," but retains the full expressiveness of rich, modern Internet applications. We have developed CloudBrowser 2.0, a system that implements this distribution model using a scalable multiprocess approach. In this paper, we perform an evaluation of the benefits and costs of this approach when compared to both more traditional approaches as well as emerging alternatives. We focus on programmability and systems aspects including performance and latency.

Novel technologies represent a promising way for boosting learning quality in scientific sectors, by engaging students more effectively into experimental activities. Mobile devices allow increasing learning effectiveness significantly, thanks to their diffusion, especially amongst youngsters. Built-in sensors can enable easily-deployable, low-cost and large-scale sensing networks, which exploit the Mobile Crowd-Sensing (MCS) paradigm and involve their owners directly into scientific monitoring activities. For such reasons, in this paper we present a MCS-based noise-sensing platform for engaging students in learning acoustics and sound metering. The proposed platform can be included into traditional didactic activities about those topics. This capability is fostered also by the Bring Your Own Device (BYOD) approach, which further eases the platform diffusion across students. Moreover, BYOD paves the way for the platform application as a MOOC (Massive Online Open Course) enabler. The paper presents the adopted design and implementation methodologies, as well as the platform prototype and its technical validation. We believe that our approach offers students new possibilities for learning how to use professional sound level meters profitably and how to perform measurements correctly.

A fundamental challenge in robotics is to reason with incomplete domain knowledge to explain unexpected observations, and partial descriptions of domain objects and events extracted from sensor observations. Existing explanation generation systems are based on ideas drawn from two broad classes of systems, and do not support all the desired explanation generation capabilities for robots. The objective of this paper is to first compare the explanation generation capabilities of a state of the art system from each of these two classes, using execution scenarios of a robot waiter assisting in a restaurant. Specifically, we investigate KRASP, a system based on the declarative language Answer Set Prolog, which uses an elaborate system description and observations of system behavior to explain unexpected observations and partial descriptions. We also explore UMBRA, an architecture that provides explanations using a weaker system description, a heuristic representation of past experience, and other heuristics for selectively and incrementally searching through relevant ground literals. Based on this study, this paper identifies some key criteria, and provides some recommendations, for developing an explanation generation system for robots that exploits the complementary strengths of the two classes of explanation generation systems.

Cloud computing is rapidly reshaping the server administration landscape. The widespread use of virtualization and the increasingly high server consolidation ratios, in particular, have introduced unprecedented security challenges for users, increasing the exposure to intrusions and opening up new opportunities for attacks. Deploying security mechanisms in the hypervisor to detect and stop intrusion attempts is a promising strategy to address this problem. Existing hypervisor-based solutions, however, are typically limited to very specific classes of attacks and introduce exceedingly high performance overhead for production use.In this paper, we present Slick (Storage-Level Intrusion ChecKer), an intrusion detection system (IDS) for virtualized storage devices. Slick detects intrusion attempts by efficiently and transparently monitoring write accesses to critical regions on storage devices. The low-overhead monitoring component operates entirely inside the hypervisor, with no introspection or modifications required in the guest VMs. Using Slick, users can deploy generic IDS rules to detect a broad range of real-world intrusions in a flexible and practical way. Experimental results confirm that Slick is effective at enhancing the security of virtualized servers, while imposing less than 5% overhead in production.

The paper describes a method for monitoring operating systems and applications in a virtual machine. We present a framework based on plugins, receiving information from the running system. The framework can be used for debugging, dynamic analysis, intrusion detection, etc.

In cloud computing, multi-tenancy is concomitant with scalability in the sense that sharing a single deployment instance between many customer organizations (tenants) maximizes the utilization of the available resources. However, this also introduces the need to customize the application to the (slightly) different requirements of different tenants. In the context of workflow-based SaaS offerings, this is not straightforward to accomplish without compromising scalability or manageability of the offering. In this paper, we present a middleware for multi-tenant customization of workflows that enables software providers (i) to decrease coupling of multi-tenant customization concerns and workflow design for better manageability, (ii) to activate tenant preferences at runtime, but (iii) without incurring a scalability penalty. We validate a prototype implementation of our middleware in the context of a realistic SaaS application, evaluate its scalability, and extensively compare the results with related work confirming that the proposed middleware indeed supports customization of workflows in a significantly more scalable fashion. ispartof: pages:432-439 ispartof: Proceedings of the 2016 ACM Symposium on Applied Computing vol:04-08-April-2016 pages:432-439 ispartof: ACM Symposium on Applied Computing location:Pisa, Italy date:4 Apr - 8 Apr 2016 status: published

A major challenge of the existing attack detection approaches is the identification of relevant information to a particular situation, and the use of such information to perform multi-evidence intrusion detection. Addressing such a limitation requires integrating several aspects of context to better predict, avoid and respond to impending attacks. The quality and adequacy of contextual information is important to decrease uncertainty and correctly identify potential cyber-attacks. In this paper, a systematic methodology has been used to identify contextual dimensions that improve the effectiveness of detecting cyber-attacks. This methodology combines graph, probability, and information theories to create several context-based attack prediction models that analyze data at a high- and low-level. An extensive validation of our approach has been performed using a prototype system and several benchmark intrusion detection datasets yielding very promising results.

In this paper we take an important step towards better understanding the existence and extent of entity-centric language-specific bias in multilingual Wikipedia, and any deviation from its targeted neutral point of view. We propose a methodology using sentiment analysis techniques to systematically extract the variations in sentiments associated with real-world entities in different language editions of Wikipedia, illustrated with a case study of five Wikipedia language editions and a set of target entities from four categories.

Parsing Expression Grammars (PEGs) are a formalism for specifying the syntax of programming languages which can be viewed as a description of a recursive descent parser for the language it describes. An issue that users of PEG-based parsers face is poor reporting of syntax errors on the part of PEG-based parsers. Labeled failures are an extension to PEGs that aims to address this issue by annotating a PEG with labels corresponding to syntax errors, improving the quality of error messages generated by a PEG-based parser. An alternative formulation of PEGs gives the meaning of a PEG by translation into a program of a virtual parsing machine. In this paper, we present an updated semantics for PEGs with labeled failures, and we show how to extend the parsing machine to support them. We also prove the correctness of the translation from PEGs with labels to programs of this extended parsing machine, and we evaluate the use of labeled failures on PEG-based parsers which implement their own ad-hoc error reporting strategy.

Recent computing paradigms like cloud computing and big data have become very appealing to outsource computation and storage, making it easier to realize personalized and patient centric healthcare through real-time analytics on user data. Although these technologies can significantly complement resource constrained mobile and wearable devices to store and process personal health information, privacy concerns are keeping patients from reaping the full benefits. In this paper, we present and evaluate a practical smartwatch based lifelog application for diabetics that leverages the cloud and homomorphic encryption for caregivers to analyze blood glucose, insulin values, and other parameters in a privacy friendly manner to ensure confidentiality such that even a curious cloud service provider remains oblivious of sensitive health data. ispartof: pages:119-124 ispartof: Proceedings of the 31st Annual ACM Symposium on Applied Computing vol:1 pages:119-124 ispartof: Symposium on Applied Computing location:Pisa, Italy date:4 Apr - 8 Apr 2016 status: published

The amount of online shops is growing daily and many Web shops focus on the same product types, like consumer electronics. Since Web shops use different product representations, it is hard to compare products among different Web shops. Duplicate detection methods aim to solve this problem by identifying the same products in differentWeb shops. In this paper, we focus on reducing the computation time of a state-of-the-art duplicate detection algorithm. First, we construct uniform vector representations for the products. We use these vectors as input for a Locality Sensitive Hashing (LSH) algorithm, which pre-selects potential duplicates. Finally, duplicate products are found by applying the Multi-component Similarity Method (MSM). Compared to original MSM, the number of needed computations can be reduced by 95% with only a minor decrease by 9% in the F1-measure.

C is the dominant programming language for developing embedded software, operating systems, and device drivers. Unlike programs written in managed languages like Java, C programs rely on explicit memory management and are prone to memory leaks. Existing (static or dynamic) detectors only report leaks, but fixing them often requires considerable manual effort by inspecting a list of reported true and false alarms. How to develop on-demand lightweight techniques for automated leak fixing without introducing new memory errors remains challenging. In this paper, we introduce AutoFix, a fully automated leak-fixing approach for C programs by combining static and dynamic program analysis. Given a leaky allocation site reported by a static memory leak detector, AutoFix performs a graph reachability analysis to identify leaky paths on the value-flow slices of the program, and then conducts a liveness analysis to locate the program points for inserting fixes (i.e., the missing free calls) on the identified leaky paths. We have implemented AutoFix in LLVM-3.5.0 and evaluated it using five SPEC2000 benchmarks and three open-source applications. Experimental results show that AutoFix can safely fix all the memory leaks reported by a state-of-the-art static memory leak detector with small instrumentation overhead.

The teaching and learning of operating systems are hampered due to the complex nature of concepts involved. It is necessary not only theoretical studies, but importantly the laboratory practices, which are not always possible due to the lack of appropriate software instruments. This paper presents the NKE, a Nanokernel-based OS developed for ARM microprocessors and oriented to the teaching support for practical activities in operating systems classes. The NKE is developed in C language and has been successfully used in laboratory practices as part of OS and embedded systems classes. The results obtained so far are very exciting, given that the NKE promoted richer teaching and learning experiences, providing to the students a real environment for embedded OS development.

To cluster a data stream is a more challenging task than its regular batch version, having stricter performance constraints. In this paper an approach to this problem is presented, based on WiSARD, a memory-based artificial neural network (ANN) model. This model functioning was reviewed and improved, in order to adapt it to this task. The experimental results obtained support the use of this system for the analysis of data streams in an informative way.

Today, consumers request virtual resources like CPU, RAM, disk (etc.) supplied by the service providers (like Amazon) and they pay on a "pay-as-you-go" basis. Generally, the supervisors adopt virtualization technologies, which optimize resources usage and limit the operating cost. The virtualization technologies are classified in two categories. The first one concerns the heavy virtualization. Each virtual machines (VM) emulates hardware and embeds its own operating system (OS) that is completely isolated from the host OS. The second one concerns the light virtualization, which is based on the management of containers. The containers share the host OS kernel [5] while ensuring isolation. In this paper, we benchmark the performance and the energy consumption of an infrastructure that is based on the software Hadoop regarding the two technologies of virtualization. At first, we will identify the points to be improved concerning Hadoop performances and then we will reduce the deployment cost on the cloud. Second, the Hadoop community finds an in-depth study of the resources consumption depending on the environment of deployment. Our experiments are based on the comparison of the Docker technology (light virtualization) and VMware technology® (heavy virtualization). We come to the point that in most experiments the light technology offers better performances in completion time of workloads and it is more adapted to be used with the Hadoop software.

Large set cardinality estimators and other streaming oriented operations are the cornerstone of big data processing. Cardinality estimators combined with in-memory based storage systems provide a fast framework for keeping valuable application data easily queryable and maintanable. This has a plethora of applications. For instance, a common use case is to maintain a number of counters for monitoring application statistics for real time dashboard purposes. Another such case is large set size estimation for big data systems in internal operations like counting. In this paper is addressed the issue of scaling the computation of a cardinality estimator in the presence of node failures in a distributed setting. Moreover, for the proposed estimation technique eventual consistency is proved, which is adequate for most cases in distributed applications. To the best of the authors knowledge, this functionality is not currently provided by commonly used commercial and open source systems. Additionally, the proposed approach is generic enough to be applied to other algorithms, which can help build a basic framework for more complex operations in the big data field. We demonstrate this with graph metric calculation applications in the large scale biodata mining field.

Automated program repair is a promising way to reduce costs on program debugging dramatically. Some repair techniques with genetic algorithm have been proposed, and they were able to fix several dozen of actual bugs in open source software. However, existing techniques occasionally take a long time to generate a repaired version of a given program. The dominant factor for that is generating so many programs that do not pass given test cases. In this research, we are trying to generate a repaired program, which passes all the test cases, in less time. Our key idea is using code similarity to select code lines to be inserted into a given program. More concretely, we propose to select code lines in code regions similar to the faulty code regions. In existing techniques, code lines for insertion are randomly selected from a given program. Currently, we are still in an early stage of this research. In this paper, we report some promising results of our pilot study, which show that using code similarity is very effective to generate repaired programs in less time.

Built-in data structures are a key contributor to the performance of dynamic languages. Record data structures, or records, are one of the common advanced, but not easily optimizable built-in data structures supported by those languages. Records may be used in an object-oriented fashion or to implement object orientation itself. In this paper, we analyze how records are used in different applications in the Scheme dialect Racket. Based on the data obtained, we suggest the application of existing optimization techniques for records and devise a new one for immutable boolean fields. Most of them can be applied to a wide range of record implementations in dynamic languages. We apply these optimizations to records in Pycket, an implementation of Racket. With one exception, microbenchmarks show a two-to ten-fold speed-up of our implementation over plain Racket.

As the era of Big-data has risen, the importance of big data technologies is also increasing day by day. Especially, Hadoop has become a critical part of the overall Big-data system because of its ability to store, process, and analyze thousands of terabytes of data. A major issue for supporting high performance on Hadoop is managing the growth of data while satisfying high storage I/O request. Hadoop's overall performance is largely influenced by the storage input/output(I/O). However, storage I/O technologies are still very limited. Therefore, now more than ever, studies on improving storage I/O on a distributed file system of Hadoop(HDFS) have been gaining popularity. To this end, latest trend in storage systems is to utilize hybrid storage devices. However, it is not easy to use the information of heterogeneous storage devices in HDFS. This is because, when reading data, HDFS is unable to exploit such heterogeneous storage type information yet. In this paper, we propose a hybrid block-selection method on the HDFS, we consider the storage type such as SSD and HDD when reading data. Using this method, the Hadoop Eco System utilizes the high SSD bandwidth by priority. As a result, we certainly improve the Hadoop Eco System overall performance. In the experiments, we demonstrated that our new method efficiently reduced the execution time of select count(*) query and TPC H benchmark up to 22% and 30% on average.

This paper presents an empirical study of exception handling strategies in Java libraries. The study conducts an integrated analysis of exception flows and handler actions from Java libraries with the aim to understand the impact of adopted exception handling strategies from the perspective of libraries' users. We extended an existing static analysis tool to identify exception flows in software libraries and collected data from the eight most downloaded Java libraries in Maven repository. After that, manual analysis was performed to categorize the tailored handler actions for each exception handler. Our results show that a high number of uncaught runtime exceptions and subsumption handlers were applied in some libraries. We also investigated the community anti-patterns implemented by handler actions in exception flows. Our results reveal the need to have automated support to allow the integrated analysis of exception flows and their handler actions explicitly.

Lack of trust and transparency are among the main reasons hindering adoption of cloud computing. Users in fact can inspect neither their applications nor the treatment of their data, and have little or no guarantees about their security. In this context, there is a pressing need for assurance techniques supporting some key properties of cloud services and applications. Cloud security certification is a major assurance technique that has been proposed to increase cloud security, trust, and transparency. However, certification is a tedious, costly, and time-consuming process for the provider that wants to certify one of its services/applications. In this paper, we propose a test-based security certification framework for the cloud implementing a certification process and a cloud engineering methodology based on it, which supports providers in the design and development of ready-to-be-certified services/applications.

This paper tackles the problem of estimating the volume of social media posts (e.g., tweets) that pertain to a particular topic. This task differs from related filtering and event detection applications in that the filtered content isn't meant for direct human consumption, but rather we are primarily interested in estimating the cardinality of relevant posts. We present a simple yet effective technique for generating and curating keywords to create what we call "overlap filters", which can be applied to a stream of social media posts. Our approach leverages human labeling and thus a crucial element of the work involves minimizing the cost of human computation. On top of a "day zero" cold start algorithm, we describe a number of optimizations that take advantage of history to further reduce labeling costs. Experimental results show that our overlap filters produce accurate volume estimates at low costs, and our method is simple enough to deploy in practice.

The conventional application of learning to rank algorithms tends to use as many training queries as possible to leverage the benefit brought by a large amount of labeled data. However, the use of all training queries available may also include the low quality ones, and consequently, degrades the retrieval effectiveness, hence the need for selecting training queries. Existing training query selection approaches incorporate a variety of indirect indicators of the training queries such as the query performance predictors and the relevance scores into a classification or regression based approach. In this paper, we propose to select training queries by the direct measurement of the training query quality, namely the resulting retrieval performance on a subset of validation queries, instead of the indirect indicators that may not have strong correlations with a training query's quality. Evaluation on the standard LETOR 4.0 dataset shows that our proposed approach outperforms the state-of-the-art baselines.

The identification of relevant information in large text databases is a challenging task. One of the reasons is human beings' limitations in handling large volumes of data. A common solution for scavenging data from texts are word clouds. A word cloud illustrates word usage in a document by resizing individual words in documents proportionally to how frequently they appear. Even though word clouds are easy to understand, they are not particularly efficient, because they are static. In addition, the presented information lacks context, i.e., words are not explained and they may lead to radically erroneous interpretations. To tackle these problems we developed VCloud, a tool that allows the user to interact with word clouds, therefore allowing informative and interactive data exploration. Furthermore, our tool also allows one to compare two data sets presented as word clouds. We evaluated VCloud using real data about the evolution of gastritis research through the years. The papers indexed by Pubmed related to this medical context were selected for visualization and data analysis using VCloud. A domain expert explored these visualizations, being able to extract useful information from it. This illustrates how can VCloud be a valuable tool for visual text analytics.

In this paper, we present two efficient tree-based algorithms for mining recent WFIs (RWFIs), which consider both item weights and the recency of patterns. A novel tree called the recent weighted frequent (RWF)-tree and a sorted downward closure property of RWFIs are proposed. Moreover, two data structures, named element (E)-table and RWFtable, are designed to store the compact information. The RWFI-Mine and its improved RWFI-EMine algorithms are proposed to discover RWFIs in a recursive way and without candidate generation. Experiments show that the proposed algorithms outperform both the traditional WFIM algorithms and the state-of-the-art algorithm for mining RWFIs.

Global demographics show a steady growth in the population of cognitively impaired patients. Consequently, the aging societies are looking to adopt smart technologies in healthcare services to early detect the onset of cognitive decline. These technologies include advanced methods that enable continuous in-house monitoring of the elderly's activities through unobtrusive sensing for recognizing abnormal behaviors that may indicate cognitive deficits. In an earlier work, we proposed a technique to detect the early symptoms of cognitive impairment by continuously monitoring the daily behavior of an elderly at home to recognize fine-grained abnormal behaviors. Recognition was based on rule-based descriptions of anomalies manually defined by domain experts. However, those rules strongly depend on the specific home environment, on the used sensors, and on the particular habits of the elderly; hence, their definition is time-expensive, and rules are not seamlessly portable to different environments. In order to address this issue, in this paper we propose a method to automatically learn the rule-based definitions of behavioral anomalies. In particular, we use a rule induction algorithm to infer those rules based on a dataset of activities and anomalies. We evaluated our method using a dataset of activities and abnormal behaviors carried out in an instrumented smart home. Our method achieves high precision and recall values, around 0.97 and 0.85, respectively, which are comparable to those obtained using manually-defined rules.

SimRank is a well-known link-based similarity measure that can be applied on a citation graph to compute similarity of academic literature data. The intuition behind SimRank is that two objects are similar if they are referenced by similar objects. SimRank has attracted a growing interest in the areas of data mining and information retrieval recently. Despite of the current success of SimRank, it has some problems that negatively affect its effectiveness in similarity computation. In this paper, we discuss the three existing problems of SimRank, present SimRank variants that have been proposed to solve those problems, and evaluate the effectiveness of SimRank and its variants in similarity computation for academic literature data by conducting extensive experiments on a real-world dataset.

The large scale and dynamic behavior of cyber-physical systems (CPS) require great effort at the middleware level. Middleware lies at the architectural point where low-level communication and execution meet the horizontal control and orchestration accross nodes and systems. Most realtime research on distributed CPS concentrates on off-line schedulability algorithms for systems with static structure and make heavy assumptions on the network predictability, neglecting the role of the middleware layer. In this paper, we explore the usage of middleware technology to support dynamic and timely execution in CPS, with a middleware design that considers the time requirements of the distributed processes or units. We have carried out a specific implementation that validates or approach, showing a stable service time for large numbers of clients, over an actual network that uses Internet protocols for transport and routing.

To cope with large data sets, distributed data stores partition their data across servers. However, real-world systems usually do not provide useful transactional semantics for operations accessing multiple partitions due to the delays involved in achieving multi-partition consistency. Read Atomic Multi-Partition (RAMP) transactions have recently been proposed as efficient light-weight multi-partition transactions that guarantee read atomicity: either all updates or no updates of a transaction are visible to other transactions. In this paper we formalize RAMP transactions in rewriting logic and perform model checking verification of key properties using the Maude tool. In particular, we develop detailed formal models---and formally analyze---a number of extensions and optimizations of RAMP that are only briefly mentioned by the RAMP developers.

In this paper, we investigate an optimization scheme for extreme learning machine (ELM) regression, named OELR, to overcome the limitation of ELM that it may lead to overfitting on large training data sets. OELR amounts to minimization of e-insensitive loss and minimization of the norm of the output weights of single hidden layer feedforward networks (SLFNs). Compared to support vector regression (SVR), OELR has less optimization constraints. Empirical results on the benchmark data sets show that the competitive performance of the OELR over the state-ofthe-art regression learning algorithms.

In this paper, we explore how legacy software logic can be re-used in a new context-of-use. In effect, oftentimes existing software is required to evolve or to be integrated into a new complex environment. Technological improvements, new usages, regulations or financial constraints are such reasons for evolution. Parts of the legacy functions are still useful and it is certainly challenging to integrate such code, as legacy systems were designed and implemented for a specific purpose in the past. Nevertheless, they are an expensive investment and transforming them to allow modification and integration with other actors would not only save high investment, but also enable future modifications. We consider that an adequate technique to drive the integration of legacy systems into self-adaptive systems is to transform first the legacy code into a multi-agent system (MAS), from which adaptation within the system and communication with external actors is easier to attain. We refer to this process as "adaptization". We use as an adaptation proxy conceptually intelligent agents conforming to the Belief, Desire, Intention (BDI) model, one of the tools of Agent-Oriented Software Engineering (AOSE). This proxy permits to understand the legacy system in terms of goals to achieve and to address adaptiveness as a goal selection problem at run-time (based on context), thus abstracting away the current implementation to a high level goal-achievement mechanism. We propose KOALA, a novel stepwise methodology towards adaptization.

Today's Web Applications (WAs) are complex multi-user and multi-tenant software systems, used by users with different roles and often developed to support and manage complex business processes. Due to the changing nature of such processes, WAs need to be easily and quickly modified, to be adapted and aligned to the processes they support. In recent years, Model Driven Engineering (MDE) approaches have been used to support the development and the evolution of WAs. However, the definition of appropriate MDE approaches for the development of flexible process-centric WAs is still limited. In particular, flexible workflow models have never been integrated with the models used in MDE approaches to develop this type of applications. This paper proposes an MDE approach for the development and the evolution of flexible process-centric WAs that integrates four MDE metamodels used to represent the main components of a WA with the metamodel of Declare, a declarative language to model business processes. A case study, carried out to validate the feasibility, the correctness and the effectiveness of the proposed approach is presented and discussed.

This paper presents the application of shape distributions to diagnose lung nodules in computerized tomography images. Our study uses the nodule surface and also interior surfaces generated by their voxel's joint attributes and distribution. The surfaces are captured using 3D Alpha Shapes algorithm. All surfaces are characterized using shape distributions D1, D2, D3, D4 and A3 in order to represent shape behavior based on statistical distribution of their points in a 3D contour. We evaluate experiments with these features using Support Vector Machines and the combination of all descriptors proving above of 90% of accuracy. This indicates a promising feature to distinguish malignant from benign nodules for lung cancer diagnosis.

Transactional memory is an abstraction where concurrent memory accesses are grouped into atomic transactions, similar to database transactions. There are many advantages in using this model instead of conventional ones, such as ease of programming: programmers simply mark code where race conditions may occur and the transactional system takes care to ensure the correctness of the results. This model has proven to be promising for Symmetric Multi-Processing (SMP) machines, however few studies in this area are focused on distributed architectures. These architectures are extremely important nowadays, as they compose a large portion of high performance computing platforms, and because of the trend of more and more computing devices communicating with each other. The main objective of this paper is to propose a domain specific language embedded in Java, for implementing memory transactions that can involve local and distributed objects on a network. This goal was approached both in the language level, allowing the programmer to define composable transactional actions, and in transactional system level, supporting the implementation of the language's abstractions. To validate our model, preliminary measurements of a prototype implementation of the system described here are presented.

Fixing a non-deadlock concurrency bug is a difficult job that sometimes introduces additional bugs and requires a long time. To overcome this difficulty and efficiently perform fixing jobs, engineers should have broad knowledge of various fix patterns, and the ability to select the most proper one among those patterns based on quantitative data gathered from real-world bug databases. In this paper, we provide a real-world characteristic study on the fixes of non-deadlock concurrency bugs to help engineers responsible for program maintenance. In particular, we examine various fix patterns and the factors that influence the selection of those patterns with respect to the preexistence of locks and failure types. Our results will provide useful information for engineers who write bug patches, and researchers who study efficient testing and fixing techniques.

The widespread of applications like e-commerce and recommendation systems requires the use of efficient customization techniques and user preferences handling. In database community a lot of research on this topic has been focused on extending standard SQL with preference facilities in order to provide personalized query answering. More specifically, user preferences are an essential ingredient of personalized database applications. In this paper, we consider the conditional preference queries (cp-queries) of CPrefSQL query language where user preferences are specified by a set of conditional rules. We propose new algorithms based on a technique we called preference partition that outperform the state-of-the-art algorithms for CPrefSQL preference operators significantly decreasing the number of scans over database.

machines are both theoretical models used to study language properties and practical models of language implementations. As with all language implementations, abstract machines are subject to security violations by the context in which they reside. This paper presents the implementation of an abstract machine for ML that preserves the abstractions of ML, in possibly malicious, low-level contexts. To guarantee this security result, we make use of a low-level memory isolation mechanism and derive the formalisation of the machine through a methodology, whose every step is accompanied by formal properties that ensure that the step has been carried out properly. We provide an implementation of the abstract machine and analyse its performance.

Product line architecture (PLA) captures the architectural commonality and variability among products of a product family. Existing PLA modeling approaches are limited in the sense that (1) it is often difficult to relate a product line feature to its implementation in the PLA, and (2) variation points in the PLA have to be manually developed and maintained. In this paper, we present a novel PLA modeling approach and a toolset called ArchFeature that addresses these two challenges. ArchFeature integrates PLA and feature specification in a single monolithic architecture model. It includes a graphical modeling environment that can (1) automatically capture, maintain, and visualize the feature-PLA relationship, (2) encapsulate variability modeling from the user, and (3) support automatic derivation of architecture instances from the PLA. ArchFeature is an Eclipse plugin integrated in ArchStudio, an Eclipse-based architecture development platform. We assessed its usability and effectiveness in a case study by using it to develop a full-featured architecture model for an open-source software system, Apache Solr.

Process aware information system (PAIS) is important in the recent business environment. Developments of PAIS need to consider contexts about technical and business elements. They are needed to develop PAIS effectively (e.g. monitoring environment and constructing adequate business process). Process mining is an important method for analyzing a business environment and utilizing PAIS development and improvement. LTL checking is an important method for checking a specific property to be satisfied with business processes, but correctly writing formal language like LTL is difficult. In this paper, we use LTL checking and prediction based on decision-tree learning for checking goal achievement, false detection and oversight detection. It helps writing properly LTL formula for representing the correct goal property. We conducted a case study using a real life log of traffic fine management process in Italy.

Mobile devices have become more powerful and are increasingly integrated in the everyday life of people; from playing games, taking pictures and interacting with social media to replacing credit cards in payment solutions. Some actions may only be appropriate in some situations, so the security of a mobile device is therefore increasingly linked to its context, such as its location, surroundings (e.g. objects in the immediate environment) and so on. However, situational awareness and context are not captured by traditional security models. In this paper, we examine the notion of Device Comfort, which captures a device's ability to secure and reason about its environment. Specifically, we study the feasibility of two device comfort calculation methods we proposed in previous work. We do trace driven simulations based on a large body of sensed data from mobile devices in the real world. This allows us to analyze the influence of the context on the comfort level of the device in different perceived contexts in the real world. Moreover, to demonstrate the utility of our device comfort calculation methods, we apply it to comfort-based access control for mobile devices. We present the policy enforcement framework and show how to enforce our two methods using an existing security policy specification language.

Elasticity is a key feature in the cloud while High-Availability (HA) is one of the challenges. Recently, an architecture has been proposed for managing HA in the cloud using the SA Forum middleware and an Elasticity Engine for triggering resource provisioning and de-provisioning at the application level while preserving HA. This Elasticity Engine requires the monitoring of the application service level workload in contrast to the monitoring of VM workload as done usually. In this paper we propose an approach for the monitoring of HA applications at the service level and its integration with the Elasticity Engine. The approach allows for the monitoring of application processes in the traditional manner and for the mapping of this workload to their combined service level workload. Resource usages are aggregated and mapped to the service level workload using a distributed client-server architecture. The approach allows for distinguishing between the different HA states, active and standby, a component can be assigned at runtime and it adapts to the situations where switchovers happen under the control of the SA Forum middleware due to failures for example.

The main drawback regarding agriculture commodities such as soybeans is that they must be uniform in quality considering the companies that produce and sell it. Thus, to reach such requirements it is necessary to establish strict parameters and quality control processes. The most important test to accomplish this task is based on the seed vigor definition. However, the great majority of seed vigor analysis is performed by a human specialist leading to an extremely tiresome and subjective approach, highly susceptible to failures, as well as, certain types of deliberate adulteration, based on monetary interests. In order to deal with this problem, the present paper proposed an image analysis framework for effective classification of seeds according to their vigor. The experiments performed showed that the proposed framework presented several notable contributions to the soybean vigor definition process, reaching up to 81% of classification accuracy. Moreover, it not only improves in a great extent the entire process from planting to harvesting, but also enables to automate and accelerate it, as well as, can be used as a counterevidence of the specialist classification.

Software Defined Network(SDN) is a promising technological advancement in the networking world. It is still evolving and security is a major concern for SDN. In this paper we proposed policy based security architecture for securing the SDN domains. Our architecture enables the administrator to enforce different types of policies such as based on the devices, users, location and path for securing the communication in SDN domain. Our architecture is developed as an application that can be run on any of the SDN Controllers. We have implemented our architecture using the POX Controller and Raspberry Pi 2 switches. We will present different case scenarios to demonstrate fine granular security policy enforcement with our architecture.

Spatiotemporal data are often expressed in terms of granularities to indicate the measurement units of the data. A granularity system usually consists of a set of granularities that share a "common refined granularity" (CRG) to enable granular comparison and data conversion within the system. However, if data from multiple granularity systems needs to be used in a unified application, it is necessary to extend the data conversion and comparison within a granularity system to those for multiple granularity systems. This paper proposes a formal framework to enable such an extension. The framework involves essentially some preconditions and properties for verifying the existence of a CRG and unifying conversions of incongruous semantics, and supports the approach to integrate multiple systems into one so as to process granular data interoperation across systems just like in a single system.

In the Android community, a commonly held belief is that rooted devices are more at-risk than their standard counterparts. Many applications include "protections" that disable certain functionality in the presence of a "rooted" device. In this paper, we carry out a detailed quantitative analysis on 6.14 million Android devices comparing rooted and non-rooted devices across a broad range of characteristics. Specifically our study focuses on measuring and analyzing various behavioral differences between rooted and non-rooted devices, and how such differences impact the security of rooted devices, e.g. making them more susceptible to malware or at higher risk. We further leverage our insights and implement a machine learning system to determine whether a device is rooted based on a comprehensive set of features with an accuracy of approximately 90%.

Image captions and keywords are the semantic descriptions of the dominant visual content features in a targeted visual scene. Traditional image keywords extraction processes involves intensive data- and knowledge-level operations by using computer vision and machine learning techniques. However, recent studies have shown that the gap between pixel-level processing and the semantic definition of an image is difficult to bridge by counting only the visual features. In this paper, augmented image semantic information has been introduced through harnessing functions of online image search engines. A graphical model named as the “Head-words Relationship Network” (HWRN) has been devised for tackling the aforementioned problems. The proposed algorithm starts from retrieving online images of similarly visual features from the input image, the text content of their hosting webpages are then extracted, classified and analysed for semantic clues. The relationships of those “head-words” from relevant webpages can then be modelled and quantified using linguistic tools. Experiments on the prototype system have proven the effectiveness of this novel approach. Performance evaluation over benchmarking state-of-the-art approaches has also shown satisfactory results and promising future applications.

Web applications are often exposed to unpredictable workloads. Therefore, they must ensure elasticity, which is addressed by hosting these applications on cloud computing infrastructures. In presence of elasticity, the application and its service layers may run adaptation tasks, which assist them in behaving in an elastic manner. These tasks may introduce errors. Therefore, the application must be tested when the adaptation tasks run. Some adaptation tasks may run only during specific elasticity behavior, and it is difficult to achieve specific behaviors without controllability. Therefore, in this paper, we propose an approach that controls the elasticity of Web applications according to requirements. It is the first step towards an approach to test elasticity applications through elasticity.