The Untitled Blog

Fun With Data: SQL Server Unpivot

2009-11-05T21:49:00.001-05:00

My dad ran for a township trustee seat this past election, so I helped him organize some data he got from the Board of Elections. I massaged and finagled it into a SQL Server table in the format seen below:

This table has all registered voters for the township he was running in.

I started to wonder about the frequency that people vote. How many people voted 0/4 years, 1/4 years, 2/4 years, etc.:

Well, lucky for me I’m working with Paul Montgomery who happens to be a whiz at all things SQL Server and he gave me a hand.

The first step in solving this challenge is manipulating the data so each voter has one row per year voted. Paul pointed me to the UNPIVOT keyword. UNPIVOT rotates columns into rows:

select * from (
SELECT * FROM Voters) src
UNPIVOT (Voted FOR [Year] IN (Voted200905, Voted200811, Voted200803, Voted2007)) unpvt

This query gives me this result:

Now I can group by the voter’s ID and sum the times they voted.

SELECT VoterID, Years = SUM(CAST(Voted AS TINYINT)) FROM (
SELECT * FROM Voters.dbo.Voters) src
UNPIVOT (Voted FOR [Year] IN (Voted200905, Voted200811, Voted200803, Voted2007)) unpvt
GROUP BY VoterId

Now I just need to group by the “Years” column and I’ve got my result:

SELECT Years, count(1) as Voters FROM (
    SELECT VoterID, Years = SUM(CAST(Voted AS TINYINT))
        FROM (SELECT * FROM Voters.dbo.Voters) src
        UNPIVOT (Voted FOR [Year] IN (Voted200905, Voted200811, Voted200803, Voted2007)) unpvt
        GROUP BY voterId) voters
GROUP BY Years
ORDER BY Years

Only 355 of the 5091 registered voters (which already is a small subset of the population) voted in all 4 of the elections I had data for!

ASP.Net MVC Firestarter

2009-10-19T12:09:00.001-04:00

Tim Wingfield and I gave a talk on “Intro to ASP.Net MVC” in Cincinnati as part of the MVC Firestarter. Slides/code and everything else from each one of the talks has been posted to the CINNUG website.

If you had any questions you were burning to ask but didn’t have time, you know how to reach me.

An Opinion on Repository

2009-07-06T09:30:00.001-04:00

First, what is a repository?

…Therefore, use a Repository, the purpose of which is to
encapsulate all the logic needed to obtain object references. The
domain objects won’t have to deal with the infrastructure to get
the needed references to other objects of the domain. They will
just get them from the Repository and the model is regaining its
clarity and focus.

Excerpt from Domain Driven Design Quickly

So what the author is saying is that the repository’s (single) responsibility is to encapsulate the logic for obtaining object references. What that means to me is that the class utilizing the repository should be querying it in clear terms, such as:

_repository.GetPendingOrdersFor(customer);

This interface keeps the behavior of the method calling the repository focused on it’s job, and eliminates querying logic. Not only that, but the intention of the code is clear and even human(non-developer) readable.

The alternative is:

_respository.Query<Order>(o => o.CustomerID = customer.CustomerID && o.Status == OrderStatus.Pending);

Here’s how these options would look as an interface.

Just one man’s opinion. What do you think?

ASP.Net MVC: Intro To MVCContrib TestHelpers

2009-07-01T09:30:00.000-04:00

MVCContrib contains an assembly specifically built to provide help when unit testing ASP.Net MVC controller actions. This is a very condensed guide to what you can accomplish using each helper method.

Test View Rendering

Test that a view is being rendered from the action:

_controller.List().AssertViewRendered();

…for a particular view

_controller.List().AssertViewRendered().ForView("SomeViewName");

…with a view model of the correct type

_controller.List().AssertViewRendered().ForView("List").WithViewData<SomeType>();

Test PartialView Rendering

Test that a partial view is being rendered from the action:

_controller.ShowAsteroid().AssertPartialViewRendered();

…for a particular view

_controller.ShowAsteroid().AssertPartialViewRendered().ForView("Asteroid");

…with a view model of the correct type

_controller.ShowAsteroid().AssertPartialViewRendered().ForView("Asteroid").WithViewData<AsteroidModel>();

Test Redirects

Assert that the action redirects to the correct action:

_controller.AddFormStar().AssertActionRedirect().ToAction("List");

