Here is the problem, as I see it:  as an MVC project gets large, keeping all of the necessary pieces and parts for a set of controller actions straight can get a bit daunting.  I’ve ended up with duplicate folder structures in views and models, which can make navigation a pain.

To make a new Area, simply right-click anywhere in you MVC project, Add->Area.  As I said, you can do this from anywhere in the project structure, but the Areas are created in a new “Areas” folder.  When you name the Area, a new folder is created with the Areas name as well.

Once created you should see all the familiar Controllers, Models, and Views folders (all blank).  In addition to that, you will see an <name>AreaRegistration.cs file.  This inherits from AreaRegistration, and this is where any new Routes go.  In the file is a prebuilt route that should look similar to this:

   1: context.MapRoute(

   2:     "test1_default",

   3:     "test1/{controller}/{action}/{id}",

   4:     new { action = "Index", id = UrlParameter.Optional }

   5: );

So a url to the area would include /test1/ (name of my Area) in the path.  That would be good if you had multiple controllers with the same name, but if you don’t, just take out the “test1” and you won’t need it in the path.

Also, if you leave Area name in the route, you will have a little more work to, here is what one of mine looked like:  <%=Html.ActionLink("test", "Index", "test1/TestArea") %>.  But it turns out this is more correct:

<%=Html.ActionLink("test", "Index", "TestArea", new { area="Test1"}, new {}) %>

This also mean that any controller actions you want to link to outside if Area needs to include a blank area in the link, like this:

<%=Html.ActionLink("Home", "Index", "Home", new { area=""}, new {}) %>

In case you are wondering, the first object in the area is for route values, the second is for html attributes.

So the downside of using Areas is that you could complicate your routing in a hurry.  Plus it does not look like the Html helpers are there to lend you a hand either.  It is very doable, just annoying.  Of course, the easy fix is to remove the Area name from the route and move on.  That should be ok so long as you do not have two controllers with the same name.

So are Areas a compelling feature? I think so.  Plus, the larger the site, the more compelling Areas can become.  For smaller sites, probably not.  But I would not say no either.

One of the long-standing MVC practices has been ‘Shun Magic Strings.’  For example, rather than specifying Controller/Action names in an ActionLink by string, we’ve always used an Expression<Action<TController>> instead to define the Controller class and Action method “in code.”  If the action changes in the future, this gives you somewhat better abilities to discover the problem sooner vs. later. 

MvcFutures includes a version of this idea, taken to the next level:  you provide the expression with the arguments you want passed to the action included – you don’t provide a 2nd anonymous type defining the arguments.  This gets rid of the somewhat confusing “null” arguments inside the expression, and just looks better overall.  Plus, if the arguments to the action change, you’ll get better warning of that as well.

<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">    <h2>Magic Strings are Evil</h2>    <p>        <%= Html.ActionLink<HomeController>(c => c.FavoriteNumber(16), "A Number") %>        <%= Html.ActionLink<HomeController>(c => c.FavoriteNumber(32), "Another Number") %>        <%= Html.ActionLink<HomeController>(c => c.FavoriteNumber(42), "Yet Another Number") %>            </p></asp:Content>

I like this method MUCH better. 

The implementation that makes this happen is in Microsoft.Web.Mvc.Internal.ExpressionHelper.  Which even though it’s in an “Internal” namespace, is neither marked Internal, Sealed, or otherwise made unavailable (hallelujah).  So you can use this trick for all sorts of things.

There is also a System.Web.Mvc.ExpressionHelper in the official MVC assembly, which is used to implement the smart Html.TextBoxFor(m => m.Property) functionality.  This class is also NOT internal, not sealed, not obfuscated and hidden away.  We’ve used it to extend the Html.[control]For() abilities to some other control types.  Very useful stuff.  Plus its just interesting code to read.

One potentially big caveat:  I’m told that the Html.ActionLink<TController>() methods don’t work if you’re using Areas in your MVC application.  I haven’t tried this myself, we aren’t using Areas in any of our MVC 2 applications yet.  That might be why this functionality is hidden in MvcFutures and not out with the rest of the smart expression code.

<UserControl.Resources>

    <Style x:Key="myButtonStyle" TargetType="Button">

        <Setter Property="Background" Value="Blue" />

        <Setter Property="Foreground" Value="Green" />

        <Setter Property="FontSize" Value="24" />

    </Style>

</UserControl.Resources>

