SoftSource Consulting: Blogs

Mine is the pattern...

Stuart Thompson — Mon, 08 Jun 2009 17:54:53 GMT

Software is broken, from the first version
Fowler has spoken, his gospel word.
Praise for the patterns, praise for MVP
Praise for our passive view of our world.

Hear there's a new thought, coming from Redmond
Wait it's an old thought we already had.
Praise for MVC, in its new format
Sprung in completeness where their feet pass.

Mine is a castle, and it's named Windsor
Born not from one light, silver or gray.
Praise it with caution, praise it with warning
MS' recreation of the new way.

SQL to Insert a State table

Stuart Thompson — Tue, 26 May 2009 23:52:40 GMT

Just in case this is useful to anyone else who needs a SQL table populated with the 50 U.S. states plus D.C.
insert [State] ([Abbreviation], [Name])
select    'AL', 'Alabama'
union
select    'AK', 'Alaska'
union
select    'AZ', 'Arizona'
union
select    'AR', 'Arkansas'
union
select    'CA', 'California'
union
select    'CO', 'Colorado'
union
select    'CT', 'Connecticut'
union
select    'DE', 'Delaware'
union
select    'DC', 'District of Columbia'
union
select    'FL', 'Florida'
union
select    'GA', 'Georgia'
union
select    'HI', 'Hawaii'
union
select    'ID', 'Idaho'
union
select    'IL', 'Illinois'
union
select    'IN', 'Indiana'
union
select    'IA', 'Iowa'
union
select    'KS', 'Kansas'
union
select    'KY', 'Kentucky'
union
select    'LA', 'Louisiana'
union
select    'ME', 'Maine'
union
select    'MD', 'Maryland'
union
select    'MA', 'Massachusetts'
union
select    'MI', 'Michigan'
union
select    'MN', 'Minnesota'
union
select    'MS', 'Mississippi'
union
select    'MO', 'Missouri'
union
select    'MT', 'Montana'
union
select    'NE', 'Nebraska'
union
select    'NV', 'Nevada'
union
select    'NH', 'New Hampshire'
union
select    'NJ', 'New Jersey'
union
select    'NM', 'New Mexico'
union
select    'NY', 'New York'
union
select    'NC', 'North Carolina'
union
select    'ND', 'North Dakota'
union
select    'OH', 'Ohio'
union
select    'OK', 'Oklahoma'
union
select    'OR', 'Oregon'
union
select    'PA', 'Pennsylvania'
union
select    'RI', 'Rhode Island'
union
select    'SC', 'South Carolina'
union
select    'SD', 'South Dakota'
union
select    'TN', 'Tennessee'
union
select    'TX', 'Texas'
union
select    'UT', 'Utah'
union
select    'VT', 'Vermont'
union
select    'VA', 'Virginia'
union
select    'WA', 'Washington'
union
select    'WV', 'West Virginia'
union
select    'WI', 'Wisconsin'
union
select    'WY', 'Wyoming'

Server Quest - A Day in the Life of a Geek

Stuart Thompson — Tue, 19 May 2009 22:13:53 GMT

Somewhere in Redmond, someone wasn't busy for far too long:
http://www.microsoft.com/click/serverquest/

This is a heck of a demonstration of just what Silverlight can do though. Very, very impressive!

To learn how to create cutting edge Silverlight applications, sign up for one of our one-day technical courses at
http://events.sftsrc.com/

SQL 2008 Management Studio - Unable to Enumerate Databases

Stuart Thompson — Wed, 13 May 2009 17:24:49 GMT

"If at first you don't succeed..."

Apparently the cool new conclusion to this motto is "throw your hands in the air and panic". This is certainly how the SQL 2008 Management Studio reacts when it encounters a problem enumerating object explorer information for one or more databases on a server. I recently installed the SQL 2008 tools and was quite surprised to encounter an error dialog following my first actions. I connected to a server that contains several databases, only a few of which I have rights to access. Upon expanding the Databases node in the Object Explorer window, I received the following error:

Failed to retrieve data for this request. (Microsoft.SqlServer.Management.Sdk.Sfc)

Additional information:
An exception occured while executing a Transact-SQL statement or batch.
(Microsoft.SqlServer.ConnectionInfo)
The server principal "MyServerPrincipal" is not able to access the database "FirstDBInList" under the current security context. (Microsoft SQL Server, Error: 916)

Yikes! I know that I don't have access to FirstDBInList but I'm unsure as to why that would stop me from enumerating the databases on the server. Typically I'm allowed to at least see the list so that I can interact with my database via that window. I am unable to perform any operations on the databases to which I don't have rights but that shouldn't stop me from interacting with the databases for which I have been granted permissions.

What's the problem?
Then a little bell rung in my head. I'd seen this before. I remember this from the SQL 2000 days. A little googling turned up this great article by Aaron Bertrand. It turns out that the Object Explorer Details window is part of the problem. Whereas the Object Explorer window only shows the familiar list of nodes, the Object Explorer Details window attempts to go one step further and show additional information about each database. However, in order to show that information the studio attempts to connect to each of the databases in the list. If the current user does not have rights to one or more of those databases and they are configured to auto-close (as many are in many environments) then studio will panic after it is unable to retrieve the information it requested. Instead of degrading gracefully and graying out the node or simply moving onto the next database in the list, it simply halts all operations and throws up the error dialog seen above. Not very shiny! Remember too that this is the SQL 2008 Management Studio in its default configuration. Not exactly an edge case.

How do I fix it?
In order to fix the issue we simply need to tell studio to not query the databases for information it won't be able to retrieve. It turns out that the offender in this case is "Collation", or rather that studio is unable to determine the state of collation on databases to which appropriate rights have not been granted. The following steps can be used to achieve this.

First, open the Object Explorer Details pane either by clicking View->Object Explorer Details or by pressing F7. Then double click Databases in the right-hand pane. Finally right-click the bar showing the column headers and uncheck Collation. You can now close the Object Explorer Details pane, right-click Databases in the regular Object Explorer pane and select Refresh. The node should now expand as expected.

Why did that work?
This solution works for the following reasons. The Object Explorer Details (OED) pane is used to show additional information about entities on a server. The column headers in the Databases view of OED each show a particular piece of information for each database on the server. When the Databases node in the regular Object Explorer pane is expanded, the management studio attempts to query for the information for each of these selected column headers just in case the OED pane will be shown. However, if the current user does not have rights to query for that information on one of the databases then an error is thrown and processing stops. This has the unfortunate side-effect of also stopping the enumeration of the databases in the regular Object Explorer window. By removing the Collation column from the OED view, we effectively removed the check for collation settings when enumerating the list of databases. The other default columns all represent data that can be queried even on databases for which the current user does not have rights. However, if you find that the error resurfaces, try removing all of the other column headers from this view.

What can we learn from this?
This illustrates a larger programming principal, one that is often ignored to the detrement of many software packages; error handling and graceful degradation.

It is great that enumerating the data for the Object Explorer window also queries for information that the OED window might need. However, it is not so great that a failure in the additional "helpful" task causes the originally requested operation to fail. As a user the first assumption when encountering an error is that the current action being performed is responsible, not that some helpful side task was the culprit. If helpful additional tasks are going to be performed, then wrap them in a layer of safety, have them handle their errors completely and get out of the way of the main task if they encounter a problem.

The second principal here is that of graceful degradation. Often programs will show an error dialog or even quit completely when they run into a problem. However, in many cases there is no need for such an abrupt halt. The areas of the application that were of importance to the user might be completely unaffected by the problem that occured. In the case of this management studio problem the user could have continued working quite happily without knowing whether collation was enabled for databases that they don't even have access rights to.

Conclusion
Throwing an exception and halting all processing in this case is a bit like taking the football home from the park just because you fell and scraped your knee. It didn't make you many friends as a young MS-DOS program and it won't as an adult enterprise management application either. Play nice...try, catch, and throw like the rest of the kids and leave the drama at home.

SSRS doesn't LIKE me anymore

Stuart Thompson — Fri, 08 May 2009 18:11:28 GMT

When is % not equal to %? When you're using the LIKE statement in SQL Server Reporting Services. If you've used the LIKE statement but haven't felt the love, it's because the standard wild-card operator (%) for a LIKE statement isn't the same in SSRS. Instead of the % operator they use *.

So the statement:
WHERE Customer.Email LIKE '%' + @qEmail + '%'
should instead be:
WHERE Customer.Email LIKE '*' + @qEmail + '*'

Upcoming Developer Courses

Stuart Thompson — Tue, 14 Apr 2009 18:55:04 GMT

Spring is here and we're now offering a new set of courses for the coming months. Be sure to check out the details below and reserve your seat now. You can keep up to date with the latest course offerings at http://events.sftsrc.com.

April 22nd - 24th: Silverlight for the Web Developer

Microsoft Silverlight is a cross-browser and cross-platform web-centric programming API which allows you to integrate extremely rich UI islands into a standard web application. Using Silverlight, developers can inject multimedia (video, audio, etc), user interactivity (games, gadgets) and other visual enhancements into their designs. This course examines the role of the Silverlight SDK and the numerous surrounding technologies (JavaScript, ASP.NET, XAML) and development tools (Microsoft Blend, Visual Studio 2005/2008 templates) used to build Silverlight-enabled web content.

May 11th - 13th: Windows Communication Foundation (WCF)

Windows Communication Foundation (WCF) is an API used to build distributed applications using .NET 3.0 and higher. WCF was designed to expose the current multitude of Windows remoting APIs (web services, MSMQ, TCP, peer-to-peer, etc) from a single unified toolkit. In this course, attendees will examine the overall WCF programming model, binding choices, host options, security issues and the use of declarative markup to specify the underlying infrastructure.

May 26th - 27th: LINQ

