Architecture smells detection¶
The quality of your architecture decides vital quality parameters of your software product. DesigniteJava detects various architecture smells in your code to help you improve the agility of your software.
Cyclic Dependency: This smell arises when two or more architecture components depend on each other directly or indirectly.
Unstable Dependency: This smell arises when a component depends on other components that are less stable than itself.
Ambiguous Interface: This smell arises when a component offers only a single, general entry-point into the component.
God Component: This smell occurs when a component is excessively large either in the terms of LOC or number of classes.
Feature Concentration: This smell occurs when a component realizes more than one architectural concern/feature.
Scattered Functionality: This smell arises when multiple components are responsible for realizing the same high-level concern.
Dense Structure: This smell arises when components have excessive and dense dependencies without any particular structure.
Design smells detection¶
Design smells are certain structures in the design that indicate violation of fundamental design principles and negatively impact design quality.” (from Refactoring for Software Design Smells: Managing Technical Debt)
DesigniteJava identifies design smells and presents them in a view that classifies them based on the fundamental principle they violate. In addition, DesigniteJava also points out the cause of the smell and therefore provides a clue towards refactoring of the smell.
The following design smells are detectable by DesigniteJava:
Abstraction Design Smells: Imperative Abstraction, Unnecessary Abstraction, Multifaceted Abstraction, Unutilized Abstraction, Feature Envy.
Encapsulation Design Smells: Deficient Encapsulation, Unexploited Encapsulation.
Modularization Design Smells: Broken Modularization, Insufficient Modularization, Hub-like Modularization, Cyclically-dependent Modularization.
Hierarchy Design Smells: Wide Hierarchy, Deep Hierarchy, Multipath Hierarchy, Cyclic Hierarchy, Rebellious Hierarchy, Missing Hierarchy, Broken Hierarchy.
Detect implementation smells¶
DesigniteJava supports variety of smells that may occur at implementation level as well. Refactoring these smells lead to better code quality. DesigniteJava supports detection of the following implementation smells:
Abstract Function Call From Constructor
Empty catch clause
Long Parameter List
Detect testability smells¶
Testability refers to the degree to which the development of test cases can be facilitated by the software design choices. DesigniteJava supports the following testability smells.
Law of Demeter violation
Detect test smells¶
Test smells are defined as bad programming practices in unit test code that indicate potential design problems in the test code. DesigniteJava supports the following test smells.
Conditional test logic
Compute object-oriented metrics¶
DesigniteJava computes object-oriented design metrics that are helpful to gauge the structural health of the software project. A list of supported metrics by DesigniteJava is presented below.
LOC (Lines Of Code - at method and class granularity)
CC (Cyclomatic Complexity - Method)
PC (Parameter Count - Method)
NOF (Number of Fields - Class)
NOPF (Number of Public Fields - Class)
NOM (Number of Methods - Class)
NOPM (Number of Public Methods - Class)
WMC (Weighted Methods per Class - Class)
NC (Number of Children - Class)
DIT (Depth of Inheritance Tree - Class)
LCOM (Lack of Cohesion in Methods - Class)
FANIN (Fan-in - Class)
FANOUT (Fan-out - Class)