When I accepted my new position with SpringSource, I realized that my need to rapidly become familiar with the Spring .NET codebase provided me with a perfect opportunity to leverage NDepend 3.  In this blog post I’m going to try to help you get a better feel for some of the finer points of NDepend 3 while using it to explore and become familiar with the structure and design of the Spring .NET codebase.

“Installing” NDepend

One of the first things you realize when it comes time to install NDepend is that there is no installer!  Instead, NDepend is one of the few .NET programs out there on the market that actually bought into the whole “XCopy Deploy” meme that .NET 1.0 was so vocal about (and has since been an idea mostly lost somewhere along the way with the growth of everything from third-party commercial installer tools to WIX to the official line from Redmond being “No .msi?  No uninstaller?  Then no Windows-logo-compatibility for you!”).

Instead of installing it, just download the ZIP file, extract it somewhere (anywhere!) and double-click the .exe to launch it.  A breath of fresh air in re: simplicity of installation, but frankly this is probably more ‘safe’ in the context of this kind of application because its target market is software developers.  The kind of things an installer would do (check for prerequisites like having the .NET framework installed, etc.) are likely things that its users would already know they would need.

Launching NDepend for the first time

Well, technically this is “Launching VisualNDepend for the first time”, but bear with me here for a second.

NDepend itself is really two different pieces of software (perhaps even more than two if you start to count its add-ins for things like Visual Studio and RedGate’s .NET Reflector, but more on that later). 

One piece, the NDepend console application, is used to perform the analysis of your assemblies (and to persist the results of that analysis as an XML-based “report”) and the other part, VisualNDepend, can be thought of as a sort of ‘visual explorer’ for those XML-based “reports”.  But since launching VisualNDepend is probably the first step most will take after completing the “install”, let’s start there.

The first thing you will notice about VisualNDepend’s ‘startup state’ is that its very well-designed to get new users up to speed and using the product with with a minimum of difficulty.  This is something that lots of software could take a cue from: consider what are likely the obvious questions a new user to your product would be asking and provide some easy-to-access guidance for them to help the user along.

In the case of VisualNDepend, this is provided for in a simple “Getting Started” task box that offers both on-click access to the extremely comprehensive and well-authored integrated help system and also to several videos (hosted on Amazon’s S3) that introduce the core concepts and initial steps required to get up and running with the product:

One of the (several) things that helps to distinguish this release of NDepend from its prior versions is the extremely high level of integration with Visual Studio that it provides.  The start screen for NDepend makes installing this dirt-simple for the new user as well – simply invoke the installer process from the obvious button below:

As you can see from the installation options dialog box, support is available for VS 2005, 2008, and 2010 and each offers a choice between Full Integration and Light Integration.

Prior to NDepend 3, Visual Studio integration was mostly limited to navigating back and forth between classes and methods in Visual NDepend and related source code in Visual Studio.  Beginning with this release however, the integration story with Visual Studio becomes much more compelling.  Light Integration is still mostly about navigating in code between a running instance of VisualNDepend and a running instance of Visual Studio although you can actually also perform CQL queries from inside Visual Studio as well as a few other so-called light-weight tasks.  Still, the Full Integration option is where I expect most software developers will want to operate as it offers nearly the entire set of capabilities of the VisualNDepend product from within the Visual Studio shell directly.

Astute readers will notice from the screenshot above that the authors of NDepend have even provided a hyperlink to an webpage with short video on getting started with Visual Studio integration.  This is just another example of some of the really thoughtful nuances of NDepend that are designed to improve the ease-of-use of an otherwise potentially quite complicated product.

Analyzing Dependencies in Spring .NET

One of the all-time best uses for a static code analysis tool like NDepend is to use the program as an exploratory tool as you “wander” through an unfamiliar code-base.  The graphs and other visualizations of the relationships between the components of the solution make the project much more comprehensible.

As an example, the following screenshot shows the dependency graph for the primary assemblies of Spring .NET:

This visualization makes it easy to see that the ‘foundation’ of Spring .NET is the Spring.Core project.  Spring.Aop, Spring.Web, and Spring.Services all have a direct dependency on Spring.Core as does Spring.Template.Velocity.  Because in this particular graph the area (size) of the boxes reflects relative number of lines of code in each project, we can see that of these immediate dependencies Spring.Aop and Spring.Web are the largest project with Spring.Services following closely behind but that Spring.Template.Velocity is a much smaller project than the others at this dependency level.

Spring.Data and Spring.Web.Extensions follow on in the next tier of dependencies followed then by a plethora of smaller ‘subsystems’ in Spring .NET such as the support libraries for the various versions of NHibernate, Messaging support libraries, Scheduling, and more.

This is more or less what one would expect of a set of framework libraries, of course – common elements at the bottom, more powerful but still general abstractions built atop that core, followed closely by ever-more-specific functional libraries atop that.  But a graph like this one – and the fact that its possible to just point NDepend at the Spring .NET assemblies and have it rapidly generate this visual is a tremendous help in starting to understand the dependency structures involved in the projects.

Identifying Potential Pain Points in Spring .NET

One of the things at which NDepend excels is in gathering and analyzing so-called ‘code metrics’.  I mentioned CQL, the Code-Query-Language, supported by NDepend in my last post about v2.x and its still present in v3 too of course.  NDepend ships with a set of very useful pre-defined queries (and you can can create your own additional queries in CQL and save/retrieve them too).

Some of the most interesting (to me) to use when inspecting an unfamiliar codebase are those in the ‘code quality’ category.  Here I’m selecting the 10 methods that have been found to have the highest cyclomatic complexity (CC) metric.

…and here we see the list of those 10 methods in Spring .NET having a CC of > 20…

The one highlighted at the top is of particular concern to me as its got a near-unbelievable CC value of 124!  This certainly makes this method stand out like the proverbial ‘sore thumb’, making it worthy of further investigation.  Fortunately, NDepend makes such exploration amazingly easy – simply double-clicking on the method name in the CQL output window immediately opens the method’s source file in the code editor window for me.  NDepend knows how to navigate the codebase to take me directly to where I want to go.