…for an action on a different controller:

_controller.AddFormStar().AssertActionRedirect().ToController("SomeController").ToAction("List");

Easily Stub HttpContext Variables

The TestHelper library contains a class (TestControllerBuilder) that builds up a complete context for your controller to operate within. This gives you the ability to easily mock anything that you would normally access from HttpContext. Here’s an example of usage:

The _builder variable is what contains all of the dictionaries for Session, ViewData, etc. that you can use to set up all of your stubs. Example:

The code in the ActionUnderTest method will now be able to access all of the variables just set up in the test. Couldn’t be easier!

Tip For Keeping ASP.Net MVC Views Easy To Read

2009-06-24T08:00:00.001-04:00

ASP.Net MVC views are harder to read when they’re built with a lot of escapes between script and HTML, such as:

There’s really just no good way to make that easy to read using this approach.

Using the MVC Futures Repeater Control

Server controls and MVC just don’t sound like they’d go together, but if used for good I believe they can really serve a useful purpose. The following code snippet achieves the exact same result as above, but reads much cleaner:

The MVC Futures repeater control gives me a way to display repeating data with a template. The control is “bound” to the Model.Items collection because I set the name of the repeater to “Items”.

To get a reference to this control you need to include a reference to the MVC Futures assembly in the web.config:

The complete solution with this code can be downloaded here:

Run Your Tests With A Keystroke

2009-06-22T08:00:00.000-04:00

Today I was looking for a way to run my unit tests with a keyboard shortcut. I got really tired of grabbing the mouse just to click a button (wow I’m lazy):

I knew there had to be a way to kick off a single test using ReSharper – and after a little digging I found the solution.

The magic lies in these 4 keyboard mappings. Assign them to something that makes sense to you, and enjoy the benefit of removing just a little more friction from your TDD experience.

Previous ReSharper keyboard shortcut tips:

Part 9 – Help When Yellow Screens Happen
Part 8 – Bird’s Eye View of Class Files
Part 7 – Add New Files Quickly
Part 6 - Move Extracted Interfaces to Their Own File using ReSharper
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

Resharper Help When Yellow Screens Happen

2009-06-18T08:00:00.001-04:00

Ran across a great utility in Resharper to help with code navigation. It comes in particularly handy when you come across one of these:

To get your app back to working order, Resharper will analyze the stack trace and then show hyperlinks so you can jump into the code that dealt the problem. Here’s how:

Now go back to Visual Studio and launch the Resharper feature (Intelli-J bindings use CTRL+SHIFT+E, Visual Studio bindings use CTRL+E, T).

When you launch the Stack Trace Explorer, your copied stack trace will already be inserted into the window and all of your user code class names/line numbers will be turned into hyperlinks. You can now easily click through to your code to see what’s up:

Previous ReSharper keyboard shortcut tips:

Part 8 – Bird’s Eye View of Class Files
Part 7 – Add New Files Quickly
Part 6 - Move Extracted Interfaces to Their Own File using ReSharper
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

Rendering A Modal Dialog with ASP.Net MVC

2009-06-15T22:21:00.001-04:00

One of the most requested ‘Web 2.0’ features by users is the ability to pop up a “modal” dialog to the user. There are a couple ways you could implement this functionality, but I’m going to show you a really easy way to do it with ASP.Net MVC. (Hat tip to Jon Kruger for sharing this idea with me.)

Start with a very simple controller action:

Nothing spectacular going on here. The “RandomModal” string points to a ASCX file that is in the views directory, and the second parameter is the model that you want the partial view to render:

And finally, on the view that is hosting the modal dialog there is a chunk of javascript that makes the call, throws the returned DOM elements into a parent div, and displays the div as a dialog:

Another place you could implement this pattern is on a grid. A common request is to click on a row and view more detailed information about the record. To implement this all you’d need to do is stash a row identifier on the html row, and pass that back to the controller on click. Something like this:

The complete solution with this code can be downloaded here:

Resharper: Bird’s Eye View Of Class Files

2009-06-13T07:42:00.001-04:00

When I’m in a unit testing class file, sometimes I have multiple classes in the same file and the file gets pretty large. It’s times like these when the file structure navigation shortcut comes in handy. For users with their keybindings set to the Visual Studio scheme, the shortcut is CTRL+ALT+F. If you’re using the Intelli-J bindings, it’s CTRL+F11.

