Android developers can use both Java and Kotlin programming languages to create their own apps. Such programming languages provide exception handling facilities to improve apps’ robustness (providing means to implement fault-tolerant measures) and maintainability (separating the error-handling code from the regular one). The Android architecture imposes complexity on the way apps handle exceptions, once exceptions may be raised in parts that are not responsible for handling this abnormal situation. A straightforward solution is to send the Exception Notification (EN) to its concerned handler. However, the way developers are using Android’s inter-component communication mechanism to perform EN may lead to well-known exception handling drawbacks related to the usage of error/return code (e.g., decaying of code readability, programmability, and extensibility). To overcome this problem, we propose a pub/sub-based mechanism to perform EN between Android components called R-EventBus. We evaluate R-EventBus through a performance benchmark and by refactoring a set of apps from the F-Droid repository and comparing the original and refactored versions regarding behavior preservation and EN concern diffusion. Our results indicate that R-EventBus shows negligible performance issues, preserves the apps’ behavior, and considerably improves the modularization of EN concern in the refactored apps.

Systems-of-systems are formed by the composition of independently created software components. These components are designed to satisfy their individual requirements, rather than the global requirements of the systems-of-systems. We refer to components that cannot be adapted to meet both individual and global requirements as "defiant" components. In this paper, we propose a "cautious" adaptation approach which supports changing the behaviour of such defiant components under exceptional conditions to satisfy global requirements, while continuing to guarantee the satisfaction of the components' individual requirements. The approach represents both normal and exceptional conditions as scenarios; models the behaviour of exceptional conditions as wrappers implemented using an aspect-oriented technique; and deals with both single and multiple instances of defiant components with different precedence order at runtime. We evaluated an implementation of the approach using drones and boats for an organ delivery application conceived by our industrial partners, in which we assess how the proposed approach help achieve the system-of-systems' global requirements while accommodating increased complexity of hybrid aspects such as multiplicity, precedence ordering, openness and heterogeneity.

Microservices are a new and rapidly growing architectural model aimed at developing highly scalable software solutions based on independently deployable and evolvable components. Due to its novelty, microservice-related discussions are increasing in Q&A websites, such as StackOverflow (SO). In order to understand what is being discussed by the microservice community, this work has applied mining techniques and topic modelling to a manually-curated dataset of 1,043 microservice-related posts from StackOverflow. As a result, we found that 13.68% of microservice technical posts on SO discuss a single technology: Netflix Eureka. Moreover, buzzwords in the microservice ecosystem, e.g., blue/green deployment, were not identified as relevant subjects of discussion on SO. Finally, we show how a high discussion rate on SO may not reflect the popularity of a certain subject within the microservice community.

Code review has been widely acknowledged as a key quality assurance process in both open-source and industrial software development. Due to the asynchronicity of the code review process, the system's codebase tends to incorporate external commits while a source code change is reviewed, which cause the need for rebasing operations. External commits have the potential to modify files currently under review, which causes re-work for developers and fatigue for reviewers. Since source code changes observed during code review may be due to external commits, rebasing operations may pose a severe threat to empirical studies that employ code review data. Yet, to the best of our knowledge, there is no empirical study that characterises and investigates rebasing in real-world software systems. Hence, this paper reports an empirical investigation aimed at understanding the frequency in which rebasing operations occur and their side-effects in the reviewing process. To achieve so, we perform an in-depth large-scale empirical investigation of the code review data of 11 software systems, 28,808 code reviews and 99,121 revisions. Our observations indicate that developers need to perform rebasing operations in an average of 75.35% of code reviews. In addition, our data suggests that an average of 34.21% of rebasing operations tend to tamper with the reviewing process. Finally, we propose a methodology to handle rebasing in empirical studies that employ code review data. We show how an empirical study that does not account for rebasing operations may report skewed, biased and inaccurate observations.

Model extraction allows the automatic construction of behaviour models from an available implementation, which can be fed into existing analysis tools. Even though these models are usually analysed using qualitative properties, many interesting and relevant properties of current systems are related to quantitative aspects, such as the probability of reaching a certain state or how many times a certain task is expected to be executed. In this work, we extend an existing model extraction approach to include probabilistic information. The original approach creates Labelled Transition Systems (LTS) from Java code based on execution traces. The traces are processed by a tool that identifies contexts, which represent abstract states of the system, considering static and dynamic information, producing context traces. We use these context traces to calculate transition probabilities and generate models in the input language of a probabilistic model checker. We evaluate our approach in case studies and demonstrate that, by using context traces rather than simple traces, we produce more accurate models, thereby with probabilistic information closer to the real behaviour of programs, based on their observed traces. We also show how to build models of programs with single and multiple components.

Probabilistic models are useful in the analysis of system behaviour and non-functional properties. Reliable estimates and measurements of probabilities are needed to annotate behaviour models in order to generate accurate predictions. However, this may not be sufficient, and may still lead to inaccurate results when the system model does not properly reflect the probabilistic choices made by the environment. Thus, not only should the probabilities be accurate in properly reflecting reality, but also the model that is being used. In this paper we identify and illustrate this problem showing that it can lead to inaccuracies and both false positive and false negative property checks. We propose state refinement as a technique to mitigate this problem, and present a framework for iteratively improving the accuracy of a probabilistically annotated behaviour model.

This paper presents a novel programming model for explicitly separating parallelization and middleware-specific concerns in bag-of-tasks (BoT) grid applications. The model uses Java threads for application decomposition, and aspect-oriented programming to dynamically (and transparently) convert the application's thread objects into independent grid tasks, using the services of a specific grid middleware API. This paper also describes early experimental results showing the model's modularity gains and performance overhead, when applied to implement BoT grid applications using OurGrid.

Refactoring, i.e., the process of changing a software system to improve its internal quality and preserving its external behavior, is gaining increasing acceptance among software developers. Even though many refactoring tools are now available for a variety of programming languages, most of them are difficult to reuse, extend or even customize, mainly because they provide no uniform way of representing and manipulating source code information. This work presents a refactoring framework, called RefaX, which relies on open, XML-based source code models and processing standards to facilitate the development, customization and reuse of refactoring tools. In particular, RefaX makes it possible to develop refactoring tools that are independent of source code model, programming language and XML processing technology. The viability of the framework is illustrated through a refactoring prototype for Java.