You're a good looking blog, what's your owner's name?

Code Review Checklist

2010-11-06T15:16:00.000Z

Here's a checklist for code reviews (in any language).

1) Would the logic be understandable by a developer of average ability proficient with other programming languages but not this one?

If it uses language features or obscure design patterns that are "clever" without good reason (e.g. something needs to have the maximum performance), then it won't be maintainable and someone will replace it or add to it badly. We've all seen code written by someone who has just read the "Design Patterns" book and wants to use all of them. If you want to use the latest trendy language features, think about if someone in 10 years time will know about these of if they will have fallen into obsolescence.

When reviewing code, thinking about this will make long term maintainability easier. It may result in some discussion about which language features and design patterns should be used and standardising on these will mean everyone understands each other's code better.

2) Are properties nouns and methods verb noun phrases.

If properties are not nouns and methods not verb-noun phrases, then it's a sign that these haven't been thought about carefully and the code will be more difficult to maintain.

When reviewing code it's easy to overlook this, but very quick to check.

3) Is there an obvious way of testing each method.

Of course we all know all methods should have unit tests but in the real world this isn't always possible. However, if there isn't one and it isn't obvious how to write one, then the method could probably be expressed better in a different way.

When reviewing code, if you can ask "how will this method be tested" you can better follow the logic. If you can't answer this question then there are more likely to be complexities that aren't picked up until it's too late.

4) Do the names of properties, methods and classes match the names used elsewhere in the organisation?

If the names of objects are different (e.g. your code refers to a regular customer and the business a star customer), then it will be harder to explain what you are doing and more likely that requirements will be misinterpreted. It's a good idea to document these in a wiki to have a single point of reference for these.

This also means if you are working on a method, you can say "I'm working on x in class y", and someone who knows your business area but who is not a developer know would know what you are talking about. This would improve the trust between developers and domain experts.

When reviewing code, thinking about this will help you understand the business domain and make you better able to communicate with them and get accurate requirements in future.

5) Is the total complexity of the system affected as little as possible? (I would define this as the number of classes * average size of each class * the total number of other classes a class has to know about).

This means if you're creating a new function that means the class it is in has to know about 3 more classes than before, the system is more complex as there are more dependencies between classes.

When reviewing code, if you think about this and rewrite if necessary it will reduce the numbers of possible points of failure and mean that testing is more likely to pick up problems before anything goes live.

Characteristics of an effective programmer.

2010-11-05T12:07:00.000Z

A lot has been written on what makes a great programmer.
I'd like to write about what makes an effective programmer. The two can be different.

I would say the characteristics of an effective programmer are as follows:

1) Do you know and care about how the application you are writing will be used, and do you have opinions about how to make it better?
2) Do you know about new technologies, can you recognise those that should be adopted in your current projects and can you explain them convincingly enough to get them adopted?
3) Can you maximise tha amout of code not written, through efficient design, reusing things that have been written before and eliminating unnecessary requirements?
4) Can you recognise your limitations and mitigate these, e.g. by understanding where you need to learn something new or code defensively, and where to get help from others?
5) Can you design and write code that can be maintained in 10 years time by someone of average ability, when tools and programming languages have moved on?
6) Do you understand more than just code, e.g. databases, infrastructure and can you use this understanding to make it more likely a project will be stable and reliable when it is live?

Do you agree?

Planning poker with Return on Investment

2010-11-01T16:35:00.000Z

A lot has been written on Planning Poker as part of an agile approach to developing web sites.

I have a new take on this - Planning poker with return on investment. I'm sure we all agree that things that give a lot of value with a small amount of work should take prioriry.

This would work as follows:

The stakeholders would divide into two groups, business people and developers. Business people would use planning poker to estimate the likely return of a proposed development in "return points". Developers would at the same time estimate the likely investment in "story points". "Return points" would likely be related to the amount of money the proposal would make. "Story points" would be related to the number of days development.

You can then divide return by investment to get a priority.

If return is small, investment big, it's probably best to forget the proposal.
If return is big, investment is small, it's a no brainer and should be done.
If return is small, investment is small, it's a medium priority.
A problem occurs if return is big and investment is big. This suggests there is a risk involved. To reduce the risk, the proposed development should be divided into smaller chunks.

Feedback loops

