Search

Blockchain technology is an emerging technology which is making a significant contribution to the ongoing digital evolution by influencing companies, business models and value creation. Since its invention, this technology was receiving great interest in different areas, starting from the financial one by also including the tourism sector. This work proposes the study of a software system, based on blockchain, to facilitate disintermediation in the tourism sector and promoting its sustainability simultaneously. The system is designed to take advantage of blockchain technology both to guarantee the security and reliability of the system, and to manage the roles and responsibilities of numerous types of actors. Thanks to the continuous collaboration of the all involved stakeholders, and to the data come from IoT devices, the system will be able to monitor a specific tourist destination by making use of ETIS indicators we specifically use for the assessment of sustainability into all aspects. The study also includes an overview of the barriers to blockchain adoption in tourism that can undermine the sustainability of the system.

This paper presents a first investigation to join agile blockchain-oriented software development principles with sustainability software design principles. The development of blockchain-oriented software should always be performed in the awareness of the potential effects generated from its use, especially in a long-term life cycle perspective. In other terms in the awareness of its present and future sustainability. By using the principles of sustainability software design and recognized the role of blockchain-oriented Agile methodologies to manage changes in technology and requirements, we present a new Agile method for the development of blockchain-oriented systems that includes sustainability awareness practices within the development phases, in particular in the requirements and the acceptance tests. This allows to deal with blockchain-oriented systems sustainability immediately and during the incremental and iterative development process. The paper describes the process in its phases and provides an example of an application to the supply chain sector.

In this work, we perform a comprehensive empirical study of smart contracts deployed on the ethereum blockchain. The objective of the analysis is to provide empirical results on smart contracts features, smart contract transactions within the blockchain, the role of the development community, and the source code characteristics. We collected a set of more than 10000 smart contracts source codes and a dataset of meta-data regarding their interaction with the blockchain from etherscan.io. We examined the collected data computing different statistics on naming policies, smart contract ether balance, number of smart contract transactions, functions, and other quantities characterizing the use and purpose of smart contracts. We found that the number of transactions and the balances follow power-law distributions and the software code metrics display, on average, values lower than corresponding metrics in standard software but have high variances. Focusing the attention on the 20 smart contracts with the topmost number of transactions, we found that most of them represent financial smart contracts and some of them have peculiar software development stories behind them. The results show that blockchain software is rapidly changing and evolving and it is no longer devoted only to cryptovalues applications but to general purpose computation.

Blockchain technology is an emerging technology that allows new forms of decentralized architectures, designed to generate trust among users, without the intervention of mediators or knowledge between the parties. Since 2015, thanks to the introduction of Smart Contracts by Ethereum, it is possible to run programs on the blockchain, greatly extending the potential of this technology. The programming of Smart Contract, through the Solidity language is different from the traditional one. First of all, any action that requires to modify the blockchain costs gas, which corresponds to a fraction of the currency used by that given blockchain, and therefore to real money. Gas optimization is a unique challenge in this context and has obvious implications. This document aims to provide a set of design patterns and tips to help gas saving in developing Smart Contracts on Ethereum. The provided patterns are presented divided into five main categories, based on their features.

Pull-request based workflows are popular trends of modern software development platform such as GitHub. A pull-request notifies other developers that new changes are proposed, a code review process follows the pull-request that may be merged in the main branch if other developers accept the changes. Many factors influence the acceptance of pull-requests. Since open source software is based on collaboration, it is essential to discover how the affect expressed by developer discussing pull-request issues, namely how they collaborate, influences the acceptance of the pull-request proposed. In this study we analysed the relations with the affect expressed in pull-request issues' comments and whether an issue is merged in the main branch or not. We focused on pull-request issues and we found that issues with higher level anger, sadness, arousal and valence are less likely to be merged while issues with higher level of valence, joy are more likely to be merged. Positive affect indicates a good collaboration environment, and our finding shows that this healthy collaboration is likely to increase the acceptance of pull-requests.

Blockchain technologies and smart contracts are becoming mainstream research fields in computer science and researchers are continuously investigating new frontiers for new applications. Likewise, microservices are getting more and more popular in the latest years thanks to their properties, that allow teams to slice existing information systems into small and independent services that can be developed independently by different teams. A symmetric paradigm applies to smart contracts as well, which represent well defined, usually isolated, executable programs, typically implementing simple and autonomous tasks with a well defined purpose, which can be assumed as services provided by the Contract. In this work we analyze a concrete case study where the microservices architecture environment is replicated and implemented through an equivalent set of smart contracts, showing for the first time the feasibility of implementing a microservices-based system with smart contracts and how the two innovative paradigms match together. Results show that it is possible to implement a simple microservices-based system with smart contracts maintaining the same set of functionalities and results. The result could be highly beneficial in contexts such as smart voting, where not only the data integrity is fundamental but also the source code executed must be trustable. acceptedVersion