Previous ReSharper keyboard shortcut tips:

Part 7 – Add New Files Quickly
Part 6 - Move Extracted Interfaces to Their Own File using ReSharper
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

Resharper: Add New Files Quickly

2009-06-10T08:00:00.000-04:00

If you’re adding a class, interface, struct, enum, or new folder to your project, then you can use a feature of ReSharper to add that file much quicker than using the menu commands in Visual Studio.

How do you use this simple shortcut? Select the node that you want your item to be created in in the solution explorer, and type ALT+Insert.

Previous ReSharper keyboard shortcut tips:

Part 6 - Move Extracted Interfaces to Their Own File using ReSharper
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

ASP.Net MVC: Testing Base Controller Methods

2009-06-06T09:42:00.001-04:00

The project that I’m working on now created the need to execute some logic before every controller action in the application executed. The ASP.Net MVC Controller class has a virtual method called OnActionExecuting which will allow me to do just what I needed. The only problem is that testing this bit of logic in the base controller wasn’t straightforward, and took a little research. This is the solution I came up with:

The class under test:

public class BaseController : Controller
{
    protected override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        ViewData["SomeKey"] = "Coming to you from a base controller!!";
    }
}

The test:

[TestFixture]
public class BaseControllerTests
{
    [Test]
    public void Before_executing_an_action_base_controller_should_populate_view_data()
    {
        var baseController = new BaseController();
        var baseControllerAccessor = new BaseControllerAccessor(baseController);
        var actionExecutingContextMock = new Mock<ActionExecutingContext>(); 
        baseControllerAccessor.OnActionExecuting(actionExecutingContextMock.Object);
 
        Assert.That(baseController.ViewData["SomeKey"], Is.EqualTo("Coming to you from a base controller!!"));
    }
}

The BaseController OnActionExecuting method is protected, so I had to do some jury-rigging using reflection to actually put the method under test:

public class BaseControllerAccessor
{
    private BaseController _baseController;
 
    public BaseControllerAccessor(BaseController baseController)
    {
        _baseController = baseController;
    }
 
    public void OnActionExecuting(ActionExecutingContext context)
    {
        MethodInfo methodInfo = _baseController.GetType().GetMethod("OnActionExecuting",
                                    BindingFlags.NonPublic | BindingFlags.Instance);
        methodInfo.Invoke(_baseController, new object[] {context});
    }
}

This was a bit of a pain, but the peaceful easy feeling I’m getting from knowing my code is backed up with an automated test makes it all worth it.

This code can be downloaded here.

Team Velocity: ASP.Net Webforms and MVC

2009-05-31T13:01:00.001-04:00

Since the release of ASP.Net MVC, one of the major talking points has been: When should I use MVC and/or webforms, and will it save or cost me time. These are my thoughts.

Consider the following:

Velocity is the number of feature hours (or feature points) completed in a given iteration (or time period – given that the time period is constant).

Why does it take longer to gain velocity with MVC?

As ASP.Net web developers we’ve been developing with a mammoth abstraction that’s made a ton of our design decisions for us. To achieve velocity with webforms, you really needed only a cursory understanding of how the web works. Contrast that with ASP.Net MVC, which puts developers closer to “the metal” and forces us to make intentional decisions about the design of our apps. Because of this freedom (and power) we’re also responsible for making sure we don’t make the wrong decisions, so it takes a great deal of critical thought and planning to make it what you want it to be.

Once your design and opinions have been established, velocity is likely to increase and then stabilize. Why? Because if you’re doing it right, then you’re designing with SOLID* principles in mind (something that’s extremely hard to do with webforms). Complexity is minimized and entropy is mitigated.

What’s with the sharp decrease in velocity with webforms?

Because it’s so hard to create SOLID* apps with webforms, complexity grows and grows until it’s out of hand. Release cycles go from weeks to months to quarters, and then the app that the company invested millions of dollars in needs to be rewritten because the cost to maintain and/or extend outweighs the cost to start over.

What do you think?

*SOLID principles are not new and whizbangy. They’re a different name and face on what’s been known about OO since the first OO languages, and what every CS college student should have learned in OO design 101.

Fluent NHibernate Configured Via Dependency Injection

2009-03-19T23:22:00.001-04:00