2010-10-24T19:27:00.000+01:00

Mark Needham describes overcompensating in feedback loops.

This reminded me of something from my control theory course at university many years ago. If you are not in a desired state, you should make changes that are a percentage of the difference between your current state and the desired state. You will gradually converge towards it, and not overcompensate for any sudden changes.

Visual Studio 2005 ASP.NET F5 Debugging performance

2007-10-17T10:27:00.000+01:00

I was experiencing a delay of about a minute between pressing F5 to start debugging my ASP.NET application (VS2005 SP1, Vista) and anything appearing in the browser.

After researching this and installing various hotfixes, nothing improved. Removing the google toolbar however seemed to make debugging return to its normal speed.

ASP/ASPX pages giving 404 errors

2007-09-05T11:12:00.000+01:00

In case I need to do this in future... I have been trying to copy a web site to a new web server (Windows Server 2003) and getting very confused about why .ASP and .ASPX pages were giving 404 errors, but HTML pages were displaying correctly. The reason was "ASP.NET" and "Active Server Pages" in the Web Service Extensions directory were both set to "Prohibited".

The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel.

2007-08-29T13:21:00.000+01:00

I was getting an error message "The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel." when trying to connect to an HTTPS site using an HttpWebRequest.

As the site I was connecting to was a test site from a 3rd party known to me, but not set up correctly at their end, to bypass this check I added the following line before calling GetRequestStream on my HttpWebRequest.


ServicePointManager.ServerCertificateValidationCallback 
+= new 
System.Net.Security.RemoteCertificateValidationCallback
(CustomValidation);

and added the CustomValidation function as follows:


private static bool CustomValidation(object sender, 
X509Certificate cert, X509Chain chain, 
System.Net.Security.SslPolicyErrors error)
{
    return true;
}

A set of principles for taking a new assignment

2007-08-06T08:40:00.000+01:00

Gerald M. Weinberg offers a set of principles for taking on a new assignment.

InternalsVisibleToAttribute, Unit Testing and Strong Names

2007-06-12T17:05:00.000+01:00

I previously posted about using the InternalsVisibleTo attibute for testing with NUnit.

I've had some problems building this with a stronly named assembly. I found the following post on Kent Boogaart's blog that describes how you should change the code in your assemblyinfo.cs file as follows:

[assembly: InternalsVisibleTo("Company")]

to

[assembly: InternalsVisibleTo("Company, PublicKey=xxxxxxxxxxxxxxxx")]

Adding a strong name to a third party dll

2007-06-12T16:35:00.000+01:00

I've been trying to build an assembly with a strong name and had some problems as it referenced a 3rd party assembly which had been built without a strong name.

To add a strong name I disassembled and reassembled the 3rd party assmbly as follows:

ildasm /out:thirdparty.dll.il thirdparty.dll

ilasm /dll /resource=thirdparty.dll.res thirdparty.dll.il /out=thirdparty.dll /key=mykey.snk

World Environment Day

2007-06-05T14:07:00.001+01:00

To celebrate World Environment Day, we have all been given a flowerpot, some peat and some forget-me-not seeds. You can follow whether the seeds grow into a beautiful plant or not here.

Refreshing Progress Bars

2007-06-05T14:01:00.000+01:00

I've been having some problems getting a progress bar to refresh, trying various calls to Refresh() and Invalidate() without much success. The solution to this is to create the dialog containing the progress bar in another thread, as described here.

Although the dialog is modeless, it should be displayed using ShowDialog(), not Show().

Standard for improving Standards

2007-05-16T10:29:00.000+01:00

Simon Baker suggests that standardisation does not have to supress innovation.

It's important to communicate the best ways of doing things, but standards are often enforced in a way that people are expected to accept without question. However, there are often many ways of doing something, and the best way will change over time with changes in technology and changes in people.

Perhaps standards should be seen as something that should be followed, but when its thought they cause a problem, judgement should be used as to the correct procedure should be followed. However, if people use judgement to deviate from the standard, any differences should be noted and their effect should be considered afterwards.

The differences can then be assessed to see if deviating from the standard was the right thing with hindsight and if so, the standard should be improved. if it was the wrong thing to do, we might need to explain the rationale behind the standard better.

Visual Studio 2005 - Disappearing controls on Windows Form

