On the Shape of Circular Dependencies in Java Programs

@article{AlMutawa2014OnTS,
  title={On the Shape of Circular Dependencies in Java Programs},
  author={Hussain A. Al-Mutawa and Jens Dietrich and Stephen R. Marsland and Catherine McCartin},
  journal={2014 23rd Australian Software Engineering Conference},
  year={2014},
  pages={48-57}
}
Circular dependencies between software artefacts are widely considered as problematic. However, empirical studies of Java programs have shown that most programs are riddled with circular dependencies. This seems to imply that not all circular dependencies are as detrimental to software quality as previously thought. Clearly, a better understanding of the types of circular dependency and their effect on software quality is required. In this paper, we provide precise definitions for different… 

Circular dependencies and change-proneness: An empirical study

TLDR
It is found that the presence of cycles can have a significant impact on the change proneness of the classes near these cycles and neither subtype knowledge nor the location of the cycle within the package containment tree are suitable criteria to distinguish between critical and harmless cycles.

Visual exploration of dependency graph in source code via embedding-based similarity

TLDR
This paper proposes a novel visual analytics system to explore code dependencies between files for visually understanding software architecture and interactively analyzing bad dependencies.

Systematic Review of Dependencies in Source Code of Software and Their Categorization

  • Mrinaal MalhotraJ. Chhabra
  • Computer Science
    Proceedings of 2nd International Conference on Communication, Computing and Networking
  • 2018
TLDR
Categorization of various source code dependencies is proposed, which can be useful for organizing dependencies based on the applications and also focuses on their computation methodologies and application.

Exploring the Relation Between Co-changes and Architectural Smells

TLDR
The findings show that Reliability is indirectly affected by low levels of Maintainability even at the architectural level, because low-quality components require more frequent changes by the developers, increasing chances to eventually introduce faults.

Identifying Domain-Based Cyclic Dependencies in Microservice APIs Using Source Code Detectors

TLDR
A novel approach for identifying and evaluating domain-based cyclic dependencies in microservice systems based on modular, reusable source code detectors based on the architecture model reconstructed by the detectors, and derived a set of architectural metrics for detecting and classifying domain- based cyclical dependencies.

Detecting Incompatibilities Concealed in Duplicated Software Libraries

  • Kamil JezekJan Ambroz
  • Computer Science
    2015 41st Euromicro Conference on Software Engineering and Advanced Applications
  • 2015
TLDR
This work cope with the problem of duplicate libraries and detect situations when a system contains different versions of the same library, one of which should be removed to retain system consistency.

Arcan: A Tool for Architectural Smells Detection

TLDR
This paper describes an open-source tool called Arcan developed for the detection of architectural smells through an evaluation of several different architecture dependency issues and focuses on the evaluation of Arcan results carried out with real-life software developers to check if the architectural smells detected by Arcan are really perceived as problems and to get an overall usefulness evaluation of the tool.

[Research Paper] Towards Anticipation of Architectural Smells Using Link Prediction Techniques

TLDR
This work explores a forward-looking approach that is able to infer groups of likely module dependencies that can anticipate architectural smells in a future system version, and focuses on dependency-related smells, such as Cyclic Dependency and Hub-like Dependency, which fit well with the link prediction model.

Support for architectural smell refactoring

TLDR
This position paper presents a tool prototype that suggests which path a developer could follow to remove Cyclic Dependency smells in Java applications, developed as an extension of the Arcan tool for architectural smells detection.

On the evolution and impact of Architectural Smells - An industrial case study

TLDR
This quantitative findings show how individual smell instances evolve over time, how long they typically survive within the system, how they overlap with instances of other smell types, and finally what the introduction order of smell types is when they overlap.

References

SHOWING 1-10 OF 33 REFERENCES

On the Automation of Dependency-Breaking Refactorings in Java

TLDR
This work presents an algorithm and a proof-of-concept implementation that removes unwanted dependencies from Java programs by removing unwanted dependencies without affecting the functionality of the program.

Using dependency models to manage complex software architecture

An approach to managing the architecture of large software systems is presented. Dependencies are extracted from the code by a conventional static analysis, and shown in a tabular form known as the

On the Existence of High-Impact Refactoring Opportunities in Programs

TLDR
A novel approach to detect starting points for the architectural refactoring of large and complex systems based on the analysis and manipulation of the type dependency graph extracted from programs, which is motivated by the emergence of technologies such as dependency injection frameworks and dynamic component models.

Identifying Cycle Causes with Enriched Dependency Structural Matrix

TLDR
Enriched DSM (eDSM) is presented where cells are enriched with contextual information about the type of dependencies (inheritance, class reference...), the proportion of referencing entities, and theportion of referenced entities is presented.

An empirical study of cycles among classes in Java

TLDR
This paper presents the first significant empirical study of cycles among the classes of 78 open- and closed-source Java applications, finding that, of the applications comprising enough classes to support such a cycle, about 45% have a cycle involving at least 100 classes and around 10% have at least 1,000 classes.

Barriers to Modularity - An Empirical Study to Assess the Potential for Modularisation of Java Programs

TLDR
The key findings of this paper are that almost all programs investigated have a significant number of these patterns, implying that modularising will be therefore difficult and expensive.

Jooj: Real-Time Support For Avoiding Cyclic Dependencies

TLDR
The 'real-time checking' approach to proactively check for dependency cycles as a developer writes code is demonstrated, analogous to a well-known manufacturing quality assurance technique known as poka-yoke.

MudPie: layers in the ball of mud

Comparative analysis of evolving software systems using the Gini coefficient

TLDR
This work proposes to analyze software metrics using the Gini coefficient, a higherorder statistic widely used in economics to study the distribution of wealth, and shows that many metrics not only display remarkably high Gini values, but that these values are remarkably consistent as a project evolves over time.

The Qualitas Corpus: A Curated Collection of Java Code for Empirical Studies

TLDR
The Qualitas Corpus, a large curated collection of open source Java systems, is described, which reduces the cost of performing large empirical studies of code and supports comparison of measurements of the same artifacts.