Then, you have to set the Style property on the Button control you want to apply the style to:

<Button Content="Button 1" Style="{StaticResource myButtonStyle}" />

Now, what if I want to apply that same style to every button in my application?  Well I would have to go and find every single button in my application and set the Style property accordingly.

<Button Content="Button 1" Style="{StaticResource myButtonStyle}" />

<Button Content="Button 2" Style="{StaticResource myButtonStyle}" />

<Button Content="Button 3" Style="{StaticResource myButtonStyle}" />

How many buttons are in your application?  What a pain in the you know what.  Well not anymore.  New in Silverlight 4 will be the ability to set your styles implicitly.  What does this mean?  It means that you can now declare your style, give it a TargetType, and exclude the x:Key; then it will apply that style to any instance of the TargetType control type.

<UserControl.Resources>

    <Style TargetType="Button">

        <Setter Property="Background" Value="Blue" />

        <Setter Property="Foreground" Value="Green" />

        <Setter Property="FontSize" Value="24" />

    </Style>

</UserControl.Resources>

<Grid x:Name="LayoutRoot">

    <StackPanel>

        <Button Content="Button 1" />

        <Button Content="Button 2" />

        <Button Content="Button 3" />

    </StackPanel>

</Grid>

Notice that I don’t need to set the Style property on my button controls individually anymore.

Well what if I have a style that I want to implicitly use, but I have this one special button that I want to give a different style?  Well in that case, just create a new Style and give it a x:Key, then set the Style property on your control.

<Style x:Key="myOtherButtonStyle" TargetType="Button">

   <Setter Property="Background" Value="Orange" />

   <Setter Property="Foreground" Value="Red" />

   <Setter Property="FontSize" Value="12" />

</Style>

<Button Content="Button 1" />

<Button Content="Button 2" Style="{StaticResource myOtherButtonStyle}" />

<Button Content="Button 3" />

Now, your special button will use your new style, and all others will remain themed.

Sneak Peek: Silverlight Application Themes

Tim Heuer has recently given us a preview of three new theme packs coming to Silverlight.

“GrayScale”

“Windows Theme”

“Metro”

Thanks Tim!

Well, this is much easier than you may think and I will show you how to accomplish this with just a few simple helper methods, and you can use any grid of your choice.  For this example, I will be using the DataGrid that comes with the Silverlight Toolkit. Make sure you download and install it, because I am not including the System.Windows.Controls.Data assembly required for the DataGrid.

It will be located at c:\Program Files\Microsoft SDKs\Silverlight\v3.0\Libraries\Client\System.Windows.Controls.Data.dll

In my scenario I am building a staffing application and I have a “StaffMember” object that has a collection of “Period” objects as a child property.  My objects look something like this:

public class StaffMember

{

    public string Name { get; set; }

    public string Department { get; set; }

    public ObservableCollection<Period> Periods { get; set; }

}

public class Period

{

    public string Title { get; set; }

    public int Hours { get; set; }

}

Pretty simple!  now, lets create our DataGrid that will show our data for editing.

<UserControl x:Class="SilverlightApplication1.MainPage"

             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

             xmlns:grid="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"

             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 

             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 

             mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="480">

    <Grid x:Name="LayoutRoot">

        <grid:DataGrid x:Name="dataGrid"/>

    </Grid>

</UserControl>

Okay, now I don’t know how many Periods my StaffMember will have until I get the data back from the database at run time.  For demonstration purposes, I just created a method on my StaffMember class that would create my objects by iterating through a loop.

public static List<StaffMember> GetData()

{

    List<StaffMember> dataList = new List<StaffMember>();

    for (int i = 0; i < 3; i++)

    {

        StaffMember member = new StaffMember { Name = String.Format("Name#{0}", i), Department = String.Format("Department#{0}", i) };

        ObservableCollection<Period> periods = new ObservableCollection<Period>();

        for (int j = 0; j < 5; j++)

            periods.Add(new Period() { Title = String.Format("Period#{0}-{1}", i, j), Hours = j });

        member.Periods = periods;

        dataList.Add(member);

    }

    return dataList;

}

Now, we need to set the datasource on the DataGrid.  Since we are creating the columns at runtime make sure you set AutoGenerateColumns to false;

List<StaffMember> dataList = StaffMember.GetData();

dataGrid.AutoGenerateColumns = false;

dataGrid.ItemsSource = dataList;

