Whilst reading an article I was curious about the number of commas and full-stops that the author used - when you become an editor of a newsletter you start to think about things like this.  After hunting around the various utilities on my system I discovered that I didn’t have anything that could easily do this.  So, I did what any self-respecting programmer would do and threw together a quick app to do it for me.

I have made both the source code and pre-compiled binary available for download under a BSD license (share, remix, no endorsement).  It is written in C# and requires the .Net 2.0 framework, if you want to compile the source you will probably require MS Visual Studio (Express should be ok), although it may work with SharpDevelop or Mono.

It is a console application (sorry, no pretty GUI this time) that reads the contents of input.txt (in the same directory as the app), it then counts the occurrences of each character and outputs the results to the console. Simple!

If you make any improvements to the code please leave a comment and/or email the changes to me: gringod [at] gmail [dot] com.

Recently I’ve had reason to take an code library written in C++ and port it to C#.  Whilst I dabbled in C++ on a compilers course at university, I hated it then and I still hate it now.  I personally think it’s an abomination and should be consigned to the great garbage collector in the sky.   Whilst I can just about read the C++ syntax there is a lot that I don’t understand about it.

The library I was porting had semi reasonable documentation outlining what classes exist and their methods and a brief description of the overall usage.  This gave me a good starting point, however the documentation didn’t include example usages and expected results, for this I was forced to delve into the code.

One development paradigm I have been interested in but have been unable to find a decent project to test it on is Test-Driven-Development and this seemed like the perfect project to try it on.  So I set to work on the first iteration getting the test set up.   Without knowing exactly what results I should be expecting I was finding it hard going, so once again I dived back into the old code.

Thankfully, the developers of the C++ library had create a fairly comprehensive set of unit tests and with my limited C++ knowledge and a text editor with RegEx Find & Replace I was quickly able to convert their unit tests into NUnit based unit tests.

For example, what started out life as:

 1: void test_row_multiply_change(void)

 2: {

 3:  row r;

 4:  RINGING_TEST( ( r *= change( 6, "X" ) ) == "214365" );

 5:  RINGING_TEST( ( r *= change( 6, "1" ) ) == "241635" );

 6:  RINGING_TEST( ( r *= change( 8, "X" ) ) == "42615387" );

 7:  RINGING_TEST( ( r *= change( 5, "3" ) ) == "24651387" );

 8:  

 9:  RINGING_TEST( row( "214365" ) * change( 7, "5" ) == row( "1234675" ) );

 10: }

Quickly became:

 1: [Test]

 2: public void TestMultiplicationByChange()

 3: {

 4:  Row r = new Row();

 5:  Assert.AreEqual((Row)"214365", r *= new Change(6, "X") );

 6:  Assert.AreEqual((Row)"241635", r *= new Change(6, "1"));

 7:  Assert.AreEqual((Row)"42615387", r *= new Change(8, "X" ));

 8:  Assert.AreEqual((Row)"24651387", r *= new Change(5, "3"));

 9:  

 10:  Assert.AreEqual((Row)"1234675", new Row("214365") * new Change(7, "5"));

 11: }

Now, with a full set of unit tests at my disposal I was quickly able to bash away at the library and very quickly got working code without the need to trawl through ghastly C++ code.

Hooray for Test-Driven-Development and three cheers for Test-Driven-Porting.

ps. The library I’m porting is an open source library for Bell Ringing - yes I know I’m a geek but anyone that has followed everything else in this post must also be a geek ;-).  Once I’m finished I will be releasing my code under an open source license as well, I just need to pick the right one.

pps. I may have exaggerated my hate of C++ a little.  I believe all languages have their place, even the esoteric languages like LOLCode.