Search

Pluggable controllers are a different way to design control constructors such as if, while, do, switch, and operators such as short circuit con-junction (&&) and the “?.” operator of the Swift programming language. Adoption of pluggable controllers enables the final user to modify and extend the control flow constructs (if, while, etc.) of an underlying programming language, the same way they can do if they implement functions such as printf and class String in a standard library. In modular, pluggable controller based language design, beside core control constructors, there are others, defined in standard libraries, with the purpose of augmenting and enriching the language. These pluggable controllers are extensible and replaceable. Being less intertwined in the main language, control constructor libraries can evolve independently from it, and their releases do not mandate new language releases. We illustrate the implementation of pluggable controllers using Lola, a powerful language-independent preprocessor and macro language. We demonstrate the introduction of new pluggable controllers with two case studies. The implementation of a Java stenography based on prevalent Java idioms, called “nano-patterns” or nanos, and the introduction in Java of new code constructs inspired by the Mathematica language’s commands.

Cloud systems are complex, large, and dynamic systems whose behavior must be continuously analyzed to timely detect misbehaviors and failures. Although there are solutions to flexibly monitor cloud systems, cost-effectively controlling the anomaly detection logic is still a challenge. In particular, cloud operators may need to quickly change the types of detected anomalies and the scope of anomaly detection, for instance based on observations. This kind of intervention still consists of a largely manual and inefficient ad-hoc effort. In this paper, we present Anomaly Detection as-a-Service (ADaaS), which uses the same as-a-service paradigm often exploited in cloud systems to declarative control the anomaly detection logic. Operators can use ADaaS to specify the set of indicators that must be analyzed and the types of anomalies that must be detected, without having to address any operational aspect. Early results with lightweight detectors show that the presented approach is a promising solution to deliver better control of the anomaly detection logic., Paper accepted at the Intl. Workshop on Governing Adaptive and Unplanned Systems of Systems (GAUSS)

The ecosystem in which mobile applications run is highly heterogeneous and configurable. All layers upon which mobile apps are built offer wide possibilities of variations, from the device and the hardware, to the operating system and middleware, up to the user preferences and settings. Testing all possible configurations exhaustively, before releasing the app, is unaffordable. As a consequence, the app may exhibit different, including faulty, behaviours when executed in the field, under specific configurations. In this paper, we describe a framework that can be instantiated to support in-vivo testing of a mobile app. The framework monitors the configuration in the field and triggers in-vivo testing when an untested configuration is recognized. Experimental results show that the overhead introduced by monitoring is unnoticeable to negligible (i.e., 0-6%) depending on the device being used (high- vs. low-end). In-vivo test execution required on average 3s: if performed upon screen lock activation, it introduces just a slight delay before locking the device., Research paper accepted to ICST'20, 10+1 pages

Cloud systems are large scalable distributed systems that must be carefully monitored to timely detect problems and anomalies. While a number of cloud monitoring frameworks are available, only a few solutions address the problem of adaptively and dynamically selecting the indicators that must be collected, based on the actual needs of the operator. Unfortunately, these solutions are either limited to infrastructure-level indicators or technology-specific, for instance, they are designed to work with OpenStack but not with other cloud platforms. This paper presents the VARYS monitoring framework, a technology-agnostic Monitoring-as-a-Service solution that can address KPI monitoring at all levels of the Cloud stack, including the application-level. Operators use VARYS to indicate their monitoring goals declaratively, letting the framework to perform all the operations necessary to achieve a requested monitoring configuration automatically. Interestingly, the VARYS architecture is general and extendable, and can thus be used to support increasingly more platforms and probing technologies.