For fun, here’s this actual method from the Spring.Expressions.Parser.ExpressionLexer class…

   1: public void mID(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException

   2: {

   3:         int _ttype; IToken _token=null; int _begin=text.Length;

   4:         _ttype = ID;

   5:         

   6:         {

   7:             switch ( cached_LA1 )

   8:             {

   9:             case 'a':  case 'b':  case 'c':  case 'd':

  10:             case 'e':  case 'f':  case 'g':  case 'h':

  11:             case 'i':  case 'j':  case 'k':  case 'l':

  12:             case 'm':  case 'n':  case 'o':  case 'p':

  13:             case 'q':  case 'r':  case 's':  case 't':

  14:             case 'u':  case 'v':  case 'w':  case 'x':

  15:             case 'y':  case 'z':

  16:             {

  17:                 matchRange('a','z');

  18:                 break;

  19:             }

  20:             case 'A':  case 'B':  case 'C':  case 'D':

  21:             case 'E':  case 'F':  case 'G':  case 'H':

  22:             case 'I':  case 'J':  case 'K':  case 'L':

  23:             case 'M':  case 'N':  case 'O':  case 'P':

  24:             case 'Q':  case 'R':  case 'S':  case 'T':

  25:             case 'U':  case 'V':  case 'W':  case 'X':

  26:             case 'Y':  case 'Z':

  27:             {

  28:                 matchRange('A','Z');

  29:                 break;

  30:             }

  31:             case '_':

  32:             {

  33:                 match('_');

  34:                 break;

  35:             }

  36:             default:

  37:             {

  38:                 throw new NoViableAltForCharException(cached_LA1, getFilename(), getLine(), getColumn());

  39:             }

  40:              }

  41:         }

  42:         {    // ( ... )*

  43:             for (;;)

  44:             {

  45:                 switch ( cached_LA1 )

  46:                 {

  47:                 case 'a':  case 'b':  case 'c':  case 'd':

  48:                 case 'e':  case 'f':  case 'g':  case 'h':

  49:                 case 'i':  case 'j':  case 'k':  case 'l':

  50:                 case 'm':  case 'n':  case 'o':  case 'p':

  51:                 case 'q':  case 'r':  case 's':  case 't':

  52:                 case 'u':  case 'v':  case 'w':  case 'x':

  53:                 case 'y':  case 'z':

  54:                 {

  55:                     matchRange('a','z');

  56:                     break;

  57:                 }

  58:                 case 'A':  case 'B':  case 'C':  case 'D':

  59:                 case 'E':  case 'F':  case 'G':  case 'H':

  60:                 case 'I':  case 'J':  case 'K':  case 'L':

  61:                 case 'M':  case 'N':  case 'O':  case 'P':

  62:                 case 'Q':  case 'R':  case 'S':  case 'T':

  63:                 case 'U':  case 'V':  case 'W':  case 'X':

  64:                 case 'Y':  case 'Z':

  65:                 {

  66:                     matchRange('A','Z');

  67:                     break;

  68:                 }

  69:                 case '_':

  70:                 {

  71:                     match('_');

  72:                     break;

  73:                 }

  74:                 case '0':  case '1':  case '2':  case '3':

  75:                 case '4':  case '5':  case '6':  case '7':

  76:                 case '8':  case '9':

  77:                 {

  78:                     matchRange('0','9');

  79:                     break;

  80:                 }

  81:                 default:

  82:                 {

  83:                     goto _loop166_breakloop;

  84:                 }

  85:                  }

  86:             }

  87: _loop166_breakloop:            ;

  88:         }    // ( ... )*

  89:         _ttype = testLiteralsTable(_ttype);

  90:         if (_createToken && (null == _token) && (_ttype != Token.SKIP))

  91:         {

  92:             _token = makeToken(_ttype);

  93:             _token.setText(text.ToString(_begin, text.Length-_begin));

  94:         }

  95:         returnToken_ = _token;

  96:     }

As you can see, the seemingly-impossible-to-achieve CC value of 124 is largely due to the approach of having a switch condition for every letter of the alphabet (both uppercase and lowercase) and another for every digit from 0-9 in this single method.  Although this does technically result in an absurdly high CC analysis metric for this method, a quick review of why this method has so high a CC value tells me that its really not as difficult to comprehend this method as a CC value of 124 would suggest at first-glance.

This is a big part of the value of having a tool like NDepend integrated so well right into the IDE in this manner: you can quickly investigate and validate such statistical outliers when they come to your attention to determine whether they are worth taking corrective action to address.

As a complete ‘aside’, you can also infer that this method was ported from the Spring Framework for Java since you can see how the checked exceptions syntax has been left intact from the port at the top of the method declaration (though obviously its been commented out since – as we all know and has been thoroughly debated by many – the C# language doesn’t have support for checked exceptions!).  Personally I find it quite interesting that while the initial design decision not to include support for Checked Exception in C# is vigorously defended by the language’s author(s), in .NET 4 we’ve now got support for Code Contracts in a way that at least tries to solve the same kinds of troubles in the code that Checked Exceptions were intended to solve, but that’s probably a post for another day…

In addition to cyclomatic complexity being a possible indication of long-term maintenance concerns for the codebase, another great metric to look at is Source Lines of Code (SLOC) in each method.  Fortunately, as seen in the following screenshot NDepend ships with a CQL query that covers that too…

The names of the top ten longest methods in the Spring .NET code are shown the CQL results pane for further investigation:

That method with the 153 lines is initially a candidate for further investigation – I sure wouldn’t want to have to read through a 153-line long method to try to understand what its doing before attempting to fix a bug or add additional functionality to it!  Just as before, NDepend makes it simple to just double-click on the method in the CQL results pane and jump right to the code:

   1: override public IToken nextToken()            //throws TokenStreamException

   2:         {

   3:             IToken theRetToken = null;

   4: tryAgain:

   5:             for (;;)

   6:             {

   7:                 IToken _token = null;

   8:                 int _ttype = Token.INVALID_TYPE;

   9:                 resetText();

  10:                 try     // for char stream error handling

  11:                 {

  12:                     try     // for lexical error handling

  13:                     {

  14:                         switch ( cached_LA1 )

  15:                         {

  16:                         case '\t':  case '\n':  case '\r':  case ' ':

  17:                         {

  18:                             mWS(true);

  19:                             theRetToken = returnToken_;

  20:                             break;

  21:                         }

  22:                         case '@':

  23:                         {

  24:                             mAT(true);

  25:                             theRetToken = returnToken_;

  26:                             break;

  27:                         }

  28:                         case '`':

  29:                         {

  30:                             mBACKTICK(true);

  31:                             theRetToken = returnToken_;

  32:                             break;

  33:                         }

  34:                         case '|':

  35:                         {

  36:                             mPIPE(true);

  37:                             theRetToken = returnToken_;

  38:                             break;

  39:                         }

  40:                         case '#':

  41:                         {

  42:                             mPOUND(true);

  43:                             theRetToken = returnToken_;

  44:                             break;

  45:                         }

  46:                         case '(':

  47:                         {

  48:                             mLPAREN(true);

  49:                             theRetToken = returnToken_;

  50:                             break;

  51:                         }

  52:                         case ')':

  53:                         {

  54:                             mRPAREN(true);

  55:                             theRetToken = returnToken_;

  56:                             break;

  57:                         }

  58:                         case '[':

  59:                         {

  60:                             mLBRACKET(true);

  61:                             theRetToken = returnToken_;

  62:                             break;

  63:                         }

  64:                         case ']':

  65:                         {

  66:                             mRBRACKET(true);

  67:                             theRetToken = returnToken_;

  68:                             break;

  69:                         }

  70:                         case '}':

  71:                         {

  72:                             mRCURLY(true);

  73:                             theRetToken = returnToken_;

  74:                             break;

  75:                         }

  76:                         case ',':

  77:                         {

  78:                             mCOMMA(true);

  79:                             theRetToken = returnToken_;

  80:                             break;

  81:                         }

  82:                         case ';':

  83:                         {

  84:                             mSEMI(true);

  85:                             theRetToken = returnToken_;

  86:                             break;

  87:                         }

  88:                         case ':':

  89:                         {

  90:                             mCOLON(true);

  91:                             theRetToken = returnToken_;

  92:                             break;

  93:                         }

  94:                         case '+':

  95:                         {

  96:                             mPLUS(true);

  97:                             theRetToken = returnToken_;

  98:                             break;

  99:                         }

 100:                         case '-':

 101:                         {

 102:                             mMINUS(true);

 103:                             theRetToken = returnToken_;

 104:                             break;

 105:                         }

 106:                         case '/':

 107:                         {

 108:                             mDIV(true);

 109:                             theRetToken = returnToken_;

 110:                             break;

 111:                         }

 112:                         case '*':

 113:                         {

 114:                             mSTAR(true);

 115:                             theRetToken = returnToken_;

 116:                             break;

 117:                         }

 118:                         case '%':

 119:                         {

 120:                             mMOD(true);

 121:                             theRetToken = returnToken_;

 122:                             break;

 123:                         }

 124:                         default:

 125:                             if ((cached_LA1=='?') && (cached_LA2=='?'))

 126:                             {

 127:                                 mDEFAULT(true);

 128:                                 theRetToken = returnToken_;

 129:                             }

 130:                             else if ((cached_LA1=='=') && (cached_LA2=='=')) {

 131:                                 mEQUAL(true);

 132:                                 theRetToken = returnToken_;

 133:                             }

 134:                             else if ((cached_LA1=='!') && (cached_LA2=='=')) {

 135:                                 mNOT_EQUAL(true);

 136:                                 theRetToken = returnToken_;

 137:                             }

 138:                             else if ((cached_LA1=='<') && (cached_LA2=='=')) {

 139:                                 mLESS_THAN_OR_EQUAL(true);

 140:                                 theRetToken = returnToken_;

 141:                             }

 142:                             else if ((cached_LA1=='>') && (cached_LA2=='=')) {

 143:                                 mGREATER_THAN_OR_EQUAL(true);

 144:                                 theRetToken = returnToken_;

 145:                             }

 146:                             else if ((cached_LA1=='!') && (cached_LA2=='{')) {

 147:                                 mPROJECT(true);

 148:                                 theRetToken = returnToken_;

 149:                             }

 150:                             else if ((cached_LA1=='?') && (cached_LA2=='{')) {

 151:                                 mSELECT(true);

 152:                                 theRetToken = returnToken_;

 153:                             }

 154:                             else if ((cached_LA1=='^') && (cached_LA2=='{')) {

 155:                                 mSELECT_FIRST(true);

 156:                                 theRetToken = returnToken_;

 157:                             }

 158:                             else if ((cached_LA1=='$') && (cached_LA2=='{')) {

 159:                                 mSELECT_LAST(true);

 160:                                 theRetToken = returnToken_;

 161:                             }

 162:                             else if ((cached_LA1=='T') && (cached_LA2=='(')) {

 163:                                 mTYPE(true);

 164:                                 theRetToken = returnToken_;

 165:                             }

 166:                             else if ((cached_LA1=='{') && (cached_LA2=='|')) {

 167:                                 mLAMBDA(true);

 168:                                 theRetToken = returnToken_;

 169:                             }

 170:                             else if ((cached_LA1=='\\') && (cached_LA2=='.')) {

 171:                                 mDOT_ESCAPED(true);

 172:                                 theRetToken = returnToken_;

 173:                             }

 174:                             else if ((cached_LA1=='\'') && ((cached_LA2 >= '\u0000' && cached_LA2 <= '\ufffe'))) {

 175:                                 mSTRING_LITERAL(true);

 176:                                 theRetToken = returnToken_;

 177:                             }

 178:                             else if ((cached_LA1=='0') && (cached_LA2=='x')) {

 179:                                 mHEXADECIMAL_INTEGER_LITERAL(true);

 180:                                 theRetToken = returnToken_;

 181:                             }

 182:                             else if ((cached_LA1=='\\') && (true)) {

 183:                                 mBACKSLASH(true);

 184:                                 theRetToken = returnToken_;

 185:                             }

 186:                             else if ((cached_LA1=='!') && (true)) {

 187:                                 mBANG(true);

 188:                                 theRetToken = returnToken_;

 189:                             }

 190:                             else if ((cached_LA1=='?') && (true)) {

 191:                                 mQMARK(true);

 192:                                 theRetToken = returnToken_;

 193:                             }

 194:                             else if ((cached_LA1=='$') && (true)) {

 195:                                 mDOLLAR(true);

 196:                                 theRetToken = returnToken_;

 197:                             }

 198:                             else if ((cached_LA1=='{') && (true)) {

 199:                                 mLCURLY(true);

 200:                                 theRetToken = returnToken_;

 201:                             }

 202:                             else if ((cached_LA1=='=') && (true)) {

 203:                                 mASSIGN(true);

 204:                                 theRetToken = returnToken_;

 205:                             }

 206:                             else if ((cached_LA1=='^') && (true)) {

 207:                                 mPOWER(true);

 208:                                 theRetToken = returnToken_;

 209:                             }

 210:                             else if ((cached_LA1=='<') && (true)) {

 211:                                 mLESS_THAN(true);

 212:                                 theRetToken = returnToken_;

 213:                             }

 214:                             else if ((cached_LA1=='>') && (true)) {

 215:                                 mGREATER_THAN(true);

 216:                                 theRetToken = returnToken_;

 217:                             }

 218:                             else if ((cached_LA1=='\'') && (true)) {

 219:                                 mQUOTE(true);

 220:                                 theRetToken = returnToken_;

 221:                             }

 222:                             else if ((tokenSet_0_.member(cached_LA1)) && (true)) {

 223:                                 mID(true);

 224:                                 theRetToken = returnToken_;

 225:                             }

 226:                             else if ((tokenSet_1_.member(cached_LA1)) && (true)) {

 227:                                 mNUMERIC_LITERAL(true);

 228:                                 theRetToken = returnToken_;

 229:                             }

 230:                         else

 231:                         {

 232:                             if (cached_LA1==EOF_CHAR) { uponEOF(); returnToken_ = makeToken(Token.EOF_TYPE); }

 233:                 else {throw new NoViableAltForCharException(cached_LA1, getFilename(), getLine(), getColumn());}

 234:                         }

 235:                         break; }

 236:                         if ( null==returnToken_ ) goto tryAgain; // found SKIP token

 237:                         _ttype = returnToken_.Type;

 238:                         returnToken_.Type = _ttype;

 239:                         return returnToken_;

 240:                     }

 241:                     catch (RecognitionException e) {

 242:                             throw new TokenStreamRecognitionException(e);

 243:                     }

 244:                 }

 245:                 catch (CharStreamException cse) {

 246:                     if ( cse is CharStreamIOException ) {

 247:                         throw new TokenStreamIOException(((CharStreamIOException)cse).io);

 248:                     }

 249:                     else {

 250:                         throw new TokenStreamException(cse.Message);

 251:                     }

 252:                 }

 253:             }

 254:         }

As a quick review of this longest single method in the entire Spring .NET codebase points out — similar to the method with the highest cyclomatic complexity — this longest method (153 lines!) is really only this long because of the sheer number of conditions (tokens, really) that it has to process.

What Else is New in NDepend 3?

There are two final somewhat related features that I really need to mention if you’re considering NDepend or any other structural analysis tooling.  One of them is the ability to compare analysis from different versions of the same project (e.g., compare v1 to v1.1, etc.) in order to identify not just code analysis metrics for a single snapshot in time but also to begin to understand trends in these metrics over time.  This is a tremendously powerful (and valuable) capability as it tells you not only where you project is but also whether its headed in the right direction or not on all of these very useful code metrics.

The second of these very important features is also extremely valuable: the ability to integrate code coverage reports from unit test runs into the analysis and visualizations.  This feature permits you to review code coverage alongside the other code metrics as you are reviewing them.  Find a method with a very high cyclomatic complexity?  Well, one of the factors that will probably play into your decision of whether or not that method should be a real cause for concern or not will likely be understanding how well that highly-complex method is covered by unit tests – and this feature gives you the ability to integrate that intelligence right into the NDepend analysis and visualizations.

Look for more info on my experiences with both of these additional features in a future post.

What About the VS2010 Ultimate Architect Tooling?

Those of you familiar with the so-called “Architecture” tools included in the VS2010 Ultimate edition are probably wondering “why wouldn’t I just use the tooling provided there instead of a third-party tool?”  This is a pretty good question (on the surface) but let’s explore some of the obvious and not-so-obvious answers to that question:

• The Architecture tools in VS2010 Ultimate Edition are only available for VS2010 and even then only in the ‘Ultimate Edition’ so if you aren’t yet on VS2010 you’re out of luck there.  NDepend’s integrated VS tooling is available for VS2005 and VS2008 as well as VS2010.  And even if (by chance) you’re still on VS2003 or VS2002 (the original VS.NET release), you can still use 100% of the NDepend functionality via the external VisualNDepend application and navigate between all the diagrams and the code in your IDE the same as if you were on a more recent Visual Studio instance.
• The cost differential between an MSDN Ultimate subscription and an MSDN Premium subscription is tremendous (over $5,000!).  Granted, there are a lot of other benefits to MSDN Ultimate that go well beyond just getting access to the Architecture tools in VS2010, but if the Architecture tools are all you really want the only way to get access to them is to pay that $5,000 per seat premium to Microsoft for the Ultimate subscription.  And that $5,000 differential gets worse of course (about $10,000 per seat) if you’re otherwise only looking at MSDN Professional subscriptions.  The NDepend pricing model (because its for *just* the Architecture-style tooling capabilities) is considerably more approachable (under $400 per seat) for the developer/team that just wants access to this singular set to tooling.
• The Architecture tools in VS2010 Ultimate are *only* integrated into the IDE.  This means that everyone needing to analyze, view, inspect, etc. the code using these tools needs a license of Visual Studio – and needs to know how to use Visual Studio.  Since NDepend operates against the compiled binaries of your project, VisualNDepend can be launched by others involved in the project who may not be well-versed in the use of Visual Studio (or have licenses of Visual Studio allocated to them).
• NDepend (from the console) has a strong Continuous Integration integration story (pardon the double use of ‘integration’ there!).  You can simply display NDepend’s own HTML report output as part of your CI build reporting or you can apply one or more XSLT transforms to its XML output to easily customize what you display in CI reports.  VS2010’s Architecture tools output .dgml diagrams that don’t benefit from this kind of an (easy) integration story.
• NDepend’s idea of being able to provide ‘analysis diffs’ between one or more versions of your compiled binaries (to see changes, trends, etc. over time) isn’t really manifest anywhere in the VS2010 Architecture tooling (at least not yet!).
• NDepend’s ability to ‘overlay’ unit test code-coverage reporting into its analysis and visual display of information is simply brilliant and also isn’t manifest anywhere in the VS2010 Architecture tooling.  And since Microsoft doesn’t have any code-coverage tool of its own AFAIK, its probably unlikely that this capability would be coming soon to VS2010 Ultimate.

Conclusion

If you’re serious about a static code analysis tool for .NET, you owe it to yourself to download the trial of NDepend 3 – its not only a tremendously valuable tool in your .NET development arsenal, but is also one of the more thoughtfully and professionally designed pieces of software I’ve had the pleasure to use in a long time!

I’m very excited to be able to announce that as of this past Monday July 12th, 2010 I have officially begun work in my new position as a Senior Software Engineer with SpringSource.  This opportunity represents the next (interesting) step in my software development career and I’m looking very forward to the kinds of things this position will permit me to focus upon as time progresses and I’m able to grow into the role.

Plus ça change, plus c’est la même chose

(for the French-challenged, that’s “The more things change the more they stay the same”)

In this new role, I will be ramping up to act as both the Technical Lead and the Community Evangelist for the Spring .NET Application Framework project.

As Technical Lead for the project, my role is expected to primarily consist of a combination of technical management and software development tasks including…

• Designing, developing, testing, and documenting Spring .NET features
• Coordinating development activities with external (non-SpringSource) committers
• Managing the release process
• Triaging and Fixing bugs

As Community Evangelist for the project, my role is expected to focus on the following areas…

• Promoting the Spring.NET Framework to .NET developers in conferences, blogs, twitter, etc.
• Interacting with users in the Spring.NET forums

Those of you who know me well will probably recognize some significant similarity between this set of responsibilities and the kinds of things that I already do in connection with several other Open Source Software projects in the .NET ecosystem.  This is an important aspect of what makes me excited about this opportunity: in a weird – and entirely accidental — way my activities in the .NET OSS community have been a sort of ‘training’ for this very position (or certainly one very much like it!).

Any time you can get paid to do something you love to do anyway you’ve pretty much got a ‘win’ on your hands.  I already had some of that in re: designing and developing software for a living, but being able to now add to that the kinds of activities in the OSS world that I previously had to perform in my spare (off-hours) time has to be considered an even bigger ‘win’ for me – and hopefully for SpringSource and the Spring .NET user community at large!

What a Long, Strange Trip its Been…

“We now rejoin our intrepid hero where we last left him…”

Seriously though, this new position is the next step for me in a journey that really began innocently enough nearly two full years ago with the combination of two events: the recording and launch of my Summer of NHibernate screencast series in June of 2008 and my co-founding (with several others) of the NYC ALT.NET User Group in August of 2008.

The Summer of NHibernate screencasts inadvertently started me down a path of significantly increased visibility as a member of arguably one of the most highly visible OSS projects in the .NET ecosystem – certainly one with the most vocal contributors :)  This had the (turns out incredibly valuable) effect of increasing my ‘street cred’ in the .NET OSS community.  The number of people I meet at CodeCamps and other similar gatherings of .NET developers that approach me and offer “I just wanted to say thanks for that great video series – it enabled me to learn NH in a fraction of the time I would have needed otherwise!” is truly the best compliment I could ever ask for in return for that effort.

The co-founding of the NYC ALT.NET User Group turned out to be important for two reasons: 1) one of the other co-founders of the group whom I met through this process was Mark Pollack, the original author of the Spring .NET Framework (and now my co-worker here at SpringSource) and 2) the local Microsoft Developer and Platform Evangelism team’s involvement in helping to provide space and other logistics support for the user group began my introduction and involvement in the rest of the local NYC area .NET development community.

