Project Analyzer is a code review and quality control tool for Microsoft Visual Basic that optimises, documents and measures source code automatically, browsing graphically through code as hypertext or graphical call trees. The problem detection feature removes unnecessary code, recommends better coding style and checks for error prone areas in a project. Project Analyzer provides industry standard quality control metrics for fine-tuning and monitoring of software development and documents projects with cross-references and other data. It is available in the following Editions:

·         Project Analyzer Standard Edition: includes a full range of professional code analysis and documentation features and can be enhanced with add-ins

·         Project Analyzer Professional Edition: includes all of the features of the Standard Edition and all add-ins

·         Project Analyzer Enterprise Edition: includes all of the features of the Professional Edition, and advanced functionality and all add-ins.

Four add-in tools can be used within Project Analyzer; they are optional in the Standard Edition and included in the Professional and Enterprise Editions:

·         Super Project Analyzer: combines several analyses into one to detect dead code. Useful for projects that share some source code files

·         Project Printer: puts source code on paper or in document files. Creates project web sites for browsing VB code as HTML or CHM (view sample). Generates code manuals out of comments in code

·         Project Graph: builds graphical call trees and dependency trees

·         Project NameCheck: enforces standard naming conventions on variables, procedures and controls etc.

Enterprise Edition features

Problem auto-fix and instant dead code removal. Repair a lot of coding problems without lifting a finger. Delete or comment out dead code instantly. Optimize your projects in a minute and make them conform to your company's coding standards. Dead code removal

Multi-project analysis. Analyze several related projects together to find dependencies between them. Analyze project groups (.vbg) and VB.NET solutions (.sln). Useful for ActiveX and library project types and dead code detection among several projects.

COM and DLL analysis. Analyze the use of COM and DLL libraries in VB code. View the use of classes, methods, enumerations and all other available interfaces in ActiveX .ocx, .dll or .exe files. Analyze the contents of conventional DLLs. See how you use 3rd-party controls and how you call your own COM classes.

Enterprise Diagrams. Diagram the structure of your program. Call diagrams, file dependency diagrams, class hierarchy diagrams, data flow diagrams, data declaration diagrams, class instantiation diagrams, project dependency diagrams and even class cohesion diagrams. Export diagrams to MS Visio. Enterprise Diagrams help

Find duplicate code. Detect repeated code blocks that frequently result from copy & paste coding. Reduce code size by joining duplicate procedures and smaller blocks.

VB.NET Compatibility Check. Get ready for VB.NET! What's the effort to migrate your VB6 project to VB.NET? Save work by preparing your code in advance. More about VB.NET compatibility

Macros. Automate your everyday analysis and reporting tasks by writing macros. Leave your computer analyze the changes you made during the day. Batch analyze several projects at once. Or take 10 reports with a single click.

Metrics. Project Analyzer Enteprise Edition counts 180 software metrics for Visual Basic code. Find out about cyclomatic complexity, lines of code, fan-in, fan-out, amount of documentation etc. See how your project has developed. Compare projects with graphs and statistical analyses. Find exceptional modules. Evaluate code quality. Project Metrics help

·         Project metrics. Measure system size in kilobytes, lines of code and the number of statements, files, procedures, variables and constants. Evaluate complexity with total cyclomatic complexity, system complexity and relative system complexity metrics. Evaluate documentation with the number of comments, meaningful comments, comment density and average length of names. Measure object-oriented programming with the number of classes, root and leaf classes, abstract and concrete classes, depth of inheritance tree, class reuse, class specialization, method inheritance factor, method hiding factor and more. Evaluate the density of data access statements, control statements and procedure calls.

·         File metrics provide measurements for each source file. List the size of each file in kilobytes, lines of code, number of procedures and variables. Evaluate the amount of commentation with comment counts, meaningful comment counts and comment density. Measure dependencies with fan-in and fan-out metrics. Count the number of statements, declarative statements, executable statements and control statements. Evaluate the density of executable statements and control statements.

·         Class metrics provide object-oriented measurements for each class. Measure class size by the number of methods, lines and statements. Measure coupling with response for a class metrics and message-passing coupling. Measure class cohesion. Count the number of constructors, events and the size of the class interface. Sort classes by their cyclomatic complexity.

·         Procedure metrics help locate exceptional and error-prone procedures. Spot candidates for refactoring. Determine procedure size by LOC (lines of code) and statement count. Count the procedure parameters. Evaluate data flow through parameters and global variables. Measure informational complexity, structural complexity, data complexity and 3 types of cyclomatic complexity. View the depth of conditional nesting and looping. Measure coupling with fan-in and fan-out metrics for procedure calls and information flow.

·         Variable metrics. Locate critical or busy variables by the number of use locations. Evaluate the length of variable names.

·         Supports object-oriented (OO) metrics suites such as Chidamber & Kemerer, MOOD and MOOD2.

Project Analyzer Pro Edition extends the Standard Edition with 4 tools: Super Project Analyzer, Project Printer, Project Graph and Project NameCheck. You can find them in the Pro menu of Project Analyzer. These tools are also included in the Enterprise Edition. More about editions

Super Project Analyzer - find dead code in shared files

Super Project Analyzer combines several analyses to detect dead code. Sometimes a single analysis is not enough to detect dead code. This happens when several projects use the same file. All the user projects have to be accounted for with Super Project Analyzer.

Super Project Analyzer is not a VB project group (.vbg) or solution (.sln) analyzer. For this purpose, use multi-project analysis in the Enterprise Edition. To use Super Project Analyzer, you need VB source code files that are included in several projects (.vbp/.vbproj).

Project Printer - document and surf the source

Need to document your projects? Then you need Project Printer. This is an advanced document generator that combines code with analysis results.

Source code documents. Put all your code in document files or on paper. Optionally include things like cross-references and detected problems.

Comment manuals. Generate a manual out of comments in code. Optionally, use special comment syntax to format the results.

Project web site. Turn all source to HTML. Click on links to surf around. Optionally, put the web site into a single .mht or .chm file to give to your colleagues or to include in your project documentation.

Project Graph - graphical code documentation

Project Graph makes graphs out of source code. Browse the trees to learn where calls come from and where they go to. Attach the trees to your project documentation for an intuitive project cross reference. Make impact analyses to see what happens when you change a part of code.

·         File dependency tree shows how source files require each other to compile or run.

·         Procedure call tree shows how procedure execution flows backward and forward.

·         Inherits and Implements tree visualizes the class hierarchy.

·         Control flow tree shows how procedure execution flows between modules. (For regular flow charts, try Visustin)

·         Data flow tree shows how data flows between modules via variable read/write, procedure parameters and function return values.

·         Instantiation tree shows where classes are being instantiated.

·         Data declaration tree shows where classes, structures, interfaces and forms are being used as data types.

·         Form show tree visualizes the order in which forms show each other.

Project NameCheck - enforce naming standards

Naming conventions are used to make code more understandable. Use "i" for Integer and "g" for Global, and everyone immediately knows which variable is a Global Integer.

Project NameCheck ensures that variable, procedure, control and other names conform to your naming standards. You can customize the rules to what you currently use. A sample standard is included if you are just beginning to use naming conventions.