I remember having to reference this “best practice” post when setting up a new project utilizing NHibernate. What a nightmare. Thankfully, there’s been some really positive activity on the Fluent NHibernate project, and configuration has become much more straightforward. In this post I am going to share my experience configuring NHibernate using:

Fluent NHibernate
Ninject
MySQL (Configuring any common database platform is trivial once you’ve seen it done)

To get my head around the basic configuration, I read the tutorial at the Fluent NHibernate site: http://fluentnhibernate.org/

After reading the tutorial, I had a good idea of the external dependencies I’d need to “inject” into my app.

Configuring the Repository

The primary point of entry for any data transferred to and from my database is via my repository. NHibernate’s ISession is what I will interface with to make queries, so I’m going to need that object created and injected into my repository.

Example of a simple repository:

    public class Repository : IRepository
    {
        private ISession _session;
 
        public Repository(ISession session)
        {
            _session = session;
        }
 
        public void Save<T>(T entity) where T : DomainEntity
        {            
        }
 
        public T Load<T>(int id) where T : DomainEntity
        {
        }
 
        public IQueryable<T> Query<T>() where T : DomainEntity
        {
        }
 
        public IQueryable<T> Query<T>(Expression<Func<T, bool>> where) where T : DomainEntity
        {
        }
    }

The constructor of my class takes an instance of ISession. This is where the dependency will be injected into my Repository class.

Widdling down the “Best Practice” article

The most important part of an NHibernate configuration is your management of the SessionFactory and Session objects. The SessionFactory object is expensive to create, and should be made a Singleton. The ISession object should be retained for the lifecycle of the current request if you’re working on a web application. For a non-web project the lifecycle of the ISession should be kept around one per thread.

Many (if not all) of the major dependency injection frameworks offer this type of “lifecycle management” out of the box. Ninject is no exception; here is how I accomplished it:

    internal class IoCConfiguration : StandardModule
    {
        public override void Load()
        {
            Bind<IRepository>().To<Repository>();
            Bind<INHibernateSessionFactoryBuilder>().To<NHibernateSessionFactoryBuilder>().Using<SingletonBehavior>();
 
            Bind<ISession>().ToMethod(ctx => ctx.Kernel.Get<INHibernateSessionFactoryBuilder>()
                .GetSessionFactory()
                .OpenSession())
                .Using<OnePerRequestBehavior>();
        }
    }

Due to the expressive nature of the API, this code is really self-explanatory. Just for fun, compare this code with the mess from the NHibernate best practices article I mentioned eariler (http://www.codeproject.com/KB/architecture/NHibernateBestPractices.aspx).

For completeness, here is the code to configure NHibnerate via Fluent Nhibernate for a MySql database:

    public class NHibernateSessionFactoryBuilder : INHibernateSessionFactoryBuilder
    {
        private ISessionFactory _sessionFactory;
 
        public ISessionFactory GetSessionFactory()
        {
            if(_sessionFactory == null)
            {
                _sessionFactory = CreateSessionFactory();
            }
 
            return _sessionFactory;
        }
 
        private ISessionFactory CreateSessionFactory()
        {
            return Fluently.Configure()
                .Database(MySQLConfiguration.Standard.ConnectionString(c => c.FromAppSetting("DBConnString")))
                .Mappings(m => m.AutoMappings.Add(AutoPersistenceModel.MapEntitiesFromAssemblyOf<DomainClass>()
                                                .Where(w => w.BaseType == typeof(DomainEntity))
                                                .ConventionDiscovery.Add<PrimaryKeyConvention>()
                                                .WithSetup(convention => 
                                                {
                                                    convention.FindIdentity = t => t.Name == "Id";
                                                    convention.IsBaseType = type => type == typeof (DomainEntity);
                                                }
                                                )))
                .BuildSessionFactory();
        }
    }

This is all best explained by the Fluent Nhibernate wiki (which is excellently written).

All this is a first swag, and I’d love to hear how it could be improved. Please leave a comment if you’ve got any questions or if you know of a way it can be better!

Content Not Being Indexed in Sitefinity

2009-03-05T11:01:00.001-05:00

This post will be a little esoteric. I’m working on a Sitefinity project, and one of the features we wanted to implement was the built in site search module.

After configuring the search module everything appeared to be working properly, but after looking a little closer we realized that none of our site content was being indexed. The only thing that was being indexed was each page’s meta tags. I found out in one of the Sitefinity forums that you can control what gets indexed on the site by using an XML configuration file. You can find your site’s configuration file in this path: /%AppDirectory%/App_Data/Search/%IndexName%/fieldsInfoProvider.xml

Here is what the file looks like when you set up a new index:

Here’s what the attributes mean:
name= This attribute is for the reader. You can name it whatever you want.
weight= Gives weight to the content in the search results. (Eg: Items weighted higher will return higher in the search results than lesser weighted items)
indexAttribute= Use this attribute to index all tags with a certain attribute.
filterTag= Use this to tell Sitefinity that you want to index by tag name.
filterAttributes= Use this to filter the attributes by value.

In the site I am building, I want an entire HTML node to be indexed it happens to be:

<div id=”primary”></div>

So to add this content to my index, I added a field node in the fieldsInfoProvider.xml file as such:

If I wanted to add a HTML node by class, I could have changed the filterAttributes= attribute to “class:someCSSClass”. If my HTML node was a <UL>, I’d change filterTag= “UL”.

Google Chrome “Feeling Lucky Search”

2009-02-22T20:40:00.001-05:00

If you want to do a “Feeling Lucky” search from Google Chrome post haste, I’ve got a great trick for you. Check this out:

Fewer clicks, happier browsing.

Here’s how to do it:

1) Create a custom search engine in Chrome:

2) Add the search engine with these properties:

URL: http://www.google.com/search?q=%s&btnI=Im+Feeling+Lucky

3) Enjoy!!

Move Extracted Interfaces to Their Own File using ReSharper

2009-02-06T08:30:00.001-05:00

Update 2/6/09:

Thanks for @orangy for pointing out that there is an even more streamlined approach that I overlooked.

With your cursor on the concrete class use the "Refactor This" keyboard shortcut (CTRL+SHIFT+R), then X. The extract interface dialog pops.

Then use the keyboard shortcut ALT+F to change the radio button to "Place in another file". Then tab through the rest of the controls and make your selections.

Much nicer.

One thing I do commonly when developing is create a class, and then extract an interface from it. ReSharper makes that easy:

~~1) Put your cursor on the concrete class name.~~

~~2) Use ReSharper's "Refactor This" keyboard shortcut (CTRL+SHIFT+R).~~

~~3) Hit "x" on the keyboard for "extract interface".~~

~~A keyboard friendly dialog will open which will allow you to select which members get extracted out into the interface.~~

So now you have an interface sitting in the same file as your concrete class. That's perfectly acceptable, but I always prefer having each class/interface in it's own file named the same as the class/interface name. To do that, you just need to put your cursor on the interface name and hit "CTRL+Enter, Enter", to select the option for "Move to another file to match type name".

Thanks to www.twitter.com/orangy for helping me find this shortcut!!

This is part 6 of a series of posts exploring how to become a ReSharper keyboard ninja.

Previously:
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

Trends For My Industry

2009-01-23T09:49:00.001-05:00

I've been doing the software consulting circuit for a while, although not too long - about 2 years. It's enough time to know that there's a lot of room for improvement, and I'm going to discuss in this blog post what trends I think will emerge as the industry matures. Many of the points I'm going to make are based on observations I've made about software quality, and how organizations will begin to value it more.

More Emphasis On Partnerships and Trust

Too many projects end in something less than success. It's time that we change perspectives on software development and become fanatical about achieving our customer's goals. What I think this means is that we completely change our business models. Instead of the old-school fixed bid or time and materials contracts, let's go for more of the incentive based contracts. In other words, I get paid when I've made you money. Doesn't that take a huge amount of trust? Yeah it does, and that's where I think we need to get. (You can do some more reading on "Agile Contracts" here.)

Incentive based contracts encourage a healthy economy between partners. There's only one goal: to make each-other successful. Now when I come to my partner and ask if it is acceptable to take care of some technical debt, or begin using Test Driven Development, he/she will know that I am only doing it because it is a true investment - and I know that it will benefit me (us!) in the future.

Less Emphasis On Methodologies

Agile, Scrum, XP, Waterfall - they all have one thing in common: they don't mean the same thing to any two people. It's all about communication. We have got to stop applying tools to the process by default and instead have one goal in mind: Keep Improving. I think we'll see companies start to understand that in order to manage a software team you have to let the software team do the managing. There are no better people to make management decisions other than your team. They're on the front-lines with the most comprehensive knowledge available, and will always make the best decision possible.