dataGrid.Columns.Clear();

Next, lets take care of creating the easy columns first.  I created a method that its’ sole purpose is to give me new DataGridTextColumns.

private static DataGridTextColumn CreateTextColumn(string fieldName, string title)

{

    DataGridTextColumn column = new DataGridTextColumn();

    column.Header = title;

    column.Binding = new System.Windows.Data.Binding(fieldName);

    return column;

}

Using this method we can create our first two columns.

dataGrid.Columns.Add(CreateTextColumn("Name", "Staff Name"));

dataGrid.Columns.Add(CreateTextColumn("Department", "Company Department"));

Your DataGrid should now look something like this.

Now we need to create our columns based off the Periods collection.  To do this we will utilize a DataGridTemplateColumn.  The first thing we need to do is create a method that will dynamically create a DataTemplate that the DataGridTemplateColumn will use as the CellTemplate.

private string CreateColumnTemplate(int index, string propertyName)

{

    StringBuilder CellTemp = new StringBuilder();

    CellTemp.Append("<DataTemplate ");

    CellTemp.Append("xmlns='http://schemas.microsoft.com/winfx/");

    CellTemp.Append("2006/xaml/presentation' ");

    CellTemp.Append("xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>");

    CellTemp.Append(String.Format("<TextBlock Text='{{Binding Periods[{0}].{1}}}'/>", index, propertyName));

    CellTemp.Append("</DataTemplate>");

    return CellTemp.ToString();

}

What I am doing here is using a StringBuilder to create a DataTemplate, represented by XAML.  Pay special attention to the TextBlock’s binding.  I am using String.Format to create my binding string base off the index the of the object in the collection and the name of the property on the child object I want to bind to.  Now, lets create our template that will be used for editing.

private string CreateColumnEditTemplate(int index, string propertyName)

{

    StringBuilder CellTemp = new StringBuilder();

    CellTemp.Append("<DataTemplate ");

    CellTemp.Append("xmlns='http://schemas.microsoft.com/winfx/");

    CellTemp.Append("2006/xaml/presentation' ");

    CellTemp.Append("xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>");

    CellTemp.Append(String.Format("<TextBox Text='{{Binding Periods[{0}].{1}, Mode=TwoWay}}'/>", index, propertyName));

    CellTemp.Append("</DataTemplate>");

    return CellTemp.ToString();

}

This method is very similar to the previous one we wrote, but notice the subtle difference; I am using a TextBox instead of a TextBlock, and the Mode is set to TwoWay.  This will allow us to edit the values in the DataGrid.  Now we need a method that will actually create the TemplateColumns.

private DataGridTemplateColumn CreateTemplateColumn(int i, string propName)

{

    DataGridTemplateColumn column = new DataGridTemplateColumn();

    column.Header = String.Format("Period#{0}.{1}", i, propName);

    column.CellTemplate = (DataTemplate)XamlReader.Load(CreateColumnTemplate(i, propName)); //display template

    column.CellEditingTemplate = (DataTemplate)XamlReader.Load(CreateColumnEditTemplate(i, propName)); //edit template

    return column;

}

Notice that we are setting the CellTemplate and CellEditTemplate by using the XamlReader to load our StringBuilder result and cast it as a legitimate DataTemplate the column can use.  Now that we have the method that will create our TemplateColumns, lets go ahead and build our dynamic columns to the n-level.  We do this by looping though the number of columns that need to be created and using our CreateTemplateColumn method to add the new columns to the DataGrid.

int periodCount = dataList[0].Periods.Count;

for (int i = 0; i < periodCount; i++)

{

   dataGrid.Columns.Add(CreateTemplateColumn(i, "Hours"));

}

Now of course, in the real world you would not want to use the first index of the child collection to figure out how many columns to build.  I would recommend some kind of definition object that will define what columns and how many columns to build.

That is it.  You have now successfully satisfied your customer’s addiction to Excel.  Well, at least a little bit.

Download Source

So, I started thinking to myself, that the real purpose behind Text-To-Speech isn’t just the cool factor, but it is accessibility for impaired users.  I have been doing web development for nearly a decade, and I have always been conscious about web users with impairments that may make viewing or navigating my websites more difficult.  Text-To-Speech isn’t very helpful if it will only work in a fully trusted out of browser Silverlight 4 application on a Windows machine. So instead, lets create a Text-To-Speech solution that will work inside the browser, on any browser, on any machine.  And heck, I want this to be in Silverlight 3.

