Clone detection provides insight about replicated fragments in a code base. With the rise of multi-language code bases, new techniques addressing cross-language code clone detection enable the analysis of polyglot systems. Such techniques have not yet been applied to the mobile apps' domain, which are naturally polyglot. Native mobile app developers must synchronize their code base in at least two different programming languages. App synchronization is a difficult and time-consuming maintenance task, as features can rapidly diverge between platforms, and feature identification must be performed manually. The end goal of this work is to provide an analysis framework to reduce the impact of app synchronization. A first step in this direction consists in a structural algorithm for cross-language clone detection, called Out of Step, exploiting the idea behind enriched concrete syntax trees. Such trees are used as a common intermediate representation built from programming languages' grammars, to detect similarities between app code bases. Our technique finds code similarities with over 80% for the evaluation of language features, where Type 1-3 clones are manually injected for the analysis of both single- and cross-language cases for Kotlin and Dart. We validate the feasibility and correctness of our approach through the evaluation of the main language constructs for Kotlin and Dart. To validate the effectiveness we use a first case study detecting clones between 12 sorting algorithms across Kotlin and Dart, identifying clone similarities with a precision between 67% and 95%. Finally, we use a corpus of 144 mobile apps implemented in Kotlin and Dart, correctly identifying code similarities for the full application logic.

Reinforcement Learning (RL) is being increasingly used to learn and adapt application behavior in many domains, including large-scale and safety critical systems, as for example, autonomous driving. With the advent of plug-n-play RL libraries, its applicability has further increased, enabling integration of RL algorithms by users. We note, however, that the majority of such code is not developed by RL engineers, which as a consequence, may lead to poor program quality yielding bugs, suboptimal performance, maintainability, and evolution problems for RL-based projects. In this paper we begin the exploration of this hypothesis, specific to code utilizing RL, analyzing different projects found in the wild, to assess their quality from a software engineering perspective. Our study includes 24 popular RL-based Python projects, analyzed with standard software engineering metrics. Our results, aligned with similar analyses for ML code in general, show that popular and widely reused RL repositories contain many code smells (3.95% of the code base on average), significantly affecting the projects’ maintainability. The most common code smells detected are long method and long method chain, highlighting problems in the definition and interaction of agents. Detected code smells suggest problems in responsibility separation, and the appropriateness of current abstractions for the definition of RL algorithms.

Static analyses, as points-to analysis, are useful to determine and assure different properties about a program, such as security or type safety. While existing analyses are effective in programs restricted to static features, precision declines in the presence of dynamic language features, and even further when the system behavior changes dynamically. As a consequence, improved points-to sets algorithms taking into account such language features and uses are required. In this paper, we present and extension of the point-to sets analysis to incorporate the language abstractions introduced by context-oriented programming adding the capability for programs to adapt their behavior dynamically to the system’s execution context. To do this, we extend WALA to detect the context-oriented language abstractions, and their representation within the system, to capture the dynamic behavior, in the particular case of the Context Traits JavaScript language extension. To prove the effectiveness of our extension, we evaluate the precision of the points-to set analysis with respect to the state of the art, over a set of context-oriented programs taken from the literature.

Self-adaptive software systems continuously adapt in response to internal and external changes in their execution environment, captured as contexts. The Context-oriented Programming (COP) paradigm posits a technique for the development of self-adaptive systems, capturing their main characteristics with specialized programming language constructs. In COP, adaptations are specified as independent modules that are composed in and out of the base system as contexts are activated and deactivated in response to sensed circumstances from the surrounding environment. However, the definition of adaptations, their contexts and associated specialized behavior, need to be specified at design time. In complex cyber physical systems this is intractable, if not impossible, due to new unpredicted operating conditions arising. In this paper, we propose Auto-COP, a new technique to enable generation of adaptations at run time. Auto-COP uses Reinforcement Learning (RL) options to build action sequences, based on the previous instances of the system execution (for example, atomic system actions enacted by human operators). Options are further explored in interaction with the environment, and the most suitable options for each context are used to generate the adaptations, exploiting COP abstractions. To validate Auto-COP, we present two case studies exhibiting different system characteristics and application domains: a driving assistant and a robot delivery system. We present examples of Auto-COP to illustrate the types of circumstances (contexts) requiring adaptation at run time, and the corresponding generated adaptations for each context. We confirm that the generated adaptations exhibit correct system behavior measured by domain-specific performance metrics (e.g., conformance to specified speed limit), while reducing the number of required execution/actuation steps by a factor of two showing that the adaptations are regularly selected by the running system as adaptive behavior is more appropriate than the execution of atomic actions. Therefore, we demonstrate that Auto-COP is able to increase system adaptivity by enabling run-time generation of new adaptations for conditions detected at run time, while retaining the modularity offered by COP languages, and reducing the upfront specification required by system developers.