You will learn to use the new .NET Framework 3.5 feature, Language Integrated Query (LINQ) to easily create complex data-independent queries. In addition, you’ll learn about the new language features added to Visual C# in Visual Studio 2008 in order to make LINQ possible. You’ll start by working through a quick overview of LINQ, and how it applies to working with collections of objects, retrieving data stored in SQL Server, and creating XML content. Subsequent topics introduce new LINQ-oriented language features, LINQ to Objects, LINQ to DataSets, LINQ to SQL, LINQ to XML, and LINQ to Entities. By the time you’ve completed the course, you’ll have a good understanding of how to construct LINQ queries to work with data and how Visual Studio 2008 supports LINQ.

May 28th: Agile in a day

While more and more companies are practicing “Agile” software development, there is still a great deal of misunderstanding and confusion that surrounds the term. This one day lecture class will cover the basics of Agile development using Scrum, including

* Product, release and sprint planning
* The product backlog
* The roles of the Scrum master and product owner
* The importance of demos
* What it means to be done with a task in Scrum

The instructor has participated in numerous Agile projects in a wide variety of organizations, and will include a discussion on common pitfalls and barriers to Agile adoption as well.

May 29th: Hands-on Continuous Integration with Free Tools

This one day course will provide a hands on look at setting up a Continuous Integration process using freely available tools from beginning to end. Students will learn the theory and practice behind establishing a Continuous Integration process, including setting up a build script, running unit tests, setting up an automated build/test server, and capturing reporting information for the whole process.

DirectX 10 - Learning from scratch

Stuart Thompson — Thu, 09 Apr 2009 02:00:52 GMT

It's been several years since I did any games programming. I have always maintained an avid interest in 3d modelling and graphics programming and love the world of video games and video game development, however I have found it hard to set aside the time necessary to really dig into the field further. I've been unwilling to consider becoming a professional games developer because the reality is that all but a select few earn the kind of money that is available in commercial software development. As the head of household and provider for our family I can't justify cutting my salary in half (or more) to work insane hours in one of the most demanding corners of our industry.

However, the draw of games development and more specifically of DirectX development has sucked me in once more. I'm enamored by the idea of being able to create 3d models and render them inside a game engine. It's not even about an interest in commercial exploitation or of using a game framework to create the next big hit, I'm just fascinated by the science and technology of 3dmodeling, rendering, shading, lighting, and voodoo.

So, dear friends, I am going to do my best to document my journeys through the jungle of DirectX development. Primarily my goals from this are to create a basic DirectX 10 application, capable of rendering .x models created in TrueSpace 7.6 and develop an understanding for how graphics devices and model rendering in DX10 works. I understand the basic principles and a lot of the underlying math, but the technology of rendering has moved on so much since I was last involved (DirectX 6). This project will hopefully provide a nice refresher on C++ as well as give me a deeper understanding on where 3d graphics technology stands today. Who knows, perhaps this little venture will produce something I can share. :)

SQL Delta diff tool problem with datetime2

Leo Bartnik — Tue, 31 Mar 2009 23:55:29 GMT