2007-04-16T11:21:00.000+01:00

My computer crashed the other day and when I returned to edit my application, to my horror I noticed that the controls on a very complicated windows form that I was working on had vanished. When I tried to edit it, all I got was an empty dialog box, but all the source code for my form was still there.

I found several references to disappearing controls in VS2003, but they all said the problem had been fixed in VS2005.

The cause of this turned out to be that some lines had removed themselves from the designer.cs file :-

///
/// formMyForm
///
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink;
this.ClientSize = new System.Drawing.Size(869, 717);
this.Controls.Add(this.splitContainer1);
this.Controls.Add(this.buttonOK);
this.Controls.Add(this.buttonCancel);
this.Controls.Add(this.buttonAccept);
this.Name = "formMyForm";
this.Text = "My form title";

Copying these lines from the version in source control seemed to restore all the controls in the dialog.

Complete years between 2 dates

2007-03-01T16:23:00.000Z

A problem we have had calculating ages was due to it using the SQL Server "DateDiff" function. This counts the number of times a day crosses a boundary, e.g.

DateDiff(year,'12/31/2006','1/1/2007') is 1, as it crosses the 2006-2007 boundary.
DateDiff(year,'1/1/2006','12/31/2006') is 0 as it doesn't cross a year boundary.

I have written a function "yeardiff", which calculates the number of complete years between 2 dates, so

YearDiff('12/31/2006','1/1/2007') is 0
YearDiff('1/1/2006','12/31/2006') is 0
YearDiff('12/31/2006','1/1/2008') is 1

This function works by calculating the number of days the start date is into the year, subtracting this from both start and end dates (so the start date is 1 January), and calling DateDiff on the resulting date.

Here's the source code for this function:

CREATE FUNCTION yeardiff
(@start as datetime, @end as datetime)
returns int
AS
BEGIN
declare @years as int

declare @daysintoyear as int
declare @firstdayofyear as datetime
declare @newstart as datetime
declare @newend as datetime

set @firstdayofyear = convert(datetime,
'1/1/'+convert(varchar,year(@start)))
set @daysintoyear =datediff(day, @start, @firstdayofyear)

set @newstart = dateadd(dd, @daysintoyear,@start)
set @newend = dateadd(dd, @daysintoyear,@end)

return datediff(year,@newstart,@newend)

END

Nant and licensed 3rd party controls

2007-02-06T17:04:00.000Z

I've been having some problems building a project containing licensed grid and graph components from ComponentOne using NAnt. The project built correctly in Visual Studio, but when built with NAnt I got a box saying the component was not licensed.

I've found some others have had similar problems, but no solutions have been posted. I go it working after a lot of trial and error as follows:

1) Use an <exec> task to run the license compiler (lc.exe).
2) Ensure the /target: command does not contain a path.
3) Ensure your <csc> task does not contain a path in its output section.
4) Ensure the licenses file is included in the resources section. This did not work when it was included as an argument with an <arg value="/resource" element.
5) Copy the file to the correct destination directory at the end.

Here's the relevant part of my build file.

<target name="project" description="build project"
depends="..." >

<exec program="C:\Program Files\Microsoft
Visual Studio 8\SDK\v2.0\bin\LC.exe"
commandline="/target:project.exe
/complist:c:/nantcheckout/project/Properties\
licenses.licx
/outdir:c:/nantbuild /i:c:\nantbuild\C1.Data.2.dll
/i:c:\nantbuild\C1.Win.C1Chart.2.dll
/i:c:\nantbuild\C1.Win.C1Chart3D.2.dll
/i:c:\nantbuild\CAInterfaces.dll
/i:c:\nantbuild\CDERules.dll
/i:c:\nantbuild\clTreeViewHashT.dll
/i:C:\WINDOWS\Microsoft.NET\Framework\
v2.0.50727\System.configuration.dll
/i:C:\WINDOWS\Microsoft.NET\Framework\
v2.0.50727\System.Data.dll
/i:C:\WINDOWS\Microsoft.NET\Framework\
v2.0.50727\System.Deployment.dll

...

/>

