In this paper we present an empirical study on the refactoring activity in three well-known projects We have studied five research questions that explore the different types of refactorings applied to different types of sources, the individual contribution of team members on refactoring activities, the alignment of refactoring activity with release dates and testing periods, and the motivation behind the applied refactorings The studied projects have a history of 12, 7, and 6 years, respectively We have found that there is very little variation in the types of refactorings applied on test code, since the majority of the refactorings focus on the reorganization and renaming of classes Additionally, we have identified that the refactoring decision making and application is often performed by individual refactoring "managers" We have found a strong alignment between refactoring activity and release dates Moreover, we found that the development teams apply a considerable amount of refactorings during testing periods Finally, we have also found that in addition to code smell resolution the main drivers for applying refactorings are the introduction of extension points, and the resolution of backward compatibility issues

A multidimensional empirical study on refactoring activity

This paper proposes a novel feature-based photo album compression scheme for cloud storage. The main contribution of this paper is the use of local features rather than pixel values for analyzing and exploring the correlation between images. Unlike previously established image set compression schemes, we adopt content-based feature matching, which is invariant to scale, rotation, and robust to illumination changes, in both correlation estimation and redundancy reduction. Based on feature-based correlation analysis, we organize correlated images as a pseudo sequence by minimizing the predictive cost. Since pseudo sequences have much more complicated correlations than natural videos, we further propose a three-step prediction to reduce inter-image redundancy based on local features. We first propose a feature-based multi-model approach to reduce local geometric deformations between images, resulting in multiple deformed predictions. We then decrease the illumination difference between each deformed prediction and the target image with a photometric transformation. Finally, we reduce redundancy between images using a block-based motion compensation, similar to video compression. Experimental results show that our proposed feature-based coding scheme can be 10 times more efficient than individual JPEG compression.

Photo Album Compression for Cloud Storage Using Local Features

In this paper, we describe a versioned database storage manager we are developing for the SciDB scientific database. The system is designed to efficiently store and retrieve array-oriented data, exposing a ``no-overwrite'' storage model in which each update creates a new ``version'' of an array. This makes it possible to perform comparisons of versions produced at different times or by different algorithms, and to create complex chains and trees of versions. We present algorithms to efficiently encode these versions, minimizing storage space while still providing efficient access to the data. Additionally, we present an optimal algorithm that, given a long sequence of versions, determines which versions to encode in terms of each other (using delta compression) to minimize total storage space or query execution cost. We compare the performance of these algorithms on real world data sets from the National Oceanic and Atmospheric Administration (NOAA), Open Street Maps, and several other sources. We show that our algorithms provide better performance than existing version control systems not optimized for array data, both in terms of storage size and access time, and that our delta-compression algorithms are able to substantially reduce the total storage space when versions exist with a high degree of similarity.

Efficient Versioning for Scientific Array Databases

The biggest challenge in image set compression is how to efficiently remove the set redundancy among images as well as the redundancy inside a single image. Different from all the previous schemes, in this paper we are the first to propose a generic image set compression scheme which removes the set redundancy based on local features in addition to luminance values. The SIFT (Scale Invariant Feature Transform) descriptor which characterizes an image region invariant to scale and rotation is utilized in our scheme to measure and further enhance the correlation among images. Given an image set, we build a minimal cost prediction structure according to the SIFT-based prediction measure between images. We also utilize a SIFT-based global transformation to enhance the correlation between two images by aligning them to each other in terms of both geometry and intensity. The set redundancy and image redundancy are both further reduced by block-based motion estimation and rate-distortion optimal mechanism proposed in HEVC. Experimental results show that our new feature based scheme always produces the best result regardless the image set's properties.

Feature-based image set compression

Several conventions and standards aim to improve maintain-ability of software code. However, low levels of code readabil- ity perceived by developers still represent a barrier to their daily work. In this paper, we describe a survey that assessed the impact of a set of Java coding practices on the readability perceived by software developers. While some practices pro- moted an enhancement of readability, others did not show statistically signicant effects. Interestingly, one of the prac- tices worsened the readability. Our results may help to iden- tify coding conventions with a positive impact on readability and, thus, guide the creation of coding standards.

Impacts of coding practices on readability

Maintainability is a desired property of software, and a variety of metrics have been proposed for measuring it, focusing on different notions of complexity and code readability. Many practices have been proposed to improve maintainability through code refactorings: improving the cohesion, simplification of interfaces, renamings to improve understandability. Code conventions are a body of advice on lexical and syntactic aspects of code, aiming to standardize low-level code design under the assumption that such a systematic approach will make code easier to read, understand, and maintain. We present the first stage in our examination of code-convention adherence practices as a proxy measurement for maintainability. Based on a preliminary survey of software engineers, we identify a set of coding conventions that most relate to maintainability. Then we devise a “convention adherence” metric, based on the number and severity of violations of a defined coding convention. Finally, we analyze several open-source projects according to this metric to better understand how consistent different teams are with respect to adopting and conforming to code conventions.

Code convention adherence in evolving software