I am a big fan of SQL Delta (http://www.sqldelta.com/) and in the time I have been using the trial version have found it to be very useful and far better than the Schema Compare tool in Visual Studio. I ran across one annoying (but easy to fix) problem: it does not know about the datetime2 data type in SQL Server 2008 and it punts when it encounters that type in your database objects.

The fix is pretty simple: when scripting tables that have columns of type datetime2, manually enter the type in the nice, empty space SQL Delta places there where the type ought to be.

My trial has since run out so I never got the opportunity to see if there is a way to configure or add new types for it to recognize, but that would be a pretty cool feature, wouldn't it?

SQL Server scripting woes

Leo Bartnik — Tue, 31 Mar 2009 22:26:01 GMT

For the past few days a co-worker Geoff and I have been working on setting up database object creation scripts in a SQL Express 2008 environment, and we ran into two issues where the script generation tools built into SQL Server Management Studio have some unexpected behaviors that were tripping up the process. In one case there was a silent failure to perform a particular scripting task and in the other there was a loud failure that seemingly was unrelated to the configuration of the scripts we were attempting to generate. In both cases we were able to solve the issues and move forward, but not without some head scratching and trial-and-error problem solving effort.

Scenario 1: The script wizard indicates it successfully scripted all objects in the database but actually does not script one or more of the table objects. The constraints, etc. are scripted, and the wizard reports that it successfully scripted the object in question, but when you examine the T-SQL output, the CREATE of the table is not there. And of course when you run the script it fails at the point where it attempts to apply constraints to tables that do not exist.

The problem is that the object name and references to it throughout the various scripts and relationships were not always in the same case. Even if your SQL Server instance is not configured to be case sensitive, the scripting engine apparently is configured that way, at least when it is trying to figure out dependent objects of associative tables. The solution that Geoff came up with was to find and replace all instances of the table name so that they were in the same case, run the script at that point to get the objects updated, then re-run the whole thing from the start to capture all the changes correctly in the final script that gets checked into source control. Hats off to Geoff and his hunch on this one; he was right on the money.

Scenario 2: The script generator throws a "full-text index" scripting not supported error, even though you have set that setting to *not* script full-text indexes. This arises when you choose which database objects to script by checking their boxes in a list of all the items in the database. Interestingly, the error is not thrown when you indicate at the beginning of the scripting process that you want the tool to generate scripts for all the objects in the database and you don't choose them individually. It also does not occur if you go the route of scripting the table directly from the object browser, which made it all the more elusive to track down.

My hunch is that either there are two different scripting processes at work in this scenario, or there is some kind of additional licensing-related check that happens when you take a certain path that is not present in the other methods. The generator acted as if a setting of false on the full-text index option meant that we wanted it scripted and did not consider that it should just be skipped altogether (that's just a hunch, I didn't confirm it).

What all this tells me is nothing I didn't already know: working with SQL Server means delving into a sometimes arcane, often darkly lit environment where it seems like the only way to get through successfully is to keep experimenting and following hunches. Even when you have what you think is a pretty clear error message it often turns out to be the case that other peoples' solutions are not for the same problem you are having (even though the message is the same). Once you have a few of these experiences, though, they come in handy down the road and you won't forget them the next time you run across the same situation.

Twitted my last tweet?

Stuart Thompson — Tue, 31 Mar 2009 21:23:42 GMT

I had a realization this afternoon that I may have twitted my last tweet on twitter (say that six times fast!) The social networking phenomenon that I've contributed to over the last year has become less and less interesting to me as time has passed. I can see where the service delivers incredible value for some people, I'm just not certain I'm that audience. In fact, I found myself having to actively become that audience in order for the service to make sense in my life. That's altogether the wrong way round.

I still like the idea of updating my status for friends to see, but FaceBook fills that niche much more succesfully than twitter for me, not only in terms of the people in my life who use facebook versus twitter, but also because the people I know who use facebook post updates that are of more interest to me. I've found that my tweeps (friends on twitter) tend to post more from a marketing and "personal online brand" perspective. On twitter my friends network, promote brands and initiatives, and support each other's promotions in an effort to further the common good, and for that crowd those are wonderful things. My friends on facebook tend to update more of what is happening in their personal lives and how they are feeling on a day to day basis. For me, those are simply the posts that I find more interesting and that add more value to my life in terms of what I'm looking to achieve from social networking.

Auto-Generate Friendly Urls

Stuart Thompson — Thu, 05 Mar 2009 19:40:46 GMT

I'd forgotten to check the Auto-Generate Friends Urls for this blog when setting it up. The posts will now be named using a friendly version of the post title instead of a sequential number.

Dynamic OrderBy in LINQ

Stuart Thompson — Thu, 19 Feb 2009 21:01:18 GMT

Have you ever found yourself writing this code?

 switch (columnName)

{

    case "Name":

        return objList.OrderBy(o => o.Name);

    case "Address":

        return objList.OrderBy(o => o.Address);

    ... etc ...

}

If so then you have probably wished you could do this:

     return objList.OrderBy(columnName); 

However, that's not going to work because the LINQ method is looking for an expression tree rather than a column name. There are a few libraries out there such as the Dynamic LINQ Library, but if that feels a little heavyweight for you then the following solution may help.

This class is a generic sorter for collections of type T. There are two basic usage scenarios that are covered by its two sort methods. The first scenario is as above where you want to specify a column upon an object in a collection.
You would call the class using:

 var prm = Expression.Parameter(typeof(MyObject), "root");

IList<MyObject> sortedList = new Sorter<MyObject>().Sort(list, prm, "Name", SortDirection.Ascending); 

However, what if your object hierarchy was a little deeper than that. Consider the following:

     return objList.OrderBy(o => o.Details.Name); 

The column is actually a property of an embedded object. This is the scenario that the second method handles. Because the actual sort column is an embedded object, we need to build an expression manually that describes the "path" to that property. The code is very similar to that of the first example, except in this case we are providing a MemberExpression instead of the string sortExpression.

 var prm = Expression.Parameter(typeof(MyObject), "root");

MemberExpression keySelectExpr =

    Expression.Property(Expression.Property(prm, "Details"), "Name");

IList<MyObject> sortedList = new Sorter<MyObject>().Sort(list, prm, keySelectExpr, SortDirection.Ascending);

Source Code
The following is the code for the generic sorter class:

/// <summary>
 /// A generic sorter class used to wrap the LINQ OrderBy functions.
 /// </summary>
 /// <typeparam name="T">The <see cref="System.Type"/> of object being sorted.</typeparam>
public class Sorter<T>

{
/// <summary>
     /// Sorts a list of type T.
     /// </summary>
     /// <param name="list">The list to sort.</param>
     /// <param name="prmExpression">The expression defining the parameter to supply to the lambda expression.</param>
     /// <param name="sortExpression">The name of the property on the parameter object to sort by.
     /// <param name="sortDirection">The direction in which to sort the objects.</param>
     /// <returns>The sorted list.</returns>
public List<T> Sort(
IEnumerable<T> list,
ParameterExpression prmExpression,
string sortExpression,
SortDirection sortDirection) {
var lambda = Expression.Lambda<Func<T, object>>(Expression.Convert(Expression.Property(prmExpression, sortExpression), typeof(object)), prmExpression);
return sortDirection == SortDirection.Ascending ?

            list.AsQueryable<T>().OrderBy<T, object>(lambda).ToList() :

            list.AsQueryable<T>().OrderByDescending<T, object>(lambda).ToList();

    }

/// <summary>
     /// Sorts a list of type T.
     /// </summary>
     /// <param name="list">The list to sort.</param>
     /// <param name="prmExpression">The expression defining the parameter to supply to the lambda expression.</param>
     /// <param name="keySelectionExpression">
     /// A <see cref="MemberExpression"/> that identifies a property on an object in the supplied <param name="list"/> that is used to
     /// perform the sort.
     /// </param>
     /// <param name="sortDirection">The direction in which to sort the objects.</param>
     /// <returns>The sorted list.</returns>
public List<T> Sort(
IEnumerable<T> list,
ParameterExpression prmExpression,
MemberExpression sortExpression,
SortDirection sortDirection) {
         var lambda = Expression.Lambda<Func<T, object>>(Expression.Convert(sortExpression, typeof(object)), prmExpression);

return sortDirection == SortDirection.Ascending ?

            list.AsQueryable<T>().OrderBy<T, object>(lambda).ToList() :

            list.AsQueryable<T>().OrderByDescending<T, object>(lambda).ToList();

    }

} 

What is the Expression.Convert() part for?
You may have noticed the code does a conversion on the sort expression that we provide:

 Expression.Convert(sortExpression, typeof(object)) 

You may wonder why this is necessary as you are providing a string for the sortExpression parameter. However, it is important to remember that this isn't the type that is being specified in the expression tree, it is the type of the property on the object that is being sorted.

If you are sorting by MyObject.Name (where Name is a string property) then the type is string. However, if you are sorting by MyObject.Date (where Date is a DateTime) then this type needs to be a Date, not a string. That is why we do Expression.Convert(sortExpression, typeof(object)). We downcast to object to avoid a type mismatch problem in the evaluated expression tree.

Sample Listing
The following is a sample listing for a console application. Just remember to add a reference to System.Web as I use the SortDirection class from System.Web.UI.WebControls. Just use a different type if you end up using this outside of a web application.

 using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Linq.Expressions;

using System.Web.UI.WebControls;

namespace DynamicOrderBy

{

class Program

{

    static void Main(string[] args)

    {

        IList<MyObject> list = new List<MyObject>();

        list.Add(new MyObject { Name = "Name3", Address = "Address3" });

        list.Add(new MyObject { Name = "Name1", Address = "Address1" });

        list.Add(new MyObject { Name = "Name2", Address = "Address2" });

        var prm = Expression.Parameter(typeof(MyObject), "root");

        IList<MyObject> sortedList = new Sorter<MyObject>().Sort(list, prm, "Name", SortDirection.Ascending);

        Console.WriteLine("Sorting simple list:");

        foreach (MyObject obj in sortedList)

            Console.WriteLine(String.Format("{0} : {1}", obj.Name, obj.Address));

        Console.WriteLine(String.Empty);

        IList<MyComplexObject> complexList =

            new List<MyComplexObject>();

        complexList.Add(new MyComplexObject { Detail = new MyObject { Name = "Name3", Address = "Address3" } });

        complexList.Add(new MyComplexObject { Detail = new MyObject { Name = "Name1", Address = "Address1" } });

        complexList.Add(new MyComplexObject { Detail = new MyObject { Name = "Name2", Address = "Address2" } });

        var prmComplex = Expression.Parameter(typeof(MyComplexObject), "root");

        MemberExpression keySelectExpr =

            Expression.Property(Expression.Property(prmComplex, "Detail"), "Name");

        IList<MyComplexObject> sortedComplexList = new Sorter<MyComplexObject>().Sort(complexList, prmComplex, keySelectExpr, SortDirection.Ascending);

        Console.WriteLine("Sorting complex list:");

        foreach (MyComplexObject obj in sortedComplexList)

            Console.WriteLine(String.Format("{0} : {1}", obj.Detail.Name, obj.Detail.Address));

        Console.WriteLine(String.Empty);

        Console.WriteLine("Press any key to exit...");

        Console.ReadLine();

    }

}

public class MyObject

{

    public string Name { get; set; }

    public string Address { get; set; }

}

public class MyComplexObject

{

    public MyObject Detail { get; set; }

}

/// <summary>

 /// A generic sorter class used to wrap the LINQ OrderBy functions.

 /// </summary>

 /// <typeparam name="T">The <see cref="System.Type"/> of object being sorted.</typeparam>

public class Sorter<T>

{

    /// <summary>

     /// Sorts a list of type T.

     /// </summary>

     /// <param name="list">The list to sort.</param>

     /// <param name="prmExpression">The expression defining the parameter to supply to the lambda expression.</param>

     /// <param name="sortExpression">The name of the property on the parameter object to sort by.

     /// <param name="sortDirection">The direction in which to sort the objects.</param>

     /// <returns>The sorted list.</returns>

    public List<T> Sort(

        IEnumerable<T> list,

        ParameterExpression prmExpression,

        string sortExpression,

        SortDirection sortDirection) {

        var lambda = Expression.Lambda<Func<T, object>>(Expression.Convert(Expression.Property(prmExpression, sortExpression), typeof(object)), prmExpression);

        return sortDirection == SortDirection.Ascending ?

            list.AsQueryable<T>().OrderBy<T, object>(lambda).ToList() :

            list.AsQueryable<T>().OrderByDescending<T, object>(lambda).ToList();

    }

    /// <summary>

     /// Sorts a list of type T.

     /// </summary>

     /// <param name="list">The list to sort.</param>

     /// <param name="prmExpression">The expression defining the parameter to supply to the lambda expression.</param>

     /// <param name="keySelectionExpression">

     /// A <see cref="MemberExpression"/> that identifies a property on an object in the supplied <param name="list"/> that is used to

     /// perform the sort.

     /// </param>

     /// <param name="sortDirection">The direction in which to sort the objects.</param>

     /// <returns>The sorted list.</returns>

    public List<T> Sort(

        IEnumerable<T> list,

        ParameterExpression prmExpression,

        MemberExpression sortExpression,

        SortDirection sortDirection) {

        var lambda = Expression.Lambda<Func<T, object>>(Expression.Convert(sortExpression, typeof(object)), prmExpression);

        return sortDirection == SortDirection.Ascending ?

            list.AsQueryable<T>().OrderBy<T, object>(lambda).ToList() :

            list.AsQueryable<T>().OrderByDescending<T, object>(lambda).ToList();

    }

}

}

Silverlight Days

Shaun McAravey — Fri, 13 Feb 2009 13:21:33 GMT

Patrick Cauldwell and I have just completed presenting two one day deep-dive sessions on what we felt are practical Silverlight topics. After thinking about it, I have decided that over the next few days I will share some of my demos with my editorializing.

In my first presentation, I covered Styling, Skinning and Custom Controls, and in my second presentation I covered Silverlight/browser integration.

The first topic I will be addressing will be "How to use Silverlight as a replacement for Javascript libraries".

As I complete each topic, I will add them to the following table of contents:

Silverlight as a Javascript Library Replacement

I would also invite you to contact me at shaun@sftsrc.com if you have specific Silverlight (or other) topics that you would like me to consider addressing.

Practical Silverlight: More than just Flash

Stuart Thompson — Fri, 23 Jan 2009 16:55:51 GMT

Register here to learn how to use Silverlight to build next-generation applications in half the time it would take with traditional web development technologies. SoftSource provides you with a competitive advantage in application development, delivering the highest quality of software on time and within your budget. Now learn the secrets from our trainers about how to leverage this cutting edge technology to deliver the same results yourself.

"Until now, the standard for user experience for browser-hosted applications has been defined by AJAX and JavaScript. However, the powerful and rich user experience provided by these applications has come at a significant cost in development. Silverlight allows us to deliver an even more compelling user experience while simultaneously simplifying the programming model and leveraging our existing .NET skills. During this session we will cover the foundational concepts and technologies you will need to know to jumpstart your transition to Silverlight development. Several highlights include:

Silverlight Architecture
Dependency and Attached properties
XAML resources
How to access your code in XAML."

Registration for the Portland event can be found here: https://registration.sftsrc.com/Register.aspx?EventId=1
There is also a Bellevue event you can attend here: https://registration.sftsrc.com/Register.aspx?EventId=382

Spots are limited, so sign up early to ensure that you get yours.

Walking in other shoes

Stuart Thompson — Wed, 21 Jan 2009 17:37:10 GMT

Your l33t sk1llz are so bad ass that if given an open canvas you could write software to solve all the world's problems and still be home in time for tea. Unfortunately for you, a thousand and one project managers feel the need to get in the way and provide direction, appoint technical leads with no clue what they are doing, and generally hamper your ability to kick ass at every turn.

However, the thought of you stepping into those shoes and "showing them how it is done" has you saying "No way man!" This article is a great review of why their shoes might provide a very informative journey that will help you apply your mad skills more effectively than ever before:
Why Kick Ass Developers Should Become Managers - If You Dont Run Your Projects They Will

Thanks to Rajiv for putting this great article together.

Web 2.0

Stuart Thompson — Mon, 12 Jan 2009 16:53:46 GMT

I think this is the best description I've come across for Web 2.0. I found this in the monthly dreamhosts.com newsletter:

"Ajaxy-Javascript-Web 2.0-itude"

Yeah baby...hail to the king!

Visual Studio 2010 CTP

Stuart Thompson — Wed, 07 Jan 2009 18:06:23 GMT

Have you downloaded your copy yet?

http://www.microsoft.com/downloads/details.aspx?FamilyId=922B4655-93D0-4476-BDA4-94CF5F8D4814&displaylang=en#filelist

The Secret to Organizational Agility

Stuart Thompson — Mon, 08 Dec 2008 21:23:08 GMT

Mike Cottmeyer wrote an excellent article about the importance of eliminating dependencies in agile projects:
http://www.leadingagile.com/2008/12/secret-to-organizational-agility.html

How many times have the following been true:

"Many teams are trying to sprint through product development using a traditional MRD or PRD."
"Many teams are working with traditional project managers who are doing their best to be agile, but have been trained to manage dependencies and tell people what to do."
"Teams are trying to be agile with tightly coupled software architectures, insufficient test coverage, legacy code bases, and unable to do a daily build."

Removing dependencies is a key step that can be taken towards a truly agile development environment.

Be careful with your online brand...

Stuart Thompson — Mon, 08 Dec 2008 19:17:40 GMT

As the popularity of Web 2.0 is growing, so is the ability for others to observe and evaluate your story and your personal online brand. This article from JASE marketing reports that a "survey of 500 top colleges found that 10 percent of admissions officers said they look at MySpace and Facebook to evaluate applicants."

I've always lived by two golden rules with regards to blogging:
1) Blog only something you would wish to see printed and cited at any time in the future.
2) Do not edit or update a blog assuming that a printed/archived/cached copy of the original does not exist.

