19,595 research outputs found
Review on software metrics thresholds for object-oriented software
Software metrics like any other measures have been advocated as the essential tool in Object-oriented systems. Controlling software metrics is an important for building quality software systems. Software metrics thresholds have been used in various disciplines in identifying the unsafe design by setting an alarm at a place where the value of the specific internal measure exceeds some predefined values. Although, the researchers and other practitioners tried to introduce a variety of software metrics, but the issue of thresholds has been given limited attention. A few meaningful software metric thresholds have been introduced in the literature. In this review paper, the authors went through different literatures to identify the existing object-oriented software metrics thresholds in order to gain an insight about the phenomena. By studying the validation process and the sensations of the metrics presented in the literature, the study found the thresholds for CK metrics have been validated more than any other metrics
Evaluation Criteria for Object-oriented Metrics
In this paper an evaluation model for object-oriented (OO) metrics is proposed. We have evaluated the existing evaluation criteria for OO metrics, and based on the observations, a model is proposed which tries to cover most of the features for the evaluation of OO metrics. The model is validated by applying it to existing OO metrics. In contrast to the other existing criteria, the proposed model is simple in implementation and includes the practical and important aspects of evaluation; hence it suitable to evaluate and validate any OO complexity metric
Bayesian Hierarchical Modelling for Tailoring Metric Thresholds
Software is highly contextual. While there are cross-cutting `global'
lessons, individual software projects exhibit many `local' properties. This
data heterogeneity makes drawing local conclusions from global data dangerous.
A key research challenge is to construct locally accurate prediction models
that are informed by global characteristics and data volumes. Previous work has
tackled this problem using clustering and transfer learning approaches, which
identify locally similar characteristics. This paper applies a simpler approach
known as Bayesian hierarchical modeling. We show that hierarchical modeling
supports cross-project comparisons, while preserving local context. To
demonstrate the approach, we conduct a conceptual replication of an existing
study on setting software metrics thresholds. Our emerging results show our
hierarchical model reduces model prediction error compared to a global approach
by up to 50%.Comment: Short paper, published at MSR '18: 15th International Conference on
Mining Software Repositories May 28--29, 2018, Gothenburg, Swede
Should I Bug You? Identifying Domain Experts in Software Projects Using Code Complexity Metrics
In any sufficiently complex software system there are experts, having a
deeper understanding of parts of the system than others. However, it is not
always clear who these experts are and which particular parts of the system
they can provide help with. We propose a framework to elicit the expertise of
developers and recommend experts by analyzing complexity measures over time.
Furthermore, teams can detect those parts of the software for which currently
no, or only few experts exist and take preventive actions to keep the
collective code knowledge and ownership high. We employed the developed
approach at a medium-sized company. The results were evaluated with a survey,
comparing the perceived and the computed expertise of developers. We show that
aggregated code metrics can be used to identify experts for different software
components. The identified experts were rated as acceptable candidates by
developers in over 90% of all cases
JSClassFinder: A Tool to Detect Class-like Structures in JavaScript
With the increasing usage of JavaScript in web applications, there is a great
demand to write JavaScript code that is reliable and maintainable. To achieve
these goals, classes can be emulated in the current JavaScript standard
version. In this paper, we propose a reengineering tool to identify such
class-like structures and to create an object-oriented model based on
JavaScript source code. The tool has a parser that loads the AST (Abstract
Syntax Tree) of a JavaScript application to model its structure. It is also
integrated with the Moose platform to provide powerful visualization, e.g., UML
diagram and Distribution Maps, and well-known metric values for software
analysis. We also provide some examples with real JavaScript applications to
evaluate the tool.Comment: VI Brazilian Conference on Software: Theory and Practice (Tools
Track), p. 1-8, 201
RefDiff: Detecting Refactorings in Version Histories
Refactoring is a well-known technique that is widely adopted by software
engineers to improve the design and enable the evolution of a system. Knowing
which refactoring operations were applied in a code change is a valuable
information to understand software evolution, adapt software components, merge
code changes, and other applications. In this paper, we present RefDiff, an
automated approach that identifies refactorings performed between two code
revisions in a git repository. RefDiff employs a combination of heuristics
based on static analysis and code similarity to detect 13 well-known
refactoring types. In an evaluation using an oracle of 448 known refactoring
operations, distributed across seven Java projects, our approach achieved
precision of 100% and recall of 88%. Moreover, our evaluation suggests that
RefDiff has superior precision and recall than existing state-of-the-art
approaches.Comment: Paper accepted at 14th International Conference on Mining Software
Repositories (MSR), pages 1-11, 201
Identifying and improving reusability based on coupling patterns
Open Source Software (OSS) communities have not yet taken full advantage of reuse mechanisms. Typically many OSS projects which share the same application domain and topic, duplicate effort and code, without fully leveraging the vast amounts of available code.
This study proposes the empirical evaluation of source code folders of OSS projects in order to determine their actual internal reuse and their potential as shareable, fine-grained and externally reusable software components by future projects.
This paper empirically analyzes four OSS systems, identifies which components (in the form of folders) are currently being reused internally and studies their coupling characteristics. Stable components (i.e., those which act as service providers rather than service consumers) are shown to be more likely to be reusable. As a means of supporting replication of these successful instances of OSS reuse, source folders with similar patterns are extracted from the studied systems, and identified as externally reusable components
- …