I’m way too late to post the conclusion of the trial, but for all of you who wanted to know here are the results.

Will I continue to use vi/Vim in my everyday life? Probably. But not for a little while. The experience was fun but I did not find that my productivity increased a lot. I can’t really say for sure. The problem I had was that I did not have a proper typing technique. So I found myself distracted because I was hitting the wrong key and caused side effects. So, I came to the conclusion that I needed to learn how to type properly.

I have already started to follow the lessons provided by typeonline.co.uk. And while typing with the proper skill in Visual Studio, I found myself missing viEmu real bad. I did not wanted to remove my hand from the keyboard to move around. Having seen what vi/vim was capable of, it’s a huge way back.

I have been using NDepend on various project I am working on and there is so much to say that I can’t wait to do a full review because I will make you wait too long. I got a free license and wanted you to know what the tool can do and what were my impression.

First of all NDepend is a tool that analyse your code. It’s huge! Definitely not a tool you can learn in an hour or two. Simply give the tool a solution or project file and start analyzing. You are first presented with a a complete map of your application. By default it shows all your code sorted by the number of lines but you can quickly switch by different kinds of metrics (LOC, Cyclomatic Complexity, IL instructions, Efferent coupling, etc.).

The best part is that you can write query against your code. This feature is called CQL (custom query language). Need to know which method have more than 200 lines of code? No problem. Really. It looks like SQL and is easy to write (I haven’t written any yet, but I’m sure it will prove useful later).

Take a look at this :

// <Name>Methods with too many local variables (NbVariables)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE NbVariables > 15 ORDER BY NbVariables DESC

Out of the box, NDepend provide around 200 CQL queries. It has queries to find unused or dead code, find which method are not test covered, naming convention not respected, types with too many methods, ect. Each rules has a short description on what it does and even provide links to more complete documentation if needed. It also has intellisence as if this wasn’t enough.

A cool feature is the dependency matrix. It’s easy to see where is your dependencies.

The tools itself is beautiful, it make us want to play more with it (it does not use WPF, but it appears to). 

A lot of features that I haven’t used yet are :

• Compare assemblies
• Code Coverage
• Writing complex  custom rules