Driven by the surge of interest generated around blockchain technologies over the last years, a new category of systems, called Blockchain-Oriented Software (BOS), which are strictly tied to Blockchain distributed environment, has become increasingly popular. Yet, there is not a thorough understanding of their structure and behaviour and if and to which extent they differ from traditional software systems. The present work provide a first statistical characterisation of BOS. We analysed and compared 5 C++ open source Blockchain-Oriented and 5 Traditional Java software systems, aiming at detecting potential differences between the two categories of projects, and specifically in the statistical distribution of 10 software metrics. Although, in general, the statistical distributions for Traditional software and Blockchain software show similarities, the distribution of Average Cyclomatic and Ration Comment To Code metrics reveal significant differences in their queue, whereas the Number of Statements metric shows meaningful differences on the double Pareto distribution.

The European Rail Traffic Management System (ERTMS) represents a class of embedded software-intensive systems of systems for the management of the European rail traffic, in a scenario where interoperability between different European rail traffic infrastructures must be maintained. Due to the intrinsically safety-critical nature of ERTMS, software testing must meet the strict prescriptions imposed by the certification authorities, which often require the availability of the entire system. This potentially leads to perform the tests at a late stage of development, even though the best practices suggest that it would be more convenient to test the system incrementally since the early stages of development. This paper deals with the solution we devised to address this issue in a recent ERTMS project. We adopted a design-for-testability pattern which purposely enhances the observability and the controllability of the software under test to make it testable at any stage of development, allowing the exploitation of system tests even during component and integration testing.

Patterns, micro-patterns, and nano-patterns have many applications: program comprehension, code transformations, documentation aids, improving code robustness, etc. This work revisits the notion of nano-patterns—originally an obiter dictum of the work on micro-patterns. Nano-patterns here are taken as more general than their previous definition in the literature: predicates on short code snippets that represent some common and elementary programming missions such as “for each m ∈ M do...”, or, “use x (but if x is null, y is a substitute)”, which represent small and recurring programming idioms. With this generalization, we offer a taxonomized languageof nanos nano-patterns for Java. We also describe the process of pattern harvesting we used and the underlying rationale, including our proposed prevalence threshold criterion, which, by capitalizing on Hirsch’s famous h-index, makes a robust yard-stick of the pattern’s significance. An empirical survey of 78 Open Source Java projects indicates that the nano-patterns of our proposed language described here have a substantial prevalence in the code. About a third of the commands (executable statements) and half of the methods are instances of nano-patterns in the proposed language. Also, the language’s prevalence is typically higher than that of languages harvested in a project specific, automated machine learning process. Nano-patterns are implementation/language level details for most high level software engineering purposes. One contribution made by the present paper is in identifying the clutter made by the snippets, appreciating its presence, and imposing order on it. The language, the nano-patterns in it, and the contributed automatic tool for tracing nano-patterns in code may help to deal systematically with this low level, yet significant, portion of code.

This paper presents two new challenges for the Telco ecosystem transformation in the era of cloud-native microservice-based architectures. (1) Development-for-Operations (Dev-for-Operations) impacts not only the overall workflow for deploying a Platform as a Service (PaaS) in an open foundry environment, but also the Telco business as well as operational models to achieve an economy of scope and an economy of scale. (2) For that purpose, we construct an integrative platform business model in the form of a Multi-Sided Platform (MSP) for building Telco PaaSes. The proposed MSP based architecture enables a multi-organizational ecosystem with increased automation possibilities for Telco-grade service creation and operation. The paper describes how the Dev-for-Operations and MSP lift constraints and offers an effective way for next-generation PaaS building, while mutually reinforcing each other in the Next Generation Platform as a Service (NGPaaS) framework., Comment: 6 pages