It's a general faux pas to update a blog post for any reason. The web is alive with caches and indexes so the chances are that the original is still out there for people to compare. Spelling errors are generally ok, but if the content of an article is to be updated it is good form to list at Updated: [description of update] at the top or bottom of the post. If an opinion is being revised, be clear about why there is a change in stance. Comments are a great way to revise an opinion after learning new information as it allows readers to see the thought processes and perhaps benefit from the same line of thinking that provoked your own turn around.

Web 2.0 means we are all ultra-connected. This can be great not only for staying in touch with friends but also for business networking and establishing a reputation and a brand in the online world. However, remember that this "permanent record" can go both ways: and this one is for the world to see.

FireFox 3.x Unstable

Stuart Thompson — Tue, 02 Dec 2008 17:22:29 GMT

I'm not sure what changed. FireFox used to be one of the most stable browsers I'd ever used. However, since the upgrade to the 3.x track I've had nothing but problems. The browser is still functionally great, but the stability has taken a nose-dive. I've had crashes and lockups on both XP and Vista and despite getting the latest updates and fixes in both environments, the problems continue. I'd switch to Chrome if it weren't for concerns over security vulnerabilities. It's a new browser that's still in beta so I'm not surprised there are a few kinks to iron out; but I'd rather not be the guinea pig that finds the problems.

So for now, I guess it's back to IE. *sigh*

Ruby on Rails Setup with DreamHost

Stuart Thompson — Tue, 28 Oct 2008 22:29:21 GMT

As step 1 of my latest experiment, I've started by configuring a Ruby on Rails site with DreamHost. This actually involved quite a bit of setup work, which is not unusual when remotely hosting a new website. I have documented the steps as fully as I can for anyone else curious about trying development in Rails.

Step 1 - Signup with DreamHost
You can sign up using this link or use the promo code LETMETRYRAILS and receive $50 off (i.e. no setup fee).

Step 2 - Configure your domain
The next step is to configure your domain. We'll start at the DreamHost configuration panel. Select Domains and then Manage Domains from the left-hand sidebar. This will bring up the list of domains in your account. Click the Edit button in the Web Hosting column.

This will open the settings page for that domain. Check the FastCGI and Passenger (mod_rails) checkboxes. Finally click the Change fully hosted settings now! button (note that this button is not at the bottom of the page, rather at the end of the first section).

FastCGI support allows your Rails project to run much faster. The Passenger (mod_rails) option allows your Rails application to be configured much more easily and is the preferred DreamHost method for hosting Ruby on Rails applications.

Step 3 - Configure your FTP/SSH user
We will be performing much of the setup and configuration of the website via SSH. We will need to setup a user account for this purpose. During your initial setup you should have created an ftp account for your domain, probably with the same name as that domain (if you accepted the defaults). Select the Users and then Manage Users options from the left side-bar. Click the Edit button next to your user in the Actions column.

This will open the following page where you can edit your user. Change the User Account Type to Shell account and select the /bin/bash shell type. Finally, hit the Save Changes button at the bottom of the page.

This enables the user to connect using a Telnet/SSH client, which is exactly what we are going to do next.

Step 4 - Download some tools
Next we're going to download the tools we'll need to create and configure our rails website. We'll need the latest release of Ruby, MySQL, HeidiSql, and PuTTY. HeidiSql is a free gui for maintaining MySQL databases. PuTTY is a free Telnet/SSH client that we'll use for remote configuration of our site. Note that you do not need to signup on the MySQL site to get the download. Click the No thanks, just let me download link.

Ruby 1.8.6-27 RC1 can be downloaded here.
MySQL 5.0 Community Server can be downloaded here (select the Windows ZIP/Setup.EXE (x86) option)
HeidiSQL 3.2 can be downloaded here.
PuTTY can be downloaded here.

Step 5 - Installing Rails
Now that we have the necessary tools installed it is time to setup Rails locally. Fortunately, Ruby comes with everything we need to get setup and running, including the WEBrick web server that we can use to run and test our site before deployment. When installing Ruby, be sure to check the Enable RubyGems option on the first page of the installer.

Once the installer completes, open up a command window and execute the following commands:

cd ruby/bin
gem update --system
gem install rails --version 2.1.2

This will use the gem system to install rails locally. If everything is successful, your command window should look something like this:

You may need to restart your system at this point. Ughh. This is because Windows Vista and XP sometimes struggle to detect that new environment variables were added to the $PATH. Unless you relish fully qualifying the C:/Ruby/bin directory on the next few commands, I'd advise you restart now. It's also not a bad idea since we did just install four new programs. I've found Windows seems to run more smoothly if you reboot after installing new things.

Step 6 - Create your Rails site locally
Now that we have Rails setup, let's create a simple site locally. I created a new directory on C:\ called projects in which to develop the site. Open a command prompt and type the following:

cd \
md projects
cd projects
rails MyRailsSite

This will create your rails site in C:\projects\MyRailsSite. Before we add our first view and controller, let's quickly check that everything wired up properly. To do this we need to start the WEBrick server:

cd C:\projects\MyRailsSite
ruby script/server

Vista may ask if you wish to unblock Ruby, which you do. Your command prompt should look something like the following:

You can now navigate to http://127.0.0.1:3000 to see your site. If everything is configured correctly you should see the Ruby on Rails welcome page:

We can shutdown the WEBrick server by pressing Ctrl-C in the command prompt window.

Now let's create our first controller and view. We're going to keep it simple and put up a page that displays the message "Hello World!". At the command prompt type the following:

cd projects\MyRailsSite
ruby script/generate controller HelloWorld

This will generate a new controller for you as well as a new view. If you aren't familiar with MVC development, just follow along for now until the sample becomes clear. The rest will come in time and with additional reading and practice. For now it is suffice to say that a controller will perform the work for a web page request where the view will display the results of that work.

Let's edit the controller that was generated. To do this, open up an explorer window, navigate to C:\projects\MyRailsSite\app\controllers, right-click over the hello_world_controller.rb file and select Edit from the context menu. This should open the controller file in the SciTE editor. We need to add lines to the class to respond to the index action. The index action is the default action that will be performed for a controller. To do this, edit the file to look like the following:

This controller will now set the variable @message to the literal "Hello World"; when the index action is requested. Controllers perform actions.

Save the file and close it. Now we will create a view to display the message. Navigate to the C:\projects\MyRailsSite\app\views\hello_world directory in explorer (notice how Rails created the view directory for us). Right-click in the directory and create a new file called index.html.erb. Now right-click this file and open it in your favorite editor (Notepad will suffice). Add the following to the file:

Save the file and close the editor. We're almost ready to test out our new controller and view. First, however, we need to configure a route for our site. A route is a mapping from an end-point (url) in our site to an actual controller and view that will fulfil the request. In explorer, navigate to C:\projects\MyRailsSite\config, right-click the file routes.rb and select Edit from the context-menu. This will open your routes file in the SciTE editor. Almost the entire file is commented out. Most of this file contains instructions for configuring custom routes. We're going to comment out the last two lines of the file and insert a single mapped route of our own. Edit the end of the file to look like the following:

This line connects the helloworld route to the hello_world controller for the index action. The action specification isn't actually necessary as the index action is assumed by default if none is specified, but I prefer to be explicit.

There is one final thing we'll need to do before we can browse to our page locally. We need to install and configure MySQL.

Step 7 - Install and configure MySQL
This is a very short step. Run the MySQL setup package you downloaded earlier and select the Typical installation option. Then hit Next->Next->Finish all the way to the end. When the configuration wizard runs, choose Detailed Configuration, then Developer Machine, then Multifunctional Database. When asked for a location for the Inno files, I used C:\projects\MySQL. Choose Decision Support (DSS)/OLAP then leave both boxes checked on the next dialog with 3306 as the port number. Choose Standard Character Set, then check Install As Windows Service and leave Include Bin Directory in Windows PATH unchecked. Enter a new root password, leave Create An Anonymous Account unchecked. Finally, hit Execute to finish the configuration wizard. MySQL is now installed and configured.

