SubMain Community

SubMain acquires Exact Magic's TestMatrix, CodeSpell and StudioTools

Serge B. — Tue, 09 Mar 2010 06:32:00 GMT

SubMain will continue development of TestMatrix, CodeSpell and StudioTools; adds to Code Quality developer tools Suite.

Kirkland, WA, March 9, 2010 - SubMain announced today that it has acquired TestMatrix, the popular Visual Studio .NET extension for unit testing and code coverage, as well as CodeSpell and StudioTools from Exact Magic Software.

"I'm happy to place TestMatrix and our other .NET products in the hands of SubMain," says Duane Fields, Managing Partner at Exact Magic Software, the original owner and developer of TestMatrix. "Like their other acquisitions, SubMain will take good care of our TestMatrix and take it to the next level."

TestMatrix (http://submain.com/testmatrix) adds support for unit testing, code coverage analysis, and test profiling to Visual Studio, seamlessly incorporating these critical development practices directly into the coding process itself; CodeSpell (http://submain.com/codespell) adds real-time, intelligent detection and correction of misspellings to Visual Studio; and StudioTools (http://submain.com/studiotools) is a rich collection of Visual Studio enhancements.

"TestMatrix has a well-deserved reputation for making test driven development painless and convenient by enabling unit testing tasks an integral part of the programming experience, not an occasional external exercise," says Serge Baranovsky, President of SubMain. "It fits SubMain's code quality tools line-up perfectly and we are proud to serve the .NET community by continuing the development of this valuable tool."

SubMain has a track record for acquiring products, enhancing and integrating them in the product offering. Most recently, SubMain purchased GhostDoc and continues to improve and maintain it as a free tool for the .NET community.

About SubMain

SubMain, a Division of vbCity.com LLC, makes code quality tools for .NET developers. The company's flagship product CodeIt.Right (http://submain.com/codeit.right) helps developers across the globe to follow team standards and best practices, improve code security and performance and find potential issues early in the development cycle.

About Exact Magic Software, LLC

Exact Magic Software, LLC specializes in building native applications for the Apple iPhone iPad, and iPod Touch. The company has shipped dozens of applications, but is best known for its top selling applications Weather Radar, Business Phone Numbers, and Infinite Maze.

Media Contact

Wendy Cavens
Director of Marketing, SubMain
Tel: 1(800) 936-2134
Email: wendyc@submain.com

SubMain acquires Exact Magic's TestMatrix, CodeSpell and StudioTools

SubMain.Blog() — Tue, 09 Mar 2010 00:03:02 GMT

As announced earlier today we just closed the acquisition of the popular unti testing and code coverage product TestMatrix , as well as CodeSpell and StudioTools . We, SubMain, will continue to maintain and enhance these products. TestMatrix adds support for unit testing, code coverage analysis, and test profiling to Visual Studio, seamlessly incorporating these critical development practices directly into the coding process itself; CodeSpell adds real-time, intelligent detection and correction of...(read more)

Released: CodeIt.Right v1.9.10053

SubMain.Blog() — Thu, 25 Feb 2010 16:31:00 GMT

Today we released update for CodeIt.Right Standard and Enterprise Editions - v1.9.10053. As part of our 2010 Product Roadmap , this version changes include significantly improved performance, support for GlobalSuppressions, new rules and bug fixes. New in CodeIt.Right v1.9.10053: Major performance improvements throughout the rule base Added support for GlobalSuppressions - syntax is the same as the VSTS GlobalSuppressions file. This new feature is supported in both Standard and Enterprise editions....(read more)

2010 Product Roadmap

SubMain.Blog() — Tue, 23 Feb 2010 09:13:00 GMT

Code Quality developer tools is the direction we've been following since the introduction of CodeIt.Right and we are taking this commitment to the next level in 2010 with two new products and new features for our existing products. One of the new products to be released in 2010 will assist in unit testing, code coverage and test code profiling; the second new product will be complementary to CodeIt.Right. All three products together will comprise our new Code Quality Suite. Additionally, we will...(read more)

How CodeIt.Right is better than FxCop?

Serge B. — Thu, 04 Feb 2010 06:52:00 GMT

The biggest benefit of CodeIt.Right is the automatic code correction and refactoring to patterns. The alternative is you could manually spend hours or even days on some pesky violations rather CodeIt.Right do the work for you in a matter of minutes.

You can also choose to follow Microsoft Guidelines or you own custom standards, group rule sets into profiles, generate your custom standard documentation, efficiently work with existing/legacy projects, avoid false positives.

The Enterprise Edition adds Team features, Code Metrics, Statistics, enhanced reporting.

	CodeIt.Right	FxCop
	Scans and analyzes source code	Runs on compiled assemblies (you have to compile code to use it)
Correction	Corrects violations and code smells automatically	N/A
Refactoring to patterns	Automatically implements and corrects most common coding patterns like Dispose/Finalize, ISerializable, Custom Serialization, etc	N/A
Visual Studio Integration	Natively integrates into Visual Studio IDE; quick navigation to the violation source code; highlights modifications in the editor; safe Undo/Redo.	Basic/Command line
ASP.NET	ASPX/ASCX/ASMX pages, in-page code, code behind source	Only compiled code behind assemblies
Local variables/constants	Includes rules that are targeting local variables/constants and any data that is present in the source code	Not possible in FxCop - the data is lost in the MSIL
Follow your own standards	Includes Microsoft Guidelines and best industry practices out of the box. Allows to define your own standard to follow - tweak the rule set to your needs without having to write custom rules (which is an option too). For example, go as crazy as enforce Hungarian naming conventions; or convert existing project with Hungarian notation to the new MS style conventions.	Strictly enforces Microsoft Guidelines - inflexible and enforces the set with no options to configure
Define custom rule set	Profiles - configure multiple rule subsets and quickly switch between them. Share profiles between the Team members or (EE) push them to the Team.	N/A
Rule Instances	Introduces Rule Instances - multiple instances of a single rule that are configured (via rule Properties) to your Team needs	Only allows to turn off specific rule, cannot configure/tweak
Reducing noise (false positives)	Exclude violation in Project Exclude violation in source code Exclude Violation, Rule, File, Project Exclude code regions Custom Profiles Override default rule severity, target, scope, etc	Exclude violation in Project Exclude violation in source code
Severity Threshold	Unique feature - Severity Threshold - allows to concentrate on most critical violations first and drill down from most severe issues to simple warnings.	N/A
	Scan entire solution, project, folder or individual file	Scan projects only
Create own guidelines documentation	Generate Team Guidelines document within a mouse click, with description, code samples, etc - based on your custom configured Profile
Team features	(EE) separate modules to (a) author / configure team standards and (b) run analysis and correction based on the team standard configured by Team Lead/Architect; publish and push (share) Team standard configuration to the Team members; Team usage statistics	N/A
Reporting	Flexible reporting/pivot that can be exported and printed	N/A
Code Metrics	Available (EE); can be exported, printed, emailed	N/A
Command line output	Violations, Code Metrics (EE)	Violations only
Command line filtering	Solution, Project, Profile, Severity Threshold	Project, Assembly
Command line delivery	File, Send via email	File only
Command line integration	Command line tool, MsBuild and NAnt tasks	Command line tool
Update delivery	Rule Library auto-update - get new rules when we publish them	N/A

Download trial copy of CodeIt.Right today and see the difference yourself!

XML Comment template: IntelliComment or XML Comment Stub?

Serge B. — Fri, 29 Jan 2010 00:39:00 GMT

One of the very helpful and important rules that we added in the past few months is the one that finds members that missing XML documents when these are required - General / Type, Member -> Should have XML comments (Externally visible types and members should have XML comments).

One of the most frequently asked question about the rule is why some users are not seeing the missing XML comment violation on select project. There are two possible reasons for that:

The rule will only trigger violation on public and protected members in its default configuration. If you choose to have it validate private and/or static members, you will need to edit the rule's Scope property to include those as well.
The option to generate XML documentation is turned OFF in your project. In this case the rule doesn't the missing XML comment violation to reduce false positives since the project setting state it does not need XML documentation.

To turn the option to generate documentation ON, in C# project, go to project Properties -> Build -> XML documentation file

In VB project, go to project Properties -> Compile -> Generate XML documentation file

In the spirit of CodeIt.Right the rule offers two automatic correction options - IntelliComment and XML Comment Stub. In the default configuration these are fairly similar, the difference is that IntelliComment will fill in the generated XML Comment using data from our GhostDoc engine, while the Stub template will create an empty XML Comment Stub.

Here is example generated by IntelliComment template

    /// <summary>
    /// Determines the size of the page buffer.
    /// </summary>
    /// <param name="initialPageBufferSize">Initial size of the page buffer.</param>
    /// <returns></returns>
    /// <remarks></remarks>
    public int DeterminePageBufferSize(
                           int initialPageBufferSize) {

        // Implement the method here
        return 1;

    }

And example generated by XML Comment Stub template

    /// <summary>
    ///  
    /// </summary>
    /// <param name="initialPageBufferSize"> </param>
    /// <returns></returns>
    /// <remarks></remarks>
    public int DeterminePageBufferSize(
                           int initialPageBufferSize) {

        // Implement the method here
        return 1;

    }

So, the rule offers two correction option - it is up to you to pick which template works best for your project.

I notice that I keep using the word "template" when describing the two correction options. That is because these are true T4 templates that you can customize to fit your team requirements.

Here is default IntelliComment template:

<#@ template language="C#" #>
<#
    CodeElement codeElement = Context.CurrentCodeElement;
#>
/// <summary>
/// <#= codeElement.XmlComment.SummaryTagText #>    
/// </summary>
<#
    if(codeElement.HasTypeParameters) 
    {
        foreach(TypeParameter typeParameter in codeElement.TypeParameters) {
#>
/// <typeparam name="<#= typeParameter.Name #>"><#= typeParameter.XmlComment.TypeParamTagText #></typeparam>
<#
        }
    }
    
    if(codeElement.HasParameters) 
    {
        foreach(Parameter parameter in codeElement.Parameters) {
#>
/// <param name="<#= parameter.Name #>"><#= parameter.XmlComment.ParaTagText #></param>
<#
        }
    }
    
    if(codeElement.HasReturnType) {
#>
/// <returns><#= codeElement.XmlComment.ReturnsTagText #></returns>
<#
    }
    
    if(codeElement.IsProperty) {
#>
/// <value><#= codeElement.XmlComment.ValueTagText #></value>
<#
    }    
    
    if(codeElement.IsMember) {
#>
/// <remarks></remarks>
<#
    }    
#>

As you can see it is very much self-explanatory and you can customize it to your needs. For example, in combination with the CodeIt.Right Global Properties feature, we can have <reviewed/> and <copyright/> data automatically when we add the following at the very end of the template:

/// <reviewed><#= Context.GetGlobalProperty("UserName") #></reviewed>
/// <copyright><#= Context.GetGlobalProperty("CompanyName") #> Copyright <#= System.DateTime.Now.Year.ToString() #></copyright>

Pretty powerful stuff, huh?

Released: CodeIt.Right Enterprise v1.9.09355

SubMain.Blog() — Tue, 22 Dec 2009 22:55:00 GMT

New version of CodeIt.Right Enterprise Edition - build 1.9.09355 - is available for download now. This version introduces new feature Merge Profiles that allows to compare and merge user configured profiles, enhances VSTS integration with the new "Add WorkItem" feature, adds command line version parameters and ability to load/unload CodeIt.Right in the menu and Add-In Manager. This update is free for all users who are current on their Software Assurance and Gold Support Subscription New in CodeIt.Right...(read more)

5+1=3 or 10+1=6 Promotion - Save up to 50%!

SubMain.Blog() — Mon, 14 Dec 2009 16:01:03 GMT

For two weeks - December 15 to December 29th - we are running the best volume license promotion we have had to date! This promotion is aimed at small and medium businesses. 5+1=3 6 Standard Edition licenses for the price of 3: 5 user licenses + 1 server license + 1 Year maintenance subscription = $1050 Learn More » 10+1=6 11 Enterprise Edition licenses for the price of 6: 10 user licenses + 1 server license + 1 Year maintenance subscription = $4500 Learn More » Hurry and save money - this offer will...(read more)

Tutorial: Extending Existing Rules

Serge B. — Thu, 29 Oct 2009 08:05:52 GMT

You already know how you can create new custom rules using CodeIt.Right SDK, of not, you may want to read this article first.

In this tutorial we will show how to extend existing rules using the new SDK features introduced in CodeIt.Right v1.8.09300. The new technique is derive the custom rule from a base rule and override only the methods that need to be modified.

Let's extend the rule "Avoid single line If statement" (RuleID: CD0002; base class AvoidSingleLineIfStatement) in the Coding Style category:

The base rule above will trigger a violation when find a code pattern like this:

if (x > 0) y = 0;

When the rule default correction action "Split If block into a multiline statement" is used it will modify the code into:

if (x > 0)
{
y = 0;
}

That is what comes in the box.

Our team may have an internal guideline that requires a single line conditional to be split into two lines without the squiggly brackets:

if (x > 0)
y = 0;

Hey, not all teams are created equal :)

