Review of JustCode! Universal 1.0
[Want me to review your product? Contact me]
JustCode! is a new productivity add-in for Visual Studio 2003 and 2005. It claims to enhance the Visual Studio Experience with solution-wide on-the-fly error checking, smart code navigation features, refactoring and other coding tools for C#, J# and Visual Basic.NET.
In this article I'll be reviewing the JustCode! Universal Edition, which is aimed at VS 2003 and 2005, both for C# and VB.NET. The addin was tested against VS 2005 only.
Let’s face it. JetBrains, the company who created Resharper for Visual Studio 2003, set a standard for refactoring and “quick-fix” addins which has the whole “productivity addins” industry taking notes. Their two biggest problems these days are that
- Resharper does not support VB.NET, only C#
- Resharper does not support Visual Studio 2005 (a public alpha is available, and it’s practically unusable as I write this)
That’s why when I saw the cool demonstration video of JustCode! I immediately thought to myself that this is the addin to fill the gap that Resharper left behind. JustCode! supports C#, VB.NET and J# editing and runs on VS 2005 and 2003. I set out to start building a simple product in both C# and VB.NET that would make me exercise this new addin.
Usability
In the interface department JustCode! Follows in the footsteps of another well known addin, CodeRush, and has no modal dialog windows while editing code. All it’s “dialogs” are comfortably located inside the code window, allowing you to do all the editing and refactoring without leaving the keyboard.
Shortcuts are available for all of its functions (albeit, not many of them exist) and the default key bindings are easy to memorize (Ctrl-Shift-Backspace for code refactoring, Ctrl-Alt-Home to navigate etc.).
Refactoring - That's not it
If you don’t know what refactoring is, here’s a little definition:
Refactoring is changing existing code without changing its functionality. Renaming a variable is Refactoring. So is splitting a large method into several smaller methods without changing the overall functionality. Tools and addins that support automated refactoring offer the ability to do such changes automatically thus reducing the likelihood of blundering things up along the way and messing up the code.
You’d expect that a product that highlights one of its main features as “Refactoring” would have support for a large number of refactorings, or at least the most common ones. Surprisingly, JustCode! Does not meet this criteria very well, and only supports a small number of possible refactorings including “Rename”, “Move/Delete Parameter”, “Inline/Introduce Variable” ,“Organize Imports”, “Promote field to property”, “add constructor” and not much else. They are relying on the fact that refactoring support is already there in VS 2005 both for C# and VB.NET, and are only adding the bare essentials.
One feature I did like is the ability to select one or more private fields in code and create a constructor out of them automatically.
The problem is, even the basic refactorings that exist in the product don’t always work as well as advertised. Here are some examples:
“Rename” for a class does not automatically rename the filename the class is located in. that’s what you want to do 99% of the time, and still no one seems to get this right except the guys at JetBrains.
Repeatedly “Introduce Parameter” behaved badly in two ways:
- It “Introduced” a new parameter in the line below the current line instead of above it, causing a compilation error on that line since the variable hasn’t yet been declared. So if I wanted to Refactor the highlighted value in this line
Dim groupNode As TreeNode = New TreeNode("[" & groups(groupindex).Value & "]")
The resulting could would look like this:
Dim groupNode As TreeNode = New TreeNode(value) ‘<-- compile error here
Dim value As String = "[" & groups(groupindex).Value & "]"
Instead of what sould have happened:
Dim value As String = "[" & groups(groupindex).Value & "]"
Dim groupNode As TreeNode = New TreeNode(value)
- You can’t introduce a variable on a simple partial selection of code element. It only works on a whole element. It’s hard to explain without an example:
Say I have this line:
RegexMatch.Groups.Count
And I’d like the highlited part to be a separate variable. I bloody can’t. Even with the correct selection of code, the introduce variable Refactoring will always produce a variable of type integer for the groups.count. In short - you'll always get this: int count = RegexMatch.Groups.count
instead of GroupCollection groups = RegexMatch.Groups
That’s just wrong and should be an essential part of any refactoring tool.
One nice bonus is that the “Rename” refactoring is also effective on namespaces throughout the solution, so renaming a namespace or removing parts of a namespace work very well.
Navigation - Pretty Good, Missing some stuff
JustCode provides the following features for navigation:
- Go to next/previous error/using
- Go to overriding, overridden methods
- Go to definition
- Find usages
- Find sub classes
- Find inheritors of this type
- Find methods returning this type
- Find methods taking this type as an argument
- Go to class by name
- Go to symbol by name
Overall the navigational features work very well and are very helpful. These are the basic kind of features you’d expected Visual Studio 2005 to contain out of the box, so they are definitely a “killer feature” for developers.
One caveat in the the last two features is that the dialogs do not allow using “placeholder” searches such as “*Assembly” to search for everything ending with “Assembly”, which is an easy feature and very powerful.
I’d also like to see a “Go to overriding/base method” feature for methods.
Code Assistance - Good
Here are some of the features JustCode! Contains for editing code:
- Fast on-the-fly error checking of the whole solution
- Status indicator showing error status of current file
- Indicators in scrollbar show error positions
These three features are just like the features Resharper Introduced for visual studio 2003, and they works very well.
Overall the code editing experience is much better thatn that of VS 2005 without the addin and allows quicker and better feedback without compiling the solution to find an compilation errors.
Summary
The real time error highlighting and indicators are one of the best features, and so are the navigational features. The product lacks the most when it comes to refactoring abilities and even blunders what little it has to offer in that department, which is a shame for a product which touts this as one of its main functionalities.
With VB.NET and C# getting refactoring support out of the Box (well, almost out of the box for VBers), the only things standing out for this product is navigation and real time error indicators. Some people will find it’s worth the $199 for the cost, and some won’t. I suspect most will wait for Resharper.
JustCode! Tries to follow the footsteps of Resharper, but stop shy of embarrassing itself in the process. If I just couldn’t wait until Resharper 2.0 is out on the market, I’d consider it as a temporary crutch to lean in until that day comes.