In a previous empirical study by Bavota et al., multiple releases of three open-source systems reported the extent to which refactorings induced defect-fixes. In a much earlier study, van Deursen and Moonen (vD&M) provided a test taxonomy in which Fowler's seventy-two refactorings were categorized according to the post refactoring test burden of each (i.e., the changes required to unit tests after each refactoring had been undertaken). A refactoring was categorized as 'Type B' if it required no change to the original tests and 'Type E' if significant changes were necessary. In this paper, we investigate nine refactorings spread across vD&M's taxonomy and the corresponding defect-fix data provided by Bavota et al., to explore the relationship between defect-fixes due to refactoring and vD&M's taxonomy. Results showed that, in contrast to our intuition, the most defect-fix prone refactorings were of Types C and D and not, as we thought, of Type E. The 'Extract method' refactoring stood out as particularly 'defect-fix' inducing, suggesting that while it may solve one problem (i.e., in decomposing an excessively long method), it may well introduce other problems and required defect-fixes as a by-product.

Smart Contracts have gained tremendous popularity in the past few years, to the point that billions of US Dollars are currently exchanged every day through such technology. However, since the release of the Frontier network of Ethereum in 2015, there have been many cases in which the execution of Smart Contracts managing Ether coins has led to problems or conflicts. Compared to traditional Software Engineering, a discipline of Smart Contract and Blockchain programming, with standardized best practices that can help solve the mentioned problems and conflicts, is not yet sufficiently developed. Furthermore, Smart Contracts rely on a non-standard software life-cycle, according to which, for instance, delivered applications can hardly be updated or bugs resolved by releasing a new version of the software. In this paper we advocate the need for a discipline of Blockchain Software Engineering, addressing the issues posed by smart contract programming and other applications running on blockchains.We analyse a case of study where a bug discovered in a Smart Contract library, and perhaps "unsafe" programming, allowed an attack on Parity, a wallet application, causing the freezing of about 500K Ethers (about 150M USD, in November 2017). In this study we analyze the source code of Parity and the library, and discuss how recognised best practices could mitigate, if adopted and adapted, such detrimental software misbehavior. We also reflect on the specificity of Smart Contract software development, which makes some of the existing approaches insufficient, and call for the definition of a specific Blockchain Software Engineering.

In the past few years, cryptocurrencies and blockchain applications has been one of the most rapidly emerging fields of computer science, leading to a strong demand of software applications. Several new projects have been emerging almost daily, with an impetus that was not seen since the days of the dawn of the Internet. However, the need of being timely on the market and the lack of experience in a brand new field led to epic disasters, such as those of DAO in 2016 and of Parity Ethereum wallet in 2017. Also, there have been several hacks successfully performed on cryptocurrency exchanges, the biggest being those of MtGox in 2014 (350 million US$), Bitfinex in 2016 (72 million US$), and Coincheck in 2017 (400 million US$). The application of sound SE practices to Blockchain software development, both for Smart Contract and generic Blockchain software, might be crucial to the success of this new field. Here the issues are the need for specific analysis and design methods, quality control through testing and metrics, security assessment and overall development process. At the same time, Blockchain development offers new opportunities, such as the certification of empirical data used for experiment; the ability to design processes where developers are paid upon completion of their tasks through Blockchain tokens, after acceptance tests performed using Smart Contracts; and more sound techniques enabling pay-per-use software, again using tokens.

Bloekehain — software technology used for peer-to-peer transaction platforms — is being increasingly applied to alternative opportunities for a variety of industries and use cases such as also in the energy sector. As of now all energy related to blockchain applications are still in a concept stage. This paper aims to present the preliminary ideas of a research project that we have launched in collaboration with a small Fintech company: the Crypto-Trading project. From a research perspective we have explored how a blockchain-based system integrating smart contract functionality can be used to share energy in order to promote smart grids for the management of electricity in the Sardinia Region. From a technical perspective the project will implement a modular blockchain-based software platform for extending the features of cryptocurrency exchanges to the renewable Energy Market, including a robo-advisor which will suggest prosumers the best selling strategy. Blockchain technology shows a lot of promise. In our opinion this might boost the growth of renewable energy production and consequently also have a positive effect on the regional economy.

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 Maintainability Index (MI) metric was proposed in the early nineties to gauge ease of code maintenance. A high value of MI indicates well-constructed code which is easy to maintain and a low MI, the opposite. The metric has been criticized in the past and more recently for its applicability to code and validity more generally. Very few studies however have explored whether the MI correlates strongly with class features such as coupling, defects or size - features of object-oriented (OO) classes which are acknowledged to be surrogates of maintenance complexity. We explore the relationship between the MI and these four perspectives. Three releases of two Eclipse projects were used as the empirical basis of the study and the JHawk tool was used to extract class-based metrics. Significant correlations were found between class features and the MI for all class features except fan-in which measures incoming coupling and determined externally by 'using' classes; however, further exploration of the data revealed that the application of the MI to an OO paradigm was not particularly successful, due primarily to the influence of class size. For OO systems, we would thus warn against the use of MI as a measure of maintenance.

