DesigniteJava is a code quality assessment tool for code written in Java.
It detects numerous architecture, design, and implementation smells that show maintainability issues
present
in the analyzed code. It also computes many commonly used object-oriented metrics. It helps you reduce
technical debt and improve maintainability of your software.
The Enterprise edition of DesigniteJava not only supports the features offered by DesigniteJava
Community edition
but also comes with additional features such as support to
detect architecture smells.
Other additions include cause of smell which plays a significant
role to
understand the reported smell and take corrective action along with many stability improvements and bug
fixes compared
to the community edition.
Free
Download - DesigniteJava (Enterprise)
Buy DesigniteJava
If you are an academic researchers and would like to use DesigniteJava Enterprise edition for
research/educational purposes, you may request an academic
license for the same.
Features
DesigniteJava detects 7 smells at architecture granularity that impact
maintainability of your software architecture.
DesigniteJava detects 18 design smells violating one of the
object-oriented
design principles.
DesigniteJava detects 10 implementation smells to keep your software
readable
and less complex.
DesigniteJava computes object-oriented design metrics that are helpful to
gauge the structural health of a software.
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 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.
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
- Complex Conditional
- Complex Method
- Empty catch clause
- Long Identifier
- Long Method
- Long Parameter List
- Long Statement
- Magic Number
- Missing default
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)
Visit the DesigniteJava documentation for detailed
DesigniteJava usage instructions.