The Transformation Priority Premise

I just read the most brilliant new idea that I’ve seen since I learned TDD and Refactoring ten years ago. Naturally, it comes from the brain of Uncle Bob Martin. It’s called “The Transformation Priority Premise.” I’ll describe it briefly here. But, if you want to really understand it, you should go read Uncle Bob’s blog yourself:

Ok… So, what is the Transformation Priority Premise?

If you are familiar with Test Driven Development, you know the phrase “red, green, refactor.” That phrase encapsulates the process of writing tests before you write the code:

  • Red = Write a failing test and watch it fail.
  • Green = Write just enough code to make the test pass.
  • Refactor = Remove any duplication in the code without changing it’s behavior (all tests should still pass).

And, if you’re familiar with Martin Fowler’s book “Refactoring,” you know that a refactoring is a simple change to the structure of the code that is guaranteed not to change the behavior of the code. These are things like:

  • Introduce Variable – Replaces a constant with a variable.
  • Extract Method – Extracts one of more lines of code from one method into another (new) method.
  • Rename – Renames a variable, method or class.

These changes are so easy to implement that we can actually build tools that do them for us. Visual Studio comes with a handful of built-in refactorings. ReSharper adds significantly to that list.

What Uncle Bob is proposing is that there are similarly simple “Transformations” that change the behavior of a code base. Furthermore, he states that there is an order or priority in which we should apply these transformations – from simple to complex. He proposes the following (admittedly incomplete and probably mis-ordered) list:

  • [] –> nil
  • nil –> constant
  • constant –> constant+
  • constant –> scalar
  • statement –> statements
  • unconditional –> if
  • scalar –> array
  • array –> container
  • statements –> recursion
  • if –> while
  • expression –> function
  • variable –> assignment

Don’t worry if that doesn’t make any sense. I really just blogged it so I’ll have a quick reference. But, what’s cool about them is that they can actually help us pick which tests we should write in what order. For example, if we decide to write a test that requires us to add an if statement to our code, that test requires the “unconditional –> if” transformation. Knowing that, we can try to think of other tests that rely solely on transformations higher up the list.

The ultimate reward is that by writing our tests using transformation priority order, we should not ever get to a point where one test causes us to rewrite an entire method. Furthermore, because these transformations are all relatively simple in and of themselves, smart tools vendors may be able to build support for them directly into tools like ReSharper.

I’ve probably just confused the heck out of you with all this. Suffice to say that Uncle Bob’s posts are excellent. They include source code that he uses to show you how not using the priority order causes pain, and how using the priority order resolves that pain.

What are you waiting for? Go read those posts!

(Oh, and for those of you unfamiliar with Uncle Bob’s work, he references something called a Kata several times. The term comes from martial arts. It refers to a movement that is practiced over and over and over until it becomes second nature. Think “wax on, wax off”. Uncle Bob is a big fan of solving the same problems over and over and over to gain new insights into the potential solutions. And, he’s published several Katas ranging from calculating a bowling score to identifying prime factors of an integer. They’re worth your time, too.)

ReSharper Tip #123: Creating new classes and moving them to their own file

As I was writing all the source code for my last post, I relied heavily on ReSharper: first to generate classes for me, then to move them to a new file named the same thing as the class. This is a particularly handy technique if you practice Test Driven Development. Here’s how:

When I write a test, I write the whole thing, even though some of the classes may not exist, like this:

image

By placing my cursor on the class name (the red text) and pressing ALT+Enter, I receive the following ReSharper menu:

image

This generates the class in the same file as the test fixture. This is convenient at first. But, it’ll be impossible to find later, so I use ReSharper to move the class to a new file, again by placing the cursor on the class name and pressing ALT+Enter:

image

Which results in this:

image

Me like!

Reason #467 to use ReSharper: Live Templates

I just learned to use ReSharper’s code snippet feature, called Live Templates. I was looking for a code snippet to generate an NUnit test method. Oddly, despite ReSharper’s support for running NUnit tests, they didn’t see fit to include an NUnit test snippet. (Instead they included templates for the xUnit framework [Fact] and [Theory] methods, so I guess we know what framework they’re using.) So, I just created my own. Here’s how:

Step 1: Open ReSharper’s Live Templates dialog from the ReSharper menu in Visual Studio.

image