<csc target="winexe"
output="PCOBrowserGE.exe" debug="false"
define="TRACE" >
<sources>
<include name="c:/nantcheckout/
project/*.cs" />
<include name="c:/nantcheckout/
project/Properties/*.cs" />
</sources>
<resources>
<include name="c:/nantcheckout/
project/Properties/*.resx" />
<include name="c:/nantcheckout/
project/*.resx" />
<include name="c:/nantbuild/
project.exe.licenses" />
</resources>
<arg value="/reference:C:\nantbuild\
c1.win.c1chart.2.dll" />
<arg value="/reference:C:\nantbuild\
c1.win.c1chart3d.2.dll" />
<arg value="/reference:C:\nantbuild\
c1.data.2.dll" />
</csc>

<copy file="pcobrowserge.exe" tofile="
c:/nantbuild/project.exe" />
</target>

10 Characteristics of a great programmer

2007-02-06T10:11:00.000Z

Steve Riley has complied a great list of the 10 characteristics of a great programmer.

I'd agree with everything on the list - the one thing that is missing is that great programmers know why they are doing what they are doing - there's no point producing an excellent solution to the wrong problem.

Cakes

2007-01-25T10:14:00.000Z

Cote writes about requirements gathering and cakes.

If your powerful boss asks you for a cake, you can't easily find out the details of what he wants. You have to find out via secondary sources (e.g. the boss's calendar, asking the baker what sort of cakes the boss has ordered before). The calendar may not be up to date, and the baker may not remember accurately.

This takes longer and is more likely to go wrong. If there are more steps than necessary in finding out requirements, the solution is to understand what the difficulty is with asking him directly and work on reducing these difficulties.

Personal Search Filter

2007-01-24T15:44:00.000Z

If you want to find out information about something, you will typically enter terms into a search engine.

The search engine will determine which results are most relevant (by using a complex algorithm based on how important it thinks the pages are). Everybody using this search engine will see the same results.

The things you want to see might not be the same as the things others want to see. However, you are more likely to want to see things that people "compatible with you" liked. If A likes B and B likes C, and B also likes D, then chances are that A will like D.

You could filter the results of your search (from the search engine) through a personal search filter. This would reorder your searches depending on

1) Things you have liked before
2) Things that people compatible with you have liked before.

When you visit a web page, you record whether you found it valuable. This updates your personal search filter and how compatible you are with other people. If you liked page A and B didn't like page A, you will not value the opinion that B liked page C. However if B liked A, you would be compatible with B and their opinion would affect your search filter.

This can be seen below:

Anti-tests

2007-01-12T10:21:00.000Z

Charles Miller describes the concept of an "Anti-Test", which is a test that verifies a bug exists.

This can be written when the problem is discovered, even if it's not going to be fixed immediately.

It means that if the problem is inadvertently fixed as a result of something else, we know this has happened, have a look at why this is the case and update our records accordingly. The test can then be changed to a normal test to make sure it doesn't go wrong again.

When you're ready to fix an anti-test, you can change it to a normal test - it should now fail (and this change should be easy to make), fix the bug and make sure the test passes.

NAnt version

2007-01-12T10:09:00.000Z

I've been trying to add version numbers to a NAnt build script using the <version> task, and come across a problem with the script in Marc Holmes' "Expert .NET delivery" book.

The task increments a property called "buildnumber.version", not "sys.version". Adding the following line to the script (as described here) seems to fix it.

<property name="sys.version" value="${buildnumber.version}" />

Using attributes to specify the contents of a menu

2006-12-03T16:22:00.000Z

Most people think it is a good idea to separate business and presentation logic in your application, so you can update one without changing the other. When you create an application with a menu bar, the menu items will often call functions in your business logic, and if you add a new business logic function you will need to add a handler in your presentation layer and the business logic function in your business logic layer.

This article describes how you can add attributes in your business logic layer and have these dynamically bound to a menu when your application runs. The attributes will look like the following:

   public class MenuHandler
    {
        [MenuOption ("Menu Option 1")]
        public void MenuHandler(object sender, 
EventArgs e)
        {
            //Business Logic
        }
    }

Creating your Attribute

The first thing you need to do is to set up your attribute. Create a class derived from System.Attribute as follows.

    [AttributeUsage(AttributeTargets.Method)]
    public class MenuOptionAttribute : 
System.Attribute
    {
        private string MenuText;

        public MenuOptionAttribute(String 
menutext)
        {
            MenuText = menutext;
        }

        public string GetMenuText
        {
            get
            {
                return MenuText;
            }
        }
    }

The first line of this specifies your attribute can be applied to methods (and not to classes). The constructor takes one argument, which is a string representing the menu text.

Applying your attribute to your business logic

Next, you write your business logic layer to use the MenuOption attribute. All you need to do is to put this before any functions you want on your menu, with the text to go on your menu:

    public class BusinessLogic
    {
        [MenuOption ("Menu Option 1")]
        public void Option1(object sender, 
EventArgs e)
        {
            // Option 1 code
        }

        [MenuOption("Option 2")]
        public void Option2(object sender, 
EventArgs e)
        {
             // Option 2 code
        }

You can add as many of these functions as you like.

Setting up your menu

Finally, you need to create your presentation layer. You can drag a MenuStrip to a form and add a title for your drop down menu. If you call the title "Main", when you add the title, it will create a ToolStripMenuItem, called "mainToolStripMenuItem" by default.

You need to use reflection to iterate over all the methods in the MenuHandler class, and see which of those methods have the MenuOptionAttribute attribute set.

If it is set, you need to call the GetMenuText() function on the attribute to find out the text to display on the menu bar and add the menu item.

Next, you need to create a delegate to your method.

Finally, you add the event handler to your newly created menu item. It's easier to understand this if you read the code example.

  public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            BusinessLogic bl = new BusinessLogic();

            mainToolStripMenuItem.DropDownItems.
Clear();
            foreach (MethodInfo method in 
(typeof (BusinessLogic)).GetMethods())
            {
                foreach (object attribute in 
method.GetCustomAttributes(true))
                {
                    if (attribute is 
MenuOptionAttribute)
                    {
                        ToolStripItem newitem = 
mainToolStripMenuItem.DropDownItems.Add((
attribute as MenuOptionAttribute).GetMenuText);
                        EventInfo ci = typeof
(ToolStripItem).GetEvent("Click");
                        Type tdelegate = ci.
EventHandlerType;
                        Delegate del = Delegate.
CreateDelegate(tdelegate,bl,method);
                        ci.AddEventHandler(
newitem, del);
                    }
                }
            }
        }
    }

You could add some code to your attribute to specify its position, and use this to order your menu items. You might want to specify more than one string, one for the heading and one for the item itself, so you can put menu items in under different headings.

InternalsVisibleToAttribute and Unit Testing

2006-10-21T13:10:00.000+01:00

When creating unit tests to be run with NUnit, I like to keep my tests in a separate assembly, which is not delivered when my project is deployed.

This can make it difficult to create unit tests for classes that should not be visible outside of that assembly. One of my classes uses one of 3 strategy classes that encapsulate a feature of the business logic. I would normally declare these with the intern access modifier, but to test each strategy works I've needed to make them publically available.

If, however, I add the [assembly: InternalsVisibleTo("UnitTests")] line to my AssemblyInfo.cs file, any objects declared with the intern access modifier can be seen by the UnitTests assembly.

Processes and Practices

2006-10-10T22:33:00.000+01:00

Jared Richardson describes a process he wants his team to follow. Many others have attempted the same and have reached similar conclusions, and I can't disagree with any of Jared's thoughts.

However, I think he misses out the most important part of the process which should be to regularly think about your process and what you have done and how you could have done it better. All processes and practices should be adaptable. Different people have different strengths and new technologies mean we have to develop things in different ways.

A lot has been written about technical debt, where if not enough time is invested in developing high quality software, it becomes harder to maintain and costs of new developments increase over time. We should also think about process debt, where if not enough time is spent improving and adapting our processes, they become less efficient and costs of new developments also increase.

C# collection classes performance

2006-10-10T21:42:00.000+01:00

I was looking for a table summarizing how different C# generic and non-generic collection classes performed, relative to one another, thought there would be hundreds available, but could not find one. So here one is for my future reference, and for anyone else who reads this.

O(1) = constant time
O(log n) = time proportional to the log of the number of elements in the collection
O(n) = time proportional to the number of elements in the collection

Some collections are better for smaller collections, but don't scale to larger ones. The List, LinkedList, SortedList, Queue and Stack classes are better for smaller collections than the Dictionary, Hashtable and SortedDictionary classes.