Cloud systems are complex and large systems where services provided by different operators must coexist and eventually cooperate. In such a complex environment, controlling the health of both the whole environment and the individual services is extremely important to timely and effectively react to misbehaviours, unexpected events, and failures. Although there are solutions to monitor cloud systems at different granularity levels, how to relate the many KPIs that can be collected about the health of the system and how health information can be properly reported to operators are open questions. This paper reports the early results we achieved in the challenge of monitoring the health of cloud systems. In particular we present CloudHealth, a model-based health monitoring approach that can be used by operators to watch specific quality attributes. The CloudHealth Monitoring Model describes how to operationalize high level monitoring goals by dividing them into subgoals, deriving metrics for the subgoals, and using probes to collect the metrics. We use the CloudHealth Monitoring Model to control the probes that must be deployed on the target system, the KPIs that are dynamically collected, and the visualization of the data in dashboards., 8 pages, 2 figures, 1 table

Platform-As-A-Service (PaaS) systems offer customers a rich environment in which to build, deploy, and run applications. Today’s PaaS offerings are tailored mainly to the needs of web and mobile applications developers, and involve a fairly rigid stack of components and features. The vision of the H2020 5GPPP Phase 2 Next Generation Platform-as-a-Service (NGPaaS) project is to enable “build-to-order” customized PaaSes, tailored to the needs of a wide range of use cases with telcograde5G characteristics. This paper sets out the salient and innovative features of NGPaaS and explores the impacts on Operational Support Systems and Business Support Systems (OSS/BSS), moving from fixed centralized stacks to a much more flexible and modular distributed architecture.

Spartan programming is a coding style which tries to minimize the elements of code, like in a laconic speech. In the context of code, the minimized elements of speech include lines, characters, arguments, nesting use of ifs and whiles, etc. The style is achieved by the process of repeated application of code transformation techniques, or refactoring operations, drawn from the spartan toolbox of tippers. Each tipper improves at least one of the code size metrics, without degrading any of the others. We present the unique look of spartan code, and the process of achieving it, including the three main kinds of tippers: structural, nominal, and modular. We do not make the case for the spartan style here, leaving the readers to find beauty or savageness in it. The evaluation part of this work gives evidence that the application of structural tippers contributes to the naturalness of software.

The Spartanizer is an eclipse plugin featuring over one hundred and fifty refactoring techniques, all aimed at reducing various size complexity of the code, without changing its design, i.e., inheritance relations, modular structure, etc. Typical use case of the Spartanizer is in an automatic mode: refactoring operations are successively selected and applied by the tool, until the code is reshaped in spartan style (a frugal coding style minimizing the use of characters, variables, tokens, etc.). The Spartanizer demonstrates the potential of automatic refactoring: tens of thousands of transformations are applied in matter of seconds, chains of dependent applications of transformations with tens of operations in them, significant impact on code size, and extent reaching almost every line of code, even of professional libraries.

This paper raises the idea of giving end users the ability to modify and extend the control flow constructs (if, while, etc.) of the underlying programming language, just as they can modify and extend the library standard implementation of function printf and class String. Pluggable Controllers are means for modular design of control constructors, e.g., if, while, do, switch, and operators such as short circuit conjunction (&&) and the '?.' operator of the Swift programming language. We propose a modular, pluggable controllers based, design of a language. In this design there are control constructors which are core, augmented by a standard library of control constructors, which just like all standard libraries, is extensible and replaceable. The control constructors standard library can then follow a course of evolution that is less coupled with that of the main language, where a library release does not mandate new language release. At the same time, the library could be extended by individuals, corporate and communities to implement more or less idiosyncratic Nano-Patterns. We demonstrate the imposition of pluggable control constructors on Java by employing Lola - a Turing-complete and programming language independent code preprocessor.

We present a study of 600 Java software networks with the aim of characterizing the relationship among their defectiveness and community metrics. We analyze the community structure of such networks, defined as their topological division into subnetworks of densely connected nodes. A high density of connections represents a higher level of cooperation between classes, so a well-defined division in communities could indicate that the software system has been designed in a modular fashion and all its functionalities are well separated. We show how the community structure can be an indicator of well-written, high quality code by retrieving the communities of the analyzed systems and by ranking their division in communities through the built-in metric called modularity. We found that the software systems with highest modularity possess the majority of bugs, and tested whether this result is related to some confounding effect. We found two power laws relating the maximum defect density with two different metrics: the number of detected communities inside a software network and the clustering coefficient. We finally found a linear correlation between clustering coefficient and number of communities. Our results can be used to make predictive hypotheses about software defectiveness of future releases of the analyzed systems.