Step 8 - Create a database for our project
We'll need to create a database for our project. To do this we'll need to install HeidiSql. Let's run that installer now. I use the defaults from the installer except on the Select Additional Tasks dialog where I uncheck Associate .SQL Files with HeidiSQL. When the installer completes it will launch the HeidiSQL gui. Click the New button at the top of the first dialog. Name the connection MyRailsSite, click OK, and then enter the password you selected during your MySQL installation into the password box provided. The first thing we're going to do is create a new database. Right-click over root@127.0.0.1 in the left side-bar and select Create database from the context menu. Enter MyRailsSite as the database name and click ok. Now select Tools->User-Manager from the top menu. We're going to create a new user to avoid using the root user in our application. For the Username type myrailsdbuser, set From Host to localhost, and type a password for your new user. Don't use the same password you used for root. In the Allow access to list, left-click over the myrailssite database (it will turn yellow). Now click Add User. Then click Close to close the user manager dialog. Now we've created a database and a specific user for our Rails application to use.

Step 9 - Configure Rails to use the database
Finally we need to configure our Rails site to use our new database. In an Explorer window, navigate to C:\projects\MyRailsSite\config, right-click the database.yml file and edit it in your favorite editor (I use TextPad but NotePad will suffice). Edit your file to look like the following:

Step 10 - Testing the site locally
We're finally ready to test the site locally! Open up a command window are run the following to start the WEBrick server:

cd c:\projects\myrailssite
ruby script/server

Then open a browser and navigate to http://127.0.0.1:3000/. You'll notice that the Rails welcome page still displays. However, change the url in the browser to point to http://127.0.0.1:3000/helloworld. You should now see your view displaying the message "Hello World!". Let's remove the default index page now and then make your default route point to your helloworld view. To do this, open up Explorer and navigate to c:\projects\myrailssite\public. This is your site's public directory. From here, delete the index.html file. That's the welcome page gone; we don't need it anymore. Now navigate to c:\projects\myrailssite\config and open the routes.rb file again. Add the following line just before the map.connect line we added earlier:

map.root :controller=>"hello_world"

This configures the root route to point to our hello world controller. As we stated earlier, there is no need to specify the index action as it is assumed by default. Save and close the file, then browse to http://127.0.0.1:3000 once more. Your site should now be displaying your "Hello World!" message. Note how the url is just http://127.0.0.1:3000 and doesn't have helloworld at the end. This is an important point about routes. You aren't navigating a particular directory structure on the site, you are simply navigating routes and actions. The controller could be named anything you like as long as the route for a particular end-point correctly routed requests for that end-point to your controller. For now, let's stop the WEBrick server and close the command window. The final task is to get your Rails site up to DreamHost and serve your "Hello World!" request remotely.

Step 11 - Configuring DreamHost for your site
This final configuration step may seem a little confusing at first, but only if you aren't familiar with Linux and BASH. It doesn't take very long and it isn't important to understand how it works because you'll only need to do it once. We're going to install version 2.1.2 of rails to your remote host because that's the version that Passenger (mod_rails) needs in order to run your site. This is where we'll need PuTTY. Fortunately there is no installation step with PuTTY. It is simply an executable that you download and run.

When you run PuTTY, you will need to supply the username and password of the user we configured in step 3. This will connect you to the server that will host your site. The following instructions are commands to enter into the BASH shell as well as instructions on editing your ~/.bash_profile file (which is similar to environment settings for the command shell in Windows). The first part of these instructions is about editing your ~/.bash_profile file to ensure that some paths and other required settings are configured before beginning installation. These instructions have been adapted from the DreamHost wiki article on this topic.

Before we update rails, let's first create our Rails site remotely. To do this, first run PuTTY. For the Host Name you will supply your domain name in the form www.MyDomainName.com. Then click Open. I choose No from the next dialog as I don't want to store anything in the registry. You will now enter the username and password for the user we created in step 3. When you connect, type ls and hit enter. This is the BASH command to list the contents of the current directory. You should see MyDomainName.com listed in the output. We are going to navigate to that folder and then create a rails site inside that folder.

cd MyDomainName.com
rails MyRailsSite

This will create a Rails site on the DreamHost server, the same way we did it locally earlier. We're going to create the site like this and then upload our site files from our local machine to the remote site. To upload our files, we'll use an Explorer window and ftp. First, however, we need to create a copy of our database.yml and environment.rb files. This is because those files will be different on our remote host than they are locally. Create a copy of each of those files called database.yml.live and environment.rb.live now. Now edit the database.yml.live file to look like the following:

Edit your environment.rb.live file and uncomment the following line (its on line 5):

ENV['RAILS_ENV'] ||= 'production'

This is important because running in development mode under FastCGI will cause memory leaks on the DreamHost server. They will catch them and clean them up but it's better to run in full production mode and not cause problems.

One final change we need to make locally is to update the c:\projects\myrailssite\config\environments\production.rb file. Comment out the config.action_view.cache_template_loading = true line as it causes problems with the Passenger product that will host our site.

Now we're ready to install Rails 2.1.2 remotely. Switch back to your PuTTY session (or log in again if you exited). Let's first edit the ~/.bash_profile file. To do this we will be using the nano text editor. To open the ~/.bash_profile file in nano, type the following:

nano ~/.bash_profile

Now you can use the cursor keys to navigate the file. We need to add the following lines to the end of the file:

# Path settings
export GEM_HOME="$HOME/.gems"
export GEM_PATH="$GEM_HOME:/usr/lib/ruby/gems/1.8"
export PATH="$HOME/bin:$HOME/.gems/bin:$PATH"
export RUBYLIB="$HOME/lib:$RUBYLIB"

# Stops the DreamHost processes from killing the gem install process
alias gem="nice -n19 ~/bin/gem"

To save your changes press Ctrl-O then hit enter. Press Ctrl-X to exit the editor and return to the shell. You can now type cat ~/.bash_profile and the contents of the file should be printed out. This is a good way to check that your changes were saved and that you typed everything correctly.

Now we need to perform the installation. The following commands will achieve this:

cd ~
mkdir .gems

mkdir bin lib src

cd ~/src
wget http://rubyforge.org/frs/download.php/43985/rubygems-1.3.0.tgz
tar xzvf rubygems-1.3.0.tgz
cd rubygems-1.3.0
ruby setup.rb --prefix=$HOME

cd ~/bin
ln -s gem1.8 gem

For more information on what each of these steps is doing check the DreamHost wiki article. We can check that the path and gem versions are correct by typing the following:

which gem
gem -v

These commands should return /home/USERNAME/bin/gem and 1.3.0 respectively. Now we can execute the command to install Rails 2.1.2, which is:

gem install rails --version 2.1.2

What we've accomplished here is to install RubyGems and Rails 2.1.2 to our hosted server. The last thing we need to do to make everything work is to use rake to freeze our version of Rails to 2.1.2 so that Passenger will use our Rails installation when running our site. The commands to do this are as follows. Please note that you need to supply your domain name in the format MyDomainName.com and the name of your Rails site in place of MyRailsSite in the first command. This simply changes the current directory so that we're running rake in the right place.

cd ~/MyDomainName.com/MyRailsSite/
rake rails:freeze:edge TAG=rel_2-1-2

That's it! Phew. That felt like a lot of work, but at least you only have to do it once.

Step 12 - Deploying and testing your site remotely
Now that we've set up the environment with DreamHost, the only task left is to deploy the site remotely and test it out. Before we do that though, we are going to check one last configuration setting in the DreamHost control panel, just to be sure that everything is setup correctly. If you navigate to Domains->Manage Domains in the left side-bar and then click the Edit button again (see step 2), then check out the Specify your web directory setting. This is where DreamHost will send requests to MyDomainName.com. It should be set to:

/home/username/MyDomainName.com/MyRailsSite/public

By setting the directory to the public directory of your Rails site, it means that users cannot navigate outside of that directory and browse places that they aren't supposed to be.

Let's finish up and deploy our Rails site from the local machine to the remote server. We'll use Explorer and ftp to do this. Open up Explorer and type ftp://ftp.MyDomainName.com into the address bar. Now open up the MyDomainName.com and then MyRailsSite folders. You will need to copy your app directory from your local machine at c:\projects\myrrailssite\app up to the remote server. When you have copied these files, navigate to the pubilc directory on the remote server and delete the index.html file. We don't need the Rails welcome page on live anymore either! Then navigate to the config directory and copy the routes.rb, environment.rb.live and database.yml.live files up to the corresponding folder on the server. Don't forget to rename these to environment.rb and database.yml on the remote server. We only renamed them so that we could have two different files locally. Finally, navigate to the config/environments folder and copy the production.rb file that we edited up to the corresponding location on the remote server. From now on, when you deploy your site, you will only have to copy the app folder to the remote server (unless you change config settings that is).

The final step before we can test our site on live is to setup the MySQL database on the DreamHost side to match the one we set up locally. Since we didn't create any database tables, this is fairly simple to do through the DreamHost interface. Go to Goodies->Manage MySQL and repeat the same steps here as we did in step 8. You can also use HeidiSQL if you want to manage your database remotely that way. However, for now I recommend using the DreamHost web interface to do this work. All you need to ensure is that the database name and username/password for that database match the settings you specified in your database.yml file. I'm going to cover using databases in Rails in more detail in a future article. For now we just need to get an empty database and a user that has access to keep Rails happy.

Congratulations! Assuming that everything was wired up correctly, you should now be able to open a browser and navigate to http://www.MyDomainName.com to see your site being hosted remotely.

Hopefully this article will help you get up and running with a basic Rails site that is hosted remotely. The focus of this article was understanding the relationship between running a Rails site locally and hosting it on a remote server. Setting up your development in this way from day one will save a lot of headaches later when it comes to deployment time. Developing and testing locally, then deploying to a live host means that problems can be identified early and that changes can be tested locally rather than on a live site. I'm going to expand upon this article as part of my ongoing experiement with ASP.NET, Silverlight, PHP, and Ruby on Rails. Next we're going to develop a database, understand models using ActiveRecord, and dig a little deeper into Rails. For now: happy hosting!