In this case correction option that comes with the base rule AvoidSingleLineIfStatement is not very useful and we need to extend the rule with our custom correction.

So, let's start.

We will skip the list of required referenced assemblies - you will find them in the complete code sample at the end of the post.

Declare new class that inherits from the base rule class:

namespace CustomRuleLibrary.CodingStyle  
{  
    [Serializable]  
    [ModificationDate("10/14/2009")]  
    [Category("CustomRuleLibrary.CodingStyle")]  
    public class AvoidSingleLineIfStatement2 : AvoidSingleLineIfStatement  
    { 

In the code above we also set the Category attribute to "CustomRuleLibrary.CodingStyle" so we could easier find the custom in the Profile.

We override ID property and use GUID for the new RuleID value. Some of the CodeIt.Right functions, for example, help pages are handled differently for custom rules. Using GUID for RuleID hits CodeIt.Right that the rule is custom.

        public override string ID  
        {  
            get  
            {   
                // Override the RuleID value with own GUID (recommended)      
                return "6C832235-0B02-4227-911A-156F0B1FAC71";  
            }  
        }  

Property AutoCorrectionOptions needs to be overridden to add new correction action "Split If block into a multiline statement without block":

        /// <summary>      
        /// Returns list of auto correction options      
        /// </summary>      
        public override string[] AutoCorrectionOptions  
        {  
            get  
            {  
                IMethodInfo methodInfo = Element as IMethodInfo;  
                if (methodInfo != null)  
                {  
                    // Get the base class list of available corrections      
                    string[] baseOptions = base.AutoCorrectionOptions;  
                    string[] options = (string[])Array.CreateInstance(typeof(string), baseOptions.Length + 1);  
                    // Add new correction action to the list      
                    Array.Copy(baseOptions, 0, options, 0, baseOptions.Length);  
                    options[options.Length - 1] = "Split \"If\" block into a multiline statement without block";  
    
                    return options;  
                }  
    
                return new string[] { };  
            }  
        } 

The base rule correction option:

Our custom rule correction options with the new action added in the AutoCorrectionOptions above:

Now we implement our new custom correction action just the way we like it to work:

        /// <summary>      
        /// Implementation of our custom correction action       
        /// </summary>      
        private bool Correct_1(IElementInfo elementInfo)  
        {  
            IMethodInfo methodInfo = Element as IMethodInfo;  
            if (methodInfo != null)  
            {  
                StatementCollection statements = RuleUtilities.GetMethodStatements(methodInfo);  
                IStatement statement = SearchForSingleLineIfStatement(statements);  
                if (statement != null)  
                {  
                    string codeToInsertAfter = Environment.NewLine;  
                    string codeToInsertBefore = Environment.NewLine;  
    
                    IRegion ifBlockRegion = GetIfBlockRegion(statement);  
                    if (ifBlockRegion != null)  
                    {  
                        string ifBlockText = GetIfBlockText(statement, ifBlockRegion);  
                        if (ifBlockText != null)  
                        {  
                            methodInfo.ReplaceCodeBlock(ifBlockRegion,  
                                codeToInsertBefore + ifBlockText + codeToInsertAfter);  
    
                            return true;  
                        }  
                    }  
                }  
            }  
    
            return false;  
        } 

And we tie it all together in the method Correct - for correction action with index 0 we execute the base rule correction and for the index 1 (that we added) execute method Correct_1 that implements our custom correction:

        /// <summary>      
        /// Execute the specified correction action      
        /// </summary>      
        /// <param name="correctionOptionIndex">Index of the correction action</param>      
        public override bool Correct(int correctionOptionIndex)  
        {  
            bool result = base.Correct(correctionOptionIndex);  
    
            switch (correctionOptionIndex)  
            {  
                case 0:  
                    // For correction action 0 execute the base class correction      
                    return result;  
                case 1:  
                    // For correction action 1 execute our custom correction      
                    return Correct_1(Element);  
    
                default:  
                    break;  
            }  
    
            return false;  
        } 

And we are done!

The final steps are to compile the new rule, drop the assembly to Program Files\SubMain\CodeIt.Right\Rules\ and we can now add the rule to a profile:

Here is the complete code for our custom rule:

using System;     
using System.IO;     
using System.Collections;     
using System.Collections.Specialized;     
using System.Runtime.Serialization;     
using System.Globalization;     
    
using SubMain.CodeObjectModel.Reflection;     
using SubMain.Core.Services;     
using SubMain.CodeItRight.Sdk;     
using SubMain.CodeItRight.Sdk.Core.Collections;     
using SubMain.CodeItRight.Sdk.Core.Reflection;     
using SubMain.CodeItRight.Sdk.Core.Rules;     
using SubMain.CodeItRight.Sdk.Core.Utils;     
using SubMain.CodeItRight.Sdk.Rules;     
using SubMain.CodeItRight.Sdk.Utils;     
using SubMain.CodeItRight.Rules.CodingStyle;     
    
namespace CustomRuleLibrary.CodingStyle     
{     
    [Serializable]     
    [ModificationDate("10/14/2009")]     
    [Category("CustomRuleLibrary.CodingStyle")]     
    public class AvoidSingleLineIfStatement2 : AvoidSingleLineIfStatement     
    {     
        /// <summary>     
        /// Returns list of auto correction options     
        /// </summary>     
        public override string[] AutoCorrectionOptions     
        {     
            get     
            {     
                IMethodInfo methodInfo = Element as IMethodInfo;     
                if (methodInfo != null)     
                {     
                    // Get the base class list of available corrections     
                    string[] baseOptions = base.AutoCorrectionOptions;     
                    string[] options = (string[])Array.CreateInstance(typeof(string), baseOptions.Length + 1);     
                    // Add new correction action to the list     
                    Array.Copy(baseOptions, 0, options, 0, baseOptions.Length);     
                    options[options.Length - 1] = "Split \"If\" block into a multiline statement without block";     
    
                    return options;     
                }     
    
                return new string[] { };     
            }     
        }     
    
