Features

1. Detect Architecture Smells

(click to expand/collapse)
The quality of your architecture decides vital quality parameters of your software product. Designite detects various architecture smells in your code to help you help you improve the agility of your software.

Designite identifies architecture smells and presents them in a sunburst visualization. Each detected smell is presented with its definition and its cause. This information could be used to analyze the identified smell further and plan for refactoring of the smell.

The  following architecture smells are detectable by Designite:

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.

2. Detect Design Smells

(click to expand/collapse)
Designite detects various design smells in your code to help you manage your “design debt”.“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)

Designite identifies design smells and presents them in a view that classifies them based on the fundamental principle they violate. In addition, Designite 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 Designite:

Abstraction Design Smells

Imperative Abstraction, Unnecessary Abstraction, Multifaceted Abstraction, Unutilized Abstraction, Duplicate Abstraction.

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, Unfactored Hierarchy, Missing Hierarchy.

Please note that the Designite follows classification proposed by “Refactoring for Software Design Smells: Managing Technical Debt” by Girish Suryanarayana, Ganesh Samarthyam, and Tushar Sharma.

Smells_smaller
Sunburst visualization of detected design smells to support better navigation and filtering

3. Compute Metrics

(click to expand/collapse)
Designite computes object-oriented design metrics that are helpful to gauge the structural health of the software project. Designite classifies these metrics in four categories: solution-level metrics, project-level metrics, method-level metrics and class-level metrics. Designite highlights specific metric values that violate metric threshold as a metric violation in a different color to help you spot the violations.

Solution-level Metrics

LOC (Lines Of Code), NON (Number Of Namespaces), NOC (Number Of Classes), NOM (Number Of Methods), MV (Metrics Violations), SD (Smell Density), DUP (Code Duplication).

Project-level Metrics

LOC (Lines Of Code), NON (Number Of Namespaces), NOC (Number Of Classes), NOM (Number Of Methods), MV (Metrics Violations), SD (Smell Density), DUP (Code Duplication), DDS (Detected Design Smells).

Class-level Metrics

NOF (Number Of Fields), NOM (Number Of Methods), NOP (Number Of Properties), NOPF (Number of Public Fields), NOPM (Number of Public Methods), LOC (Lines of Code), WMC (Weighted Methods per Class), NC (Number of Children), DIT (Depth of Inheritance Tree), LCOM (Lack of Cohesion of Methods), FANIN (Fan-in), FANOUT (Fan-out).

Method-level Metrics

LOC (Lines Of Code), CC (Cyclomatic Complexity), PC (Parameter Count).

DeeperMetricsAnalysis
Pie chart visualization for computed metrics

4. Analyze Trend

(click to expand/collapse)
Designite supports “trend analysis” to reveal evolution of software from the smells perspective. Specifically, the trend shows how many smells (both design and implementation) have been introduced, remained, and removed from one version to another. It is useful when the development team wanted to observe the quality of the software especially after a refactoring cycle.

summary_new
Observe evolution of your code from smell’s perspective

5. Smell Distribution (Treemap)

(click to expand/collapse)

Designite allows the user to see the distribution of design and implementation smells using Treemap. The smell treemap shows two dimensions – size of classes/namespace and corresponding severity of smell density. The diagram shows severity of smell density using intuitive color scheme; smell density increases from green to red.

smallertreemap
Treemap

6. Dependency Structure Matrix

(click to expand/collapse)

The Dependency Structure Matrix (DSM) is a compact and visual representation of dependencies (with corresponding strength) among software system entities (such as Type, Namespace, or Project) in the form of a square matrix. Designite offers an interactive and simple yet effective implementation of DSM.

dsm_smaller
DSM for dependency analysis

7. Detect Implementation Smells

(click to expand/collapse)
Designite supports variety of smells that may occur at implementation level as well (in addition to design smells). Refactoring these smells lead to better code quality.Designite supports detection of the following implementation smells:
Long Method, Complex Method, Long Parameter List, Long Identifier, Long Statement, Complex Conditional, Virtual Method Call from Constructor, Empty Catch Block, Magic Number, Duplicate Code, Missing Default.

implsunburst
Sunburst visualization for detected implementation smells for easier navigation and filtering

8. Identify Code Clones

(click to expand/collapse)
Designite detects code duplication in your code and reports design smells based on the identified clones. The identified code clones can be further analyzed manually by exploring the excel sheet generated by Designite that contains information associated with code clones along with the identified design smells and metrics.

9. Console Application

(click to expand/collapse)

Designite provides a console application with various options to allow integration with external tools. For instance, one can integrate Designite with SonarQube to see the design smells detected by Designite in SonarQube.
The new console application not only supports previously supported functionality (analyze projects and export results in MS Excel, XML, or CSV formats) but also allows a user to carry out trend analysis with a rich set of options.

Usage instructions of the new Designite console application
Usage instructions of the new Designite console application

10. Customize Your Quality Analysis

(click to expand/collapse)

Every piece of code is different in terms of domain, context, and its quality requirements. Measuring quality aspects of all the software systems using the same stick is not appropriate and often not desirable. Keeping it in mind, Designite has introduced a new feature “Preferences” in version 1.33.0 to allow users to customize their analysis by selecting thresholds based on their context and requirements.

Customize Your Quality Analysis
Customize Your Quality Analysis

11. Identify Hotspots

(click to expand/collapse)
The hotspot analysis assigns a “Hotspot score” to each class based on the detected design smells in the class and highlights the classes that you may choose for refactoring first.

hotspots
Hotspot analysis

12. Export Results

(click to expand/collapse)

Designite allows you to export the analyzed information (detected smells and computed metrics). Three export formats are available to choose from MS Excel, XML, and CSV. This extremely useful feature allows you to share the result of the tool with other stakeholders in your team and analyze the results further.

13. Summary of Design Analysis

(click to expand/collapse)
Designite analyzes the design of your software and presents the summary of the analysis in a graphical form. The summary shows the distribution of smells in the form of a treemap. Two pie charts are also presented showing the summary of detected architecture and design smells. The summary also includes total size of the software solution in LOC, total number of metric violations and design smells, and design smell density per KLOC. In addition, the project-specific numbers are also presented.

14. Visual Studio Extensions

(click to expand/collapse)
With the version 2.1.1, Designite offers Visual Studio extension of Designite. This will allow developers to analyze their source code right in their working environment. One can keep an instance of Designite open in a tab within the IDE and refer the detected smells for refactoring. The extension is available for Visual Studio 2015 and 2017.

Visual Studio extension