This series of relationships more recently resulted in my being Chairperson of the most-recent NYC CodeCamp event in March of this year – which in turn put me on a first-name basis with all kinds of speakers, presenters, attendees, and others in the local community and beyond.  And its though this series of ever-expanding professional relationships that much of my opportunity to do a variety of other public speaking engagements has progressed.

Looking back on all this, one might be tempted to conclude that it was all part of some grand plan to end up being offered an actual job that pays me to do all this that I already do on a volunteer basis, but that’s simply not the case.  This present opportunity for me is merely the result of some strange confluence of events all happening to coincide at about the same time – including but not limited to my interest in leaving my last position with Skiff as it was acquired by NewsCorp and my not really being too excited about the opportunity to work for Rupert Murdock, et. al. in a journalism industry with a somewhat questionable future.

The Essence of Spring .NET

How do I see Spring .NET?  Well, there’s always the official brief of the Framework…

Led and sustained by SpringSource, a division of VMware, Spring .NET is an open source application framework that makes building  enterprise .NET applications easier.  

Providing components based on proven design patterns that can be integrated into all tiers of your application architecture, Spring helps increase development productivity and improve application quality and performance.

…but from my perspective the important part of the Spring.NET Framework is found on the overview page of the project website:

The design of Spring .NET is based on the Java version of the Spring Framework, which has shown real-world benefits and is used in thousands of enterprise applications world wide.  Spring .NET is not a quick port from the Java version, but rather a ’spiritual port’ based on following proven architectural and design patterns in that are not tied to a particular platform.

