Simon on Software

Last week, I was looking at the code for a project. I was unfamiliar with the domain, some of the frameworks it utilised, and its architecture. In addition to this, the project documentation is extremely limited or out of date, mainly due to the relative immaturity of the project, and the fast pace of change in development. As it is an open source project, I don’t have access to the other developers, except through the project forum and mailing list.

What makes it difficult

When unfamiliar with the domain, it is not always easy to find the key classes that contain the domain logic. Some domains use relatively abstract or ambiguous terms for names of objects.

It can be difficult to find out how code is executed – for example when the concrete implementations of interfaces are configured through an IoC container and interception.

How I tackled the problem

• By reviewing any unit tests

• Reviewing documentation and scanning forums for items of interest

• Set breakpoints in UI to try and understand lifecycle of application, and identify key classes from call stack. This is useful for understanding how information is retrieved and rendered onto the screen.

• Noting down any key classes for future examination

• Identifying patterns and frameworks used for further research

• Attempt to fix some bugs/small issues to give your probing some concrete direction. You should seek feedback via code review or the committer if open source.

• The final stage is when you understand the project architecture and idioms, and are able contribute new features and feel comfortable that they integrate well with the rest of the application

Mmmm, a VBA post. Hopefully there won’t be too many of these.

Our system has an excel interface, and many models are built on top of this interface. The issue with this is that when the spreadsheet opens, it will refresh the data that is currently in the system. Normally, this is exactly what you want, but sometimes it would be nice to create a snapshot of a model at a certain time. Copy and paste as values is how you achieve this manually, here are some functions that achieve this programatically via VBA, and automatically creating a new workbook.

Public Sub ArchiveWorkbook()
    Set NewWorkbook = CreateWorkBook(ThisWorkbook.Worksheets.Count)
    If SaveWorkbook(ThisWorkbook.FullName) Then
        CopyValuesToDestination
    End If
End Sub

Function CreateWorkBook(wsCount As Integer) As Workbook
    Dim OriginalWorksheetCount As Long
    Set NewWorkbook = Nothing
    If wsCount < 1 Or wsCount > 255 Then Exit Function
    OriginalWorksheetCount = Application.SheetsInNewWorkbook
    Application.SheetsInNewWorkbook = wsCount
    Set NewWorkbook = Workbooks.Add
    Application.SheetsInNewWorkbook = OriginalWorksheetCount
    Set CreateWorkBook = NewWorkbook
End Function

Function SaveWorkbook(originalFileName As String)
    On Error GoTo ErrHandler:
    NewWorkbook.SaveAs Filename:=originalFileName & "_staticCopy"
    SaveWorkbook = True
    Exit Function
    
ErrHandler:
    SaveWorkbook = False
End Function

Function CopyValuesToDestination()
    Dim source As Range
    Dim dest As Range
    Dim sourceWs As Worksheet
    Dim destWs As Worksheet
    Dim wsCounter As Integer
    
    For wsCounter = 1 To ThisWorkbook.Worksheets.Count
        Set sourceWs = Nothing
        Set source = Nothing
        Set dest = Nothing
        Set destWs = Nothing
        Set sourceWs = ThisWorkbook.Worksheets(wsCounter)
        Set source = sourceWs.Range("A1:DA150")
        
        source.Copy
        
        Set destWs = NewWorkbook.Worksheets(wsCounter)
        Set dest = destWs.Range("A1:DA150")
               
        dest.PasteSpecial xlPasteValues
        dest.PasteSpecial xlPasteFormats
        dest.PasteSpecial xlPasteColumnWidths       
        destWs.Name = sourceWs.Name
    
    Next wsCounter
    
End Function

This is more of a note to myself so I remember the next time I need to do it, but perhaps somebody will find this useful.

If you are generating a patch file for a Mercurial project, it appears that TortoiseHG doesn’t support this. However, like me, I am sure you are not wary of the command line, and we can easily generate a patch file using hg diff via the command

hg diff -c 1020 -g > c:\temp\mypatch.patch

-c specifies the changeset number, and -g specifies using git extended format.

If you take it as a given truth, that you do not want your presentation layers to be exposed to Domain Objects directly, then you need some way of “mapping” them to a Presentation Model/DTO structure. Developers hate writing this code. It is boring, fragile and laborious to test.

There is a better way! There is a mature project called AutoMapper, developed by Jimmy Bogard.
I watched a short episode of DotNetRocks TV which had me sold.

AutoMapper generally works via convention. In the simplest case, the names of your properties/methods need to match on the source and destination object. So, if you have a “Name” property on your Domain Object and on your Presentation Model, this will be mapped automatically. All you need to do is configure the types that can be mapped together during application initialisation.

Where this convention over configuration is not sufficient, AutoMapper also supports Custom Formatting, Conversion and Resolving, so you can flexibily flatten or project your domain types onto other objects. It seems to be very flexible and it was easy to create the Presentation Model I wanted. The project seems mature enough to cover just about any use case you could have.

A really nice feature is the Configuration Validation checking, which will point out errors or omissions resulting in the mapping from one object to the other, which you can call from a unit test:

[Test]
public void TestMappingsAreGood()
{
     Program.AutoMapperConfiguration();
     Mapper.AssertConfigurationIsValid();
}

I have created a small Visual Studio Solution which contains the early results of my AutoMapper experimentation that I hope will illustrate the frameworks power and ease of use.AutoMapper Example Project.

For further samples, the source includes a Samples Project

People keep coming up to me at Christmas parties and asking me what I log in my applications.

And I tell them:

• All unhandled exceptions, via an Application-wide exception handler
• Performance data for certain critical areas of the app
• In certain areas of the application, we suspect aren’t being used much
• At application start-up so we can see how often the app is being used

And in development – debug statements can be used to “print” the state of objects – often saves getting slowed down by the debugger.

You could also add log statements for code paths you suspect are not being used in Production.

Now I can just tell these partygoers to subscribe to my RSS feed, and get back to enjoying another snowball, or a glass of Baileys.