Mobile apps are certainly a significant part of thesoftware industry market, and their centrality in our economicand social life is becoming more and more relevant as time goesby. In this preliminary work we propose a complex networkapproach, never used before in this field, to study mobileapps from a software engineering perspective. We analyzed thenetworks associated to 5 popular open-source android apps, and found that they share some properties with other kinds ofsoftware systems. We employed complex networks to obtain adeeper insight both on internal and external dependencies, aimingat studying the relationship between mobile apps dependenciesand software quality. Our goal is to better understand thenature of the existing relationship between mobile apps and theunderlying hosting operating system thus providing developerswith valuable information.

Refactoring, the activity of changing source code design with- out affecting its external behavior, is a widely used practice among developers, since it is considered to positively affect the quality of software systems. However, there are some "human factors" to be considered while performing refactor-ing, including developers knowledge of systems architecture. Recent studies showed how much "people" metrics, such as code ownership, might affect software quality as well. In this preliminary study we investigated the relationship between code ownership and refactoring activity performed by developers. This study can provide useful insights on who performs refactoring and help team leaders to properly man- age human resources during software development.

Refactoring is the practice of changing source code without altering its external behavior. It is widely used since it is acknowledged to have a positive effect on software quality. However, different studies on the impact of Refactoring on software quality led to contrasting results. This might be due also to the fact that research works on Refactoring rely on different approaches to collect information about the refactoring activity on software repositories. Having a reliable approach is fundamental to draw solid conclusions. In this paper we empirically analyzed two of the most popular approaches to detect the refactoring activity on software repositories, finding that they return different outcomes. These results should be taken into account by researchers while designing the experimental settings of their studies.

In this work we present an empirical study on the use of inheritance in a curated corpus of Python systems. Replicating a study preformed on Java, we analyzed a collection of 51 software systems written in Python, and investigated how inheritance is effectively used by Python developers in practice through a convenient set of inheritance metrics. Our results suggest that on average fewer classes inherit from other classes than in Java, but more classes are inherited from. We also see a sort of symmetry relating the number of ancestors and the number of descendants in each system.

The aim of this paper is to present a dataset of metrics as- sociated to the first release of a curated collection of Python software systems. We describe the dataset along with the adopted criteria and the issues we faced while building such corpus. This dataset can enhance the reliability of empirical studies, enabling their reproducibility, reducing their cost, and it can foster further research on Python software.

Refactoring is certainly one of the most widespread practices used by developers to improve software quality. During the last two decades, it has been the subject of an increasing number of research studies. But how much do we know about the trends, and the appearance of new topics, in the research field of refactoring? What have researchers found about its application since the time of its first introduction? In this work we provide a preliminary analysis of the state of the art and the evolution of the research on refactoring. We attempt to represent the actual body of knowledge in this field through the analysis of its cognitive structure, leveraging science mapping methodology to focus on the most relevant concepts in this research area. We model the body of knowledge by mining bibliographic databases and by retrieving the co-occurrence of keywords. We have found that some different general themes can be recognized, but not all of them have the same role and equally catalyzed researchers' interest. In addition, we provide a preliminary analysis on the trends and directions as well as the hot topics we identified in the refactoring research field.

In this paper we present a case study about the clustering of maintenance activities applied on large software systems, from the complex networks perspective. We analyze several releases of two large Open Source Java software systems, using data extracted from Software Configuration Management systems and from Issue Tracking systems (ITS). We find that Java files affected by maintenance activity are likely to be connected with each other, forming interconnected clusters inside the software network associated to the software system. This means that Java files interested by the maintenance activities requested on ITS are likely to be connected each other through dependencies at the source code level. The information carried by the clusters of Java files may be used to improve strategies for large maintenance operations. Since the tendency to form clusters can vary across different systems, such analysis can also be a useful indicator of the impact of defects on source code files in different software systems.

