16,628 research outputs found
Mining developer communication data streams
This paper explores the concepts of modelling a software development project
as a process that results in the creation of a continuous stream of data. In
terms of the Jazz repository used in this research, one aspect of that stream
of data would be developer communication. Such data can be used to create an
evolving social network characterized by a range of metrics. This paper
presents the application of data stream mining techniques to identify the most
useful metrics for predicting build outcomes. Results are presented from
applying the Hoeffding Tree classification method used in conjunction with the
Adaptive Sliding Window (ADWIN) method for detecting concept drift. The results
indicate that only a small number of the available metrics considered have any
significance for predicting the outcome of a build
Self-healing topology discovery protocol for software defined networks
“© 2018 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes, creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works. http://ieeexplore.ieee.org/document/8319433/”This letter presents the design of a self-healing protocol for automatic discovery and maintenance of the network topology in Software Defined Networks (SDN). The proposed protocol integrates two enhanced features (i.e. layer 2 topology discovery and autonomic fault recovery) in a unified mechanism. This novel approach is validated through simulation experiments using OMNET++. Obtained results show that our protocol discovers and recovers the control topology efficiently in terms of time and message load over a wide range of generated networks.Peer ReviewedPostprint (author's final draft
Tree-Chain: A Fast Lightweight Consensus Algorithm for IoT Applications
Blockchain has received tremendous attention in non-monetary applications
including the Internet of Things (IoT) due to its salient features including
decentralization, security, auditability, and anonymity. Most conventional
blockchains rely on computationally expensive consensus algorithms, have
limited throughput, and high transaction delays. In this paper, we propose
tree-chain a scalable fast blockchain instantiation that introduces two levels
of randomization among the validators: i) transaction level where the validator
of each transaction is selected randomly based on the most significant
characters of the hash function output (known as consensus code), and ii)
blockchain level where validator is randomly allocated to a particular
consensus code based on the hash of their public key. Tree-chain introduces
parallel chain branches where each validator commits the corresponding
transactions in a unique ledger. Implementation results show that tree-chain is
runnable on low resource devices and incurs low processing overhead, achieving
near real-time transaction settlement
A scalable reliable instant messenger using the SD Erlang libraries
Erlang has world leading reliability capabilities, but while it scales
extremely well within a single node, distributed Erlang has some
scalability issues. The Scalable Distributed (SD) Erlang libraries
have been designed to address the scalability limitations while
preserving the reliability model, and shown to deliver significant
performance benefits above 40 hosts using some relatively simple
benchmarks.
This paper compares the reliability and scalability of SD Erlang
and distributed Erlang using an Instant Messaging (IM) server
benchmark that is a far more typical Erlang application; a relatively
large and sophisticated benchmark; has throughput as the key
performance metric; and uses non-trivial reliability mechanisms.
We provide a careful reliability evaluation using chaos monkey.
The key performance results consider scenarios with and without
failures on up to 17 server hosts (272 cores). We show that SD
Erlang adds no performance overhead when all nodes are grouped in
a single s_group. However, either adding redundant router nodes in
distributed Erlang applications, or dividing a set of nodes into small
s_groups in SD Erlang applications, have small negative impact.
Both the distributed Erlang and SD Erlang IM tolerate failures and,
up to the failure rates measured, the failures have no impact on
throughput. The IM implementations show that SD Erlang preserves
the distributed Erlang reliability properties and mechanisms
Learning Tractable Probabilistic Models for Fault Localization
In recent years, several probabilistic techniques have been applied to
various debugging problems. However, most existing probabilistic debugging
systems use relatively simple statistical models, and fail to generalize across
multiple programs. In this work, we propose Tractable Fault Localization Models
(TFLMs) that can be learned from data, and probabilistically infer the location
of the bug. While most previous statistical debugging methods generalize over
many executions of a single program, TFLMs are trained on a corpus of
previously seen buggy programs, and learn to identify recurring patterns of
bugs. Widely-used fault localization techniques such as TARANTULA evaluate the
suspiciousness of each line in isolation; in contrast, a TFLM defines a joint
probability distribution over buggy indicator variables for each line. Joint
distributions with rich dependency structure are often computationally
intractable; TFLMs avoid this by exploiting recent developments in tractable
probabilistic models (specifically, Relational SPNs). Further, TFLMs can
incorporate additional sources of information, including coverage-based
features such as TARANTULA. We evaluate the fault localization performance of
TFLMs that include TARANTULA scores as features in the probabilistic model. Our
study shows that the learned TFLMs isolate bugs more effectively than previous
statistical methods or using TARANTULA directly.Comment: Fifth International Workshop on Statistical Relational AI (StaR-AI
2015
Animating the evolution of software
The use and development of open source software has increased significantly in the last decade. The high frequency of changes and releases across a distributed environment requires good project management tools in order to control the process adequately. However, even with these tools in place, the nature of the development and the fact that developers will often work on many other projects simultaneously, means that the developers are unlikely to have a clear picture of the current state of the project at any time. Furthermore, the poor documentation associated with many projects has a detrimental effect when encouraging new developers to contribute to the software. A typical version control repository contains a mine of information that is not always obvious and not easy to comprehend in its raw form. However, presenting this historical data in a suitable format by using software visualisation techniques allows the evolution of the software over a number of releases to be shown. This allows the changes that have been made to the software to be identified clearly, thus ensuring that the effect of those changes will also be emphasised. This then enables both managers and developers to gain a more detailed view of the current state of the project. The visualisation of evolving software introduces a number of new issues. This thesis investigates some of these issues in detail, and recommends a number of solutions in order to alleviate the problems that may otherwise arise. The solutions are then demonstrated in the definition of two new visualisations. These use historical data contained within version control repositories to show the evolution of the software at a number of levels of granularity. Additionally, animation is used as an integral part of both visualisations - not only to show the evolution by representing the progression of time, but also to highlight the changes that have occurred. Previously, the use of animation within software visualisation has been primarily restricted to small-scale, hand generated visualisations. However, this thesis shows the viability of using animation within software visualisation with automated visualisations on a large scale. In addition, evaluation of the visualisations has shown that they are suitable for showing the changes that have occurred in the software over a period of time, and subsequently how the software has evolved. These visualisations are therefore suitable for use by developers and managers involved with open source software. In addition, they also provide a basis for future research in evolutionary visualisations, software evolution and open source development
- …