Learning basic concepts before complex ones is a natural form of learning. This paper addresses the specific problem of identifying concept prerequisites to inform about the basic knowledge required to understand a particular concept. Briefly, given a target concept c, the goal is to (a) find candidate concepts in a Knowledge Graph (KG) that serve as possible prerequisite for c; and, (b) evaluate the prerequisite relation between the target and candidates concepts via a supervised learning model. Our approach explores the DBpedia Knowledge Graph and its semantic relations to find candidate concepts as well as a pruning step to reduce the candidate concept set. Finally, we employ supervised learning algorithms to evaluate and generate a list of prerequisites for the target concept. A ground truth created based on expert knowledge is used to validate our approach, exhibiting promising results with a precision varying between 83% and 92.9%.

MOTIVATION: Accurate detection, genotyping and downstream analysis of genomic variants from high-throughput sequencing data are fundamental features in modern production pipelines for genetic-based diagnosis in medicine or genomic selection in plant and animal breeding. Our research group maintains the Next-Generation Sequencing Experience Platform (NGSEP) as a precise, efficient and easy-to-use software solution for these features. RESULTS: Understanding that incorrect alignments around short tandem repeats are an important source of genotyping errors, we implemented in NGSEP new algorithms for realignment and haplotype clustering of reads spanning indels and short tandem repeats. We performed extensive benchmark experiments comparing NGSEP to state-of-the-art software using real data from three sequencing protocols and four species with different distributions of repetitive elements. NGSEP consistently shows comparative accuracy and better efficiency compared to the existing solutions. We expect that this work will contribute to the continuous improvement of quality in variant calling needed for modern applications in medicine and agriculture. AVAILABILITY AND IMPLEMENTATION: NGSEP is available as open source software at http://ngsep.sf.net. SUPPLEMENTARY INFORMATION: Supplementary data are available at Bioinformatics online.

Code clones mostly have been proven harmful for the development and maintenance of software systems, leading to code deterioration and an increase in bugs as the system evolves. Modern software systems are composed of several components, incorporating multiple technologies in their development. In such systems, it is common to replicate (parts of) functionality across the different components, potentially in a different programming language. Effect of these duplicates is more acute, as their identification becomes more challenging. This paper presents LICCA, a tool for the identification of duplicate code fragments across multiple languages. LICCA is integrated with the SSQSA platform and relies on its high-level representation of code in which it is possible to extract syntactic and semantic characteristics of code fragments positing full cross-language clone detection. LICCA is on a technology development level. We demonstrate its potential by adopting a set of cloning scenarios, extended and rewritten in five characteristic languages: Java, C, JavaScript, Modula-2 and Scheme.

The identification of prerequisite relationships among concepts is a fundamental step toward the organization of knowledge for educational purposes. In the context of a learning process, simplest concepts that are requirements to understand and address more complex concepts should be presented first. Therefore, the identification of prerequisite relationships is a fundamental step for effective course design and automatic learning path generation systems. Although there have been recent advances in machine learning methods for the automatic identification of prerequisite relationships between concepts, little research has been done on whether these automatic strategies can be extended to establish precedence relationships among learning resources. The precedence relation between two learning resources establishes which of the resources must be presented first. In this paper, we approach this problem and propose a strategy to identify the precedence relation. Given two learning resources our strategy analyzes prerequisites among the concepts addressed by the learning resources to estimate the precedence relation. A set of 1588 pairs of learning resources extracted from MOOCs refined by human experts is used to evaluate the strategy. The experimental results show that it is possible to identify the precedence relation between learning resources through the automatic identification of prerequisite relationships between concepts.

Mobile, pervasive computing environments respond to users’ requirements by providing access to and composition of various services over networked devices. In such an environment, service composition needs to satisfy a request’s goal, and be mobile-aware even throughout service discovery and service execution. A composite service also needs to be adaptable to cope with the environment’s dynamic network topology. Existing composition solutions employ goal-oriented planning to provide flexible composition, and assign service providers at runtime, to avoid composition failure. However, these solutions have limited support for complex service flows and composite service adaptation. This paper proposes a self-organizing, goal-driven service model for task resolution and execution in mobile pervasive environments. In particular, it proposes a decentralized heuristic planning algorithm based on backward-chaining to support flexible service discovery. Further, we introduce an adaptation architecture that allows execution paths to dynamically adapt, which reduces failures, and lessens re-execution effort for failure recovery. Simulation results show the suitability of the proposed mechanism in pervasive computing environments where providers are mobile, and it is uncertain what services are available. Our evaluation additionally reveals the model’s limits with regard to network dynamism and resource constraints.

The development of self-adaptive systems requires the definition of the parts of the system that will be adapted, when such adaptations will take place, and how these adaptations will interact with each other. However, foreseeing all possible adaptations and their interactions is a difficult task, opening the possibility to inconsistencies or erroneous system behavior. To avoid inconsistencies, self adaptive systems require a sound programming model that allows to reason about the correctness of the system in spite of its dynamic reconfigurations. This paper presents context Petri nets, a Petri net-based programming model for selfadaptive systems. This model provides a formal definition of adaptations and their interaction, as well as a consistent process for their inclusion in the system. Besides serving as an underlying run-time model to ensure that adaptations and their constraints remain consistent, context Petri nets allow to analyze properties such as reachability, and liveness in the configuration of self-adaptive systems. Context Petri nets thus are a convenient tool to model and analyze the dynamics of self-adaptive systems, both formally and computationally.