While the compression of individual images have been studied extensively, there have been fewer studies on the problem of compressing image sets. A number of schemes have been proposed to compress an image set by taking advantage of the inter-image redundancy between pairs of images. In this paper, we present a unified graph-theoretic framework that includes all such previous schemes. A minimum spanning tree gives the optimal compression method for lossless compression. We also show that while this framework does not necessarily give the optimal compression scheme for lossy compression, we can provide performance guarantees relative to the optimal scheme. Our experiments show that the new minimum spanning tree method performs better than the previous schemes, especially when the image sets are not well suited for any of the previously proposed schemes.

/pdf/a-unified-framework-for-image-set-compression-2n0lnh4ihn.pdf

A Unified Framework for Image Set Compression.

Maintainability is a desirable property of software, and a variety of metrics have been proposed for measuring it, all based on different notions of complexity. Although these metrics are useful, complexity is only one factor influencing maintainability. Practical experience in software development has led to a set of best practices and coding conventions that are believed to make source code easier to read, understand and maintain. Based on a survey of software engineers, we identify the relative importance of 71 coding conventions to maintainability. We propose a metric that offers a different perspective on maintenance, namely a “convention adherence” metric based on the number and severity of violations of these coding conventions. We examine the code repositories of four open-source Java projects to measure their adherence to coding conventions over the life of the project, based on both their self-identified conventions and those of the convention-adherence metric. Through our analysis, we discovered several interesting phenomena, including pre-release effort to bring new code in line with desirable conventions, effective usage of automated code convention checkers as part of the build process to improve adherence, variations in adherence over the software lifecycle, and a class of conventions consistently ignored in open source projects.

/pdf/maintainability-and-source-code-conventions-an-analysis-of-s9jtrg1735.pdf

Maintainability and Source Code Conventions: An Analysis of Open Source Projects

We consider the evaluation of the truncated hypergeometric series[EQUATION]to high precision, where a, b, p, and q are polynomials with integer coefficients, and a(n), b(n), p(n), q(n) have bit length O(log n). We also assume that the series is linearly convergent, so that the nth term of (1) is O(c-n) with c > 1. These series are commonly used in the high precision evaluation of elementary functions and other constants, including the exponential function, logarithms, trigonometric functions, and constants such as the Apery's constant ζ(3) [9, 10]."Binary splitting" is an approach that has been independently discovered and used by many authors in the computation of (1) [2, 3, 4, 5, 8, 10, 12]. Binary splitting computes the numerator and denominator of the rational number S(N). The decimal representation of S(N) is then computed by fixed-point division of the numerator by the denominator. The binary splitting approach takes advantage of the special form of the series (1) to obtain a denominator that is relatively small (of size O(N log N)). It also takes advantage of fast integer multiplication to obtain a time complexity of O((log N)2M(N)), where M(N) = O(N log N log log N) is the complexity of integer multiplication of two N-bit integers [16]. The space complexity of the algorithm is O(N log N), the size of the computed numerator and denominator.Typically, the numerator and denominator computed by binary splitting have large common factors. For example, in the computation of 640000 digits of ζ(3), as much as 86% of the size of the computed numerator and denominator can be attributed to their common factor [7]. Empirically, we have observed that the size of the reduced numerator and denominator is O(N) instead of O(N log N) as computed by binary splitting. The additional digits computed not only slow down the final division but also require more memory to be used during the computation. For computing a large number of decimal digits, either the computation cannot be done at all or some data would have to be swapped out of memory, increasing the computation time dramatically.In this poster, we study the application of well-known techniques in computer algebra to the evaluation of (1). If a bound on the size of the reduced numerator and denominator is known, we can compute the image of S(N) in (1) under an appropriately chosen modulus. Fast rational number reconstruction can then be applied to recover the reduced numerator and denominator [13, 14, 15, 17]. We show how to apply our techniques to the computation of ζ(3), including the prediction of the size of the reduced numerator and denominator. In particular, we obtain the desired O(N) bound on the size of reduced numerator and denominator, which is an interesting result by itself. The techniques used in the analysis can be applied to similar hypergeometric series.

/pdf/space-efficient-evaluation-of-hypergeometric-series-1h2usoh5lo.pdf

Space-efficient evaluation of hypergeometric series

Summary form only given. This paper presents a framework to effectively compress sets of images in a lossless manner. An image set is represented as a graph and its minimum spanning tree is computed to decide which images and differences to encode. The Centroid scheme and the previous MST scheme can both be represented as a spanning tree in our graph. Thus, the scheme is guaranteed to be no worse than these previous schemes. In fact, the framework provides the best lossless compression for all schemes that consider interimage redundancy between two images in a set. Experimental results show that the new MST method always produces the best result regardless of the properties of the image sets. In some cases, the first-order entropy of the image set using our scheme results in a 29% improvement over the traditional scheme of compressing each image individually.

Barry Gergel

Papers

Code convention adherence in evolving software

A Unified Framework for Image Set Compression.

Maintainability and Source Code Conventions: An Analysis of Open Source Projects

Space-efficient evaluation of hypergeometric series

A unified framework for lossless image set compression