Currently, the majority of apps running on mobile devices are Android apps developed in Java. However, developers can now write Android applications using a new programming language: Kotlin, which Google adopted in 2017 as an official programming language for developing Android apps. Since then, Android developers have been able to: a) start writing Android applications from scratch using Kotlin, b) evolve their existing Android applications written in Java by adding Kotlin code (possible thanks to the interoperability between the two languages), or c) migrate their Android apps from Java to Kotlin. This paper aims to study this last case. We conducted a qualitative study to find outwhyAndroid developers have migrated Java code to Kotlin and to bring together their experiences about the process, in order to identify the main difficulties they have faced. To execute the study, we first identified commits from open-source Android projects that have migrated Java code to Kotlin. Then, we emailed the developers that wrote those migrations. We thus obtained information from 98 developers who had migrated code from Java to Kotlin. This paper presents the main reasons identified by the study for performing the migration. We found that developers migrated Java code to Kotlin in order to access programming language features (e.g., extension functions, lambdas, smart casts) that are not available with Java for Android development, and to obtain safer code (i.e., avoid null-pointer exceptions). We also identified research directions that the research community could focus on in order to help developers to improve the experience of migrating their Java applications to Kotlin.

Background: Google announced Kotlin as an Android official programming language in 2017, giving developers an option of writing applications using a language that combines object-oriented and functional features. Aims: The goal of this work is to understand the usage of Kotlin features considering four aspects: i) which features are adopted, ii) what is the degree of adoption, iii) when are these features added into Android applications for the first time, and iv) how the usage of features evolves along with applications' evolution. Method: Exploring the source code of 387 Android applications, we identify the usage of Kotlin features on each version application's version and compute the moment that each feature is used for the first time. Finally, we identify the evolution trend that better describes the usage of these features. Results: 15 out of 26 features are used on at least 50% of applications. Moreover, we found that type inference, lambda and safe call are the most used features. Also, we observed that the most used Kotlin features are those first included on Android applications. Finally, we report that the majority of applications tend to add more instances of 24 out of 26 features along with their evolution. Conclusions: Our study generates 7 main findings. We present their implications, which are addressed to developers, researchers and tool builders in order to foster the use of Kotlin features to develop Android applications.

The widespread use of mobile devices is reshaping the way users interact, allowing applications to explore physical proximity of devices to offer intelligent services. Although there are several communication technologies available (e.g., Wi- Fi, Wi-Fi Direct, LTE, UMTS, Bluetooth, NFC), building an application from scratch considering both communication and application requirements is not a trivial task. In order to help developers to implement communication primitives, this paper presents a communication framework for ubiquitous systems called USABle. Two important contributions of this framework can be highlighted: i) a set of technology-independent interfaces to handle communication requirements; and ii) a modular and extensible layer-based architecture that permits developers to implement new communication technologies and message dissemination strategies. The outcome of using this communication framework is a simpler way to build applications that explore physical proximity. To validate the claims presented in this paper, a performance evaluation using real devices is done, analyzing two multi-hop and three carry-and-forward implementations of routing algorithms that were implemented using the USABle framework.

Designing routing protocols in vehicular network is a challenging task due to the high mobility of nodes, the instability of wireless links, and the diversity of deployment scenarios. Several routing protocols have been designed with the goal of solving one or more specific problems of each scenario. In this paper, we present a performance evaluation of routing protocols in vehicular networks addressing the impact of density, load, and mobility pattern. Four protocols are evaluated in urban and highway scenarios. The results presented in this paper provide guidelines for network designers in planning efficient routing protocols for vehicular network, able to adapt to different scenarios.