Why Should I Care About Spring .NET?

Its a fact of history that Java preceded the .NET Framework’s development.  Because of this (and many other factors too of course), the Java developer community has in many ways had a sort of ‘head-start’ on the .NET developer community.

This isn’t a post about so-called ‘Java-envy’ from the perspective of a .NET developer – I’ve known (and worked with) enough poor-quality Java developers to know that there’s a significant amount of grass-is-always-greener going on when most .NET developers look to the Java community.  Having spent some time there, I can assure you that its not all ‘roses’ over there in Java-land – its got its own warts too

But with their frameworks, platforms, and general approach to the practices of software development, the Java developer community has tread on ahead further down the path of evolution than that of the .NET ecosystem in many ways.  We can debate the veracity of some of their conclusions, but that they are battle-tested and the result of a lot of real-world stress-testing is beyond contention.  Some of the issues with which the .NET developer ecosystem is only just now starting to grapple in significant numbers, the broader Java community has long-since settled and addressed. 

We in .NET often see the physical manifestation of this in the so called “N* projects” that began their lives as (often direct) ports of Java projects on the JVM into the C# language on the CLR (NUnit, NHibernate, NBehave, NSpec, etc., etc., etc. – and, yes, Spring .NET too, despite the fact that its not named “NSpring” – thank God <g>).

Even though many of these began as ‘pure’ language-porting efforts, over time these frameworks began to grow and diverge from their ‘Java’ roots to express themselves more as .NET projects, adopting the memes of their new environment – often mostly in the form of .NET language syntax for their APIs (lambdas being the most visible recent example of this but also in more subtle ways) but also to add features and capabilities not found in their Java ‘parent’ projects that were more appropriate the .NET platform.

But at their core, most of these such projects still share significant commonalities with their Java roots – and that means that in important ways they are a kind of codification of the results of the early struggles that the Java community had with these same software development issues.  I see these frameworks, tools, and other artifacts as a kind of “trail of bread crumbs” marking where the Java community has been and the conclusions gleaned from some hard-learned lessons that they picked up along the way.

In the Java ecosystem, the Spring Framework is in many ways the defacto development stack on top of the core Java libraries on the JVM.  There are a good number of business and historical reasons why that is the case, but many of the reasons are also technical and architectural: the Java community has learned some painful lessons from many past missteps and much of the results of those lessons are to be found codified in the design of the Spring Framework for Java.

Borrowing heavily from the concepts and patterns in the Spring Framework for Java, Spring .NET is in many ways the best embodiment of the lessons learned by the Java community in the context of Enterprise Systems Development – and as such, one of the best ways for a .NET enterprise developer to acquire some of the benefit of those very same lessons (without having to relearn them for themselves in quite the same — usually painful — way!).

What’s in the Future for Spring .NET?

Its clear from history that not all of the challenges in the Enterprise Systems development space have been solved by “the Java guys” (or even by “the .NET guys”) by a long-shot.  There’s plenty more to solve, patterns to uncover, and areas to explore, both in Enterprise software development and elsewhere.

And its clear to me that the .NET ecosystem has a lot of valuable experiences to offer other software development communities in return.  We’re looking to the Spring .NET Framework project to be the vehicle by which such experiences and patterns are captured, codified, and made available to others for their easy and efficient consumption in subsequent software development projects – making it just as easy for developers to leverage the collective lessons-learned by others in their own software development projects.