The ASP.NET, Silverlight, PHP, Rails Experiment

Stuart Thompson — Mon, 27 Oct 2008 20:06:37 GMT

I've been working with Microsoft technologies for over ten years, specifically Microsoft's web development technologies. During that time I have built a variety sites ranging in scope from e-commerce, educational, service provision, SaaS, to dashboards, portals, internal tools, and even SAP-migration. While I praise the technology stack for what it allows me to do, it also comes with a whole host of limitations that make it hard for me to deliver the experience my clients would like. Throughout this decade of web development I have heard a lot from those around me about alternative technology stacks that promise all manner of improvements and experiences. Unfortunately there is a lot of resistance from any one technology stack to listen to and learn from the stacks around them, most of the cross-platform feedback comes in the form of "Microsoft sucks" or "PHP is for fan-boy script kiddies". The truth is that a large number of successful business are hosted on a wide variety of platforms. Each technology stack has to at least be viable for that to be true. The problem is getting at the truth without the zealous noise of "my stacks better than your stack" getting in the way.

I decided that it was time for me to branch out and become more informed on these technologies myself so that I could truly understand the differences and what made each of them unique. I'm hoping that as part of this experience I can not only become a better developer but also learn the problems that Ruby on Rails or PHP addresses. I'll like to be able to speak from an informed standpoint about the differences between the Microsoft and open-source approaches as well as better understand the problems each of those development worlds faces on a daily basis. Either way, it's going to be a heck of a lot of fun.

The experiment I have in mind is to build the same web-site using four different technologies. From the Microsoft camp I have chosen ASP.NET and Silverlight. From the open-source perspective I have chosen PHP and Ruby on Rails. I chose PHP and RoR because they are two technologies that I have always wanted to learn. Learning both of those will also require some digging into Apache and Linux, another two areas that I have too little direct experience with to effectively participate in an informed conversation.

Our horses are ready to race. In terms of hosting, I have selected DreamHost for the PHP and Rails sites, and I'm going to use StormHosts for the ASP.NET and Silverlight projects (assuming that SH can do .NET 3.5, which I believe I saw at some point). The reason I'm using remote hosting services for this experiment is that I don't believe you get the true experience of a technology stack until you host it in this way. It is very easy to get a Rails site up and running using WEBrick and a local installation of Ruby. Similarly, it is easy to get an ASP.NET site running on the personal web server that ships with Visual Studio 2008.

The first phase of the experiment is to get a "Hello World!" site up and running for each of the four environments. The specifications are that a single end-point be accessible that displays the text "Hello World!" and that this end-point is accessible in both Internet Explorer 7 and FireFox 3.

Reflector to go to RedGate

Stuart Thompson — Wed, 20 Aug 2008 16:21:13 GMT

Lutz Roeder has decided to move on from Reflector. RedGate will be taking over the project from now on. Fortunately, they have agreed to maintain the community edition of the software.

http://blog.lutzroeder.com/2008/08/future-of-net-reflector.html

NDepend Part II - Beginning CQL

Stuart Thompson — Tue, 19 Aug 2008 18:25:12 GMT

In my continuing use of NDepend on both my work and home projects, I have been investigating CQL more and more, especially from the perspective of use in continuous integration. NDepend provides some incredibly powerful analysis features and I find the idea that constraints can be applied and warnings reported as part of day 1 builds to be extremely appealing. I'm all about keeping code clean, constrained, and consistent. NDepend provides another great tool in my kit to ensure that my own code is marshalled to my standards from the very first line that is written. As David Muhondro put so eloquently in his blog post, NDepend is static analysis on steroids. When most users encounter CQL for the first time, the response is "wow, this looks really powerful, now what does it mean?". I've started by taking the stock queries that are included in a basic NDepend project and understanding what they mean and the warnings that they are expected to generate. By understanding the warnings and their purpose in the project, I began to understand how I could tweak those queries and even write my own to enforce the rules I'd like my code to live by.

Let's start by looking at an example. After creating a new NDepend project and pointing it at a list of assemblies to analyze, the default CQL queries that are included are grouped into the following categories:

Code Quality
Design
Unused Code / Dead Code
Encapsulation
Diff / Changes / Evolution
Test Coverage
Purity / Immutability / Side-Effects
Naming Conventions
.NET Framework Usage
Statistics
Samples of Custom Constraints
Constraints extracted from Source Code

I started by looking at the Unused Code / Dead Code queries, specifically at the Potentially unused methods query. By double-clicking on the query it is opened in the CQL query editor and displays the following:

 // <Name>Potentially unused methods</Name>

WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE

MethodCa == 0 AND            // Ca=0 -> No Afferent Coupling -> The method is not used in the context of this application.

!IsPublic AND                // Public methods might be used by client applications of your assemblies.

!IsEntryPoint AND            // Main() method is not used by-design.

!IsExplicitInterfaceImpl AND // The IL code never explicitely calls explicit interface methods implementation.

!IsClassConstructor AND      // The IL code never explicitely calls class constructors.

!IsFinalizer                 // The IL code never explicitely calls finalizers.

Breaking it Down
Let's break this down a little. First of all it is important to realize that this is not SQL, despite any similarities in the syntax. The first line selects the top 10 methods that satisfy the query and then raises a warning if the total number of methods is greater than 0. The reason for the seemingly superfluous top 10 selection is that if the count is greater than zero then those top 10 will be displayed as the results of the query. To avoid swamping with noise the query is restricting to only the first ten offenders. The next line is the first part of the WHERE clause and looks for methods with an CruiseControl to bring these warning and reports into the daily life of your projects. While static analysis en masse isn't for everyone (not even for me), a small list of CQL queries can help you perform necessary housekeeping without having to do the hard hunting work yourself. The inevitable question is whether or not this overlaps with FxCop. There is some overlap, but they are both just tools from which you should pluck the best of the functionality you like and strike down the cruft that gets in the way. There are some cases where writing an FxCop rule specific to your application is a good thing, however I'm finding that writing CQL queries for warnings lends itself a little better to how I think about static analysis in the first place. The key is finding that sweet spot in the middle.

Designing for Testability

Stuart Thompson — Wed, 30 Jul 2008 19:56:41 GMT

Automotive manufactures have long been on the vaunted TDD bandwagon. For years they have harnessed the amazing potential of unit testing, verifying components individually prior to the expensive and time-consuming exercise of assembling them to make a completed vehicle. Integration testing in the automotive world is very expensive and to find that a single component failure has wasted a fleet of test vehicles as well as many months of construction and fabrication is close to unacceptable. However, they have also long faced the question of when and where to design for testability; a line still not clearly defined in any industry.

It makes perfect sense that if a component is to be tested in isolation from the system it will eventually be integrated with that a certain amount of planning is necessary in order to facilitate that testing. This means that certain designs, while technically and functionally brilliant, may need to be modified if they are ever to be tested. The question is where to draw the line. All too often in software engineering the line is drawn firmly on one side or the other, rarely in a position of balance.

I can understand on a modern motor vehicle with multiple on-board computers performing a variety of related tasks that there is a need to interface with and test those computers thoroughly. I'm sure that to the component manufacturers the need for extra diagnostic access ports and programmable interfaces is a hindrance to their development; after all they are working in a very closed system. However, to the test engineers the ability to simulate all manner of failures and receive highly detailed information about everything the computer is doing is absolutely indispensible. They cannot guarantee the component functions correctly without it.

Unfortunately this desire for components to be testable can easily get out of hand. Consider that a test engineer is tasked with ensuring that the onboard computer functions at various speeds. Unforuntately his equipment is bulky and doesn't fit inside the vehicle. Even at low speeds he finds that keeping up with a car in motion requires him to run alongside pretty quickly. Should he require that the car not go faster than 8mph in order to ensure that he can completely guarantee the functionality of the computer for the legal range of speeds he is able to test? Something tells me that the manufacturer wouldn't be able to sell too many of that particular model.

Instead the test engineer must find other ways to test the car at high speeds. Custom models of the car are constructed that allow a connected rig to be tethered to the car, carrying all of the the test equipment alongside even at high speeds. At even higher speeds, motion simulations and car treadmills are employed to allow for testing that the tethered rig is unsafe for. The design of the car wasn't limited to a maximum speed of 8mph, rather a compromise was found to allow the right balance of functionality and testing.

In software engineering, we have a variety of tools and frameworks at our disposal to accomplish similar testing of software. Unit testing frameworks, mock frameworks, dependency injection containers; they are tools. Each plays a specific role and solves a particular flavor of problem, however none of them are all-encompassing and all of them require thought before use.

There is a growing epidemic of code grown out of the desire for "high coverage" unit testing. However, some of the motivations behind this testing appear to have taken an 8mph turn somewhere; for the worse. In an effort to improve code quality, the initiatives towards testing have started to build 8mph cars with 6 wheels and no doors. In terms of test coverage the cars are truly superb, but from the outside many consumers are left scratching their heads and wondering where it all went wrong.

I usually find that if a particular design decision is inhibiting the testability of a component, one of three things is happening:

The design is so tightly coupled and stable that no testing could hope to penetrate the darkness of the black box surrounding it. (i.e. a dll with one 5,000 line method inside that does "something")
The design is so abstract that is doesn't actually do anything. (i.e. a dll containing only interfaces - test that suckas!)
The testing tool being applied is the wrong one for the job.

As a software engineer, I can fix 1 and 2. Fortunately with good design and architecture we can actually prevent 1 and 2 from ever reaching QA in the first place.

There isn't much I can do about number 3. This is where I ask for the line to be moved a little with regards to the tool that is being employed. Here are a few examples of hammering screws and screwing nails.