Teams will still require leadership, but leadership should begin to lean more and more on their people to do the critical thinking and solve not only software problems, but also process problems. In summary: More thinking, less blindly applying tools and/or process.

More Value Placed In Established Software Teams

It sounds reasonable to believe that a developer is a developer is a developer. You always hear how everyone is replaceable and we're just all cogs in the wheel. I'd argue that, however. Developers who have built relationships, established trust, and learned strengths and weaknesses will outperform any other team that has been banded together on-the-fly. Managers and decision makers will eventually begin to see this as they make decisions on who will build their software. Thus you'll see more software teams grow and strengthen and their services will become more valuable.

Single Responsibility Teams Will Fade

As people mature in their careers as software developers, skill sets will mature to the point where it will become expected that feature development will occur in a vertical fashion. By this, I mean that each developer on a team should be able to construct a software feature from top (UI) to bottom (Database) with minimal intervention from other developers. There will always be developers with talents that weigh more on user interface design versus skill in SQL Server (for instance), and they will be valuable as team members. But, every team member should have the ability to work independently to provide value to the paying customer.

Developers Will Provide Their Own Tools

I've come onto a customer's site on a staff aug contract to be seated at a computer that my mother would have grown frustrated with after using a word processor. This is an edge case for sure, but hopefully it illustrates that our clients don't always understand the need for quality tools. I don't blame them - it's not their area of expertise. We are brought in to fill a need, and we know the most about what we require - so we should be the ones to provide the tools necessary to do the job. There are other trades that require their craftsmen to provide their own tools, take for instance mechanics or construction workers.

Less Emphasis On Technology, More On the Domain

We know this: software does not fail to meet customer expectations because of technology. Our first goal shouldn't be to start writing code, but to understand the domain and help our customer make more money. We should be looking at their model and suggesting improvement points. We should be more than the geeks who write code, we should be looked at to solve challenges - technical or otherwise.

Less Staff Augmentation Consulting

In a couple of companies that I've consulted for on a staff-aug basis I've seen software systems that were almost literally being held together by duct-tape and paper mache. The observation I made was that the company was hiring contractors almost exclusively and that these hard working people would swoop in, get a cursory understanding of the system, and make patchwork fixes. These fixes were always just good enough to get the system operational again. And that is probably noble of them because everyone knows that in order to prove you're worth your salt is to be the hero and save the day. This model has got to end.

Agile Elevator Speech

2008-11-23T15:21:00.001-05:00

I've given quite a few "elevator speeches" about Agile. After giving each speech, I've either failed to deliver my message, or my audience failed to understand.

Well, I'm giving up on them. If I can't be successful then I don't want to add to the confusing cacophony of messages about Agile.

Stop Advocating?

No, I am too passionate about software and software teams to give up advocating Agile. So here is my plan.

I'm going to explain the prizes. It's too hard to explain the tools, so I'll give them the good stuff up front.

Why? Because it's too complex (and important) of a topic to discuss in short time. So in paraphrase here is what I'll tell them:

When constructing software as a team, I don't care what methodology you're using as long as the team can achieve these goals:

1) Fail fast.
2) Continuously improve the team.
3) Continuously reduce and eliminate waste.
4) Indicate (visually or otherwise) the teams progress.
5) Embrace change.

Agile happens to have some pretty practical tools that will get us there. If you'd like to join me for lunch, I'd be happy to tell you more!!

Testing Expressions With Moq

2008-11-18T09:07:00.001-05:00

In one of the tests I was writing using Moq, I needed to test that my repository was called with a particular expression. After struggling for a bit, I found a solution which I am sharing here in hopes that it will benefit you.

    1         [Test]
    2         public void Then_Repository_Should_Be_Queried_For_Files_In_Pending_Status()
    3         {
    4             List<JSOFile> dummyFiles = new List<JSOFile>()
    5                       {
    6                           new JSOFile() { STATUS_CD = "P", FILE_NM = "teststring"},
    7                           new JSOFile() { STATUS_CD = "Z", FILE_NM = "test.txt"}
    8                       };
    9 
   10             _repository.Expect(x => x.FindAll(It.IsAny<Func<JSOFile, bool>>()))
   11                 .Callback((Func<JSOFile, bool> del) =>
   12                 {
   13                     dummyFiles = dummyFiles.Where(del).ToList();
   14                 });
   15 
   16             _fileManagement = new FileManagement(_repository.Object, _logger.Object, _file.Object, _jsoFileReader.Object, _jsoFileParser.Object);
   17 
   18             _fileManagement.ProcessReceivedFilesToPending();
   19 
   20             Assert.That(dummyFiles.Count == 1, "Expression passed into the FindAll method was incorrect.");
   21             Assert.That(dummyFiles.FirstOrDefault().FILE_NM == "teststring");
   22 
   23             _repository.Verify();
   24         }

