Beardy Box

Functional Fun with Python

2011-10-03T12:24:00.001+01:00

Built in currying:

>>> from functools import partial

>>> binary = partial (int, base=2)

>>> binary('000001')

>>> binary('000011')

>>> binary('001011')

The state information is invalid for this page and might be corrupted

2010-06-02T18:35:00.006+01:00

This is a nice gotcha for load balanced ASP.NET sites:

If you have a dynamically compiled ASP.NET website, and you put objects from a dynamic part into the ViewState, you'll be in for a NASTY surprise when you move to a load-balanced scenario.

Basically, you'll occasionally get exceptions with the message "The state information is invalid for this page and might be corrupted" as the compiled types on the different servers are different.

Either:

Move the types you put into ViewState into a compiled assembly (dll for old-schoolers ), or,
Only use primitive types (int, byte, string, char, etc) in the ViewState. Enums do not count as primitive types.

Another reason to use log4net rather than rolling your own logging framework

2010-01-15T12:13:00.001Z

Exception during StringFormat: Index (zero based) must be greater than or equal to zero and less than the size of the argument list. Served {0} coupons out of {1} for {3}{296366, 100, Campaign{id#891e4cb2-da21-456b-bb5e-38cfbf9a90db}}

Google Visualisations API

2009-12-16T14:26:00.002Z

I set up an example of using the Google Visualisations API at

http://swampstaging.co.uk/uk_singles_chart.html

The process for generating this was:

Scrape code from website (ruby+hpricot)

Process code for google's datatable (ruby)

It was a neat way to learn stuff about ruby. programming without a modern IDE is a PITA. i'd forgotten how great resharper+visual studio is. mostly resharper.

jQuery code to cycle background colors

2009-10-05T10:04:00.001+01:00


<script type="text/javascript">
        //<![CDATA[
        $(function() {
            $body = $(document.body);
            var colours = ["#007777", "#777700", "#777777", "#770077"];
            var currentColour = 0;
            var fade = function() {
                $body.animate({ backgroundColor: colours[currentColour % colours.length]}, 127000, fade);
                currentColour++;
            };
            fade();
        });
    //]]>
<script>

ViewModel - the missing link?

2009-01-15T15:42:00.003Z

With ASP.NET MVC getting all the press now-a-days (well, in my tiny part of the web anyway), it's difficult to (a) not feel jealous if you're still stuck on .Net 2.0, and (b) wonder who's employer let's them used stuff that's still in beta for live websites.

However, whilst ASP.NET MVC/FubuMVC/MyMumsMVC provides a framework, and gives you more opportunity to get things right, there's still a missing piece of the puzzle that makes it all fit together.

Consider the lilly of the field.

If you modelled this, it would probably have a Field property.
Your view can probably handle a FieldId, but it shouldn't really know about a Field property. (Having the View access lilly.Field.Id breaks the Law Of Demeter (or, "Two Dots And You're Out"), and your whole SOLID Principals may as well be thrown out with the trash).

In one project we did, we got around this problem by having our Domain Model classes expose this kind of thing. It get messy really quickly, and really quickly pollutes your Domain Model classes with lots of methods and properties that are only ever used for display. Then they start getting used for business decisions, and pretty soon the project is one big code smell.

So, how else might we go about this?

Two patterns that might give us clues are the Facade Pattern and the Adapter Pattern. Go look 'em up. And, whilst you're at it, go look up the Data Transfer Object in your copy of Patterns of Enterprise Application Architecture. (Yeah, get it out from propping up your monitor, wipe off the dust off (a damp cloth is ok on the coated cover) DTO ison page 401).

So, you get the grasp of taking a bunch of objects (it's called an Object Graph if you're Martin Fowler) and converting it into something else for another purpose. When it's used in the context of aiding and abetting the communications between the Controller and the View (The C and the V in MVC), it's called a ViewModel (people how come up with these clever names are too busy to type a space it seems).

And it's great. Your ViewModel may include a LillyDescription class, which has properties like FieldId and FieldName, but, and here's the important thing, it doesn't have any non-primitive members (i.e. you're limited to strings, numbers and dates). Also, keep any logic out of them. If it wouldn't be universally frown upon, I'd say just use plain old Fields on the ViewModel classes (but that's heresy, so forget I ever said that) .

So now, you've got your controller converting between your Domain Model (used by your Business Logic) and your View Model (used my your view). STOP. Your controllers are not meant to do this. Your controllers are meant to control, not convert. Your SOLID Principals are under attack - your "too cool for school" badge will be ripped off your programmer's blazer, and you'll be asked to hand in your gun and your badge. The ALT.NET gang will ex-communicate you, and you'll loose all your profile points on StackOverflow.com.

So we need something else to assemble the ViewModel objects from the Domain Model objects. Go create another class (or even a Service!) to do this. Unit test the hell out of it - it's a purely programmatical problem, so Unit Testing is easy. Ensure that the ViewModel object has the right set of stuff from the Domain Model, and that it doesn't/does break stuff.

There - wire up your IoC container with the IViewModelLillyConverterService and it's implementation, and you're good to go. (i.e. expect the Yellow Screen of Death a few times).

There's a lot of stuff here. I'm still not entirely sure where the line is between all the parts. Although it seems like it'll create an explosion of classes, it really does simplify things. More code is normally worse, but I'd argue that this is more of a Refactoring (yeah, dubious I know).

Go and play with this idea. See if you can make your view utterly independant of your Domain Model. Go on. Go completely over the top. Then, maybe, you'll get a feel for it.

Branches and Tags and All That

2008-12-16T13:54:00.001Z

Today, my diligence in creating branches, and then tags, for releases finally paid off. And bit me back.

A product, live at version 28.1, and currently at version 29.2 in User acceptance testing, had a critical bug reported in Build 28.

No problem - I created a branch from the Build 28 tag, checked this out, fixed the bug (one line), and deployed that to the customer. Hooray - happy customer.

However, after creating a new build 28.2 tag, I then had to merge this change back into both the current 29 branch and the trunk, and commit both separately.

I know I would not have been able to support this change without the rigorous tagging/branching, but it still grates when you have to do the same merge more than once.

It was worth writing those unit tests...

2008-09-25T17:07:00.001+01:00

Simple specification:

If the user is not in the "Admin" role, then buttons x, y, and z are hidden.

You'd have thought that unit tested the presenter/controller for this would be pointless, but it highlighted the fact that I'd hard-coded false for the visibility of one of the buttons.

I think that was worth the five minutes it took to put the tests together.

SyntaxHighlighter

2008-06-17T15:00:00.005+01:00

As you can see, I've used SyntaxHighlighter to smarted up the posted code.

One thing I found was that Blogger likes to put "<br>" elements in any "<pre>" code, so I wrote a little javascript to replace them with newlines:


(function(){var pres = document.getElementsByTagName('pre');
for ( var i = 0; i < pres.length; ++i ) { 
  for ( var br = pres[i].childNodes.length; br > 0; --br ) {
    if ( pres[i].childNodes[br-1].nodeName == 'BR' ) {
       pres[i].replaceChild(document.createTextNode('\n'), pres[i].childNodes[br-1] );
    }
  }
}})();

1 UI Control, 73 Unit Tests

2007-11-16T17:05:00.000Z

When you start introducing dependencies into things, they get complicated pretty quick.
This is doubly true with validation: if one value relies on another, then you need to validate both inputs when either of them change.
If A and B depend on each other, and B and C depend on each other, then you get into really deep water.
The way I've dealt with this is by using a "propagate" flag in the validation functions, which determines whether something should call validation on its dependents.
It seems to work pretty well, but I can see this getting grizzly when theres more than one thing going on. It does help isolate each validation function to be able to validate one thing at a time.
Also, doing it test driven has helped - towards the end, the cycle was only hindered by the speed of compilation.
I'm now confident that it's a robust control that I can build other parts of the UI around.
I think using some kind microcontroller may have helped break it up a bit mind, but that's a refactoring for another day.

Shuffling a List in C#

2007-10-12T10:24:00.004+01:00

Fixed this post:


public static readonly Random random = new Random();
public static IList<T> Shuffle<T>(IList<T> toShuffle)
{
List<T> deck = new List<T> ( toShuffle );
int N = deck.Count;

for (int i = 0; i < N; ++i )
{
   int r = i + (int)(random.Next(N - i));
   T t = deck[r];
   deck[r] = deck[i];
   deck[i] = t;
}

return deck;
}

Generics Array Helper

2007-10-12T09:42:00.002+01:00

Rather than


ObjectWithReallyLongName [] array = new ObjectWithReallyLongName [] { new ObjectWithReallyLongName(...), ... }

We can use generics to create a function:


public T[] Array<T> ( params T[] array )
{
    return array;
}

used


ObjectWithReallyLongName [] array = Array(new ObjectWithReallyLongName(...), ...);

Seems to read better too.

Installing Infragistics NetAdvantage on Vista

2007-09-26T14:43:00.001+01:00

Note to self: To do this successfully, you need to turn off UAC. If you don't it won't install properly.

Take a bath...

2007-09-17T13:17:00.000+01:00

From Pi:

SOL	Remember Archimedes of Syracuse? The King asks Archimedes to determine if a present he's received was actually solid gold. Unsolved problem at the time. It tortures the great Greek mathematician for weeks. Insomnia haunts him and he twists and turns on his bed for nights on end. Finally, his equally exhausted wife, she's forced to share a bed with this genius, convinces him to take a bath, to relax. While stepping into the tub he observes the bathwater rise as he enters. Displacement. A way to determine volume. And thus, a way to determine density, weight over volume. And thus, Archimedes solves the problem. He screams "Eureka!"—Greek for "I found it!"—and is so overwhelmed he runs dripping naked through the streets to the King's castle to report his discovery. Now, what's the moral of the story.
MAX	That a breakthrough will come...
SOL	Wrong. The point of the story is the wife. Listen to your wife, she will give you perspective. Meaning, you need a break, Max, you have to take a bath, otherwise you'll get nowhere. There will be no order, only chaos. Go home and take a bath.

I had an Archimedes moment over the weekend. I'd been struggling to work out the problem all last week. Came in this morning and got it nailed in a few hours.

Take a bath ;)

Enum

2007-09-17T11:37:00.001+01:00

inspired by Enum, here's my version... it still needs to work with resources, but works otherwise.


public static class Enum <T>
{
          
 public static T Parse ( string name )
 {
  return ( T ) Enum.Parse ( typeof ( T ), name );
 }
                      
 public static IEnumerable < T > GetValues ( )
 {
  foreach ( T value in Enum.GetValues ( typeof ( T ) ) )
  {
   yield return value;
  }
 }
        

 public static IEnumerable<AttributeType> GetAttributes <AttributeType> ( T value ) where AttributeType : Attribute
 {
  FieldInfo fieldInfo = typeof ( T ).GetField ( value.ToString ( ) );
                        

  if (fieldInfo != null)
  {
   foreach ( object customAttribute in fieldInfo.GetCustomAttributes ( typeof ( AttributeType ), false )  )
   {
    yield return customAttribute as AttributeType;
   }
  }
 }
              
 public static IList<AttributeType> GetAttributeList <AttributeType> ( T value ) where AttributeType : Attribute
 {
  return new List<AttributeType> ( GetAttributes<AttributeType> ( value ) );
 }
    
 public static string GetDescription( T value )
 {
  IList< DescriptionAttribute > attributeList = GetAttributeList<DescriptionAttribute> ( value );
        
  if (attributeList.Count < 1)
   return value.ToString();
          
  return attributeList[ 0 ].Description;
 }
}

Tools

2007-09-09T15:37:00.000+01:00

Programmers love tools - just to write a program, you need at least three: text editor; compiler; and, a linker - and that's excluding the computer and the operating system!
However, as with any other craft, there are certain rules you need to follow when using tools:

Use the right tool for the job
Obviously, you wouldn't try to edit your text with a linker, but even-so...
Know how to use your tools
The same way you can take your fingers using a circular saw incorrectly, you can run your project into a lot of trouble by abusing your tools.
Use the best tools you can get your hands on
It's not just about cost - you can get good and cheap tools, but you can also get expensive shit.
Look after your tools
You main tool as a programmer is your computer. Keep it clean and sharp and it'll be a lot easier to use.

.Net Testing And Assemblies Signed with Strong Names

2007-07-04T11:48:00.000+01:00

.Net Testing And Assemblies Signed with Strong Names

An old post about clearing the GAC download cache when unit testing signed assemblies: gacutil /cdl

Welcome To Beardy Box

2007-06-29T12:30:00.000+01:00

This blog is my "programmers notes" blog; somewhere I can put all programming and development stuff I think about and not bore my non-technical friends with.
At the moment, as you can see, it's blank, but hopefully it will become a mine of useful information*.

*some chance!