Step 2: Navigate to the folder where you’d like to add a Live Template and click the New Template button: (For me, this was the C# folder under the User Templates folder.)

image

(ALT+PrtScn didn’t capture the mouse pointer, but you get the idea.)

Step 3: Give your Live Template a shortcut and description, then enter the same kind of snippet code that you’d put in a traditional Visual Studio code snippet.
image

Step 4: Save your new Live Template and turn it on by selecting the checkbox next to it in the Templates Explorer dialog.

image

(Again, ALT+PrtScn didn’t capture the mouse pointer, but you get the idea.)

So, now, assuming I’m using ReSharper’s IntelliSense (to check go to ReSharper / Options / IntelliSense / General), I can create a test simply by typing “te” and selecting my Live Template from IntelliSense.

image

Sure, you could do all of this in Visual Studio, without ReSharper. In fact, Visual Studio 2010 includes a code snippet to generate tests in their syntax (where [Test] becomes [TestMethod]). But, you would have had to hand edit the snippet XML. Plus, ReSharper also includes Surround Templates (i.e. “surround the selected code in an if/for/try statement, please”) and File Templates (to create that new Test Fixture classes with all the correct NUnit using clause and [TestFixture] statement, for example).

To paraphrase Red Green: If your peers don’t find you handsome, they should at least find you handy.

ReSharper: Don't use Visual Studio without it!

According to IntelliBrains, ReSharper is:

the most intelligent add-in for Visual Studio 2005, 2008 and 2010 that provides a rich set of features to boost individual and team productivity in the world of .NET development.

Ooo! Marketing speak! Allow me to translate:

ReSharper is a Visual Studio add-in that adds over 70 features to the development environment. I linked directly to the feature list on the ReSharper web site, because there are just way too many for me to cover here, and they do a good job of showing you the salient points of each feature. But, I would like to point out a few of my favorite features: (I borrowed the images from the ReSharper web site to save me the time.)

Code Analysis

As I type, ReSharper is analyzing my code, looking for several things:

  • Errors (“that code won’t compile”),
  • Warnings (“that code may cause a null reference exception at runtime”),
  • Suggestions (“the type of that parameter can safely be changed to its parent class”), and
  • Hints (“your code might be easier to read if you invert that if statement”).

ReSharper Hint

This, to me, is the single most valuable feature of ReSharper. I would not code nearly as fast without it.

Navigation & Search

ReSharper offers several “Go To” tools that will significantly speed up your navigation of your code:

  • Go To Type (CTRL+N) takes you to any type in your solution, even by typing just the upper case letters (a feature JetBrains calls “CamelHumps”):

ReSharper Go To Type

  • Go To File (CTRL+SHIFT+N) takes you to any file in your solution – a huge help on huge projects.
  • Go To Symbol (CTRL+SHIFT+ALT+N) takes you to any method or variable in your project.

Refactorings

Here’s a picture of a small subset of the refactoring support in ReSharper:

image

One particularly interesting one in that list is “Use Base Type where Possible…” which is a very good habit. Using abstract classes and interfaces allows you to break coupling in your code. I could write several blog posts about just this one refactoring. Admittedly, though, my use of the refactorings tends toward smaller scale things like “Extract Method” and “Inline Method”.

 

Code Generation

Advocates of the agile practice called Test Driven Development (like myself) have long derided Visual Studio for offering to write unit tests for code that already exists, but not offering the opposite feature – generating method stubs from tests that were written before the code existed. ReSharper fills that gap quite nicely:

ReSharper method generation

If you do TDD in Visual Studio, this feature alone will pay for ReSharper. (And, if you’re not doing TDD, why not?)

Coding Assistance

Here’s a feature I didn’t even know existed until I started writing this article. It’s called “Complete Statement” and it automatically completes the current statement.

When you reach the end of a statement, like this:

ReSharper Complete Statement 1

Simply press CTRL+SHIFT+Enter and ReSharper completes the statement, and places the insertion point exactly where you’d want it, like this:

ReSharper Complete Statement 2

I think I’ll be trying that one out later today.

Code Cleanup

Ever open a file and discover that whoever created it had their tabs set to 2 spaces, making the text too dense and the indentations too shallow for you to quickly grasp the structure of the document? ReSharper can help you there, too. Simply press CTRL+ALT+F to format the file using your preferred format settings.

Code Templates

ReSharper completely replaces the rather limited Visual Studio “Code Snippets” feature with their own Live Templates feature. Here’s an example of their “foreach” template at work:

ReSharper foreach Template

Notice that ReSharper knew which object you were likely to want to iterate over. Very smart. Very useful. To access the feature, press TAB after typing in the name of a live template, in this case “foreach”.

Unit Testing

ReSharper automatically detects NUnit and MSTest-based unit tests in your projects and allows you to run them directly within the Visual Studio user interface. The runner is not perfect – JetBrains doesn’t always quickly add support for new features as they are added to the unit test frameworks. For example, ReSharper 4.5 does not support the NUnit [TestCase] attribute for creating data driven tests. But, I rarely use the [TestCase] attribute when doing TDD tests, which is primarily how I use the unit test runner.

In Conclusion…

If I still haven’t convinced you to take a look at ReSharper, I recommend taking a look at their website before writing it off completely. There are so many useful features that I didn’t cover here, you’re bound to find half a dozen favorites of your own. Heck, even if you’re already using ReSharper, spending some time on their website will likely show you something you don’t know about the product.