A wide range of tools are used

• Cppcheck: Cppcheck supports a wide variety of static checks that may not be covered by the compiler itself. These checks are static analysis checks that can be performed at a source code level. The program is directed towards static analysis checks that are rigorous, rather than heuristic in nature.


• Clang: Clang aims to produce beautiful diagnostics by default, particularly for new users that first come to Clang. However, different people have different preferences, and sometimes Clang is driven by another program that wants to parse simple and consistent output, not a person. For these cases, Clang provides a wide range of options to control the exact output format of the diagnostics that it generates.


• C++ Modernizer: is a standalone tool used to parse C++ code written against old standards to suggest the use of features of the newest C++ standard where appropriate.


• Visual Studio Analyzer: Visual Studio Analyzer is a performance analysis tool you can use to examine and debug distributed applications. As your application runs, Visual Studio Analyzer can record data about its performance and execution


• CppDepend: CppDepend manages complex code base and achieves high Code Quality. With CppDepend, software quality can be measured using Code Metrics, visualized using Graphs and Treemaps, and enforced using standard and custom Rules.


• Vera++: Vera++ is a programmable tool for verification, analysis and transformation of C++ source code. Vera++ provides source code metrics and statistics.


• Our technical team: Our highly skilled engineers have comprehensive knowledge of these listed tools to give you the most positive reports about your project implementation.

Checked aspects

The analysis will concern the design and the implementation of your project. Here are some checked aspects:

• Issues detected from Clang, CppCheck, Visual Studio Analyzer and Vera ++,
• Coupling,
• Cohesion,
• Abstracness vs Instability,
• Inheritence,
• Dependency cycles,
• Layering issues,
• Purity - immutability,
• Types too complex,
• Methods too complex,
• Naming Conventions,
• Template best practices,
• Object oriented Design best practices,
• Dead Code.