Refactoring is widely used among the practices of Agile software development. In this preliminary work we present an empirical study carried out on several releases of 5 software systems written in Java. We focus our attention on the effect of refactoring activities on the topology of the software network. We find that refactoring activities involve classes linked together into clusters inside the software network and the clusters may be modified in different ways by the refactoring activity. This could lead to significative changes in source code, whose knowledge could be valuable for people involved in software development.

We present a study on the refactoring activities performed during the evolution of 7 popular Java open source software systems, using a complex network approach. We find that classes affected by refactorings are more likely to be interlinked than others, forming connected subgraphs. Our results show that in a software network, classes linked to refactored classes are likely to be refactored themselves. This result is meaningful because knowing how refactored classes are arranged inside a network could be useful to support developers in maintenance and refactoring activities.

This paper presents a case study of a large software system, Netbeans 6.0, made of independent subsystems, which are analyzed as complex software networks. Starting from the source code we built the associated software graphs, where classes represent graph nodes and inter-class relationships represent graph edges. We computed various metrics for the software systems and found interdependences with various quantities computed by mean of the complex network analysis. In particular we found that the number of communities in which the software networks can be partitioned and their modularity, average path length and mean degree can be related to the amount of bugs detected in the system. This result can be useful to provide indications about the fault proneness of software clusters in terms of quantities related to the associated graph structure.

In a globalized economy, cultural heritage is a strong attractor. Thanks to ICT, it is possible to trigger new development dynamics. For cultural heritage, the contribution of new technologies can offer the highest degree of distribution and access opportunities. A modern museum can actually be seen as a complex ICT system, deeply interconnected, with typically a large quantity of data to manage, extremely dynamic due to ever-changing temporary exhibitions, and with applications that feature a high level of usability for a higher visitor involvement. The aim of this position paper is to create an approach geared to provide aggregated information on the nature, range and articulation of the belongings of the museum, through a paradigm based on the concept of complex network. Applying the complex network model, it will be possible to map a corpora of items made of works of art, artifacts and any object of interest for a museum. The implications derived from the adoption of this approach are multifarious: for example, a curator could evaluate partnership opportunities in the organization of temporary exhibitions, guided paths or catalog editing through an analysis of the relations between the items in their museum and the ones in other museums.

The Instagram is a social network for smartphones created in 2010 and acquired by Facebook in 2012. It currently has more than 300 million registered users and allows for the immediate upload of images (square, inspired by Polaroid), to which users can associate hashtags and comments. Moreover, connections can be created between users that share the same interests. In our work, we intend to analyze the hashtags entered by users: the use of such hashtags, as it happens in other social networks like Twitter, generates a folksonomy, that is a user-driven classification of information. We intend to map that folksonomy as a complex network to which we can associate all the typical analysis and evaluations of such a mathematical model. Our purpose is to use the resulting complex network as a marketing tool, in order to improve brand or product awareness.

Mobile apps can be executed with an extremely large set of partially unpredictable configurations.Indeed, they can be executed on an unbounded combination of devices, operating systems, settings, and user preferences since apps may also interact with other apps or devices that were not even available when they were released.This results in a virtually infinite set of configurations that might be responsible for unexpected behaviors which can be validated in-house only to a negligible extent. To address this challenge, this paper discusses the application of in-vivo testing to mobile apps. The main idea is to run test cases in the field, where we exploit the intrinsic heterogeneity and variety of the end-user environment to dramatically increase the range of validated configurations. Actually, the many devices available in-the-field generate a naturally distributed and highly scalable environment that can be exploited to timely validate many configurations as soon as they are observed.&nbsp