Abstract
IDEs are environments specialized in support during the development of programs. They contain several utilities to code, run, debug, and deploy programs quickly. However, they do not provide the automatic assessment of programming exercises, which is required in both learning and competitive programming environment. Therefore, IDEs are often underestimated in these contexts and replaced by basic code editors. Yet, IDEs have unique features which are essential for programmers, such as the debugger or the package explorer. This paper presents Raccode, a plugin for assessment of programming exercises in Eclipse. This plugin integrates with Mooshak to combine the diverse capabilities of an IDE, like Eclipse, with the automatic evaluation of exercises, clarification requests, printouts, balloons, and rankings. It can be used both in competitive and learning environments. The paper describes Raccode, its concept, architecture and design. © André Silva, José Paulo Leal, and José Carlos Paiva.

Abstract

Abstract
In ubiquitous streaming data sources, such as sensor networks, clustering nodes by the data they produce gives insights on the phenomenon being monitored. However, centralized algorithms force communication and storage requirements to grow unbounded. This article presents L2GClust, an algorithm to compute local clusterings at each node as an approximation of the global clustering. L2GClust performs local clustering of the sources based on the moving average of each node's data over time: the moving average is approximated using memory-less statistics; clustering is based on the furthest-point algorithm applied to the centroids computed by the node's direct neighbors. Evaluation is performed both on synthetic and real sensor data, using a state-of-the-art sensor network simulator and measuring sensitivity to network size, number of clusters, cluster overlapping, and communication incompleteness. A high level of agreement was found between local and global clusterings, with special emphasis on separability agreement, while an overall robustness to incomplete communications emerged. Communication reduction was also theoretically shown, with communication ratios empirically evaluated for large networks. L2GClust is able to keep a good approximation of the global clustering, using less communication than a centralized alternative, supporting the recommendation to use local algorithms for distributed clustering of streaming data sources.

Abstract
FLUX is a platform for dynamically reconfigurable crowd-sensing using mobile devices like smartphones and tablets, programmed under a notion of region-based sensing. Each region is defined by a set of physical constraints that determine the sensing scope, e.g., based on device position or other environmental variables, plus a set of periodic tasks that perform the actual sensing. The resulting behavior is inherently dynamic: as a device's state changes, e.g., moves in space, it enters and/or leaves different regions, thereby changing the set of active tasks; moreover, regions can be added, deleted, and reprogrammed on-the-fly. FLUX makes use of a domain-specific language for sensing tasks that is compiled into abstract bytecode, later executed by a low-footprint virtual machine within a device, guaranteeing runtime safety by construction. For region/task dissemination, FLUX employs a broker that holds a changeable region configuration plus gateways that mirror the configuration throughout different network access points to which devices connect. Sensing data is streamed by devices to gateways and then back to the broker. Live or archived data streams are in turn fed by the broker to data-processing clients, which interface with the broker using a publish/subscribe API. We conducted two case-study experiments illustrating FLUX: a single-region deployment to monitor WiFi signal quality, and a multi-region deployment to monitor noise, temperature, and places-of-interest based on device movement.

Abstract
One of the main advantages of Prolog is its potential for the implicit exploitation of parallelism and, as a high-level language, Prolog is also often used as a means to explicitly control concurrent tasks. Tabling is a powerful implementation technique that overcomes some limitations of traditional Prolog systems in dealing with recursion and redundant subcomputations. Given these advantages, the question that arises is if tabling has also the potential for the exploitation of concurrency/parallelism. On one hand, tabling still exploits a search space as traditional Prolog but, on the other hand, the concurrent model of tabling is necessarily far more complex, since it also introduces concurrency on the access to the tables. In this paper, we summarize Yap's main contributions to concurrent tabled evaluation and we describe the design and implementation challenges of several alternative table space designs for implicit and explicit concurrent tabled evaluation that represent different tradeoffs between concurrency and memory usage. We also motivate for the advantages of using fixed-size and lock freedata structures, elaborate on the key role that the engine's memory allocator plays on such environments, and discuss how Yap's mode-directed tabling support can be extended to concurrent evaluation. Finally, we present our future perspectives toward an efficient and novel concurrent framework which integrates both implicit and explicit concurrent tabled evaluation in a single Prolog engine.

Abstract
Many real-world phenomena exhibit both relational structure and uncertainty. Probabilistic Inductive Logic Programming (PILP) uses Inductive Logic Programming (ILP) extended with probabilistic facts to produce meaningful and interpretable models for real-world phenomena. This merge between First Order Logic (FOL) theories and uncertainty makes PILP a very adequate tool for knowledge representation and extraction. However, this flexibility is coupled with a problem (inherited from ILP) of exponential search space growth and so, often, only a subset of all possible models is explored due to limited resources. Furthermore, the probabilistic evaluation of FOL theories, coming from the underlying probabilistic logic language and its solver, is also computationally demanding. This work introduces a prediction-based pruning strategy, which can reduce the search space based on the probabilistic evaluation of models, and a safe pruning criterion, which guarantees that the optimal model is not pruned away, as well as two alternative more aggressive criteria that do not provide this guarantee. Experiments performed using three benchmarks from different areas show that prediction pruning is effective in (i) maintaining predictive accuracy for all criteria and experimental settings; (ii) reducing the execution time when using some of the more aggressive criteria, compared to using no pruning; and (iii) selecting better candidate models in limited resource settings, also when compared to using no pruning. © Joana Côrte-Real, Anton Dries, Inês Dutra, and Ricardo Rocha; licensed under Creative Commons License CC-BY