Want More Info?

What is this drivel?  I want specifics, damn it!

There will be much more to follow but as I’m just five days into the job (and still figuring out the shortest path from my desk to the coffee machine!) its a bit early for me to be publicly communicating a project roadmap, release milestones, or anything else ‘official-sounding’, but stay tuned for more coherent announcements, activity, and details about both short and long-term plans for Spring .NET.

You can watch my blog here for more info, but I would encourage you to visit the http://www.springframework.net site itself for ‘official announcements’.

And for more up-to-the-minute micro-announcements and interesting Spring .NET news, follow our new SpringForNet account on Twitter (@SpringForNet).

I’d love to hear from you about opinions, features, functions, focus, and more – let the conversation begin!

This is a post that’s a bit off-topic but I hope that you will find value in it all the same.  Let me take a moment to introduce you to Wendy Friedlander.

Wendy Friedlander is a software developer, loving mom and wife who turned into a cancer-survivor-in-training on 8/14/2009.

It was the weekend of her daughter’s first birthday, when she found out she has a rare pediatric cancer called aveolar rhabdomyosarcoma. She had to immediately wean her daughter, Kaylee, and start a new life of being separated from Kaylee and her husband, Matt.

This has taken an emotional and financial toll on her family. She has had to stop working and Matt has had to switch to part-time work to care for Wendy and Kaylee. As you can imagine, the costs of childcare, mortgage, and medical expenses add up quickly.

This cancer has changed Wendy’s world. Rhabdo is a very aggressive form of cancer. The treatment consists of high dose chemotherapy and radiation. Receiving her treatment at Sloan Kettering Memorial Cancer Center separates her from her family most of the time.

Before becoming a cancer patient (and soon to be cancer survivor!), Wendy was a software developer consultant for her company, Agile Solutions LLC. She specialized in agile software development with a focus on pair programming and test driven development. Most of her expertise is in the rich client community, mostly WPF over the last few years.

After taking some time to recover from treatment and reconnect with her family, Wendy hopes to return to her coding ways.

And we hope to welcome her back!

What Can *YOU* Do To Make a Difference?

To help them financially and to show support for them emotionally, the NYC-area software development community is organizing a benefit dinner to help raise money for Wendy and her family.  This brilliant idea was started by Sara Chipps and I have been contributing what effort I can to assist in helping out where needed.

This dinner will be held At 7pm on this coming Wednesday evening July 7th in New York City – the exact location is still awaiting confirmation (and may need to vary based on the number of RSVPs we receive).

The cost of this dinner is $75 per person and 100% of all proceeds go direct to Wendy and her family.  Its likely that the dinner will consist merely of the oh-so-common user-group fare of Pizza and Soda so you can rest assured that probably $65 or more of every $75 collected will go to benefit Wendy.

You can RSVP for the dinner here – and the sooner the better so that we can begin to select a location capable of accommodating the right number of attendees.  Payment is accepted via most major credit cards, PayPal, and even electronic check if that suits you.

Times are Hard, I can’t Quite Swing the $75

If you don’t think you can handle the $75 per person cost of attending the dinner, cannot adjust your schedule in time to attend, or are simply too remote to attend the event, please consider strongly making a donation directly to Wendy and her family.

Donations are accepted here and may be made in ANY amount you feel comfortable contributing.  1$, 5$, $10, $50 or more – the wonderful thing about SCALE is that even the smallest of contributions when added together can often produce GIANT results.  If even 100 people each gave $10, that would be $1000 for Wendy and her family.

Think about it.  Really.  Please.

A Very Special Guest Speaker :

Charles Petzold

We are very pleased to be able to announce that Charles Petzold has graciously agreed to be our featured speaker at the event!  Author of about a gazillion books on Programming, Computers, .NET, and more, if you have never had the pleasure of watching him deliver a talk, you are in for a real treat!

Clever, entertaining, enthusiastic, and informative, Charles never fails to deliver a talk worth seeing on just about any topic.  For this event, Charles has promised to deliver a very special talk on a unique topic available only to paid attendees at this benefit dinner:

The evening will include a unique presentation by Charles Petzold on an obscure (but interesting) chapter in the history of computing with appearances (in chronological order) by Cicero, Galileo, Kepler, Newton, Fourier, Charles Darwin, Lord Kelvin, Madame Curie, and Albert Einstein.

The intent of this talk is actually to take a look at some of the history of computing in a different and historical light so as to appeal not only to the technology crowd but also to be broad enough to be of interest to spouses, life-partners, and significant-others that might also be interested in attending the event.

Seriously – think about buying an extra ticket and bringing your spouse or significant other to this event – despite the presence of pizza and soda, this evening will prove to be so much more than your typical geek-fest – we promise

Also Starring Miguel Castro

Venerable NYC-area (yes, and NJ-area too <g>) “.NET Dude” Miguel Castro has also volunteered to speak at this benefit event!

Boisterous, annoying, flippant, and frequently insulting, if anyone has seen a Miguel Castro presentation before you can rest assured he has promised to deliver something very un-Miguel for this event so you needn’t worry too much!

I am of course kidding :)  Miguel actually has promised to deliver a talk just for this event that’s a little different from his usual fare, but I’m sure we can count on his usual personality still being front-and-center for us all to “enjoy” !

(Seriously – Miguel is actually a great speaker who never fails to deliver an excellent and thought-provoking talk on some of the more complex technologies in the MS universe so this is a great chance to see him in perfect form!)

Free 30-day TEKPUB Subscriptions for EVERY Attendee!

To sweeten the pot for attendees even more, the great people behind the screencasting / developer education site TekPub have graciously committed to provide a free 30-day unlimited access subscription to all of their content for every attendee who purchases a ticket to the event.

With screencasts on topics ranging from NHibernate to Ruby on Rails to ASP.NET MVC to Entity Framework 4 and more, this 30-day TekPub subscription will permit you to ‘drink from their firehose of content’ as much as you can for 30 days!

To accommodate those that cannot attend, anyone making a donation of $75 or more will also qualify for this guaranteed subscription offer.

Further demonstrating their commitment to the developer community, TekPub has also contributed a single 1-year subscription to their site which  is to be raffled off at the event to one lucky attendee!

More Cowbell, More SWAG!

We also have commitments from several other vendors (including JetBrains, Developer Express, and more!) to donate additional software licenses to raffle off to attendees!  All of this points to a whole host of reasons why you should make it a point to try to attend this event next Wednesday evening!

And if by chance you cannot attend due to schedule, finances, geography, or other constraints, please, please, please consider making even the smallest of monetary donations.  The economics of scale can easily turn the tiniest of efforts into a very effective campaign!

Help Get the Word Out to all the Corners of the Internet!

Please do what you can to share info about Wendy, this event, and the donation link with your friends, acquaintances, connections, followers – heck, even share this with your ENEMIES!

Help get the word out so that we can all collectively do everything in our considerable power to help Wendy and her family through this difficult time.

If the word ‘community’ is to mean anything, then its in support of something like this that it can really show its ability to make a difference in a meaningful way.

Your contribution of money, time, effort, or just spreading the word is much appreciated by everyone!

Although all of these plugins are open source and thus its easy for anyone to check them out compile them for themselves, as a convenience for others I am also providing compiled instances of them here for download as follows:

1. DX_SourceOutliner
2. CR_ClassCleaner
3. Refactor_ClassCleaner_Menu
4. CR_DeclareClassInProject
5. Refactor_MoveTypeToFileInSpecificProject
6. Refactor_UpdateNamespace

Enjoy~!

That said, since DevExpress had promised a final RTM of DXCore/CodeRush/Refactor!Pro by the end of April (and its already May 5th without an RTM), I’m giving up on waiting and providing a single download containing DXCore 10.1.3 (what DevExpress calls ‘RC2’ of DXCore 10.1) –compatible builds of the following tools for anyone who cannot wait any longer:

• DX SourceOutliner
• CR_ClassCleaner
• Refactor_ClassCleaner_Menu (the extension to classlcleaner that adds it to the refactor pro context menu)

You can download all of these in a single ZIP file from here.

Once the final RTM of DXCore/CodeRush/Refactor!Pro 10.1 is released, I will post updated versions of the same binaries once the platform is stable.