Lets get started by creating a new Silverlight 3 application, and be sure to include a web project as well.

Right click the web project and add a reference to the System.Speech.dll.

Next, lets right click the web project and click Properties –> Web and set the specific port number to your liking, I set mine to 1914. This will come in handy when we create our WCF service.

Now we need to create the WCF service that will take our text and send it back as a WAV stream, so go ahead and right click the web project and select “Add New Item”.  From this list add a new WCF service and name is SpeechService.  Now this is important; when you have created your WCF service an endpoint is created for you in the Web.config file.  You need to change the binding of the endpoint to basicHttpBinding.  Silverlight only works using basicHttpBinding, and will not create the ServiceReferences.ClientConfig file properly if you do not do this.

Now, lets add an OperationCOntract to your WCF services interface called Speak that returns a byte[], and takes a string parameter.

[ServiceContract]

public interface ISpeechService

{

    [OperationContract]

    byte[] Speak(string textToSay);

}

The implementation of this method will look like the following:

public byte[] Speak(string textToSay)

{

    SpeechSynthesizer ss = new SpeechSynthesizer();

    MemoryStream ms = new MemoryStream();

    ss.SetOutputToWaveStream(ms);

    ss.Speak(textToSay);

    return ms.ToArray();

}

The next thing we need to do is create our UI in Silverlight.  Here is what mine looks like.

<Grid x:Name="LayoutRoot">

<StackPanel>

    <TextBox x:Name="_txtTextToSay" />

    <Button Content="Speak To Me" Click="Button_Click" />

    <MediaElement x:Name="_audioPlayer"/>

</StackPanel>

</Grid>

Create an event handler for your button.  Next add a service reference to your SpeechService in your web project.

The next part is somewhat complicated and time consuming.  You have to write your own WAVV decoding class that takes the byte array that is return from the service and converts it to a System.Windows.Media.MediaStreamSource. Luckily for you, I already did this for you with the help of some resources on MSDN.  In the button’s event handler add this code:

private void Button_Click(object sender, RoutedEventArgs e)

{

    SpeechServiceClient client = new SpeechServiceClient("BasicHttpBinding_ISpeechService");

    client.SpeakCompleted += (o, ea) =>

        {

            WavMediaStreamSource audioStream = new WavMediaStreamSource(new MemoryStream(ea.Result));

            _audioPlayer.SetSource(audioStream);

        };

    client.SpeakAsync(_txtTextToSay.Text);

}

Basically what this does is uses the WavMediaStreamSource class I created that inherits from MediaStreamSource, takes the byte[] returned from the SpeechService and converts it back to a stream, then is passes it off to my WAV decoding classes, which is used as the source for the MediaElement responsible for playing the audio.

All that is next is to build your solution and start making your Silverlight applications more accessible.

Download the Source

I thought creating a custom pre-loader was common knowledge, but I guess I was wrong. So, what is a custom pre-loader really? Well, it is a small and lightweight Silverlight application that runs while your main Silverlight application is being downloaded to the client. Creating your own is really easy and only involves a few basic steps.

The first thing we need to do is add a Silverlight JavaScript  page to the Web project of your Silverlight application. So just right click your Web project and click add new item, then select Silverlight JScript Page.

You can name it whatever you want. I named my SplashScreen.xaml. When you click “Add” you will notice two files were created for you; a XAML file and a JavaScript file.

The XAML file is where you will create your pre-loader UI. So lets create a simple UI.