Static methods, unless invoked through reflection, attract coupling from consumers. That is to say that if an assembly contains a static method, there is a good chance that something calling that static method has a strong reference to the assembly that exposes it. This is not a bad thing and there are many places where such a design makes perfect sense. However, in certain situations, this can cause mocking frameworks to perform more work than necessary to set up the premise for a unit test because they can't mock away the reference the exposed assembly that performs work. This is because mocking frameworks are ideal for mocking abstract implementations and poor for mocking tightly coupled components. There is nothing to mock because everything is explicitly stated. See screw, swing hammer. Static methods are perfect for unit testing thanks to the magic of reflection. Inspect the method contract (the logical contract not the physical source code - i.e. what, in English, does it do) and based upon that contract construct a suite of tests to affirm that the method is indeed doing what it promised it would.

Service assemblies, such as configuration loaders or proxies, tend to operate more upon interfaces than implementations. That is because the value they add is an operation upon some implementation of an interface rather than a concrete process defined up front. This is the provider model. We write a set of interfaces describing the kinds of things a provider can do. We also write a set of services than help those providers achieve some work. We don't write the actual providers themselves because this is a plugin model. Well, how do we test a provider that hasn't been written yet? Wait, this could be hard in unit testing. We call a method on an interface but have no way to know what the "as yet unwritten" provider will do in that method call and have no way of knowing whether the result is correct. NTemporalDisplacementUnit 1.0 hasn't been released yet so we can't do it in a state of temporal flux either...panic! But wait, in thinking about the problem further we realise that we don't care what the provider does. The contract we are providing is that we will interact with a provider in a predictable and documented fashion. As long as we interact with the interface in the correct way and at the correct time, our part of the contract is fulfilled. Woohoo! That's what a mock framework is for. We mock up a provider and check that our service correctly interacts with the provider. Mock frameworks are great for this. Finally, a nail that we can hit with our hammer.

If you find that such thinking manifests itself in dogmatic emails that state "static methods shouldn't be used because they inhibit testability" or "interfaces are bad because we can't get coverage with them." then it might be time to inspect both the situation and the tools and see that the two are being correctly paired.

The goal of testing is to improve the quality of the end product, not to turn lots of lights a pretty shade of green. 8mph cars with lots of green LEDs and no doors for great dogmatic case study's and really awful consumer responses.

Planning for the worst

Stuart Thompson — Fri, 25 Jul 2008 20:28:28 GMT

"The status page we use to report service disruptions in progress is suffering a temporary misconfiguration."

Brilliance!

Technorati Blog Claim

Stuart Thompson — Tue, 15 Jul 2008 21:19:20 GMT

I claim this blog in the name of Stuart Thompson for my new Technorati Profile.

LINQ to Coffee

Stuart Thompson — Tue, 15 Jul 2008 19:55:41 GMT

Nice! A perfect addition to the reference material you keep within reach.

http://www.cafepress.com/linq.225122905

Debugging Into .NET Source Code

Stuart Thompson — Mon, 14 Jul 2008 20:04:31 GMT

Many have “heard” that you can now step into .NET source code when debugging in Visual Studio 2008. For those who have not been doing this since the start of the year, you can find excellent instructions for configuring Visual Studio to get the necessary symbols here.

I highly recommend understanding this process and making it a part of your debugging routine. It often becomes necessary to understand why the .NET framework is behaving in a certain fashion while developing. By stepping into the source code and using the watch window, I’ve saved myself a lot of hours of head-scratching. More often than not it’s as simple as understanding why an exception was thrown and the hidden meaning behind the message. Within minutes I can usually pinpoint how I was incorrectly using one of the libraries, fix the bug, and be on my way.

LINQ'd In #1 - Behavior Injection

Stuart Thompson — Mon, 14 Jul 2008 18:51:44 GMT

As part of a continuing set of articles on LINQ, I want to first take a moment to look at how the "natural" syntax of LINQ is turned into executable code. Once we understand how those expressions and compiled we can investigate ways to extend the code that is being executed.

First of all let’s consider a very simple LINQ expression:

from num in Enumerable.Range(1,9)
where num % 2 == 0
select num

This expression selects the even numbers in the series 1–9. Let’s first break this down into the actual code that is being executed. Behind the scenes LINQ is viewing this expression as a series of lambda expressions and extension methods. Our example is actually being run as:

Enumerable.Range(1,9).Where(n => n % 2 == 0)

Enumerable.Range(1,9) yields an IEnumerable<int>. By using Reflector we can discover that the signature of the Where method looks like the following:

public static IEnumerable<TSource> Where<TSource>(
this IEnumerable<TSource> source,
Func<TSource, bool> predicate)

This is clearly an extension method on IEnumerable<TSource> that takes a Func<TSource, bool> as its only parameter. While the actual internals of the Where method are actually a little more complex due to the way in which iterators have been abstracted, we could theorize that the behavior is roughly similar to the following:

public static IEnumerable<TSource> Where<TSource>(
    this IEnumerable<TSource> source,
    Func<TSource, bool> predicate)
{
    foreach (TSource t in source)
    {
        if (predicate.Invoke(t) == true)
            yield return t;
    }
}

“For each item in the supplied IEnumerable, invoke the supplied predicate and add the item to the returned collection if that predicate returned true.”

Note: If you haven’t encountered keyword yield before, check out this post about how it works.

Now that we understand how the statement is working internally, lets look at ways in which we can extend it. To understand the following trick we need to think for a second about how extension methods are implemented, or more importantly about how they are resolved.

When the compiler encounters a statement of the form:

<type>.<method>() (e.g. IEnumerable<int>.Where(…))

for which there is no explicitly defined method, it searches the current list of scoped namespaces for an extension method that matches the implied signature. The System.Linq namespace defines the extension method we’ve been examining above. However, what if we wanted to use our own method instead of the System.Linq version of Where()?

We might want to add in some logging statements when the predicate finds a match. Let’s do this right now by adding our own extension method for the IList<T> generic. To do this we need to define a static class that contains a static Where method that has this IList<T> as its first parameter:

public static class ListExtensions
{
    public static IEnumerable<T> Where<T>(
        this IList<T> source, Func<T, bool> predicate)
    {
        foreach (T t in source)
        {
            if (predicate.Invoke(t) == true)
            {
                Console.WriteLine(
                    String.Format("Predicate indicated success for value: {0}", t));
                yield return t;
            }
        }
    }
}

This method is almost identical to the theoretical version of Where we built above. The only differences are that it extends IList<T> instead of IEnumerable<T> and that it logs when the predicate finds a match prior to yielding the matched item.

Now let’s put together a little snippet that will exercise this extension method. We can actually use the first sample we used in this post and by simply adding ToList() to the end of Enumerable.Range(1,9) we’ll be calling our extension method for Where() instead of the built-in System.Linq version. Let’s look at that sample:

from num in Enumerable.Range(1,9).ToList()
where num % 2 == 0
select num

By simply adding the ToList() to the sample above we’ve caused the compiler to call our new Where() method. This gives a pretty clear idea of how LINQ is working internally and what’s actually going on when we use the new C# 3.0 language keywords. There is a lot less voodoo involved in the process that one might first believe!

Example Listing
The following is a complete example suitable for pasting into snippet compiler:

using System;
using System.Collections.Generic;
using System.Linq;

public class MyClass
{
    public static void RunSnippet()
    {
        Console.WriteLine("Results using the IEnumerable<T>.Where() method from System.Linq.");
        var enumResults =
            from n in Enumerable.Range(1,9)
            where n % 2 == 0
            select n;
        foreach (int n in enumResults)
            Console.WriteLine(n);

        Console.WriteLine("Results using the custom IList<T>.Where() method from this sample.");
        var listResults =
            from n in Enumerable.Range(1,9).ToList()
            where n % 2 == 0
            select n;
        foreach (int n in listResults)
            Console.WriteLine(n);
    }

    #region Helper methods

    public static void Main()
    {
        try
        {
            RunSnippet();
        }
        catch (Exception e)
        {
            string error = string.Format("---\nThe following error occurred while executing the snippet:\n{0}\n---", e.ToString());
            Console.WriteLine(error);
        }
        finally
        {
            Console.Write("Press any key to continue...");
            Console.ReadKey();
        }
    }

    private static void WL(object text, params object[] args)
    {
        Console.WriteLine(text.ToString(), args);
    }

    private static void RL()
    {
        Console.ReadLine();
    }

    private static void Break()
    {
        System.Diagnostics.Debugger.Break();
    }

#endregion
}

public static class ListExtensions
{
    public static IEnumerable<T> Where<T>(this IList<T> source, Func<T, bool> predicate)
    {
        foreach (T t in source)
        {
            if (predicate.Invoke(t) == true)
            {
                Console.WriteLine(String.Format("Predicate indicated success for value: {0}", t));
                yield return t;
            }
        }
    }
}

Bluetooth Retro Handset

Stuart Thompson — Thu, 10 Jul 2008 19:45:19 GMT

Here’s one for all the folks who had a hard time letting go of “the way things used to be”:

ThinkGeek Bluetooth Retro Handset

Deeper Project Visibility - with NDepend

Stuart Thompson — Thu, 10 Jul 2008 18:21:54 GMT

Software projects, by nature, have a propensity for getting out of hand. No matter how tightly we adhere to our carefully crafted development processes, despite diligent and methodical software designing and refactoring, the elusive software project always seems to manage to get away from us and mask its true nature from our prying eyes. Something close to a bajillion dollars has probably already been spent in attempts to tame the software project and convince it to open up and reveal its inner secrets and with increasing success. It has certainly been my experience that the software projects I’ve worked on in the last five years are much more transparent than they were fifteen years ago. This is in no small part due to the fact that I am no longer a teenager banging out Win32 applications in Borland C++, stumbling my way through APIs until an acceptable solution to the problem in hand somehow occurred. However, the view that software projects are becoming increasingly transparent is also shared by my peers. The general consensus is that the tools and development environments have played a significant role in this, a significantly larger role than the maturity or structure of the code being developed.