For more info on the event itself, check out Dani Diaz’s blog post over here.

Mean time, if you’re here for my slides or my code, they are available for download at the following links:

• Slides
• Initial Starting Code Sample
• Final Ending Code Sample

If anyone here reading this was present for this session, I’d really appreciate any comments/feedback as this is the first time I’ve delivered this particular combination of the content and topic so I’m keenly interested in whether you thought it was well-conceived, targeted properly, or confusing and completely overwhelming.

(of course, if you’re here to get the code and the slides, its probably also the case that you thought the session was pretty good, so maybe this is too self-selecting a sample for which I could draw any useful conclusions!)

Happy coding, everyone~!

WTF is a Community Megaphone?

Community Megaphone is a site created by Andrew Duthie, a MS Developer Evangelist for the mid-Atlantic region to help connect .NET developers with (community) events in their region (or elsewhere too, if they are interested).  If you haven’t tried the site out, I strongly recommend it as a way to get connected to events in your own local software development community.

As an outgrowth of that effort, Andrew and Dane Morgridge have teamed up to co-create The Community Megaphone Podcast that focuses on discussions with people active in their local .NET developer communities.  Although a relatively recent addition to the podcasting universe (they just published episode #6), by focusing on people and community rather than specific technologies per se, their content offers an interesting change from the more familiar “Today we’re interviewing one of the PMs on the Silverlight 9 team to talk about data-binding without writing a line of code…” type of podcast that already clogs the InterTubes in more-than-sufficient-number.

Can’t be That Good: They Wanted to Talk to Me!

Despite all that, they wanted to interview me for their latest episode anyway ;)  In a somewhat rambling, conversational style discussion we covered some of my thoughts on getting started on contributing to Open Source Projects, some of the challenges to managing OSS work, some of the highlights of the recent NYC CodeCamp event (that I have also blogged about prior both here and here), and some of my impressions of some of the announcements that came out of the MIX2010 conference that just recently concluded.

If you’ve got an hour to kill and nothing better to do, go over and have a listen

As always, comments, feedback, constructive criticism (and more) are always welcome.

Happy Coding~!

To make productive use of that time, I write code on my laptop, catch up on some reading, nap a bit sometimes (I’m getting old, you know!), and mostly listen to podcasts.  I also draft blog posts as I’m doing right now with this one :)  The other day I was listening to one of the many podcasts that I subscribe to in order to fill this 2-3 hours every day and I heard an interviewee say something that struck me as being both seemingly obvious and yet also profound:

In order to work effectively [in software development], its important to select frameworks written by people who think about the problem in the same way as yourself.

Shared Values –> No (nasty) Surprises

On its face, this seems like pretty obvious advice to me.  If the author of a framework you select to build atop shares a similar ‘technology world-view’ and mental model of the problem-space as yourself, then its also likely that you will share a similar value-system re: what’s important in good software and what’s not, how to extend and grow software atop a framework, the best way to implement solutions, and more.  All of this commonality of value-system brings with it certain intangible advantages, probably chief among them being a feeling of sort of ‘being in the head’ of the framework authors – a feeling of having found a kindred software development ‘spirit’ in the framework’s author(s).

When this happens, you often find that the framework behaves “the way you reasonably expect it to” and rarely will its behavior significantly surprise you (except perhaps pleasantly!).  Methods and classes in the framework are found pretty much “right where you would expect them to be” because that’s similar to where you would have put them yourself had you written the framework code.  The framework is extensible in just the right places (and in just the right way!) that you need it to be because you and the author share a commonality of values leading to similar design decisions in software.

I’m obviously describing the ideal case where you find a framework that perfectly suits you.  In the real world this rarely if ever happens in quite this way because the only way to ensure this to be true would be for you to have written the framework yourself of course.  But I bet we can all relate to having worked with frameworks and technology that shared our value system more than others.  And we can all also acknowledge that there is a significantly reduced friction when working with those frameworks authored by those who share our underlying value system and increasing friction from using frameworks and technologies whose underpinnings tend to diverge from our values.

Did I Ever Think My Choices Through This Way?

This certainly makes a lot of good sense to me (and hopefully you as well), but I confess to never having really thought about it like that on a conscious level.  Certainly there have been those technologies and frameworks that I have used in my work that come closer to ‘fitting me like a glove’ than others, but I never really stopped to consider that it might be an underlying difference of world-view that was at the root of much of the friction I have experienced with some of these things at varying times in the past.

So I began to wonder to myself whether I was perhaps applying this decision-making process on a subconscious level.

This Isn’t Another WebForms vs. MVC Post

No, really.  Its not.  I don’t think the choice between ASP.NET WebForms and ASP.NET MVC comes down to “A is better than B” or “A is for people who know WTF they are doing and B is for idiots who can’t program their way out of a paper bag” or “A is for people who care about the quality of their work and B is for people who want to just get the job done fast and go home”, and I certainly don’t think it comes down to “A is a car and B is a motorcycle” as has been suggested by others in the past (an interesting if somewhat confusing metaphor IMO).

If we look at the choice between WebForms and MVC through the lens of which one best fits my ‘world view’, then it becomes easy to see why I would say “I will never again (willingly) build another WebForms application as long as I live.  Period.”  Its got nothing to do with the commonly-offered decision points like some or all of the following:

• Is the project something quick as a proof-of-concept vs. something that I (or anyone else) will be maintaining long-term?
• Is it forms-over-data vs. something with a richer UX than just query-update-save (with an occasional delete sprinkled in there for fun)?
• Is it a small departmental app vs. an enterprise or public-facing site that needs to scale?

None of these ‘pivot-points’ are remotely useful to me in deciding which of these two frameworks to choose because both WebForms and MVC have perfectly capable and arguable reasons why they are the best answer to each of these potential decision-points, making these criteria useless to me as discriminators.

WebForms Through Different Eyes

But looking at WebForms through the eyes of thinking about the people behind it either sharing my value system or not makes it immediately obvious to me why I have never liked WebForms, always found the interminable Page-Postback-Lifecycle craziness opaque, dense, and impenetrable, and constantly struggled with it (even in later years when prevailing wisdom took hold and most reasonable people began to find ways to shoehorn WebForms into semi-manageable Model-View-Presenter patterns to alleviate at least some of the pain of the platform).  Put simply: ASP.NET WebForms is the brainchild of people who do not share a similar value-system/world-view as do I and this mismatch is at the core of why I always found that platform so frustrating to work on.

This isn’t a value-judgment about WebForms in any way.  No, really.  Its not.  Whatever I feel about the frustration that I have experienced in interacting with the WebForms platform over my career, the software engineer in me absolutely has to marvel at its technical implementation even as I try to keep myself as far away from it as possible for the foreseeable future.  Finding a way (any way!) to (semi-)effectively project the appearance of statefullness in an inherently stateless context (HTTP request/response) is an amazing technical feat (imperfect though it is in its implementation).

But at the same time, it doesn’t align with my mental model of the web at all.  And that inherent difference of world-view is at the core of my troubles with working with WebForms.  Yes, I can (and have!) learned the WebForms framework, but the underlying feeling of “something just ain’t right here” never goes away, no matter your knowledge of how something works.

MVC For Me

While there are probably all kinds of things I would do differently were I building the ASP.NET MVC Framework for myself, those technical differences don’t matter to me in the end.  Because in the spectrum that runs from ‘shared mental model of the problem and the way to build a solution’ on one end and ‘completely different set of values at the core’ on the other, MVC is much, much closer to aligning with my own mental model than WebForms could ever be.

This is fundamentally why I don’t care if the MVC Routing engine has been ported to WebForms so URLs needn’t any longer end in .aspx or reflect their folder paths on disk.  I don’t care if WebForms has introduced ‘deterministic client id values’ for DOM elements to make it easier to work with javascript libraries like JQuery and others.  None of these are remotely appealing to me because I think the underlying problems for me with WebForms still remain after all of these ‘bolt-ons’ are added to the platform: the friction between my own mental model of the problem (‘writing web applications’) and that of the authors of the WebForms platform are still just as front-and-center as they have always been.