<Canvas        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"        x:Name="parentCanvas"        Width="850"        Height="600"        Background="OldLace"        >  <Canvas Canvas.Top="228.834" Canvas.Left="246.329" Width="357" Height="31.379">    <Rectangle Width="27.545" Height="1" x:Name="uxProgress" Canvas.Top="29.545" Canvas.Left="1.4">      <Rectangle.RenderTransform>        <TransformGroup>          <ScaleTransform x:Name="uxProgressBar" ScaleX="1" ScaleY="0"/>          <SkewTransform AngleX="0" AngleY="0"/>          <RotateTransform Angle="270"/>          <TranslateTransform X="0" Y="0"/>        </TransformGroup>      </Rectangle.RenderTransform>      <Rectangle.Fill>        <LinearGradientBrush EndPoint="1,0.5" StartPoint="0,0.5">          <GradientStop Color="#FFFFFFFF" Offset="1"/>          <GradientStop Color="#FFFFFFFF" Offset="0"/>          <GradientStop Color="#FF2975D0" Offset="0.28"/>          <GradientStop Color="#FF2975D0" Offset="0.72"/>        </LinearGradientBrush>      </Rectangle.Fill>    </Rectangle>

    <TextBlock x:Name="uxStatus" Height="25" Canvas.Left="125" Text="Loading..." TextWrapping="Wrap" Canvas.Top="4.16"/>

    <Path Width="356.85" Height="1" Fill="#FF3A3A3A" Stretch="Fill" Stroke="#FF000000" Canvas.Top="0" Data="M0,170.5 L356.84209,170.5" Opacity="0.35"/>    <Path Width="1.662" Height="29.03" Fill="#FF3A3A3A" Stretch="Fill" Stroke="#FF000000" Canvas.Top="0.48" Canvas.Left="0.2" Data="M360,168 L360,0" Opacity="0.35" />

    <Path Width="357.84" Height="1" Fill="#FF3A3A3A" Stretch="Fill" Stroke="#FF000000" Canvas.Top="29" Data="M0,170.5 L356.84209,170.5" Opacity="0.35"/>    <Path Width="358.85" Height="1" Fill="#FFA2A2A2" Stretch="Fill" Stroke="#FF000000" Canvas.Top="30" Data="M0,170.5 L356.84209,170.5" Opacity="0.25"/>    <Path Width="1.662" Height="30" Fill="#FF3A3A3A" Stretch="Fill" Stroke="#FF000000" Canvas.Left="356.01" Data="M360,168 L360,0" Opacity="0.35" Canvas.Top="-0.498"/>    <Path Width="1" Height="31" Fill="#FFA2A2A2" Stretch="Fill" Stroke="#FF000000" Canvas.Left="357.333" Data="M360,168 L360,0" Opacity="0.245" Canvas.Top="-0.498" />  </Canvas></Canvas>

I actually copied this XAML from MSDN because I was to lazy to write my own.

The JavaScript file is where you will interact with you pre-loader.  To do this there are three properties that are exposed by the Silverlight plug-in:

1. splashscreensource: The URI of a XAML page that displays while the primary package (source) is being downloaded.
2. onsourcedownloadprogresschanged: References a JavaScript event handler that will be invoked continuously while the source is being downloaded.
3. onsourcedownloadcomplete: References a JavaScript event handler that will be invoked once, when the source download is complete.

Enter Params:

You will need to add two Object Params to your page hosting the Silverlight application.

<param name="splashscreensource" value="SplashScreen.xaml"/><param name="onSourceDownloadProgressChanged" value="onSourceDownloadProgressChanged" />

The first one tells the host where to find the custom XAML file you created. The second one tells it which JavaScript function to execute when the sourceDownloadProgressChanged event fires.

So go ahead and open up your JavaScript file and delete all the code that is in there and replace it with this:

function onSourceDownloadProgressChanged(sender, eventArgs) {    sender.findName("uxStatus").Text = "Loading: " + Math.round((eventArgs.progress * 1000)) / 10 + "%";    sender.findName("uxProgressBar").ScaleY = eventArgs.progress * 356;}

The next step is very important. Make sure you add your JavaScript file into the head tag of your hosting page.

<script type="text/javascript" src="splashscreen.js"></script>

Now in order to test this thing, you need to add something very big to your main Silverlight application, set its Build Action to Content, and set Copy to Output Directory to Copy if newer.  I added a video file that was about 100MB in size. Now run your application.

And there is our custom pre-loader.

For more information on creating custom pre-loaders visit http://msdn.microsoft.com/en-us/library/cc838130(VS.95).aspx

Download the Source

With all of the competing technologies for content embedding and resource sharing on the web it can be difficult to determine which options to use.  Have you ever wished that you could embed YouTube videos and Flickr photos into your site just by knowing the consumer friendly URLi’s to them?  That is exactly what oEmbed provides.  I would like to introduce you to the basics of the specification.  I hope the simplicity encourages you to support it as a provider and as a consumer when embedding resources from other providers.  Many popular sites already support it!

oEmbed is a format for allowing an embedded representation of a URL on third party sites. The simple API allows a website to display embedded content (such as photos or videos) when a user posts a link to that resource, without having to parse the resource directly.

