Designite

Designite is a software design quality assessment tool. It analyzes C# codebase and detects a comprehensive set of architecture, design, and implementation smells. Currently, Designite supports detection of 7 common architecture, 19 design, and 11 implementation smells. Designite computes more than 30 source code metrics to gauge the structural health of a software system. Designite offers a rich set of visualizations for software developers, designers, and architects to visualize various issues affecting the maintainability of their software. These visualizations include sunburst diagram for showing detected smells, treemap diagram for visualizing the distribution of smells in a codebase, and a pie-chart of the metrics for holistically visualizing the state of the code from a specific metrics point of view. Additionally, the tool supports detection of code clones, prepares DSM (Dependency Structure Matrix), and performs trend analysis showing the number of smells remained, refactored, and introduced in a new version from its previous version.

Features

1. Detect Architecture Smells

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.

The following architecture smells are detectable by Designite:

1. Cyclic Dependency
2. Unstable Dependency
3. Ambiguous Interface
4. God Component
5. Feature Concentration
6. Scattered Functionality
7. Dense Structure

2. Detect Design Smells

Designite detects various design smells in your code to help you manage your "design 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.

3. Compute Metrics

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).

4. Analyze Trend

Designite supports "trend analysis" to reveal the 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.

5. Action Hub

Action Hub is your friend when it comes to track, manage, and plan identified smells in a project. Based on the semantics, you may change the status of identified smells to one of the four smell status supported by Designite (i.e., Identified, Wrong, Drop, Refactor). By selecting one of the statuses, you are essentially analyzing the identified smells and preparing a plan to resolve them. Within Action Hub, you may also filter the smells based on various factors such as smell types (architecture, design, or implementation), smell status, or belonging to a source code element (such as project or namespace).

6. Smell Distribution (Treemap)

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 the severity of smell density using intuitive color scheme; smell density increases from green to red.

7. Dependency Structure Matrix

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.

8. Detect Implementation Smells

Designite supports a 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

9. Identify Code Clones

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.

10. Console Application

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.

11 Customize Your Quality Analysis

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.

12. Identify Hotspots

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.

13. Export Results

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.

Which problems can be addressed using Designite?

• Identification of architecture, implementation, and design smells. Refactoring these smells improve the maintainability of the software.
• Monitoring the quality of software by employing trend analysis.
• Interactive software design quality analysis by using the provided visualization and comprehension aids
• Refactoring guidance based on the kind and number of smells identified in a piece of code

More information can be found here.