Contrast that with the approach used to build the ASP.NET MVC framework and you see a preference for interface-based contracts between classes, extensibility hooks at many, many more locations (though still perhaps not all), an explicit INTENT that someone would wire an Inversion-of-Control Container into the MVC infrastructure, and all kinds of other things that just fit more closely with my own mental-model of the problem space and the value-system that I bring to engineering my own software solutions.  Again, ASP.NET MVC is hardly perfect, but its much closer to my value system than WebForms (even if implemented in an MVP pattern) could ever hope to be.

This isn’t an Entity Framework vs NHibernate Post Either

No, really.  Its not.  Honest.  But the reason I would choose ASP.NET MVC over WebForms is the same reason that I would choose NHibernate over the oft-maligned Entity Framework: one of those O/RMs matches my own mental-model of the problem space better than the other.  And just as with WebForms vs. MVC, this choice isn’t really made based on having performed the kind of feature-by-feature Pros and Cons comparison that Ben Franklin (and, later, others) typically champion as a way to make an informed, logical decision.  This choice transcends just about any feature or capability that Entity Framework might have to offer me at this time (or for the foreseeable future).

Notwithstanding some of the very valuable and powerful features coming to light in EF4 (really just v2 of course), EF was built by a team who seems to believe strongly in the following value system (admittedly reverse-engineered and inferred by me from the various design choices they have made along the way):

• applications exist primarily to manipulate data (CRUD is the purpose of much enterprise software systems and most business rules can be expressed as database constraints)
• a consistent enterprise-wide data dictionary is the best way to solve enterprise-wide software challenges (e.g., with enough tooling, foresight, and upfront planning its possible for the enterprise to agree on the definition of “the one, true customer entity” that can be reused across the company in multiple software systems)
• the best way to manifest that enterprise-wide agreement on data/entity concepts is in an abstract entity model that can be reused and projected across many different software projects and for many different purposes
• the long-term value of enterprise software is in its data rather than its codification and enablement of business process, rules, and constraints that govern legitimate interaction with that data
• data in a database retains its value long after the software that understood how to interpret that data and enforce consistency rules around it has been removed from the scene over time
• the value of data is given primacy over the value of the software that interacts with it

Those Just Aren’t My Values

Notice none of those above statements about EF are about any specific feature EF might have (or not).  Its not about whether it supports transparent vs. explicit lazy-loading.  Its not about whether Foreign Key values are exposed by the model or not.  Its not about whether (or how well) it supports POCO classes and persistence ignorance (let’s not mention the whole IPOCO interface and the hilarity that ensued).

Instead, its about the mental model of the problem space that was in the heads of the software engineering team that built it.  When they were making high-order design decisions about the framework, what principles guided their decisions and trade-offs when they had to make them?  And the differences there are the root of the reasons that I have experienced such friction with trying to leverage EF in my work.  My perspective just comes from the far other side of the known universe from where the heads of the EF designers were when they built their ORM.

To be clear, those values listed above that I ascribe to the EF design team are entirely defensible and I know many software developers who share them.  But for the most part, they don’t reflect my view of the problem space (how to build enterprise software solutions that need to interact with data to do work) and so even with the many additional features in v4, EF doesn’t suit me well in re: solving the kinds of problems I face.  It’s not built by people who share my world-view or my value system or my mental model of the problem of building software solutions that must interact with a database.  EF just isn’t for me (or the kinds of problems with which I want to work).

Just as this mismatch between myself and WebForms doesn’t make WebForms a terrible technology, neither does this same mismatch make EF a terrible technology.  But also just as with WebForms not matching my view-of-the-world, neither does EF and that’s the real reason that I choose something like NHibernate over Entity Framework.  Its actually got much less to do with features, pedigree, support, or any other ‘technical’ aspect and more to do with how well it aligns with the way I think about software systems.

But Don’t Features Matter?

Of course they do.  Any framework that matches my mental model of the problem space but lacks necessary features obviously won’t cut it and needs to be eliminated from contention as choice.  But similarly, the framework that does have all the needed features but fails to match (well) my mental model needs to be strongly considered for elimination as a candidate as well (unless of course there is no other choice given other constraints within which you need to make your decisions – in which case I suggest you suck it up and get moving ‘cause crying about it isn’t going to help much).

Don’t underestimate the negative repercussions to productivity, sanity, and (eventually) profitability of selecting a framework that doesn’t match well your view of the world.  Compare features, but also compare what can only be called ‘the driving philosophy’ behind the software you are considering adopting.  Try to find something that both suits your view of the problem space and has the features you need to complete the job.  Otherwise, you’re going to find yourself getting increasingly frustrated as you become decreasingly productive and in that scenario nobody wins.  So choose wisely.

Happy Coding~!

Just kidding.  There is no winner because this year we decided to do a few things differently than in years past:

• Eval forms didn’t contain numeric scoring for pre-defined categories (e.g., “Speaker was knowledgable about their topic”, “Speaker was Professional”, “Session met my expectations”, etc.)
• Eval forms weren’t anonymous
• Completion of their Eval Form was a pre-requisite for each attendee’s participation in the SWAG being raffled off in the Closing Session

The decision to eliminate numeric rankings was driven by several motivators:

• numbers (by themselves) don’t represent information that a speaker can use to improve their presentation content and/or their presentation skills (e.g., if you get a ‘1’ instead of a ‘10’, that might tell you that you suck, but its not helpful at all in telling you how to improve for the next time)
• Even if you provide ‘comment space’ in addition to number ranking scales for attendees to complete, only a VERY few will ever bother to provide comments since MOST will consider the ‘number’ speaks for them.  By completely eliminating the numeric scale entirely, the ONLY way for attendees to provide feedback was to write SOMETHING in the comment space, ensuring MOST would indeed write comments

Since forms didn’t contain numeric rankings of pre-canned questions, there is no way to declare a ‘winner’ (most-highly-rated session, etc.).  Which is probably a good thing because IMO there’s no point in turning “best-speaker” into a competition and we had no ‘prize’ to give away for that anyway

The Process

Rather than individual forms being used for each session, each attendee was given a single form (the relevant portions of which are reproduced below) and asked to keep it with them as they moved from session to session throughout the day.

Attendees would fill out the relevant info as they attended each of their desired sessions and return the completed form to the organizers right before the SWAG raffle at the Closing Session.

There was some question about how well this would work before we did it.  Some of the concerns were:

• Would attendees be comfortable completing a non-anonymous Eval Form that had their name + email address on it?
• Would attendees take the time to write anything useful in the comments section since it takes so much more time to do that than simply circling a number from 1-10 in response to predefined questions?

Gratifyingly, the answer to both of these seems to have proven to be a resounding YES.

It Wasn’t Perfect, but it DID Work

As you can see from some of these following less-than-detailed comments (sessions cropped in the interests of protecting the speakers) it didn’t work perfectly in every case…

…but for the most part, the comments were both detailed and helpful for the speakers in re: the impressions of their sessions.  And yes, that last example where every comment was blank is from an actual submitted form – fortunately it was one-of-a-kind and all others were completed to a surprisingly high degree of detail.  If you’re the one who submitted the ‘blank’ form, shame on you for cheating the speakers out of valuable feedback from you!

Here’s an excerpt from just one of the comments received on one of the day’s sessions:

Jumped around quite a bit.  Would be more effective if built a much simpler example and built it line-by-line by typing the code as going (forced to slow down).  Goal is to relay basic concepts and concept down to code.  Too fast to the point that large part of the audience seemed not to follow.  Speaker knowledge obvious – presentation weak.

Now, whether that’s a widely-felt opinion about the session or not needs to be inferred by comparing all the other attendee comments about that session that were received and considering them in their totality of course, but that level of specificity and actionable feedback to the speaker is just not something you’re going to be able to get if the attendee were limited to a 1-10 scale!

Other Interesting Excerpts

There were some other real gems in the comments too, of course.  Some of my favorites (again, specific session elided to protect the speakers)…

Very good speaker.  Humorous.  Presentation could have used more attractive examples.  Exaggerates a bit.

Not sure what was unattractive about the examples, but I’ll just leave it at that!

Wow.  Nothing else can be said.  Seriously, wow.

Sorry I missed that session!

Sucked.  Left after 10 min.

Apparently glad I missed that one!

Great and informative session.  Info was immediately useful in day-to-day work.

Probably one of the most complimentary things you could say about a session.  Immediately useful value!  WIN!

Lots of code; in depth – may not be appropriate for absolute beginner (me) in the topic.  Speaker is passionate and tries to convey as much info as possible.