What am I testing?

In the method under test (Line 18 _fileManagement.ProcessReceivedFilesToPending()), I want to ensure that my repository is being queried for the appropriate objects. In this case, all "JSOFile" objects with the STATUS_CD of "P".

The meat of this test method is line 10. This line sets up an expectation that the FindAll(Func<JSOFile, bool>) method will be called from the repository object passed in via constructor (line 16, first parameter).

(_repository defined as:)

_repository = new Moq.Mock<IRepository>();

The Expect method takes a lamba expression that allows you to set an expectation on the type being mocked. In addition to setting expectations, you can also define callbacks. In this example, the callback gets fired when the class under test (_fileManagement) executes the mocked object's FindAll() method. Line 13 will receive the delegate that was passed to the _repository.FindAll. To make sure the delegate was what I expected, I execute the delegate against a list of dummy objects. On lines 20 and 21 I make sure that my list was narrowed down to the object with a status of "P".

Why go to this trouble?

In the future if my repository call gets changed, this test will fail and alert the developer that they've broken intended functionality.

Internet Explorer CSS Quirk (border-spacing)

2008-10-30T13:20:00.001-04:00

Consider the following CSS class:

.test
{
border-spacing: 0px; /*Only works in Firefox */
border-collapse: collapse; /*Works in Firefox and IE */
}

With the border spacing CSS style attribute set to zero pixels, Firefox and IE render differently:

Internet Explorer:

Firefox:

Moral: Use "border-collapse: collapse;" when you want no border spacing in your tables.

Why Is My Property Not Being Serialized To XML?

2008-10-28T10:59:00.001-04:00

Had a very frustrating problem the other day when trying to use a service proxy that I had generated via svcutil.exe. The symptom was that some of the properties that I was setting on my proxy objects were not being serialized to the message that was being sent via my WCF binding.

The short answer is that some of the properties in my objects had some associated properties that needed set. Take these two properties for example:

 1485 
 1486     /// <remarks/>
 1487     [System.Xml.Serialization.XmlAttributeAttribute()]
 1488     public bool definitive
 1489     {
 1490         get
 1491         {
 1492             return this.definitiveField;
 1493         }
 1494         set
 1495         {
 1496             this.definitiveField = value;
 1497         }
 1498     }
 1499 
 1500     /// <remarks/>
 1501     [System.Xml.Serialization.XmlIgnoreAttribute()]
 1502     public bool definitiveSpecified
 1503     {
 1504         get
 1505         {
 1506             return this.definitiveFieldSpecified;
 1507         }
 1508         set
 1509         {
 1510             this.definitiveFieldSpecified = value;
 1511         }
 1512     }

As you can see, when svcutil created the property for the "definitiveField" property in the XML schema, it also created a "definitiveSpecified" field. If you leave the *Specified field left to it's default value (false), the property will not serialize and you'll be left scratching your head.

Why?

It turns out that if the XML schema defines a property as optional using "minOccurs=0" (or you could think of it as 'nullable'), then the .Net XMLSerializer will not serialize the default value for the property. It makes sense - you wouldn't want the framework to assume that you want the default for a particular value... but nevertheless - this is a major gotcha.

Central Ohio .Net Developers Group: jQuery

2008-10-23T15:00:00.001-04:00

I gave a very short 15 minute "Lightning Talk" on jQuery at the Central Ohio .Net Developers Group. Here is the demo project and slide deck:

jQuery Presentation (SkyDrive)

Alternating Element Highlighting With jQuery

2008-09-26T18:26:00.001-04:00

