In my last post, I queried the readers of this blog as to your preferences regarding the formatting of the simple if statement. I pontificated on my preference for the one-line format for compactness, while the predilection of those that commented roundly favored the standard four-line format, with the primary reasons – as summed up succinctly by Scott – that it “[s]cans much easier without ambiguity.”

This got me thinking about other “one liners” - some based on trivial formatting and some based on language constructs -  and whether people felt the same way towards them. Here are some examples:

The getter/setter:

Is this ok?

Or do you strictly adhere to this:

 Quick aside…Eric Gunnerson has an interesting discussion going about whether code like either of the above should be used in general.

The tertiary:

Do you sprinkle these in occasionally or religiously avoid these beasts?

Closures (new):

Will you use these time/space-savers in C# 2.0?

Or better yet, using lambda expressions in C# 3.0?

I, personally, have much love for these, but I could see arguments as to scan-ability and/or ambiguity. So, if you have just cause as to why I should not be married to them, speak now, or forever hold your peace…

Yesterday, a new guy where I work IMs me to tell me that he doesn't like a particular coding convention that I use frequently. Actually, I think the text of the IM went something like this (paraphrasing):

him: me no likey that thingy you are doinng with if (afds) {asdfa} - ech. messy. blarjh
me: messy? how so?
him: i don''t know. just is.

That's some solid reasoning there, eh. Well, since he couldn't make a reasoned argument, I thought I'd throw it to the peanut gallery and let you make it for him if you'd like.

The convention in question is my use of a single line for if statements with short, 1 method call type statements.

Here's an actual code sample:

  1 private void LoginButton_Click(object sender, System.EventArgs e) 
  2 { 
  3     if ( this.Page.IsValid ) { this.Authenticate(); } 
  4 } 

What do you think? Messy? Do you prefer this instead?

  1 private void LoginButton_Click(object sender, System.EventArgs e) 
  2 { 
  3     if ( this.Page.IsValid ) 
  4         this.Authenticate(); 
  5 } 

Or is this ‘teh only way’?

  1 private void LoginButton_Click(object sender, System.EventArgs e) 
  2 { 
  3     if ( this.Page.IsValid ) 
  4     {  
  5         this.Authenticate();  
  6     } 
  7 } 

Personally, I like the compactness of the single line, and I refuse to code an if statement with no braces, but on the whole, I think the only important thing is that individuals on a development team respect whatever conventions are decided upon. Nevertheless, I enjoy hearing why some prefer one way over another – especially if you can make a thoughtful case. Convince me.

Again, reasoned arguments only. “Messy – bleh” won’t cut it.

-- Atlas will be built using a transparent development model.  Our plan with Atlas is to eschew the traditional two-betas and then RTM model that we often use with big projects at Microsoft, and instead move to a model where we ship very often (at least once every month and often more frequently then that), get feedback as early as possible, share our ideas out in the open (even when they are not 100% baked), and above all use the broader developer community to make sure we build the right technology.

Clemens rails about technology overload with .NET (via larkware).

Meanwhile…

David Heinemeier Hansson discusses the success of Ruby on Rails and it’s minimalistic approach (via Scoble).

I read these back-to-back today, and I thought the juxtaposition was interesting. While Microsoft has been busy adding so many features to the .NET platform that no single developer can possibly know it all, ruby on rails has achieved success simply by focusing on a core set of functionality that helps real developers create the scaffolding to build clean applications quickly.

Now, don’t get me wrong here. I’m not bashing Microsoft, as I think they are doing what is necessary to meet the needs of a large and diverse set of developers and technology problems, and I love the .NET framework. I also know that the comparison is sort of apples to oranges, but I think the success of rails among many hardcore developers highlights something that may be missing from the VS.NET toolsets - or perhaps just misdirected with the mindset of drag-and-drop database connections and passing around datasets.

I think it highlights that perhaps more effort should be spent around creating rails-like scaffolding (read frameworks that are pattern-oriented and sensible) in targeted areas like web applications, but also around web services, windows apps, etc so that developers don’t have to be experts in every area to create “quick-and-clean” applications, but, yet, the experts feel comfortable with the scaffolding being used as well. That’s the draw of rails to me….that it creates a framework that is simple, object-oriented, and pattern-based (MVC) – but clean, meaning I don’t look underneath the covers and go, ‘blech’. I don’t want to write all the yucky code every time, but I want to know that it’s being done right.

I do think the patterns and practices group is doing some great work already to help cut down on the riff-raff with the Enterprise Library blocks (although they certainly don’t seem to believe in the rails idea of “convention over configuration”, heh) and especially with their work on the GAT. I’m interested to see how these converge either through the direction of the p&p group or others (maybe myself -why not?). I see no reason why these couldn’t be used in conjunction to create a scaffolding framework every bit as powerful, clean, and easy to use as ruby on rails, but with a .NET twist.