As a static analyzer, VBDepend will likely find hundreds or even thousands of issues affecting a real-world code base. Stopping work to attempt to fix all issues for weeks would be quite unproductive. Recent code smells that should be fixed before committing any code to source control are highlighted in VisualVBDepend. They can then be fixed even before reaching the source server. As a consequence the Code Quality remains under control with no major upfront investment.

Because we know developer time is invaluable, VBDepend is fast, very fast.

The analysis results can be re-estimated within just a few seconds, even for hundreds of rules passed on a very large code base and, as we are aware of its importance, without any noticeable IDE slow down.

Fixing issues is much easier as the developer is immediately informed with no delay of new issues just created, while the context is still fresh in her mind and while the code is not checked-in yet to the source control server.

Because a picture is worth a thousand words, VBDepend proposes several unique ways to visualize your code. This includes:

Trend Charts
Dependency Graph
Dependency Matrix
Code Metrics Colored Treemaping

Code maintainability improves. This positively impacts the productivity of development teams.

Over time, developers get educated about rules to follow and their skills improve.

Architects can anticipate the impact of code changes. The right decisions are taken early.

Since quality is checked automatically and continuously with a strong focus on recent changes, the team builds better code.

Executives gain control over costs and risks thanks to light being shed on development facts and trends that matter most.

CQLinq: Code Query Linq

VBDepend lets query the code base over LINQ queries thanks to CQLinq. For example the following CQLinq query matches all methods that have more than 30 lines of code:

80 default queries and rules are provided when you create a new VBDepend project. They are easy to read and easy to adapt to your need.

Writing CQLinq queries and constraints is straightforward both because it is C# LINQ syntax and because VBDepend provides a CQLinq editor which supports:

Code completion / intellisense,
Live compile error description,
Integrated tooltip documentation.

Also, once the query is compiled, it gets executed immediately and its result is well displayed and browsable:

Short CQLinq queries can be written (or even generated) to get some immediate answers to questions about a code base.

Is the code layered correctly?

Code Quality Metrics

There are many ways to measure a code base. The most common way is to count the number of lines of code. This metric gives a rough estimation of the effort that had been put in to develop the code base. It also allows you to obtain a quality level agreement by pinpointing fat methods and classes.

VBDepend counts the number of lines of code. It also comes with more than 60 other code metrics. Some of them are related to your code organization (the number of classes or Packages, the number of methods declared in a class...), some of them are related to code quality (complexity, percentage of comments, number of parameters, cohesion of classes, stability of Projects...), some of them are related to the structure of code (which types are the most used, depth of inheritance...).

Metrics on Application,
Metrics on Projects,
Metrics on Packages,
Metrics on Types,
Metrics on Methods,
Metrics on fields.

Trend Monitoring

VBDepend lets create trend charts. Trend charts are made of trend metrics values logged over time at analysis time. More than 50 trend metrics are available per default and it is easy to create your own trend metrics.

Trend charts are displayed on the VBDepend dashboard. Some trend charts are available per default to show:
Lines of code,
Number of Code Rules Violated and number of Code Rules Violations,
Max and Average values for various Code Quality Metrics,
Third-Party Usage.
Trend charts can be customized and it is easy to create your own trend charts to show default trend metrics and/or custom trend metrics.

Measuring a code base trends with VBDepend comes with many flexible sub-features:

Lines of code,
Trend charts can be created and customized,
New Trend metrics can be written through CQLinq queries.

Explore Existing Architecture

It is vital information to know how the elements of a code base depend on each other. As a developer you spend time thinking about how your layers should interact, creating interfaces and events to avoid dependencies between concrete classes.

As the code base grows, more and more time is spent managing and analyzing dependencies. If I refactor this piece of code, what will be the global impact? Is this layer allowed to access directly DB? Will I accidentally freeze the UI thread if my code invokes this method?

VBDepend comes with several facilities that allow the efficient dependency management. In seconds you can know which part of the code will be impacted if you refactor a class, you can be advised if a layer dependency violation has been accidentally created, you can pinpoint precisely which part of the code relies on a particular tier component, you can list methods that can be reached from a given method etc…

Compare Builds and Code Diff

In software development, products are constantly evolving. Hence, developers and architects must pay attention to modifications in code bases. Modern source code repositories handle incremental development. They can enumerate differences between 2 versions of source code files.

VBDepend can tell you what has been changed between 2 builds but it does more than simple text comparison. It can distinguish between comment change and code change, between what has been added/removed and what has just been modified.

With VBDepend, you can see how code metrics are evolving and you know if coupling between components is increasing or not.

VBDepend can also continuously check modifications to warn you as soon as a breaking compatibility change appears.

Enforce Immutability and Purity

At runtime, program’s states are instance and static field’s values. Controlling how/when/why states are changing is one of the most challenging programming task. This becomes incredibly difficult in multi-threaded environment. This is because potential side-effects due to a state change get too complicated to be understood.

Object-Oriented developers get more and more inspired by the functional programming approach where most states are immutable. An object is immutable if its state doesn’t change once it has been created. A method is pure if its execution doesn’t change any field state. Immutable objects and pure methods are two efficient ways to limit unexpected side-effects.

Through some dedicated CQLinq conditions and rules, XClarify lets assert immutability and purity on your classes and methods. The best place to start with this feature is to look at the list of default CQLinq constraint and to read the associated documentation.

Generate Custom Reports From your Build Process

VBDepend can analyze source code and VB6/VBA Projects through VBDependConsole.exe. Each time it analyzes a code base, VBDepend yields a report that can inform you about the status of your development. You can customize sections shown in the report and you can even provide your own XSL sheet for full customization.

You can also build your own set of CQLinq constraints that will be checked at each analysis. The report will warn you each time a constraint is violated. This feature makes automatic design and quality regression test a reality.

Detect Dependency Cycle

The easiest way to keep a code base clean is to avoid dependency cycles between its components. Components are useful to partition a huge amount of code into smaller and understandable pieces. If a dependency cycle involves N components, these N components represent a single super-component. Indeed, the benefits of having N smaller components are lost: any component can be potentially broken by a change in any of the others components, you cannot unit test a component in isolation from the N-1 other ones and finally, all N components must be versioned and deployed all together.

Whether you consider that your components are classes, packages, Projects or a mix in between, VBDepend detects dependency cycles between them. It can also help you to find the right way to get rid of a particular dependency cycle. Once dependency cycles have been removed, VBDepend can continuously check your code base to warn you as soon as a cycle is accidentally created.

Only for V.I.P