Operating system

• Windows Vista.  I’ll take some flack for this one, but I still like this OS.  And the boot time is screaming fast before you load every tool/service under the sun on it.

Tools and Utilities

• Windows Live Writer.  I’m listing this one because that is what I’m writing the blog post with.  Simply the best blog writer that I have found so far.  Works with WordPress, Blogger, and many more tools.  There are a few other tools in the Live suite that are also cool.  SkyDrive, Photo Gallery, and that  messenger thing are nice.
• Skype.  This is the reason I don’t use Messenger anymore.  I have Skype, which does the same thing plus more.  This tool allowed me to finally drop my home phone (coupled wih a pair of cell phones).
• Office 2007.  Word, Excel, Outlook, OneNote, and PowerPoint.  There is other stuff there, oh well.  Those are the ones I use.
  • Xobni.  This is an add-on for Outlook that gives you metrics and stuff for email.  If you live in Outlook, you will love this tool. (Look, it is inbox spelled backwards!)
  • Microsoft Office Save as PDF. The law suite over this tool made me hate Adobe forever.  This should be installed with Office, no excuse.
• SlickRun.  There are many launchers out there.  This one is simply an oldie-but-goodie.
• SysInternals.  All of it. Easier now that there is a single download for all of the tools.  AutoRun and ProcExplorer are the ones I find myself using more and more.
• Paint.Net.  Simply a better paint program.
• FoxIt Reader.  Pdf Reader.  Adobe Acrobat might not be as bad as it used to be, I don’t care.  This pdf reader is better than Acrobat ever was.
• FireFox.  Web Browser.  I’m not so much anti-IE7 as I am pro-Firefox.  When it comes to picking technologies, I believe in following the most vibrant community.  That is Firefox.  Better CSS support and faster Javascript doesn’t hurt either.  But it is the add-ons where Firefox really shines…
  • FireBug:  Firefox add-on. I’m a web developer.  If you are a web developer and don’t have this add-on you aren’t taking yourself seriously.  Hands down the best browser add-on on the planet.  In fact, the IE8 team liked it so much they stole it outright (and I couldn’t be happier).
    • Y-Slow: an add-on just for FireBug, create by Yahoo.  Designed to tell you why your web page is so blasted slow.
  • Read-it-later: add on that allows you to save bookmarks and share them between multiple computers.  Very well done.
  • Adblock Plus:  Ads? What ads?
• 7-Zip: Zip Compression tool, and free.  I like as much as WinZip or I wouldn’t list it.
• FileZilla: FTP client.  Not everyone needs one of these…but I do.
• Google Chrome.  I’m a glutton for punishment. I install every windows browser out there.  And I kind of like this one.  It has some significant differences from FireFox.
• Opera.  See above.  Probably the most standards compliant browser out there.
• SilverLight.  I’m a Microsoft fan box.  I admit it.  And this one is just cool.
• TeraCopy.  Copying files is a major weakness in Vista (and a core utility of what a OS is supposed to do well).  TeraCopy fixes some of that.
• Notepad++.  Because someone had to make a better notepad.  I used to use ConTEXT (I loved ConText), but the updates have stopped.  Plus the add-ons for Notepad++ do so much more.
• Free Download Manager. You might not realize how much better downloading files from the Internet could be, but this tool is just that.
• twirl. My twitter tool of choice.  Written in Adobe Air, it is a good ambassador for the product.
• Picasa.  Picture management and adjustment tool so easy even my wife loves it.

Developer Tools

I am a software developer.  My job centers around the windows/.net universe.  WinForms, WebForms, WPF, Silverlight, etc.  That is what I do.  Don’t be mad if your favorite Java/Ruby/PHP/Objective C tool isn’t in this list.