Reading tabular data is usually made a little easier by distinguishing alternating rows by a slightly different color. Normally, to accomplish this I would just assign a different CSS style using a server control such as a GridView or Repeater. While working today, I found a challenge in applying the alternating row effect because I was outputting a static HTML table with some dynamic rows thrown in the middle using a Repeater. So depending on how many dynamic rows were rendered, sometimes I would get two rows by each other with the same color.

So anyway, the solution was to implement the alternating row coloring on the client using jQuery. Here is the very simple code:

You can even substitute the <tr> tag to any html container (div/span/etc.).

jQuery rocks!!

The Balance in Design

2008-09-11T19:07:00.001-04:00

Everything in software is about balance. Today I was thinking about the balance of design. There are about an equal number of equally passionate folks on either side of the debate; some say design everything up front, and some say design as you code. I say, consider both and find the balance.

Designing everything up front is usually associated with a Waterfall model, where by definition the design is done first. Design-as-you-go is favored by Agilists who assume that all design should emerge as code is written. Agile design is communicated in the form of code and working software, Waterfall design is communicated through a series of diagrams or UML. Regardless of approach, the common denominator is that you are communicating design so your customer can provide feedback.

The Waterfall approach forces the design so that you can make decisions before you code - which makes a lot of sense; you can't write bugs if you don't write code. When this design is communicated effectively and the customer agrees that it is correct, you've got a greater chance of coding it right the first time.

The Agile approach is to design as you go. As more requirements emerge, the developer doing the construction can make the best design decision possible because he/she knows the very most about the domain that they can. After all, you can't know more about the problem and existing application design than you do the very minute you write the code. When that code is written, the design can be communicated back to the user in the form of working software, and the customer can provide feedback.

So here is my point. Writing code is costly in time and resources, and it's a lot of effort just to find out whether or not you've solved your customer's problem. If you can communicate your design by other communication mechanisms (UML or diagram) to get feedback, why wouldn't you consider that? In some cases you'll be able to get feedback without writing code; in some cases you won't. There's a decision there that will probably be based on how well you know your customer and how complex the design is.

The point is to make sure you're always advocating for the customer, trying to get the most bang for their buck. Be cognizant of a variety of approaches to solving the problem, and use critical thinking to judge which will be most successful.

Communication Is Hard

2008-09-09T22:28:00.001-04:00

Communication is the process of conveying information from a sender to a receiver with the use of a medium in which the communicated information is understood the same way by both sender and receiver. (Wikipedia)

I've been reading Domain Driven Design-Quickly recently and reviewing it with some friends, and I've done a lot of reflecting on what value I think the book holds. What really struck a cord with me was chapter 2, "The Ubiquitous Language".

In summary, chapter 2 asserts the importance of developing a core language that is shared and understood between the customer and software developers. In the context of the book, the authors point out the challenges of communicating requirements and success criteria for software development, but I'm taking this idea further and investigating other areas I can improve in my communication.

For geeks like me, it's easy to talk for hours on methodologies, war stories, the cool latest tech, and so on. I think it's fair to say that most of the time when we are talking, we assume that our audience is understanding what we're saying, but it's not always the case. Think about all of the terms we throw out on a daily basis that can carry different meanings depending on context and your audience's experiences. Here are a few of the usuals that are suspect for ambiguity:

"Service"
"Security"
"Model"
"Design"
"Framework"
"Business Object"
"Layer"
"Tier"
"SOA"
"Repository"
"Factory"

These words are all extremely useful, and convey very important software concepts. But take a minute to think about how these words could take on different meanings when put into different contexts. Not only that, but your audience may be thinking something completely different based on their training or experience. In casual conversation, this carries little to no significance, but if you're explaining how you want a system to be constructed then you're going to be in for some frustration.

Here are some of the communication touch points I make as a developer, and success indicators.

* The code I write. Does it communicate clearly my intention and purpose as it relates to my client's business? Are my classes well defined and have a single clear purpose?

* Interaction with my client. Does my client understand the solution that I am delivering to him/her? Am I able to convey my design decisions and where I am spending my time so that they feel as though I am providing as much value as I possibly can?

* Communication with team members. Am I actively listening and making sure that we are really speaking in the same language?

If I'm not taking an active role in making sure that I'm communicating in a language that both parties understand, then I'm probably going to be misunderstood. As a developer, I need to put more emphasis on communication. It's one of the most challenging aspects of my job, and if done poorly can mean failure.