That’s the kind of feedback that a speaker can act on: “If I was targeting noobs in the topic, I may have lost some people at one point.  I should evaluate whether I’m starting with simple enough basics or not…”

Great content – well focused, deft handling of questions.  Sith Lords = Great Presentation.

Love the reference to the Sith Lords in that one!

Good info.  Presenter needs to tailor slide deck such that code examples are reached more quickly.  Too many questions generated by theory.  When running low on time he should be willing to hold questions.

Again, specific feedback providing actionable intelligence to the speaker.  What went wrong, suggestions on how to perhaps deal with it in the future.  This kind of feedback is invaluable to a CodeCamp (or any other!) speaker when trying to improve their delivery!

Funny and entertaining.  Would have preferred covered more data and less styling.

Sounds like we have a budding comedian on our hands here…

Amazing.  He knows what he is talking about.

Not 100% sure about what about that is amazing…

Boring subject, even worse presenter (not engaging whatsoever)

Ouch.  Sounds like a mis-match between expectations and delivery in there somewhere :(  More work to do!

Content is good.  The delivery is too detailed.  If using a simpler example, it would be better.

Again, specific detailed commentary that a speaker can actually use to improve their delivery!  Great stuff!

Patterns Observed in the Evaluation Feedback

When reviewing the evaluation feedback in its entirety, there are a few things that come to light as repeating patterns in the data…

• some sessions have near-consistent feedback re: ‘generally positive’ or ‘generally negative’
• some sessions have wildly-varying feedback re: ‘generally positive’ or ‘generally negative’

Consistent POSITIVE or NEGATIVE Feedback

For those with near-consistent positive or negative feedback across many attendees comments, I think its reasonable to take that on its face: each such session in question probably was generally either ‘good’ or ‘bad’ and the speaker should either be satisfied with their session or should probably consider rethinking their content, their delivery, or perhaps both depending on the comments.

This is where having detailed comments really shines in re: value for the speaker: if a speaker really wants to improve their presentations for the future, then they should have little doubt about where to focus their energies based on the detailed comments from attendees.

Wildly-Varying Feedback

But another troubling theme that I think we have to acknowledge in the data is that of sessions where the feedback tended to vary wildly among attendees.  By way of illustration, here are four comments from four different attendees all about the same session…

Interesting presentation, very knowledgeable presenter.

I did not like the way the material was presented.

Not useful.  Boring.

This presentation was AWESOME.  This is the kind of presentation that I will be reviewing as soon as I get home.  It was chock full of deep/rich content.  The presenter was smart, cool, and funny!  Wish this was taped!

This wide disparity in feedback points to one probable underlying cause: a mismatch between some attendees’ expectations for the session and the session’s actual content/delivery by the speaker.

Too Advanced?  Too Beginner?

The preceding four comments are all from one of our more advanced sessions/topics of the day, but a similar pattern in disparity of feedback was observed with the comments from some of our more ‘beginner’ or ‘entry-level-introduction’ sessions too.  The one common thread identified from the parsing of feedback from such sessions strongly suggests that the disconnect is the result of insufficient indication in session abstracts as to their expected ‘level of difficulty’ (or expected prerequisite knowledge) for attendees.

This challenge is a recurring theme for CodeCamp events in that some people will attend session XYZ who already know the basics and are searching for more advanced info, tips and tricks, etc. while others will attend session XYZ with the mindset “I’ve always heard about this topic but know nothing –let me check it out!”

There’s no ‘silver bullet’ to this problem, but there are some concrete changes that we can make for future CodeCamp events to try to better ensure this mismatch isn’t so great and attendees end up in sessions that are either too boring for them or too overwhelming for them:

1. Ask speakers to indicate 100, 200, 300 level for their talks (even though this is clearly subjective too, it would at least provide GUIDANCE to attendees about expected familiarity with the topic
2. Ask speakers to list out expected prerequisite knowledge for an attendee to get ‘value’ out of their session

I routinely do #2 on all my session abstracts submitted to anywhere I am planning to speak and even though it sometimes makes event organizers ask “Would you mind trimming your abstract down to just a paragraph so we can post it now that its selected?”, I still feel its valuable to be able to define my own expectations for the skills my audience should have to get value out of a session I am delivering.

By way of an illustration, here is the relevant section from the abstract for the talk I just delivered at the NYC CodeCamp myself:

Target Audience: .NET developers interested in learning how what sometimes seem to be abstract OO design principles can actually be applied to improve the structure and flexibility of their own code.  The ideal attendee will have several years of .NET (or other OO language) development experience on at least moderately complex systems so that they can recognize the pitfalls of OO design that the S.O.L.I.D. principles are attempting to address.

And here it is again for my upcoming talk at the Philadelphia CodeCamp in April:

The ideal attendee will have several years of object-oriented software development experience on the .NET platform. Familiarity with Interfaces, Classes, inheritance, and polymorphism are assumed. Exposure to common .NET 3.5 constructs such as lambda expressions, anonymous types and methods, and extension methods are required. Attendees should also have had some prior exposure to the mechanics of writing unit tests, although not necessarily in a Test-First/Test-Driven context. Familiarity with IoC containers and dependency injection techniques on the part of the attendee are helpful but not required.

I think that if we are able to elicit this information from speakers in addition to simply a description of the content of their session, then it might be possible to mitigate some of the impedance mismatch that’s never entirely avoidable between sessions and attendees.

Let’s call that ‘Lesson-Learned’ and file it away for next time.

Honorable Mention

A couple of the evaluation forms deserve ‘Honorable Mention’ for a variety of interesting reasons.

Here’s one where the author’s handwriting looks suspiciously like MS Comic Sans and it stood out well in a stack of forms with terrible handwriting!  Kudos to this person for the high-legibility of their handwriting – it would have taken me perhaps 2+ hours to write that so clearly!

Here’s a fun one where the author wanted to ensure that we understood their rating scale when tallying their results (10 –> best!)

And lastly, here’s one that caught my eye as not only receiving ‘5-Stars’ but apparently earning them in a special pattern too!

General Comments

We also got a considerable amount of ‘general comments’ on the overall event.  Happily they were universally positive.  Most of them contained comments like ‘well-organized’, ‘great event’, and ‘thanks to the organizers and the sponsors’ but in addition to those a couple caught my eye for whatever reason:

CodeCamp made my day!

…and…

Overall it was a fun and informative day.  I’m looking forward to VS2010 now more than ever!  I’ll definitely be back next year and I’ll recommend CodeCamp to my friends and co-workers.

Feedback like that makes all the hard work worthwhile, so to all those attendees who took the time to write detailed, informative, actionable comments on their forms I can 1000x assure you that every comment was read, evaluated, and internalized by both organizers and speakers alike!

Thanks so much for taking the time to offer thoughtful, useful input to everyone involved!

(except for you of course, blank-eval-form-submitter-guy/gal!)

While this same content of mine can also be found on the main NYC CodeCamp site (alongside nearly all the other speakers’ content), here’s a link to my own download of the content from my own session:

http://unhandled-exceptions.com/downloads/NYC CodeCamp Winter 2010 - Refactoring to a SOLID Foundation.zip

Putting it to Bed for a Bit

This is the second time I’ve delivered this same presentation at a CodeCamp event – the first being at last Autumn’s Philadelphia CodeCamp as chronicled in this post here.  Although it was standing-room-only at both deliveries and I rec’d almost uniformly positive reviews/feedback from attendees at both CodeCamps, I’m deciding its time to (at least temporarily) retire this session from being my preferred session to deliver.

Its clear to me from the continued popularity of this session that there is a real thirst in the general .NET developer community for this content (when provided in an approachable, non-academic, real-world-problem-solving manner), but just to keep my own interests up I’m going to file this one away now as “just another talk I will have in my arsenal” rather than being necessarily my “preferred talk to deliver” any longer.

Speaking at the next Philly .NET CodeCamp 4/10/2010

At the upcoming Spring 2010 Philadelphia CodeCamp on 4/10/2010 I’ll be delivering my next talk, Mocks and Stubs and Fakes, Oh my!: Leveraging Mock Objects to Support Real-World TDD Practices.  For details on the whole event, see the main site here and if you’re in the area and want to attend, RSVP here (ASAP since space tends to fill up fast even though its a huge event).

Hope to see you there – it’s an event that promises to be a great time and never fails to deliver~!