Welcome to WETSoM 2013, the 4th International Workshop on Emerging Trends in Software Metrics. Since its start, WETSoM has attracted a blend of academic and industrial researchers, creating a stimulating atmosphere to discuss the progresses of software metrics. A key motivation for this workshop is the low impact that software metrics still has on current software development, raising the need for empirically evaluating the effectiveness of existing metrics, as well as to identify directions for development of new metrics.

Recent empirical work has shown that some of the most frequently applied Java-based refactorings relate to the manipulation of code conditionals and flags. The logic of such code is often complex and difficult to test regressively. One open research issue thus relates to the fault-proneness profiles of classes where these refactorings have been applied, vis-a-vis refactorings on other classes. In this paper, we explore six releases of three Eclipse projects and the faults in the refactored classes of those releases. We explore four specific conditional-based refactorings and the supposition that: classes where these four refactorings have been applied will tend to have relatively higher fault incidences because of the inherent complexity of the embedded logic given by the constructs they operate on. Results showed that one of the four refactorings in particular had been applied to classes with higher fault profiles - the `Replace Nested Conditional with Guard Clauses' refactoring. Some evidence that the `Remove Control Flag' refactoring had also been applied to relatively highly fault-prone classes was found. Relative to other types of refactoring, the result thus suggests that these two effectively signpost fault-prone classes.

Several Content Management Frameworks (CMF), either open source or with a commercial license, are available to help the publication of huge amounts of information and to develop Web applications. Unfortunately, developing Web applications through a CMF is not exempt from cost and time overruns, as in traditional software projects, and currently there is no estimation model able to adequately measure the effort of Web application development. This work presents a new methodology for estimat­ing the effort of Web applications developed with a Content Management Framework (CMF). We present the new key elements for analysis and planning, needed to define every important step in developing a Web application through a CMF. Using those elements, it is possible to estimate the effort needed to build such an ap­plication in man-days. We also present the experimental validation of the proposed methodology per­formed on a 9-project dataset, provided by three different Italian software companies.

One of the goals of Software Engineering is to reduce, or at least to try to control, the defectiveness of software systems during the development phase. The aim of our study is to analyze the relationship between micro patterns (introduced by Gil and Maman) and faults in a software system. Micro patterns are similar to design patterns, but their characteristic is that they can be identified automatically, and are at a lower level of abstraction with respect to design patterns. Our study aims to show, through empirical studies of open source software systems, which categories of micro patterns are more correlated to faults. Gil and Maman demonstrated, and subsequent studies confirmed, that 75% of the classes of a software system are covered by micro patterns. In our study we also analyze the relationship between faults and the remaining 25% of classes that do not match with any micro pattern. We found that these classes are more likely to be fault-prone than the others. We also studied the correlation among all the micro patterns of the catalog, in order to verify the existence of relationships between them.

The use of Open Source Content Management System (CMS) on the Web is increasing thanks to the flexibility provided by these systems and the semplification of the management operations. The use of CMS is simple for non programming experts. Many Public Administrations have adopted Open Source CMS for their websites, greatly reducing operating costs and ensuring scalability, advanced performance and privacy to the users. A special opportunity for a case study are the Italian municipalities. In fact the Italian Government, since January 2011, has required all municipalities to develop a website publishing all the public acts and everything related to the citizen-municipality communication (information regarding office hours, salaries of public employees, news and so on). Our study aims to quantify through empirical studies, the use of Open Source CMS in Italian municipalities websites in response to government regulations. Our results show that the number of Italian Public Administrations that use Open Source CMS is increasing, and our case study highlights how the adoption of Open Source CMS has increased about 5% in a year, leading to the 21.2% the percentage of Open Source CMS, with respect to the 15.8% registered in 2011.