Lets take a look at each side of a provider and consumer scenario to illustrate how oEmbed provides and elegant solution for each.

Providers must specify one or more URL scheme and API endpoint pairs. The URL scheme describes which URLs provided by the service may have an embedded representation.

The publisher must determine what scheme(s) they support in very basic format.  Typically the scheme matches URLs that consumers would browse resources at normally.  The YouTube API, for example, supports URLs matching the scheme http://*.youtube.com/watch*

The API endpoint is simply an http URL at which consumers request oEmbed representations of the resources you provide.  Most of the current providers offer API endpoints with obvious URL’s like http://www.youtube.com/oembed and http://www.flickr.com/services/oembed/.

Once you have the endpoint you just need to host a service there that accepts 4 specific query parameters:

url : The urlencoded url that matches a supported provider defined scheme.
maxwidth : (optional) The maximum width you want for embedding the resource.
maxheight : (optional) The maximum height you want for embedding the resource.
format: (optional) xml or json are the possible values that determine the consumers desired response Content-Type.

Requests sent to the API endpoint must be HTTP GET requests, with all arguments sent as query parameters. All arguments must be urlencoded (as per RFC 1738).

oEmbed consumers make requests for the oEmbed representation of a resource by sending a basic GET request to an API endpoint with url query parameters and any optional parameters they choose.

A request to http://www.youtube.com/oembed?url=http%3A//www.youtube.com/watch?v%3D6lbDyXu7gUQ results in a json response:

{
"provider_url": "http://www.youtube.com/",
"title": "Insert a YouTube Video With oEmbed Wordpress 2.9",
"html": "<object width=\"480\" height=\"295\">
    <param name=\"movie\" value=\"http://www.youtube.com/v/6lbDyXu7gUQ&fs=1\"></param>
    <param name=\"allowFullScreen\" value=\"true\"></param>
    <param name=\"allowscriptaccess\" value=\"always\"></param>
    <embed src=\"http://www.youtube.com/v/6lbDyXu7gUQ&fs=1\" type=\"application/x-shockwave-flash\"
        width=\"480\" height=\"295\" allowscriptaccess=\"always\" allowfullscreen=\"true\"></embed></object>",
"author_name": "adriarichards", "height": 295, "width": 480, "version": "1.0",
"author_url": "http://www.youtube.com/user/adriarichards",
"provider_name": "YouTube",
"type": "video"
}

Note the html property.  It contains everything you need to embed the video.  If this installation of WordPress was running version 2.9 I could paste a YouTube URL here and it would automatically get embeded as described in the video Insert a YouTube Video With oEmbed Wordpress 2.9

oEmbed supports 4 result types including video, photo, link and rich.  The rich type allows for just about any html to be returned and thus embedded.

Consumers may wish to load the HTML in an off-domain iframe to avoid XSS vulnerabilities.

To learn more and see a list of some current providers check it out at:

http://oembed.com/

And for a few more implementations check out http://oohembed.com/

I look forward to hearing how you end up using oEmbed!

I will never forget my first day at my first programming job. I was excited, eager, and happy to be there, feeling like I had finally made the big time. I thought, “I am going to get to be a real software developer,” and I was stoked beyond belief.

In the elevator on the way up to meet my new boss, I stood with an older, grizzled and tired looking man. I was chatty and excited, and tried to strike up a conversation. I told him it was my first day.

“F%@! you, new guy,” he said as the elevator doors opened and he strode off into the hallway. I was stunned. I stood there dumfounded long enough that the elevator doors began to close before I remembered to walk out.

Over time, I got to know Mr. Elevator. His real name was Adam and like so many people that we tend to make excuses for, I can tell you that Adam wasn’t so bad once you get to know him. In fact, after some time, Adam became something of a mentor to me technically and I worked alongside him learning a lot as I did so.

Professionalism Isn’t Just in Your Code

My introduction into the world of work and many subsequent experiences all conspired to teach me that acting like an a-hole was absolutely accepted in the subculture of software development. I struggled for years in other organizations when I carried those behaviors to other employers.

Over time, I learned not only is this ridiculous, but that this institutional acceptance of unprofessionalism has contributed significantly to the negative perception many people have of our profession. Tolerance of behavior like Adam’s is pervasive in our industry and is often dismissed as “Oh, those pesky developers”.