        /// <summary>     
        /// Implementation of our custom correction action      
        /// </summary>     
        private bool Correct_1(IElementInfo elementInfo)     
        {     
            IMethodInfo methodInfo = Element as IMethodInfo;     
            if (methodInfo != null)     
            {     
                StatementCollection statements = RuleUtilities.GetMethodStatements(methodInfo);     
                IStatement statement = SearchForSingleLineIfStatement(statements);     
                if (statement != null)     
                {     
                    string codeToInsertAfter = Environment.NewLine;     
                    string codeToInsertBefore = Environment.NewLine;     
    
                    IRegion ifBlockRegion = GetIfBlockRegion(statement);     
                    if (ifBlockRegion != null)     
                    {     
                        string ifBlockText = GetIfBlockText(statement, ifBlockRegion);     
                        if (ifBlockText != null)     
                        {     
                            methodInfo.ReplaceCodeBlock(ifBlockRegion,     
                                codeToInsertBefore + ifBlockText + codeToInsertAfter);     
    
                            return true;     
                        }     
                    }     
                }     
            }     
    
            return false;     
        }     
    
        public override string ID     
        {     
            get     
            {  
                // Override the RuleID value with own GUID (recommended)     
                return "6C832235-0B02-4227-911A-156F0B1FAC71";     
            }     
        }  
    