Many of the seventy-two refactorings originally proposed by Fowler have the aim of reducing coupling in classes and thereby aiding programmer maintainability. While we might assume that classes with high levels of coupling would be the targets for refactoring more often than any other type of class, no empirical evidence exists to support this assumption. In this paper, we explore that open question through the extraction of fifty-two of Fowler's catalog of refactorings drawn from versions of four open-source systems. We compare the coupling characteristics of each set of refactored classes with the corresponding set of non-refactored classes (those for which no refactorings were applied across versions), we seek to inform one overriding research question: is there a significant difference between these two sets of classes in terms of their level of coupling? Results showed that highly-coupled classes were more prone to refactoring, particularly through a set of 'core' refactorings. However, wide variations were found across systems for our measures of coupling namely, fan-in and fan-out. Specific individual refactorings were also explored to gain an understanding of why these differences may have occurred.

The aim of refactoring is to reduce software complexity and hence simplify the maintenance process. In this paper, we explore the impact of refactorings on "FanIn" and "FanOut" coupling metrics through extraction of refactoring data from multiple releases of five Java open-source systems, We first considered how a single refactoring modified these metric values, what happened when refactorings had been applied to a single class in unison and finally, what influence a set of refactorings had on the shape of Fan In and Fan Out distributions. Results indicated that, on average, refactored classes tended to have larger FanIn and Fan Out values when compared with non-refactored classes. Where evidence of multiple (different) refactorings applied to the same class was found, the net effect (in terms of FanIn and Fan Out coupling values) was negligible.

Refactoring is an activity which, in theory, should have minimal impact on the overall structure of a system. That said, certain refactorings change the coupling profile of a system and over time those cumulative changes in coupling can have serious implications for system maintenance effort. In this paper, we analyse effect of the fan-in and fan-out metrics from the perspective of two refactorings -- namely 'Add parameter' to, and 'Remove Parameter' from, a method. We developed a bespoke pattern-matching tool to collect these two refactorings from multiple releases of the Tomcat open-source system using the Evolizer tool to extract method signature data and the JHawk metrics tool to collect the two coupling metrics. Results point to significant differences in the profiles of fan-in and fan-out between refactored and non-refactored classes. We describe how software company can take advantage from this knowledge by defining a priority list of classes which could require a refactoring. A strong over-arching theme emerged: developers seemed to focus on the refactoring of classes with relatively high fan-in and fan-out rather than classes with high values in any one. The study is the first that we know of to analyse the direct effect of a subset of Fowler's refactorings on fan-in and fan-out - relevant metrics of the overall structure of a system.

A software system can be associated to a graph - called software network - whose nodes are the software modules (for instance, the classes in Object-oriented systems), and edges are the dependencies between modules. A recent paper demonstrated that the structure of software networks is also self-similar under a length-scale transformation, and calculated their fractal dimension using the "box counting" method. In this paper, we focus on describing and evaluating alternative approaches for the computation of the fractal dimension of networks. We show that a Merge Algorithm is the most efficient, while Simulated Annealing is the most accurate. However, the Greedy Coloring algorithm, based on the equivalence of the box counting problem with the graph coloring problem, looks the best compromise, having speed comparable to MA, and accuracy comparable with SA.

The problem of global optimization of magnetic structures composed of solenoids is examined, using a modified simulated annealing algorithm able to deal with the functions of continuous and/or discrete variables. The algorithm is tested using a discrete problem which allows determination of the cost function for every possible configuration of the system, providing information about the pattern of the cost function with respect to design variables. Despite the difficulty of minimizing the function, the proposed algorithm was able to locate the global minimum, or a point where the cost function has a value very close to it, seven times out of a total of ten runs. The algorithm is described, and results are discussed. >

We describe the Extreme Programming Ontology (XPO), a formal model specifying the main concepts used in the extreme programming methodology and their properties. XPO's modular structure was developed using the usual normative top down approach to software engineering process modeling. It relies on a set of core components rooted in three main concepts: organisational role, product and phase. Besides being useful for indexing relevant documents and XP artifacts such as user stories and Wiki pages, XPO is aimed at being a sound basis for nonintrusive analysis of agile processes, mining process data about programmers activity and repositories content in order to extract new concepts potentially identifying critical factors in agile software development. Extension to XPO are also discussed, including other agile methodologies and more general software engineering concepts.

Fast algorithms for calculating the discrete Hartley transform and the Fermat number transform (FNT) are discussed from an architectural point of view. Several systolic architectures for the real-time computation of these transforms are presented. In particular, the cascade architecture for computing the FNT with the decimation-in-time algorithm is presented. >