I recently came across this post entry by Patrick Smacchia (creator of NDepend) that used the tools to spot bugs in an existing code base (http://codebetter.com/blogs/patricksmacchia/archive/2009/06/21/agile-behavior-nurture-knowledge-database.aspx). I don’t know why but this has really struck me and kept it in my favourites. I could write custom query to spot bad practices and potential bugs.

But there is a downside. On a project I worked last year. Every query that has been executed had a warning on it, almost every single one. That’s sad. I almost cried. But I’m fine now. NDepend will help me.

There is so much to say, that it’s almost impossible to cover it all in one single post. I’ll continue to use it and post any relevant information and features that I really enjoyed in the next couple of weeks.

That was disastrous. No really. I had a lot of modifications to be made fast and it just seemed that viEmu was always in the way. I’m not blaming viEmu here, it’s just because I was not completely comfortable with it and I should had it deactivated for the rush. On another side, I learned how to do search without using Ctrl-F. Disturbing at first, a must now. 24 days left.

I’m starting to really like this. I’m much more confident and often I don’t need to think twice before using a command. Today I have used many times the “yank & put” keys along with v,V (selection)  and o,O (new line before of after the current line). I am not required to think. So far, so good.

Today I had real opportunity to use gVim so I decided to install ViEmu for Visual Studio and give it a try. A had a lot of code to write on a recent application I’m working on so why not.

I’m starting to get a hand on basic navigation and on inserting/appending removing/deleting characters. It’s too soon to know I it had improved my productivity yet, but I’m still learning so let’s see in a couple of days how it goes.

Not been typing much today, but I wanted at least to clear something. How do I cut/paste inside gVim.

First you need to enter the selection mode by hitting "v". Then move the cursor to select text using h, j, k, l, w, e, etc. When the text is selected, hit "d". This will cut the text. Now hit "p" to put the line back.

On another note, I talked about vi/vim to some of my colleagues and friends and everyone is just laughing at me. Everyone seems to agree that there is no points in learning this and should stick with "what everyone do". I do hope to show them what it’s really about.  

Day 2 of the trial, I have gone through half the tutorial (up to Lesson 3.3) and I begin to see where the power of this vi/vim residing. The most annoying thing so far is the color scheme/font that is not remembered, but I’m pretty sure it will have to do with learning vi (maybe a hidden command or something , or maybe not and will have to modify a config file somewhere).

Here is a recap of what I learned today

First, I have been using the "w" and "e" key to navigate through text in "Normal mode" (Normal Mode is where you are when you are not typing, hitting ESC get you there).

Next, the "x" key. Again, in normal mode, you hit the x key to delete the remaining of the words. If you are at the start of the word, it removes it completely and if you are at the second characters, it remove all remaining characters after the cursor.

This is it. I learned a lot through the tutorial but haven’t used it much so it does not count. Tomorrow I will try a few new commands to keep learning it until I’m a master of vi/vim!!

I’ve decided to give a serious try to the like of vi/vim. I have heard a lot of gossip around thoses editors and since it’s supposed to increase productivity (and I want to increase my productivity), I decided that I should at least try it for 30 days. I’ve started this morning and found out that it’s a hell of a learning curve.

I’ve downloaded gVim this morning and used it for all the things that involved typing (except Visual Studio, waiting to be more familiar with it). The first interaction was a little bit strange. I admit I had to use the mouse to start editing since I had no idea at all why I need to type "i" to start typing.

Later that day, I stumbled across the "why page" of viEmu, the author does a good job of clearing things. Mainly the use of the "normal" and "edit" mode. To start writing text, you need hit "i" and as soon as you are finish you hit "Esc" to get you back in navigation mode. The "normal" mode is where you need to stay at all time when you are not typing.

Where I have a lot of difficulty on this first day, is the use of the h,j,k,l keys to navigate through the text file. I’m still trying to apply the mnemonics of the first lesson of the tutorial (h is the leftmost key so you move left, j looks like the down arrow, l is the right most key so it goes right, and then k is up). I have not understood yet how it works since it’s seem to go everywhere, but where I want it to go.

And the last things I learned is the :sav command, which is basically the save as function.

I have not picked all the terms correctly since it’s only the first day and had not the time to read through all the tutorials. But I’ll keep you up to date with my new way of typing.

I think I needed to make this post since I was struck by this problem 2 times in the last year. And I didn’t learn from the first time, so here is the error message I got along with 50+ others that looked the same when building a setup from Visual Studio 2008.

The install location for prerequisites has not been set to ‘component vendor’s web site’ and the file ‘dotNetFx35setup.exe’ in item ‘Microsoft.Net.Framework.3.5.SP1′ cannot be located on disk.

At fist, I was thinking that I haven’t downloaded the right version of the framework so, I have gone mad trying to find one that was entitled “redistributable”. Can’t find. Humm maybe something has to do with Visual Studio not looking for the right folder (Program Files vs Program Files (x86)). No.

After a lot of questions and no answer, I found a lost notes in Evernote stating that I should read the VS 2008 SP 1 readme file…

Section 2.3.1.1 : Enable Samesite for the .NET Framework 3.5 SP1 bootstrapper package

Here is the section content for those who don’t want to search for their readme file.

Update the Package Data

1. Open the [Program Files]\Microsoft SDKs\Windows\v6.0A\Bootstrapper\Packages\DotNetFx35SP1 folder or %ProgramFiles(x86)%\Microsoft SDKs\Windows\v6.0A\Bootstrapper\Packages\DotNetFx35SP1 on x64 operating systems
2. Edit the Product.xml file in Notepad.
3. Paste the following into the < PackageFiles > element:
   < PackageFile Name="TOOLS\clwireg.exe" />
   < PackageFile Name="TOOLS\clwireg_x64.exe" />
   < PackageFile Name="TOOLS\clwireg_ia64.exe" />
4. Find the element for < PackageFile Name="dotNetFX30\XPSEPSC-x86-en-US.exe" and change the PublicKey value to: 3082010A0282010100A2DB0A8DCFC2C1499BCDAA3A34AD23596BDB6CBE2122B794C8EAAEBFC6D526C232118BBCDA5D2CFB36561E152BAE8F0DDD14A36E284C7F163F41AC8D40B146880DD98194AD9706D05744765CEAF1FC0EE27F74A333CB74E5EFE361A17E03B745FFD53E12D5B0CA5E0DD07BF2B7130DFC606A2885758CB7ADBC85E817B490BEF516B6625DED11DF3AEE215B8BAF8073C345E3958977609BE7AD77C1378D33142F13DB62C9AE1AA94F9867ADD420393071E08D6746E2C61CF40D5074412FE805246A216B49B092C4B239C742A56D5C184AAB8FD78E833E780A47D8A4B28423C3E2F27B66B14A74BD26414B9C6114604E30C882F3D00B707CEE554D77D2085576810203010001
5. Find the element for < PackageFile Name="dotNetFX30\XPSEPSC-amd64-en-US.exe" and change the PublicKey value to the same as in step 4 above
6. Save the product.xml file

Download and Extract the Core Installation Files

1. Navigate to the following URL: http://go.microsoft.com/fwlink?LinkID=118080
2. Download the dotNetFx35.exe file to your local disk.
3. Open a Command Prompt window and change to the directory to which you downloaded dotNetFx35.exe.
4. At the command prompt, type:
   dotNetFx35.exe /x:.
   This will extract the Framework files to a folder named “WCU” in the current directory.
5. Copy the contents of the WCU\dotNetFramework folder and paste them in the %Program Files%\Microsoft SDKs\Windows\v6.0A\Bootstrapper\Packages\DotNetFx35SP1 folder (%ProgramFiles(x86)%\Microsoft SDKs\Windows\v6.0A\Bootstrapper\Packages\DotNetFx35SP1 on x64 operating systems). Note: Do not copy the WCU\dotNetFramework folder itself. There should be 5 folders under the WCU folder, and each of these should now appear in the DotNetFx35SP1 folder. The folder structure should resemble the following:
   o DotNetFx35SP1 (folder)
   • dotNetFX20 (folder
   • dotNetFX30 (folder)
   • dotNetFX35 (folder)
   • dotNetMSP (folder)
   • TOOLS folder)
   • en (or some other localized folder)
   • dotNetFx35setup.exe (file)
     You may now delete the files and folders you downloaded and extracted in steps 2 and 4.

I almost never give my opinion about code I see, but I felt this one was interesting and educative. It all started while working on a legacy project (an ASP.NET web application), I found out that most connections were not closed. So I fixed them all and making sure every connection was closed once the I finished with it, should an error occurred or not.

try
{
    using (IDataReader reader = SqlHelper.ExecuteReader(Sql.MainConnection, "sp_name", paramter1, parameter2))
    {
        while (dr.Read())
        {
            //do something
        }
    }
}
finally
{
    Sql.MainConnection.Close();
}

Pretty basic stuff. Today I deployed the application to a server for some testing. After two or  three users getting in, Boumm! SQL Server is dead. I check the activity monitor and found out that a hundred connections were still open. The reason is : I have wrongly assumed that a static class in the project was providing me with a connection that was shared between all data access class.

I was sure I was closing all the connection, but I ended up closing nothing.  Let’s take a look at the MainConnection property of the Sql class :

public static SqlConnection GetMainConnection
{
    get { return new SqlConnection("connectionstring"); }
}

Each time I was accessing the database, and it was accessed a lot (20 times per request), I ended up with a lot of open connections. Enough to make SQL Server unavailable for some time. You could argue that it was my mistake and I shouldn’t be assuming things like this. But in my opinion, it’s a case of bad naming. The choice of name for the property that return me a connection was inconstant. If I access a property, I assumed that if I call it five times in a row, I would have five times the same result. The best choice would have been to create a method that return a new connection and name it accordingly.

public void SqlConnection GetNewSqlConnection()
{
    return new SqlConnection("connectionString");
}

It would have reduced the ambiguity and would have been a lot more easy to read. Good naming is very important and can greatly enhance productivity on a project. Good code should be easy to read and you should not ask yourself if a calling a method would cause side-effects or not doing what it said it should.

Here is, like a promised, my review of Don’t Make Me Think: A Common Sense Approach to Web Usability by Steve Krug.

First, I know some reader don’t like long post, so I begin with the conclusion.

This book is a gold mine. It will be useful for web developer. He will be useful to anyone who is in contact with the development of a web site. And I risk myself to say that it should be useful for anyone who has to design something in any field for an end-user. This is really a great book to read.

And now, the review.

Presentation

First of all, the book is short (201 pages). But it’s a good thing. It goes right to the point. And if a ratio existed for the number of pages versus the quantity of valuable contents, it would be a top performer!

The author use already existing web sites to explain his points and use the “dialog style” where we can read a conversation between peoples. It’s illustrated and some part are like a comic book.

Content

In the first chapters, he wrote about the way to get a design right. Where the various element should be positioned to make the user think less and enjoy his experience more, the visual hierarchy, etc. We are scanning and not reading a web page. Important stuff to remember in fact.

And then, he is describing the problem we already (or will) have with home pages. He guide us through the challenge of getting it right and useful for any users. He talk about the way the user think and common misconceptions about it. One part that really hit me, is where he mention that the real person it should benefit is the user. We often forgot about this simple fact. No matter how great we think the web site his, he may not be perfect for the end user.

The chapter in which he explains how to do usability testing with real user is one of my favorites. How to choose users, where the test should be, which equipment is necessary, what to test and which procedures to follow. He even talk about the way to make user feel comfortable. There is no need to spend a lot of money, where we conduct extensive tests with various users. Sometimes, the most basic stuff we can do is right. That does not mean we should not have test, they definitely are necessary. He does a great job at proving the real value of those tests. I really enjoyed this chapter.

Near the end of the book, he discuss the experience for people with disabilities. He points to various references that every web developer should read and why it’s important to respect guidelines that would help them. He kind of reminded me that we should not forget about them because it’s a lot more work for us.

Conclusion

In conclusion, I believe that this book should be one the classic book every developer should read. I will put in in the same category as Code Complete.

I watched the review of the unit tests of the ASP.NET MVC framework done by Roy Osherove and it was interesting. It’s great to have someone going through unit tests and explaining what they done right or wrong.

Here is some points he made in the review:

• No dynamic values in assert.
• Empty string tests.
• Emphasis on readability.
• Multiple assert on one test is bad.
• Only one mock object per test.
• Verify only what you need to.
• Mocks that should be stubs.

Watch it yourself here.

Important note  : I am using ReSharper 2.x / IDEA keyboard mapping.

This is the last post about shortcuts, next one will be about creating Live Templates.

Alt-F7

Find usage of anything, everywhere it is used.

Ctrl-J

Browse the list live templates and allow you to select one.

Alt-F12/Shift-Alt-F12

Respectively move to the next and previous error in your solution. Forget about the error windows.

Ctrl-Alt-M

Refactoring shortcut. Extract a piece of code and make a method with it.

F2

Rename anything your cursor is one. And it’s an intelligent renaming, meaning it will search for every usages of it and rename accordingly.

Important note  : I am using ReSharper 2.x / IDEA keyboard mapping.

CTRL-F12

With this shortcut you can navigate and search the list of methods of the class you are presently in.

ALT-Down Arrow / ALT-Up Arrow

Gives you the possibility of going to the next or previous member or method in your class.

CTRL-P

Parameter info. It’s over now. Over the time when you had to hit the backspace key and retype some characters to see the list of parameters the method will take poping up. Hit this shortcut and code with less keystrokes.

CTRL-E

I have recently discovered this neat shortcut. It gives you a list of recent files you have edited and the possibility to quickly switch to any of it.

Ctrl+Shift+Alt+Backspace

Another recent discovery. It basically does the same thing as CTRL-E (Recent files you have edited), but with a small difference. You can navigate the list of changes you have made to your code. That’s right, you can quickly go to any piece of code you have edited recently.

Important note  : I am using ReSharper 2.x / IDEA keyboard mapping.

Alt-Enter

Whenever you navigate your code and see a bulb shaped icon at the left side of your code, hit the Alt-Enter key combination that will provide you with a set of actions you can do on the selected code block.

Alt-R/R

Open the refactor menu. This will present you with a list of possible refactoring you can do.  This is the easiest way to start learning every refactoring’s shortcut.

Ctrl-N

Find a class by it’s type name. You can quickly navigate without the mouse to get you anywhere you want within your solution. This one will quickly become one of your most used shortcut.

Ctrl-Shift-G

At first you will need to know this one, but, when you’ll become a ReSharper Jedi,  you will forget everything about it’s existence. Place your keyboard cursor on anything and hit those keys. You will then be able to move to it’s declaration, inheritors, usages, unit tests, etc.

Alt-Insert

When you are navigating your solution (Ctrl-Alt-L), press the Alt-Insert key combination and you can create new folders, add classes an even add a file that you previously created with the template editor of ReSharper.