This is the key observation that I have made in thinking about the problem of software project wrangling. Despite advancement in the languages, environments, and tool-set, the code itself doesn’t seem to have become significantly more transparent. Bear in mind also that I am not describing the “API of complete awesomeness” that represents years of careful labor and also accounts for about 0.1% of the code developed each year. I’m talking about the other 99.9% of “copy/paste/tweak/pray” code that represents the bulk of what you and I will be maintaining, supporting, and extending for a notable portion of your software development career. Given this (rather lofty, sweeping, and completely personal-opinion-based) assumption, thought moves again to the area in which our wrangling efforts have advanced: the tools. If we can’t get people to architect more elegant solutions, perhaps we can find less painful ways to pry open Pandora’s box and examine the gifts our coding predecessors have left for us.

One tool in my arsenal for this task is NDepend. Tools and development styles will always be very personal. There are tools that I use for which others find no benefit and similarly there are those tools that have been recommended to me that just don’t seem to do what I need. However, I can highly recommend that any developer at least evaluate NDepend for their own use as it brings a rather unique perspective to the problem of analyzing even the most elusive of software projects.

What does NDepend do?
Arguably one of the most important questions to ask when evaluating any new piece of software is what it does. Put simply, NDepend analyzes your project and tells you stuff about it that might otherwise be difficult to discover. It breaks down a software project into its most basic components and then lets you query and visualize the sum of those components in extremely powerful ways. NDepend provides a wide variety of features for software analysis but undoubtedly the majority of its value lies in the power of CQL. The Code Query Language is not unlike traditional T-SQL in both syntax and the type of problem it is trying to solve. However, where SQL is designed to query data stores, the CQL language is designed to query software project information. This has several applications from code navigation and searching to coding quality evaluation and a whole host of standards metrics calculations.

In short, NDepend provides an incredible amount of information about how your project is glued together and how every field, method, type, and assembly is structured as well as how each of those elements relates to one another. When you first run NDepend upon a solution or set of assemblies, the amount of information that is presented can feel a little overwhelming. However, as you start to present small problems for NDepend to solve it quickly becomes clear why all of this information is very necessary.

Where do I start?
The best way to start working with NDepend is to point it at an existing set of assemblies and run an analysis. Then we can start to pick through the individual parts of the analysis and start to benefit from the information that is presented. For this purpose I have down-loaded the source code for an open source project called NArrange. This provides a nice publicly available solution on which to test NDepend such that the samples in this article can easily be reproduced.

NOTE: I also recommend viewing the video tutorials on the NDepend web-site. The getting started tutorial covers a lot of the information I present here in much more detail (and very probably with higher accuracy). The getting started tutorial video is located here.

Step 1 – Download and Install NDepend Trial
You can download a trial version of NDepend here.

Step 2 – Analyzing a Solution
First make sure that you build your solution, either using Visual Studio or via MSBuild or another tool. NDepend analyses a set of assemblies rather than a project or solution.

From the NDepend start page, select “Analyze: a set of .NET assemblies”. This will display a file selection dialog which we will use to browse to the NArrange libraries. I navigated to the NArrange.Tests.ConsoleApplication bin/Debug directory as this contains many of the solution assemblies that we wish to analyze. Once we have selected a set of assemblies, NDepend will being to run its initial analysis. This should take about 30 to 60 seconds depending upon system load and performance.

Once the analysis has completed, NDepend will display the current project in its main window as well as opening a browser that contains a full analysis report.

There is a tremendous amount of information in this report and it will take a while to become familiar with all of the data that is being presented. To that end we will look at each of the sections in turn and adopt a step by step approach to understanding why this information is useful.

Analyzing the Analysis
Let’s first look at the project map (or VisualNDepend View). If you close the browser that contains the NDepend Report you’ll see that the NDepend gui has been updated. At the top is a section containing this view.

This looks a little like a topographical analysis of the moon with yellow writing on it. In truth this is a lot like a lunar map except instead of showing the peaks and troughs of the moon’s surface it is showing the topography of our project. The NArrange solution is split into several different projects, each of which compiles into an individual assembly. The thin yellow lines separating sections of the map represent the boundaries between these assemblies. Each of the little gray circles that fill in those yellow squares represents a group of code within that assembly. In essence you are looking at the project as though it were arranged into states and counties. Each county represents a type whereas each state represents an assembly that contains several of those types. You can run your mouse over the project map and see that each gray area will turn red as you mouse over it. Additionally, the name that gray area represents is displayed. The purpose of this project map is to give you a visualization of the layout of the whole solution. It also plays into a lot of the deeper analysis functions that NDepend has to offer and becomes a center-point for visualizing the location of code in the project.

Start by clicking on one of the gray areas. Note how the class browser window to the left is updated when an area is clicked. This allows you to navigate your code visually while seeing the familiar class browser tree-view for the selected code element. Alternatively you can click on a method or type in the class browser and see the visual view update by highlighting the appropriate area of the map. Selecting an assembly in the class browser will highlight that entire assembly in the visual view pane. The class browser gives a very zoomed in perspective of your project, whereas the visual view gives a fully zoomed out view of how a particular element relates to the other elements in the full solution. I find a combination of the two to be a very powerful and expedient way to navigate a solution.

Abstractness vs Instability
Lets open the report that was generated after the initial analysis again. To do this we can click the button at the top of the Home ribbon.

The set of links at the top of the report allow you to navigate the report contents. Click the Assemblies Abstractness vs. Instability link to be taken to a graph that pinpoints this information for each assembly that was analyzed. This graph contains two major zones of pain and uselessness, leaving a sweet spot in the middle. Assemblies that are both abstract and unstable live at the top-right of the graph, in the zone of uselessness. This is to indicate that pairing abstractness with instability serves little purpose. Assemblies in the bottom-left of the graph are very stable and tightly concrete. This can lead to significant pain when they are maintained or extended as they are so tightly coupled and interwoven that making even small changes can require significant effort. The sweet spot in the middle represents the correct balance between abstraction and stability. This can be a good visual aid when learning new code or revisiting code you haven’t touched for a long time. The pain points and potential pitfalls are identified quickly.

In this graph we can see that the NArrange assemblies are sitting firmly in the green zone. The NArrange.Core assembly is the most abstract of the bunch but is also just stable enough to balance that level of abstraction. It is expected that most test assemblies will cluster in the bottom right area of the graph, which is not a bad place to be. Most test assemblies are fairly unstable and employ no abstraction as they are intended only for the purpose of testing a single type or set of known methods.

Additional Resources
This very brief overview was intended to scratch the surface of NDepend and give a feel for what this tool is trying to accomplish. I’m working on more articles around the excellent CQL language and deeper features of NDepend. These articles will be the basis of a training for some brown bags as well as the source material for more blog posts on this topic. Meanwhile, here are some resources that are other great starting points for learning more about this great tool.

Stuart Celarier put together an excellent cheat sheet for NDepend that can be found here. This is one of those sheets you just want to print out, laminate and either hang on the wall or find a place on your desk, perhaps even as a mouse mat.

The NDepend website contains a great series of videos and articles to help get started.

Other than that, one of the best ways to learn the tool is to simply install it and then start poking around with the analysis and learning by using. Analyze your current project assemblies and then start navigating using the NDepend interface. Play with some of the CQL queries (it will make reading future articles on CQL simpler because you’ll be more familiar). Make sure to install the VisualStudio and Reflector addons as these make full circle integration a part of your life. Other than that, I look forward to putting together my next NDepend article on using CQL to really understand and learn about how your code is put together and where it can be improved.

HttpRequest

Stuart Thompson — Wed, 09 Jul 2008 18:21:20 GMT

Have you ever wondered how an HttpRequest ends up returning a particular header code such as 500 Internal Server Error or 401 Unauthorized? This handy chart walks you through the entire request flow:

HttpRequest Flow Diagram - (Courtesy Thoughtpad)

I think I’m going to print this out and hang it on the wall.

New Array of Anonymous Objects

Stuart Thompson — Wed, 09 Jul 2008 18:08:57 GMT

While coding up a couple of prototype LINQ queries this morning I came across a rather interesting syntax using anonymous types and object initializers. I wanted to show an example of using a where clause upon a property of an object but didn’t want to put a bunch of plumbing around it just to set up the example. In my head an array containing three Person objects would suffice, with each person object having Name and Age properties that I could use in my query. I wasn’t sure if this would compile but dropped it into the wonderful LinqPad and sure enough found that it compiled right away, giving me exactly the results I was looking for.

from person in new [] {
    new { Name="Bob", Age=28 },
    new { Name="Ted", Age=22 }
    new { Name="Sally", Age=25 } }
where person.Age < 26
select person

I can declare a new [] { <set of anonymous types> } right there in the query, saving me the job of creating all of the plumbing around it just for the sake of the sample. Cool!

Snippet Compiler

Stuart Thompson — Mon, 07 Jul 2008 19:24:31 GMT

If you haven't used Snippet Compiler before, I highly recommend you take the 60 seconds necessary to download and evaluate it. If you're anything like me it will instantly become an indispensable part of your development toolbox. I've been using Snippet Compiler for over three years now and can't imagine development life without it.

You can download Snippet Compiler here.

For those skeptics out there who would prefer to know what they are downloading first, just imagine a tool where you could type out snippets of C# to test a certain idea and have it compile into a simple wrapper app that executes your snippet. Every time you've created a throw away web application or web form to test out a certain idea you've experienced a need for Snippet Compiler. It does the framework piece for you so that you can do that test with try catch finally you've always wanted the answer to. :)