A very versatile algorithm for the design of finite-wordlength filters is described. It is a simulated annealing algorithm, derived directly from the simulated annealing algorithm for functions of continuous variables which searches over discrete values of the filter coefficients. It has very fast development time and produces filters with good performances. Its only drawback is a very long execution time. Three examples of filter design are included. >

The discrete Hartley transform (DHT) is a real-valued transform closely related to the discrete Fourier transform (DFT) of a real-valued sequence. Several fast algorithms for the computation of the DHT (FHTs) have been proposed. A new cascade circuit for computing the DHT is presented in two versions, which implement, respectively, the radix-2 decimation-in-time and decimation-in-frequency FHT algorithms. The circuit makes use of CORDIC processors and allows an easy computation of the DFT, the amplitude and phase spectra, and the cyclic convolution and correlation of two sequences. Some architectures to perform such operations are also presented. >

A digital implementation of a multilayer neural network model that has backpropagation as its learning algorithm is presented. This architecture is characterized by a set of elementary processors (neurons) and has the form of a linear sequence, where every processor communicates only with its two nearest neighbors. A sophisticated control of data exchange among neurons, by means of two data buses, ensures full pipelining in the forward mode. The proposed architecture is very flexible since, having only local connections, it can be easily expanded by simply adjoining more processors to it. Moreover, it can be programmed in terms of number and width of layers. >

The authors present a systolic circuit for computing a fast algorithm performing the discrete Hartley transform (DHT). The proposed architecture employs a systolic elevator concept and CORDIC processors. The elevator assures local communications in the proposed algorithm, and the CORDIC processor makes it possible to enhance processing speed and exploit parallelism. The architecture appears to be regular and, therefore, very attractive for VLSI realizations. The computational cost necessary for computing the DFT (discrete Fourier transform) is also discussed with respect to other architectures. >

A class of optimization algorithms for finding the global minimum of functions of continuous variables is presented. These algorithms merge conventional local minima search strategies with the stimulated annealing (SA) technique. The rationale behind these algorithms is discussed, and a complete description is given of one of them, derived from the Hooke and Jeeves (1961) search method. Tests made on mathematical functions show an increase up to two orders of magnitudes in efficiency with respect to a conventional SA algorithm. An example of application to VLSI design is given. >

A neural network approach to the position estimation problem for a variable reluctance linear actuator is investigated. The inputs of the neural network are current ripple measurements and the switching pattern of the power converter. The neural network approach allows to account for iron saturation and iron losses effects resulting in an accurate position estimation. Numerical simulations are developed to show the feasibility of the proposed method, as well as the neural robustness. Finally, experimental measurements on a prototype are presented to validate the proposed approach.

In this paper the problem of off-line diagnosis of analog circuits affected by catastrophic multiple faults is considered. Information on the circuit behavior is given by the voltage measurements in a set of available test points. Because of the huge amount of data involved in each voltage acquisition, it is necessary to apply a compression technique to reduce the volume of the data to be given to the diagnostic system. Our diagnostic system consists of a neural network, trained to recognise catastrophic single faults, and used to diagnose multiple faults. The network has as many input nodes as the features extracted by each circuit image and the output nodes are as many as the number of circuit components. In this paper we investigate the suitability of the wavelet analysis to the problem of data compression of measurements for detecting faults in analog circuits. We also present some results obtained with the proposed diagnostic system in diagnosing multiple faults in the test circuit examined and compare these results with those previously obtained.

The possibility of using the multilayer perceptron (MLP) neural network for the processing of EEG evoked potentials (EPs) is examined. A structure composed of the cascade of a MLP and a linear combiner is proposed. Experimental results, both on synthetic and real data, show that the method provides good results with very few EP ensembles and without the necessity of prior knowledge of the signal characteristics. >

The feasibility of restricting the weight values in multilayer perceptrons to powers of two or sums of powers of two is studied. Multipliers could be thus replaced by shifters and adders on digital hardware, saving both time and chip area, under the assumption that the neuron activation function is computed through a lookup table (LUT) and that a LUT can be shared among many neurons. A learning procedure based on back-propagation for obtaining a neural network with such discrete weights is presented. This learning procedure requires full real arithmetic and therefore must be performed offline. It starts from a multilayer perceptron with continuous weights learned using back-propagation. Then a weight normalization is made to ensure that the whole shifting dynamics is used and to maximize the match between continuous and discrete weights of neurons sharing the same LUT. Finally, a discrete version of BP algorithm with automatic learning rate control is applied up to convergence. Some test runs on a simple pattern recognition problem show the feasibility of the approach