• Visual Studio 2008.  Obviously.  This is my work horse.  But I did not install Visual Studio 2005.  I’m hoping to make a clean break away from that one.
• ReSharper.  I don’t code without it.  But, if you have DevExpress CodeRush and Refactor I give you a free pass.
• SQL Server 2008.  Did not install 2005 (yet), and hope not to.  This is still my go-to database of choice.  BTW: this also installs PowerShell out of the box.
• Expression Suite.  Especially Blend.  I’m heading more and more to Silverlight and WPF.  I need this tool.
• TortoiseSVN.  Source control UI for SubVersion.  I love this one.
• Visual SVN Server.  If you need a Subversion server, and you are on windows, this is the one to get.
• SourceGear DiffMerge. I love TortoiseSVN.  I hate their merge tool.  This one make the pain go away.
• Reflector.  I can’t believe that .net developers still don’t know about this tool.  RedGate like it so much they bought it.
• CSS Vista.  Quick way to check your CSS in FireFox and IE…and adjust the css.  Wonderful tool.
• Free CSS Toolbox.  I just started playing with this tool a month back.  Very nice.
• dotTrace. Another JetBrains tool makes the list.  Best .Net profiler I’ve tried.
• TeamCity. Another JetBrains tool make the list. Continuous Integration.  If you don’t know what that is, you should look it up.
• NUnit.  There are other Unit Testing frameworks out there, but I keep coming back to this one.  Mainly because of ReSharper integration.  Looks like version 2.5 will be released soon as well.
• Rhino Mocks.  If you say you are TDD, but don’t know about mock objects, you are not TDD.
• LinqPad.  You would think this is LINQ specific, but it isn’t.  This is a full on .Net notepad.
• Fiddler2. A Web traffic debugger.  When you need it, you really need it.
• WireShark.  Similar to Fiddler, but covers anything that travels over a network card.
• Sybase IAnywhere.  This is my companies standard database.  Not a bad tool, but the management tools could be a lot better.
• VMWare Player.  In development, virtual machines are a fact of life.
• Window Virtual PC 2007.  See above.
• MyGeneration.  Code Generators are cool.
• CodeSmith Pro. See above…but with a better syntax for creating your own custom files.
  • Note: T4 comes with Visual Studio.  I’m still learning that one.
• Apex SQL Studio.  Similar to RedGate.  Does cool stuff with SQL Server.  I’m sticking with this until I can get Visual Studio Team System Data Dude.
• DaemonTools.  Runs a CD image as a drive.  Without this, my MSDN subscription would be worthless.

Presentation Stuff

• ZoomIt. Blow up part of your screen so people in the back row can see what your doing.
• Camtasia 3.  I don’t use this nearly enough.  Screen recorder with sound.

OK, that is my list.  Let me know what I missed.

It is clear (and stated) that other RDBMS vendors will follow suit as MS has provided a fundamentally pluggable model for vendors to integrate their DBs into Visual Studio with a provider model. Can you smell Oracle, boys and girls? I can. Gert is being vague about who they are working with. MySQL will be cool.

There are several levels of extensibility:

• DB Provider
• This is the actual connectivity to your own RDBMS. This provider is responsible for talking to the VS model layer for the DB project and translating between your DB and the model.
• VS Features
• The ability to alter features in Visual Studio, like:
• Refactorings available for a given provider.
• Syntax highlighting
• language formatting rules for reverse engineering operations
• Static analysis rules for your particular SQL language
• Yes, you get static analysis rules for TSQL. This is the death clock for select * from …
• Static analysis in BD2 SQL may be different than that in MS TSQL
• You can write your own static analysis rules in .Net by inheriting from the provided Rule class or *yeah* implementing an interface (are we hearing a theme out of MS?) I suppose if your company were anal enough, you could actually implement your proprietary naming convention rules as static analysis rules. Gert actually did this is an demo by writing a rule that checked column names to ensure they were in Pascal case. Neato. The funny part is when some of the developers in the room started telling him how his demo code could be refactored. Lol.
• Model Extensibility
• VS actually works against a model of the data store and lets the provider do the translation.
• Using the model paradigm for DB development provides full round trip model to implementation support for any given DB.
• Gert actually showed a little command line app that looked at a Northwind DB in Access and a different Northwind DB in SQL Server and compared them. There would be very different SQL syntaxes if we were simply comparing creation scripts. The DBs showed as the same. More accurately, the models checked as the same. Cool.
• So, I could script the process of taking a DB2 database and migrating it to SQL Server, or visa versa, in this model paradigm.

This session signaled several things to me.

1. MS products really are being designed with extensibility and integration in mind. No really, this time.
2. The Data Dude model of working with databases has genuine merit. The days of SSMS (SQL Server Management Studio) and the Query Analyzer fan base are numbered. Treating DBAs as developers really is a better model.
3. Something different is occurring at MS with the changing of the guard.

http://twitter.com/DaddyStarr

So, how do I get the most out of this? Should I switch to Jabber?