You want to turn IT from a cost to a value center in your organization? This is where you start. I learned a lot of terrible behaviors from Adam and it took years to replace them with new ones. The good news is that it can be done and the way to do so isn’t a big mystery.

It’s Like Learning a New DSL

I struggled for a long time before learning that soft skills are, in fact, skills. That means they can be taught, learned, dissected, studied, practiced, and honed. This was great news for me because unlike so many nuero-typicals I know, providing good feedback (as an example) doesn’t come naturally to me. People who share my tendencies toward autistic spectrum disorders often think that soft skills are a magical talent some people are born with. BTW: If you are reading this blog you have a good statistical chance of having at least mild Asperger’s Syndrome (it’s a super power).

Learning soft skills is like learning anything quantitative. For instance, you know how user stories have a little pattern? There are patterns to effective communication, too.

An Effective Feedback Pattern

1. May I give you some feedback?
2. Here is something you do well.
3. Here is an example of a behavior that could be improved.
4. Here is the negative effect of the behavior.
5. Express confidence in the person’s ability to improve.
6. What are your thoughts about this?

Example

Hey, Dave, may I give you some feedback?

Uh, sure.

You have some great development skills. Your OO skills are particularly good and it would be great if you could provide some design leadership to the team in helping them improve.

Being consistently late to the daily standup is hurting your effectiveness. When you are repeatedly late, it causes resentment in the team toward you. Ultimately, this undermines your own effectiveness as a leader.

I know you can do well at this if you choose to, but its up to you. What do you think about this?

It Actually Works

You may think this example is contrived and over-simplified. It isn’t. I have had this conversation and it really works. Books on the subject provide all kinds of reasons the formula works, but the bottom line is that there are patterns of human behavior and communication just like there are patterns of effective software development.

Now What?

If you care about any of this (and you likely wouldn’t have read this far if you didn’t) I think the best place to start is to do some reading about communication techniques. The cool part of this is that as you learn new techniques, you get chances to try them out on a daily basis, and not just at work. The world is a huge discovery spike for this kind of thing.

Here are some books I have found helpful.

• Emotional Intelligence
• Crucial Conversations
• The Art and Science of Negotiation
• Practices of an Agile Developer

When I see the MSpec code, I think about it being an internal DSL for doing the testing, and I start to think that perhaps it should just go ahead and be it’s own language instead of trying to live inside of C#. On the other hand, I wonder about the value of using another language to unit test C# code…

I think John was spot-on with his instinct – in my opinion, MSpec is an internal DSL.  I also think that is the beauty of the framework.  Domain-specific languages are meant to solve a target problem in a particular domain.  MSpec’s problem domain is testing .NET code.  By convention, it constrains you to its limited language to help you test your code in a meaningful yet powerful manner.

What is an Internal DSL?

According to Martin Fowler:

“Internal DSLs are particular ways of using a host language to give the host language the feel of a particular language…Internal DSLs are also referred to as embedded DSLs or FluentInterfaces”  (from Bliki article: Domain Specific Language)

“Internal DSLs use the same general purpose programming language that the wider application uses, but uses that language in a particular and limited style.”
(from DSL-WIP section: Using Domain Specific Languages)

But, as John wondered, is there value in using another language (external DSL) to test C# code?

Perhaps.  Yet, I believe there is more value in using external DSLs to test user interfaces (e.g., WatiR, WatiN, and Selenium), or for build scripting (e.g.,Rake, psake).

Let’s look at that question a little differently: Is there value in using an internal DSL (like MSpec) to test C# code?

To that I give a resounding YES! MSpec’s host language is C#…which provides great value to me.  I get all the benefits of intellisense, refactoring, and (R#) navigation in my IDE.  I don’t have to worry about the impedance mismatch between my code and an external DSL.

You Probably Use DSLs All the Time

In fact, I use several DSLs every day when I code.

Consider the following table of frameworks. You may not have thought any of these in the context of a domain-specific language, but each has a specific purpose with its own limited language constructs. Some are internal, some external.

When considering a framework within your host language: If the framework has a fluent interface with language devoted to a specific problem domain, it is probably an internal DSL.

So is MSpec an internal DSL? Yes.

And is that okay? Definitely.

Further Reading

Check out Martin Fowler’s articles on domain-specific languages:

http://www.martinfowler.com/bliki/DomainSpecificLanguage.html
http://martinfowler.com/dslwip/UsingDsls.html
http://martinfowler.com/dslwip/InternalOverview.html