        /// <summary>     
        /// Execute the specified correction action     
        /// </summary>     
        /// <param name="correctionOptionIndex">Index of the correction action</param>     
        public override bool Correct(int correctionOptionIndex)     
        {     
            bool result = base.Correct(correctionOptionIndex);     
    
            switch (correctionOptionIndex)     
            {     
                case 0:     
                    // For correction action 0 execute the base class correction     
                    return result;     
                case 1:     
                    // For correction action 1 execute our custom correction     
                    return Correct_1(Element);     
    
                default:     
                    break;     
            }     
    
            return false;     
        }     
    
    }     
}     

Released: CodeIt.Right version 1.8.09300 - now compatible with VS2010 Beta 2!

SubMain.Blog() — Wed, 28 Oct 2009 01:57:01 GMT

Today we are releasing new version of CodeIt.Right - build 1.8.09300. This version features complete ASP.NET support, it is compatible with VS2010 Beta 2 (in addition to VS2008, VS2005, VS2003), Add Rule dialog improvements - "Hide Rules in the Profile" and "Quick Search", 10+ new rules including new category "CodingStyle". Those of you who are using CodeIt.Right with very large solutions may know of the memory limitation issue for the tools that live in the Visual Studio address space, aka "Out...(read more)

How to Assign Visual Studio Shortcut for GhostDoc

Serge B. — Thu, 02 Jul 2009 00:03:00 GMT

Sometimes you may reset default GhostDoc shortcut in Visual Studio or want to assign your own custom shortcut.

Here is how you do that:

In Visual Studio go to Tools -> Options, then select Environment -> Keyboard
Filter commands by "GhostDoc" in the Show commands containing text box
Select Tools.SubMain.GhostDoc.DocumentThis in the list
Select "Text Editor" in the Use new shortcut in drop down
Choose the hotkey you want to invoke the DocumentThis command (Ctrl+Shift+D in this example)
Press Assign and OK to close the dialog and save. You are all set.

While you are in the Options dialog you may want also assign shortcut to another less known but very useful GhostDoc command Rebuild Documentation. This command will rebuild your existing XML comment using the changed signature information. Be careful with this command though - it will reset your custom edited XML comment. In the example below we assigned command RebuildDocumentation to sequence Ctrl+Shift+D, Ctrl+Shift+R

SubMain acquires GhostDoc, releases new version, integrates it with CodeIt.Right

SubMain.Blog() — Mon, 01 Jun 2009 15:25:00 GMT

As announced earlier today we just closed the acquisition of the popular XML Comment helper tool GhostDoc. We, SubMain, will continue to evolve the tool and distribute it as a free product . We are also announcing today the availability of the new version of GhostDoc v2.5.09150 which improves the user setup experience, adds support for Visual Studio 2010 Beta 1 and full support for Visual Basic. Additionally, today we are making available a new version of CodeIt.Right (v1.6.09151) that adds the IntelliComment...(read more)

What's in the shop for GhostDoc?

Serge B. — Mon, 01 Jun 2009 07:25:00 GMT

SubMain Director of Marketing Wendy Cavens interviewed Serge Baranovsky and Roland Weigelt about the recent announcement of SubMain's acquisition of GhostDoc, which the company will continue to offer as a free product.

Roland Weigelt is working as a Software Developer at Comma Soft AG in Bonn, Germany. In his spare time he is the leader of the local .NET user group "Bonn-to-Code.Net" (pun intended) and also enjoys writing software as a hobby. Among his hobby projects is GhostDoc, one of the most popular tools for .NET developers.

Serge Baranovsky is President of SubMain. He has extensive programming experience and is a recognized community leader and founder of vbCity Developer Community. Serge is a Microsoft MVP and ASP Insider.

WendyC:: "To start with, please explain what is GhostDoc?"
RolandW:: "GhostDoc is a Visual Studio extension that generates XML documentation comments for methods and properties based on their type, parameters, name, and other contextual information. "
SergeB:: "What is also great about GhostDoc that when generating documentation for class derived from a base class or for interface implementation (e.g. .NET Framework or your custom framework), GhostDoc will use the documentation that Microsoft or the framework vendor has already written for the base class or interface."
WendyC:: "Roland, GhostDoc regularly made it on the lists of essential .NET developer tools, and was listed as #2 on "10 Must-Have Add-Ins" in MSDN Magazine. Please describe how you came up with the idea."
RolandW:: "I've always stressed high importance of writing good API documentation for my code starting in my C programming years as a student in the early 90's. For me this is also a check for the quality of a method - if I'm not able to explain in a few sentences what it does, there may be something wrong with the method to begin with.

With .NET and its long identifier naming style I often felt that writing this kind of documentation was a bit dull. Many times, in order to write an actually helpful piece of additional information, I first had to repeat in the summary almost exactly what the name of the method or property was already saying. One day in November 2003 I was so tired with documenting Boolean properties ("Gets or sets a value indicating whether ...") that I wrote a macro to help me with some of the repetitive tasks.

What followed were a few half-hearted false starts to turn this into a more general tool, until the announcement of Roy Osherove's Visual Studio Add-in competition in spring 2004 motivated me to turn my experiments into a fully-featured add-in that would be useful to others. In the end the hard work paid off; GhostDoc won the competition. Even though the feature set of GhostDoc 1.0 was limited (for instance, re-using existing documentation didn't make it until version 1.3), it turned out to be a success almost immediately."
WendyC:: "What has your experience been since?"
RolandW:: "Working on GhostDoc has always been both rewarding and frustrating. Visual Studio Extensibility in general is not without problems and even though things got a bit better with each version of Visual Studio, there were many roadblocks that took a lot of time to circumvent.

On the other hand, it's always amazing at conferences or user group meetings when people recognize my name, come up to me and tell me that GhostDoc is one of the first tools they install on a new developer machine. And last but not least I'm a GhostDoc user myself so I benefit from this tool everyday! "
WendyC:: "How did this deal come about?"
SergeB:: "Our CodeIt.Right product has a feature that enforces XML Comments where required and automatically adds a comment stub. Some time ago I demoed this feature to Scott Hanselman and he suggested it would be great to integrate this with GhostDoc and have the comment content generated based on the name. So I contacted Roland, we met at the last PDC to discuss the integration options; one thing led to another and I offered to buy GhostDoc. That seemed to me like an easy way to integrate! "
RolandW:: "The offer from SubMain came at a crucial point of time when I had to make a decision on the future development of GhostDoc. Other activities besides GhostDoc were already eating up my spare time, and it was clear that going open source wouldn't magically reduce my workload immediately.

Having full-time developers take GhostDoc to the next level seemed like the best solution. Serge and I were on the same page that a free-of-charge version of GhostDoc should be available in the future. From my experience of working with the people at SubMain in the recent weeks I can say that this was the right decision."
WendyC:: "Serge, what are the plans of how GhostDoc will evolve?"
SergeB:: "The future of GhostDoc starts today - we just released a new version of the tool with improved user setup experience, added support for Visual Studio 2010 Beta 1 and full support for Visual Basic. We also added IntelliComment feature to our CodeIt.Right product based on the GhostDoc algorithm - the version of this tool is also available today.

As for the future, you know, the usual product life stuff - bug fixing, feature enhancements. We have our own ideas and also are encouraging the community to give us feedback. "
WendyC:: "Roland, will you continue to be involved with GhostDoc?"
RolandW:: "I will continue using GhostDoc both at work and at home every day; and I will definitely keep track of what the guys at SubMain are up to; and I will do what every GhostDoc user should do - swamp them with feature requests! "
SergeB:: "Over the last few weeks of the transition our team has enjoyed working with Roland and we look forward to his continued feedback. We also hope that the community at large will do so as well."

SubMain acquires GhostDoc

Serge B. — Mon, 01 Jun 2009 07:15:00 GMT

SubMain maintains GhostDoc as a free tool for .NET developers; releases new version; seeks input from the community on product enhancements

Kirkland, WA, June 1, 2009 - An agreement between SubMain and Roland Weigelt, author of GhostDoc, will place future development of GhostDoc in the hands of SubMain. GhostDoc (http://submain.com/ghostdoc) is the popular XML Comments and documentation helper tool which SubMain will continue to maintain as a free product.

"I'm happy to transfer GhostDoc to SubMain," says Roland. "SubMain has extensive experience with similar projects and can use their development team expertise to evolve the tool."

Serge Baranovsky, President of SubMain, understands the importance of GhostDoc to the .NET community and welcomes ideas on the product improvement.

"We are very excited about taking over the future of an excellent tool such as GhostDoc," says Serge. "We have great respect for what Roland has done. The tool is very easy to use and it just works! We are committed to maintaining this wonderful free tool; we welcome the community feedback and suggestions."

SubMain has a track record of supporting the development community: publishing SmartOutline for .NET, the company's own free development tool; a free 100+ page .NET Coding Guidelines eBook; vbCity.com, a VB and .NET developer community, which it founded 10 years ago; dev.net.ua, which it founded in the last 5 years, the premier Ukrainian .NET developer community; and VBFeeds, an aggregation service for Visual Basic related blogs and publications.

SubMain would also like to announce today the availability of the new version of GhostDoc (v2.5) which improves user setup experience, adds support for Visual Studio 2010 Beta 1 and full support for Visual Basic.

Additionally, today SubMain is making available a new version of CodeIt.Right (http://submain.com/codeit.right) that adds IntelliComment feature based on the GhostDoc algorithm and offers improved and automated generation of XML Comments.

For more on the agreement, please see the interview with Roland Weigelt and Serge Baranovsky - What's in the shop for GhostDoc? (http://submain.com/ghostdoc/future)

About SubMain

SubMain, a Division of vbCity.com LLC, makes productivity tools for .NET developers. The company's flagship product CodeIt.Right helps developers across the globe to follow team standards and best practices, improve code security and performance, find potential issues early in the development cycle. SubMain is a Microsoft Certified Partner.

Media Contact

Wendy Cavens
Director of Marketing, SubMain
Tel: 1(800) 936-2134
Email: wendyc@submain.com

How to Backup and Restore Visual Studio settings

Serge B. — Sun, 31 May 2009 06:57:00 GMT

If you need to preserve your Visual Studio settings, there is a tool built into VS that allows to backup and restore the settings. In this tutorial we are assuming that you are saving a copy of ALL settings to use by you personally as a backup.

Make a backup

In Visual Studio use Tools / Import and Export Settings… menu to open Import and Export Settings Wizard.
Select Export selected environment settings and click Next.
To include ALL settings make sure the All Settings box is checked. Then click Next.
Choose the file name for the settings backup file.
Then click Finish. The wizard will store settings in the file.

Restore from a backup

Use Tools / Import and Export Settings… menu to open Import and Export Settings Wizard.
Select Export selected environment settings and click Next.
Choose whether you want to make backup current settings.
Choose your backup and click Next.
To include ALL settings make sure the All Settings box is checked. Then click Finish.
The wizard will restore settings from the backup.

Released: CodeIt.Right version 1.6.09139 - now fully compatible with VS2010 Beta 1!

SubMain.Blog() — Tue, 19 May 2009 10:08:02 GMT

As you may know yesterday Microsoft released VS2010 Beta 1 to MSDN Subscribers. The Beta will also be publicly available for the rest of the world on Wednesday. This is long expected and very exciting new version of Visual Studio; and we here at SubMain are fully prepared to support the new shiny version! While some companies make a big deal posting screenshots of the upcoming VS2010 versions and announcing availability of previews for their products within a month, we at SubMain have been working...(read more)

CodeIt.Right reviewed on MSDN Toolbox

SubMain.Blog() — Tue, 30 Dec 2008 00:08:44 GMT

With just a couple of days left this year, I wanted to share with you a great article in the MSDN Magazine Toolbox column this month on Improving Software Quality with Static Code Analysis Tools where MS MVP Scott Mitchell is reviewing Static Analysis Tools For .NET . Scott is comparing FxCop, StyleCop and CodeIt.Right: While FxCop and StyleCop pinpoint rule violations, the developer is still responsible for implementing these tools' suggestions. CodeIt.Right from SubMain takes static code analysis...(read more)

Released: CodeIt.Right version 1.2.08357

SubMain.Blog() — Mon, 22 Dec 2008 09:26:40 GMT

Just before the holiday we are releasing new version of CodeIt.Right - build 1.2.08357. Download version 1.2.08357 today! This release features addition of spell checking engine to CodeIt.Right SDK, workaround for the Out of Memory error on large solutions, 12 new rules and many bugs fixed. Please share your feedback in the forums especially on the new spell checking rules - we are still working and improving them. Note: The new spelling rules are included with the built-in profile but they are turned...(read more)

PDC 2008 CodeIt.Right License giveaway!

SubMain.Blog() — Wed, 22 Oct 2008 22:08:00 GMT

by Serge Baranovsky The best and the biggest MS developer conference Microsoft PDC 2008 edition is just few days away. We, of course, wouldn't miss the great opportunity to meet and network with potentially 10000 developers. This year we will be giving away free CodeIt.Right licenses for those who manage to spot me in the crowd and talk to me about your favorite CodeIt.Right feature, what you don't like about the product or help to prioritize the upcoming features. Or talk about what's...(read more)

Released: CodeIt.Right Build 1.1.08262

SubMain.Blog() — Fri, 19 Sep 2008 23:55:47 GMT

New version of CodeIt.Right is out! You can download build 1.1.08262 today. This is a major release even though we only added ".1" to the version. It includes .NET 3.5 support, Guidelines document template generation, option to analyze single file, enhanced SDK documentation, new rules, new command line version parameters and more. Please share your feedback in the forums . This update is free for all users who are current on their Software Assurance and Gold Support Subscription Major changes in...(read more)

VSX DevCon and a very amusing incident with a kebab

SubMain.Blog() — Thu, 18 Sep 2008 22:42:40 GMT

by Serge Baranovsky Earlier this week I attended VSX DevCon on Microsoft campus where I learned quite a bit about the changes coming to the upcoming version of Visual Studio (Dev10) and its Extensibility Model. This was very important for us to be abreast of the future Microsoft releases and stay ahead of the game with our products. I twittered some of the event. It was fun conference too. I talked to many MS VSX folks, first time saw Rico Mariani talking (he is excellent!), met new people and old...(read more)

Released: PrettyCode.Print for .NET v2.0 Build 2.0.08242

SubMain.Blog() — Fri, 29 Aug 2008 22:43:50 GMT

As promised last week , new version of PrettyCode.Print for .NET is now available for download . The new version adds support for .NET Framework 3.5 and Visual Studio 2008 as well as many bug fixes since the last release. Although v2.0 (technically) marks a major version update, the upgrade is still free for current users. Here at SubMain we like to keep things simple :) Enjoy! More details at http://submain.com/pcp.net Download at http://submain.com/download Technorati Tags: PrettyCode.Print , PrettyCode...(read more)

Status update - new versions of CodeIt.Right and PrettyCode.Print for .NET are in the works

SubMain.Blog() — Thu, 21 Aug 2008 18:28:58 GMT

A quick update - we've been a little quiet lately. That's because we are working on two updates - new version of PrettyCode.Print for .NET with .NET 3.5 and VS 2008 support as well as CodeIt.Right v1.1 - beta available here - http://tinyurl.com/cir11-beta PCP.NET will be available first week of September and CodeIt.Right v1.1 the following week. Technorati Tags: CodeIt.Right , Coding Guidelines , Naming Conventions , Best Practices , .NET , NET...(read more)

New v1.1 is on the way - download CodeIt.Right Beta build 1.1.08198

SubMain.Blog() — Tue, 22 Jul 2008 22:31:18 GMT

by Serge Baranovsky New version of CodeIt.Right is almost out. We have a beta build 1.1.08198 for you today. Please download and give it a try, let us know what work and what doesn't. This is pretty big release that includes .NET 3.5 support, Guidelines document template generation, new command line version parameters and more. Please share your feedback in the forums . If you get an unhandled error dialog, please enter your email address so we could let you know when we resolved the issue or if...(read more)

How to submit CodeIt.Right Log file to SubMain support

Serge B. — Sun, 22 Jun 2008 05:43:00 GMT

CodeIt.Right Log file contains detailed debug information that allows us to troubleshoot most every issue on you experience with the product.

These are the steps to email the log file to us:

Open Visual Studio
In the menu bar, click CodeIt.Right, then click Help & Support, and then click Email Log File
Attach file from the location in the email body - in the screenshot above is "C:\Users\sergeb\Documents\SubMain\CodeIt.Right for VS2008\CodeIt.Right.log"
Click Send to email the attached file to us.