Can I tweet from MSN Messenger?

Who should I follow?

Will I care about this in 1 month?

Inheriting the code base of some legacy application that needs to be extended with a ton of new features which should have gone into production yesterday. Sure, we all have our war stories as developers. The first thing we usually do in a situation like this is reading the code. Then after some (short) time, we start complaining against our peers and managers how bad this code base really is. In fact, managers have grown a special skin against this kind of complaints coming from developers. This kind of complaints are not taken seriously by anyone just because it seems like such a subjective matter.

Actually, a good code base that is easy to maintain is not that subjective anymore. Object-oriented design has many principles, like the Single Responsibility Principle and Separation of Concerns among many others, that exactly describe how good code should look like. In order to prove to ourselves and our managers that we are writing good code an that the inherited legacy application is bad, we have to come up with some cold, hard facts. Besides code reviews, static analysis tools are the next best thing to verify the quality of our code. Such tools, integrated with daily builds and continuous integration, can help you and your team to figure out how well your project is doing. Note that these are just tools and that code reviews are still a lot better at the time of this writing.

We are using FxCop for number of years now and we are very pleased with it, although writing custom rules is rather cumbersome and has a high threshold to my feeling, probably because it is not that well documented. However, the rules that ship out-of-the-box are OK most of the time, so we keep using it.

I briefly looked at Microsoft Source Analysis last weekend, but I really didn’t like it.

A couple of months ago, Patrick Smacchia provided me a review copy of NDepend. I gave it a try last week and it literally blew me away. This tool performs a complete X-ray on the code base of your project and provides an extended report with a huge amount of information about the quality and maintainability of your project.

<confession>

Actually, I briefly reviewed this tool when it was in an early beta a couple of years ago. For some reason (probably stupidity on my behalf), I dismissed this tool entirely. What a mistake! Good that I finally come to my senses.

</confession>

I thought I’d unleash this power to Pet Shop 4.0. After creating the project, I already got a huge HTML file that contained a lot of information. Here is an example of a chart that shows the Abstractness versus Instability.

The X-axis shows the instability, that indicates how easy it is for the public interface of an assembly to change incorporating the number of other assemblies depending on it. The Y-Axis indicates the abstractness, i.e. how easy it is to extend the types in an assembly without a recompilation.

Notice that the PetShop.Model assembly is in the Zone of Pain. This means that it is used by a lot of other assemblies and that it is hard to extend the types that it contains.  A couple of other assemblies are in the Zone of Uselessness, which means their types are very extensible but with few dependencies from other assemblies.

The report also contains a diagram that shows the dependencies between the different assemblies.

These diagrams are just a small part of the information that is contained by the report. When you close the report, you can use the NDependViewer application to further analyze the data.

Now we come to the part where NDepend really shines: CQL or the Code Query Language. NDepend treats the code of your application as a database. With CQL you can perform all sorts of queries on its code base. NDepend already provides a lot of  CQL queries out-of-the-box and also lets you write you own queries. It even has intellisense!

This gets my geek heart pounding. This means that there’s a lot less friction involved when writing custom CQL queries as opposed to writing custom rules for FxCop. This particular CQL query returns the methods that have a Cyclomatic Complexity greater than 10, indicating that the OracleMembershipProvider needs some attention. When you double click one of the selected methods on the left, the code gets shown in Visual Studio. After a short inspection, it seems that the implementation of this class looks rather messy (“cough”, understatement, “cough”).

This is all just a tip of the iceberg. NDepend also lets you compare two different versions of your code base, performing CQL queries for determining the quality of the new code that was added. The latest version also supports test coverage metrics generated by NCover or Visual Studio. To make things even sweeter, NDepend ships with NAnt / MsBuild  tasks letting you generate this information as part of your daily builds / continuous integration.

With this tool, we as developers can come up with the hard facts. It allows you to dig right into the problem areas of a particular code base. There is even a CQL query that indicates which particular methods need refactoring.

The documentation of this tool is just great, the home page is filled with short demo movies and make sure to check out the metrics definitions and the quick reference.

You might suspect that I’m getting paid for this post, but actually, I’m not. This is just another great tool in my tool bag, not a silver bullet. The hardest part of starting out with this tool is the first 15 minutes. When you give it a fair chance and get past those 15 minutes, it will all be worth it. Just amazing work! My two thumbs up.