Anders Norås' blog

Blog moved...

anoras — Tue, 13 Feb 2007 10:01:00 GMT

This post is a reminder that this blog has moved to http://andersnoras.com/

Please updated your subscriptions:
RSS 2.0: http://andersnoras.com/blogs/anoras/rss.aspx
ATOM 1.0: http://andersnoras.com/blogs/anoras/atom.aspx

Blog moved...

anoras — Tue, 06 Feb 2007 20:25:00 GMT

HTTP 301: Blog moved!

anoras — Tue, 30 Jan 2007 23:11:00 GMT

Hello faithful reader!

This blog has moved to http://andersnoras.com/blogs/anoras

Please updated your subscriptions:
RSS 2.0: http://andersnoras.com/blogs/anoras/rss.aspx
ATOM 1.0: http://andersnoras.com/blogs/anoras/atom.aspx

I'm back!

anoras — Fri, 15 Sep 2006 15:58:00 GMT

I've just returned from the JavaZone 2006 where I gave a talk entitled "Our Stuff, Your Way - Developing Microsoft .NET Applications with 'Java' Frameworks", and reckoned that this would be a good occasion to get back into blogging. I've had a super busy few months, so this conference was one of the few chances I've had to go out and meet industry coleagues in a while. Judging by the number of sessions I actually found time to see, I suspect it was by time I went to an event like this.

On Tuesday I went to the speakers dinner party were I got to meet a few living legends such as Mary Poppendieck, Rod Johson and Gregor Hophe to name a few. The latter also put on a "Drinks are on Google" party at the sky bar of the hotel later that night. I had one or two drinks too many on Google, so I should really go click some ad-words to pay them back.
Wendsay mornig I did my talk on developing .NET applications "the Java way". I was a bit disappointend by the attendance, but the people who were there seemed to enjoy it. (http://blogs.ittoolbox.com/bi/confessions/archives/JavaZone-06-Day-1-11659). My talk was a quick run through of how Java developers could just their knowledge of popular frameworks like Spring and Hibernate, to develop .NET-apps with the ports of these frameworks. To close the circle, I rounded it off by showing off how one could apply some voodoo magic to program directly against log4j, or any other Java library, from within a regular .NET application. This was without doubt the most popular demo in my presentation, and also the demo that spawned the most questions. You should find the slides from my talk here: http://217.199.33.59/jz/2006/slides/4513.pdf

The session was both recorded as a podcast and video with intention to publish after the conference so stay tuned to links to those as well.

After lunch, I met up with Bruce Tate, the author of the "Bitter Java" and "Beyond Java" books, to sit down an do a back-to-back comparision of C# 3.0 and Ruby. As allways, LINQ is impressive, but C#'s extension methods aren't nearly as cool as some of the stuff you can do with Ruby mixins. I'll try to write a proper post on this some time soon.

I rushed off to do a panel discussion on SOA immediatly after my meeting with Bruce. The panel was a meet the experts forum, where the conference attendatnts were taking part in the discussion. Apart from myself, people like Interface21's Arjen Poutsma (http://blog.springframework.com/arjen/) who is the dev lead of the Spring Web Serivce framework, Mads Nissen and IBMs Gobal Sales Manager for their WebSphere suite, amongst others. We made no real, hard conclusions, but there seemd to be a consenus that a service's data was more important than its operations and that contracts should be spilt in operational and data contracts.

Wedensday night was party-night. Being tired from the night before, I kept my cool and went home after having a beer with Kevlin Henny and chatting about lean methods, kids and moving house.

Thursday I had a long meeting with Microsoft's Jürgen Pfeifer mostly about my current project which I can't tell you much about due to a NDA, but it's a large service oriented application for an insurance company. Naturally our talk was around SOA-stuff like orchestration and governance.

Later I gave a more detailed version of my "using JAR's from C#" demo to Alexandru Popescu (http://themindstorms.blogspot.com/), extending it to also using .NET assemblies from a Java application. It was the first time he'd seen a thing like that done, and I was real cool to help him out with a problem he'd been think about for some time.

During the entire conference I only saw one presentation, which was Erik Doernenburg (http://erik.doernenburg.com/) and Gregor Hohpe's (http://www.enterpriseintegrationpatterns.com/ramblings.html) talk on software visualization. The rest of the time I just hung around, talking to people. This is one of the cool things about the JavaZone conference, the atmosphere is really laid-back and allmost every session is either web or podcasted, so you can catch them after the conference. This year it was all networking and having a fun time for me.

IKeyComparer?

anoras — Sun, 19 Mar 2006 21:05:00 GMT

The preperation guide for 70-536 Microsoft .NET Framework 2.0 - Application Development Foundation points to the IKeyComparer and the IHashCodeProvider interfaces as fundamentals you should be proficient with before taking the test. There is no such thing as an IKeyComparer interface in the .NET Framework 2.0 - the interface was removed after beta 1. The IHashCodeProvider interface has been marked obsolete in .NET 2.0 and you should use the IEqualityComparer interface instead.

The beta 1 design of the IComparer interface grouped all comparison related methods into a single interface to avoid a common design fault from .NET 1.1, where one could pass an incompatible pair of IComparer and IHashCodeProvider to the Hashtable constructor. After shipping beta 1 of .NET 2.0, Microsoft split their original IComparer interface into the IEqualityComparer and a new definition of IComparer after realizing that the new design introduced incompatabilies with classes that currently didn’t implent IComparable and that the IComparable.CompareTo(T) method required types to have natural ordering.

The IKeyComparer was in essence both an IHashCodeProvider and an IComparer that was intended to be used to compare dictionary keys based on hashcode equality, thus avoiding the .NET 1.1 scenario where one could pass an IHashCodeProvider that considered two instances equal along with an IComparer that considered the same instances as inequal making the Hashtable indexer fail to find a value with a given key.
You might also have heard of an interface called IHashComparer. This was a proposed name for the IKeyComparer interface during the beta 2 refactoring, but this interface was not included in the final release of .NET 2.0.

The one interface you should know is IEqualityComparer. This is a special interface that should only be used for determining equality, and not for sorting. The interface is particularly handy for culture aware comparisons such as determing that the German words ”weiss” and ”weiß” are the same.

How To: Strongname Inheritance Demands at Runtime

anoras — Thu, 02 Mar 2006 13:18:00 GMT

Yesterday a client of mine had an interesting challenge. He had a sealed class which he needed to “unseal” due to some changes in his project. However he needed to control who could inherit the class and applied a StrongNameIdentityPermissionAttribute with an InheritanceDemand action to the class. He soon learned that the XmlSerializer cannot serialize types with declarative security. This is by design in the .NET framework, since XML serialization is achieved through runtime generated types for performance reasons. A common workaround is to apply imperative security in lieu of declarative security. However, since InheritanceDemand is a load time security assertion, this was not a feasible option for my client.
The solution to the challenge was to recreate the inheritance demand action in the class’ constructor as shown below.
public abstract class InheritanceDemandingClass
{
    protected InheritanceDemandingClass()
    {
        byte[] myPK = typeof(InheritanceDemandingClass).Assembly.GetName().GetPublicKey();
        byte[] callingPK = Assembly.GetCallingAssembly().GetName().GetPublicKey ();
        if (callingPK==null || myPK.Length!=callingPK.Length)
        {
            throw new SecurityException("The calling assembly does not have permission to create this type.");
        }
        for (int i = 0; i < myPK.Length; i++)
        {
            if (myPK[i]!=callingPK[i])
            {
                throw new SecurityException("The calling assembly does not have permission to create this type.");
            }
        }
    }
}

The above code compares the calling assembly’s public key with the class’ public key and throws a SecurityException if the two assemblies aren’t signed with the same key. This simple solution should be sufficient for most scenarios, as the common usage for inheritance demands is to ensure that only your types can extend your types. However the example can easily be extended to support other keys or public key tokens as well.
There are some differences with this approach and using declarative security; the type can be reflected since the security assertion happens at runtime, and you cannot use permview.exe to see what demands the type makes. If imperative security was applied you would still have both of these issues.

Heisenbugs and Conditional Breakpoints

anoras — Wed, 01 Mar 2006 17:58:00 GMT

Have you ever heard the term Heisenbug? If not, it is adopted from Heisenberg’s Uncertainty Principle in quantum physics. An Heisenbug is a bug that disappears or alters its behavior when one tries to observe it. In physics the principle states that on cannot assign the precise values of observable variables of a single particle even in theory. In software engineering a Heisenbug might be introduced by some force applied when debugging an application. Some Heisenbugs appear in the code, for instance within an if statement relying on System.Diagnostics.Debugger.IsAttached. With such a bug, the debugger will step into the infected code and you’re likely to spot the problem straight away. However, debuggers have more esoteric ways of introducing Heisenbugs that aren’t easily spotted. One particularly nasty Heisenbug I’ve seen a couple of times is introduced by conditional breakpoints. If you’re a C# developer and you forget that the equality operator in C# is “==” and not “=” you’re prone to Heisenbugs. Consider the following snippet:

31 IContext context=new Context();
32 context.Request request = new Request();
33 context.Request.Payload = ExtractMessageBody(soapServerMessage);
34 Uri actionUri = new Uri(soapServerMessage.Action);
35 string serviceName = actionUri.Segments[actionUri.Segments.Length - 1];
36 request.ServiceName = serviceName;
37 PipelineController.Execute(context);

Let’s imagine that the implementation of the PipelineController.Execute method is complex and uses a myriad of other classes to perform the desired operation. During testing you discover that when a certain service is requested the class does not behave as expected. To save yourself from endless F11 tapping, you set a conditional breakpoint at line 35 with the condition: serviceName=”BillingService”
When you try to figure out what is going on, all sorts of weird things start to happen. Requests for the “BillingService” receive messages used with the “OrderService” and the application seems to be horribly broken.
Unexplainable behavior like this is often an Heisenbug. In the scenario described above the conditional breakpoint assigns the value “BillingService” to then serviceName variable whenever the execution pointer passes, hence the value of request.ServiceName will always be “BillingService”. Since they’re not apparent in code, Heisenbugs like this are devious and though to spot, so be sure to pay as much attention to your break conditions as your “real” code, even during the most intense debugging sessions or else conditional breakpoints soon become a timewaster rather than a timesaver.

Connected Systems: A "Real-life" Example

anoras — Thu, 19 Jan 2006 20:44:00 GMT

The CTO at the company I work for sent me this link today. It is a perfect example of a Connected System. The "system" employs many of the common patterns used to build a connected system, such as pipes and filters, queues and stacks, routing , content enrichers and compression and many many more. Enjoy!

Visual Basic 2005 Does Not Support Friend Assemblies

anoras — Tue, 10 Jan 2006 20:57:00 GMT

I’ve gotten some feedback from Visual Basic .NET developers having trouble following my “How To” on code coverage and IL Merge. I turns out that the Visual Basic .NET 2005 compiler doesn’t support the InternalsVisibleTo attribute. After adding the attribute to an assembly, you won’t get any IntelliSense for the internal, or fiend in Visual Basic lingo, members. When you try to build the solution the compiler will raise a BC30390 compilation error akin to 'MyClass.Private Function MyMethod(x As Integer, y As Integer) As Integer' is not accessible in this context because it is 'Private'. Unfortunately, there is no workaround for this, so Visual Basic developers either have to spilt their projects into a handcrafted code project and a generated code project, and live with the housekeeping implications of having twice as many assemblies to deploy, or live with skewed code coverage results.

How To: Exclude Generated Code From Code Coverage Analysis

anoras — Sun, 08 Jan 2006 21:38:00 GMT

To ensure that your unit tests exercise your code properly, you’ll need sufficient code coverage. Your coverage should be as close as possible to 100 percent. However, if your code base includes generated artifacts, such as resource accessors or strongly typed datasets, it is unlikely that you’ll come close to this figure. This is because the generated code has methods and properties for a wide variety of usages, many more than you’re actually using, thus leaving lots of untested code in your project. Since generated code skews your code coverage results, factoring generated code to separate assemblies is a common practice to avoid misleading code coverage metrics. A basic example is to have datasets in one project and business components in another project with a reference to the dataset project. This solves the code coverage issue, but it also introduces some other issues. Since one logical assembly has to be split into two or more physical assemblies, you’ll lose cohesion between the different logical assemblies. This might not be an issue during development, but you’ll at least have twice as many assemblies to deploy, version and maintain when the solution goes to production. Michael Barnett of Microsoft Research has developed a tool called IL Merge which can be used to merge multiple .NET assemblies into a single assembly. If you’re familiar with C-programming, IL Merge is akin to a linker.

For the remainder of this post I’ll show how you can factor a resource accessor out of a business component project to its own project, make the internals of that project available to the business component project (resource accessors aren’t publicly visible) and use IL Merge to merge the two assemblies into one.

I have created a small Visual Studio 2005 solution with two projects, one for business components and another for resources.

As mentioned earlier the generated resource accessor class is an internal class, and hence it is not available outside the assembly itself. There are numerous ways you can access the internals of one assembly from another. The most elegant is to use the .NET 2.0 InternalsVisibleTo attribute. This attribute allows you to declaratively give one or more assemblies access to the assembly’s internal members. The following declaration has been added to the ClassLibrary.Resources project’s AssemblyInfo.cs file. [assembly:InternalsVisibleTo("ClassLibrary")]

For a thorough discussion on InternalsVisibleTo and the other options available for accessing one assembly’s internal members from another, see my post “InternalsVisibleTo, StrongNameIdentityPermission and reflection”.

The internals of ClassLibrary.Resources are now available from within the ClassLibrary project with IntelliSense and other Visual Studio comforts just like if both the resources and the code had been part of the same project. An important difference is that the code base is spilt into two assemblies, so that you’re able to instrument just the ClassLibrary assembly and get accurate code coverage results.

When the unit test have been run (with code coverage instrumentation) you can then merge the two into a single assembly by using the IL Merge tool.

As you would expect, the merged assembly contains both the business component from the ClassLibrary project and the resources from the ClassLibrary.Resources project. Also note that it is a regular .NET assembly, so you can add it as a reference to any other project, sign it with your strong name key or similar.

Typically you would merge the two assemblies either when you package a release version of your code or from within your continuous integration build script prior to deploying it to a test rig.

There is a NAnt task for IL Merge available for download here. I’m not aware of a MSBuild task for IL Merge, but you can easily run IL Merge from your MSBuild script using the Exec task as shown below

    <Project DefaultTargets="CompileUserControls"
     xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
     ...
     <Target Name="MergeAssemblies">
     <Exec Command="$(ILMergeEXE) /out:$MergedClassLibrary.dll
     ClassLibrary.dll ClassLibrary.Resources.dll" />
     </Target>
     ...
    </Project>

I believe this is an elegant solution to a problem which almost everyone doing Test Driven Development on the .NET platform run into. However, one feature I’d really like to see in Visual Studio Orcas is the ability to declaratively exclude types, or even members from code coverage instrumentation. This could very well follow the same convention used to suppress static analysis rules with System.Diagnostics.CodeAnalysis.SuppressMessageAttribute since this would allow any vendor to support it without forcing developers to reference a particular assembly in their code (SupressMessageAttribute is defined in mscorlib.dll). The solution described in this post is vendor neutral and works just as good with Team Test as with Clover.NET or any other code coverage analyzer.

Off topic: Best Albums of 2005

anoras — Fri, 16 Dec 2005 23:27:00 GMT

Anthony and The Johnsons – I am a Bird Now
I am a Bird now was released back in January, and it has been on heavy rotation on my iPod ever since. Anthony has a voice like the late, great Nina Simone who had a deep, masculine voice. This is a striking coincidence on songs such as “For Today I am a Boy” which is about the travails of transgender confusion with its heartbreaking line “One day I’ll grow up to be a beautiful woman, but for now I am a boy”. Musical highlights: My Lady Story, Hope There’s Someone
Arcade Fire – Funeral
Funeral is a stunningly brilliant album, filled to the rim with emotional intensity. The Arcade Fire blends the sounds from great bands from the 1980s post-punk scene, The Pixies and Roxy Music to name a few, to create their own, new and refreshing soundscape. The album was released in Canada in 2004, but it didn’t get a proper European release until this year. Musical highlights: Neighborhood #1 - #4.
My Morning Jacket - Z
After two releases that didn’t really appeal to me, My Morning Jacket rises like a phoenix with Z with an entirely new sound. The music is spontaneous and doesn’t seem to follow any conventional musical patterns. A pleasant surprise. Musical highlights: Wordless Chorus, Anytime
Kate Bush – Aerial
Kate Bush has always gone her own way, and her “comeback” this year is no exception. The double album is musically expansive, where everything from birdsong to eighties inspired synths and jazz elements blend into a lush musical journey. The lyrics are eerie, deeply personal and they grab you right from the beginning. Musical highlights: A Sky of Honey (The suite which makes up CD 2).
Sigur Rós – Takk
Takk is an album with quite, yet still noisy music that is pure bliss. I can’t understand a word they’re singing since the lyrics are in either Icelandic or in the fabricated Hopelandish language, but this makes the album even more wonderful as the beautiful vocals come across as musical instruments. Musical highlight: Hoppipolla, Glósóli
The Magic Numbers – The Magic Numbers
The Magic Numbers is the most perfect pop record of the year with great lyrics, incredible hooks and great SoCal style harmonies. Musical highlights: Forever Lost, Love Me Like You, Love Is a Game
Bell Orchestre – Recording a Tape The Colour of Light
Bell Orchestre is a spin-off from many bands in the Montréal scene, with members from bands like Arcade Fire. Their music can best be describes as a mash of chamber music and post punk. The album isn’t easily accessible, but once you get your ears around it you’re sold. Musical highlights: Les Lumineres pt. 1
Little Brother – The Minstrel Show
While you’ll probably have to browse the hip-hop section of your local record store to find this album, this album is the opposite of your regular rap album. The Minstrel Show is a concept album centered on a television show which acts as a metaphor for everything that is wrong with today’s mainstream hip hop. Musical highlights: The experience as a whole, which is rare with hip hop albums these days.
Sufjan Stevens – Illinoise
Illinoise is a sprawling musical celebration, which encompasses a vast set of musical styles, blended into magical, sophisticated arrangements. This is a great album. Musical highlights: Come Feel The Illinoise
Dangerdoom – The Mouse and The Mask
The collaboration between MF Doom and production genius Danger Mouse has resulted in a playful album that is heavy on novel details in both rhyme and rhythm. Musical highlights: Sofa King, Aqua Teen Hunger Force
Death Cab for Cutie – Plans
Devendra Banhart – Cripple Crow
Fat Freddie’s Drop – Based on a True Story
Brian Eno – Another Day on Earth
Jaga Jazzist – What We Must
Iron & Wine and Calexico – In the Reins (EP)
John Legend – Get Lifted
Kari Bremnes – Over en by
M.i.A. - Arular
Jamie Lidell – Multiply
Roots Manuva – Awfully Deep
Archer Prewitt – Wilderness
Iron & Wine – Woman King (EP)
Moneybrother – To Die Alone
Amadou et Mariam – Dimance à Bamako
Steve Reid Ensemble – Sprits Walk
Common – Be
Porn Sword Tobacco – Explains Freedom
…and You Will Know Us By The Trail of Dead – Worlds Apart
Emiliana Torrini – Fisherman’s Woman
Edan – Beauty and The Beat
Low – The Great Destoyer
The Herbaliser – Take London
VHS or Beta – Night on Fire
Andrew Bird – And The Mysterious Production of Eggs
Boards of Canada – Campfire Headphase
Pat Metheny – The Way Up
Quasimoto – The Further Adventures of Lord Quas
Clap Your Hands and Say Yeah! – Clap Your Hands and Say Yeah!
The Fiery Furnaces – Rehearsing My Choir
Harold Budd & Eraldo Bernocchi – Fragments Form The Inside
The Dandy Warhols – Oddatorium or Warlords of Mars
Harmonic 33 – Music for Film, Television and Radio vol. 1
Broadcast – Tender Buttons
Depeche Mode – Playing the Angle
M83 – Before the Dawn Heals Us
Sinéad O’Connor – Throw Down Your Arms
Buck 65 – Secret House Against The World
Nostalgia 77 – The Garden
The Perceptionists – Black Dialogue

Comparing cloned objects

anoras — Sat, 10 Dec 2005 15:21:00 GMT

My co-worker Kjell-Sverre Jerijærvi has posted a cool follow up to my “How to: Deep clone any serializable object” post. His example shows a generic IsClone method which uses serialization and MD5-hashing to determine whether two different object instances are clones of each other. Nice one, Kjell-Sverre.

DuckUnit

anoras — Wed, 07 Dec 2005 23:29:00 GMT

Some weeks ago I downloaded the new beta of Test Driven .NET. As you might know the beta is available through Folder Share, which basically is a peer to peer network. Trying to support Jamie’s excellent tool I kept the share open to help distribute Test Driven .NET. A cool side-effect from this is that I automatically get all the latest files downloaded to my computer. I’ve got my shared folder in a sub folder beneath My Documents, and my information client of choice; Jet Brains’ excellent Omea Pro keeps track of changes to files in My Documents. Earlier today I noticed that a mysterious, new folder named DuckUnit had appeared. When I opened the folder to take a closer look at what it was I discovered the creator of Test Driven .NET, Jamie Cansdale was up to something again. DuckUnit is a testing framework that let’s you specify units test by applying a custom XML code comment named test to your methods. For example:

    /// <test x="1" y="2" z="3">6</test> 
    public int Sum(int x, int y, int z)
    { 
     return x + y + z;
    }

The attributes correspond to the arguments of the method, and the inner text of the element to the expected result. The framework also lets you define your test data in separate XML documents, using the standard include directive:

    
    /// <include file="PrimeTests.xml" path="tests/test/" />
    static bool IsPrime(int num)
    {
     int max = (int)Math.Sqrt(num) + 1;
     for (int count = 2; count < max; count++)
     {
      if (num % count == 0) return false;
     }
     return true;
    }

The need to have some arbitrary test data to use within your unit tests is common. Usually I’ve restored to having DataSets with test data or serialized mock objects stored as XML within my test projects. I really like the idea of being able to inject test data into my unit tests in a declarative fashion. Especially when you can use the include statement to separate the test data from the actual test. I’d really like to see some examples of how to use more complex types as arguments for the test methods, but a primitives only solution is a good start. Maybe parameterless unit test soon will be a relic of days gone by?

Dynamic Methods and Humane Interfaces

anoras — Wed, 07 Dec 2005 22:17:00 GMT

One of the key differences between C-style languages such as C# or Java and Ruby is how libraries are designed. The Ruby crowd has coined the term “Humane Interface” describing their style of defining class interfaces. A good example is Ruby’s List type which exposes a whooping 78 instance methods, while .NET’s ArrayList class has less than twenty if you leave out the overloads. The generic List<> in .NET 2.0 has some more, but still the methods are all low-level. A good example of syntactic sugar in Ruby’s List is the flatten method which flattens a multi-dimensional array.

[1,2,[3,4,[5,6],7],8].flatten => [1, 2, 3, 4, 5, 6, 7, 8]

When I teach developers about refactoring, I often use an example I’ve borrowed from Joshua Kerievsky’s Refactoring to Patterns book to show how code can be more readable or more humane if you like; November(20, 2004) where November is a public static method accepting the day of month and the year as its arguments. The November method communicates its behavior better compared to new DateTime(2004, 11, 20) which requires you to have knowledge of the System.DateTime constructor.

Examples like the one above might seem a bit over the top, but successful Ruby frameworks such as Ruby on Rails have similar methods that have been essential to the libraries success. For instance; Ruby on Rails has a pluralize method which gets the plural form of most English nouns. Why would you need such a method? The answer lies in Ruby on Rails convention over configuration philosophy, where instances of a User class are expected to be persisted in a Users table in the database. The pluralize method makes this convention easy to apply.

John Lam has been doing some really interesting experiments with programming Ruby with the CLR, and his latest project is a great example of how Ruby’s humane interface philosophy makes Reflection.Emit, which is one of the least approachable namespaces within the .NET framework, much easier to use.

    create_ruby_method('say_hello') do
      ldstr 'Hello, World'
      call 'static System.Console.WriteLine(System.String)'
      ldc_i4_4 
      ret
    end

Above is an example of how to use his RbDynamicMethod library to create a CLR DynamicMethod from Ruby. Although MSIL still is cryptic to most, being able to write “MSIL code” within the source code is much easier than using OpCodes to emit MSIL code. Below is the same example using the .NET 2.0 Lightweight Code Generation (LCG).

    public class DynamicMethodExample
    {
      public static void Main(string[] args)
      {
        DynamicMethod method = new DynamicMethod("SayHello", 
               typeof(void), new Type[] {}, typeof(DynamicMethodExample), false);
        ILGenerator gen = method.GetILGenerator();
        gen.Emit(OpCodes.Ldstr, "Hello, World!"); 
        gen.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", 
               new Type[] { typeof(string) }));
        gen.Emit(OpCodes.Ret);
       }
    }

The lightweight in LCG has its place. In .NET 1.x you could emit the Hello World part of the above example in three lines of code, but you would typically need approximately 10 more lines of code to setup the classes needed to do this. The LCG is a huge improvement, but I still find John’s MSIL code more appealing than using reflection to get hold of MethodInfo’s and similar.

Another example of how class interfaces can be more humane is .NET’s EventLog class which throws an ArgumentException with information on how to resolve the error when the class is used without being properly configured. Such a message gives developers instant clues on what might be wrong, and can save them hours of mucking about with the debugger.

The syntactic sugar added to C# 3.0 and Visual Basic 9 in particular make the languages more expressive, and the LINQ framework provides a great abstractions allowing developers to do complex operation in just one or two lines of code. These new additions to the .NET development environment make the general developing experience more humane. Humane interfaces are a trend that reaches way beyond the small Ruby community, and you should always look for options to make your class interface more humane. Even if your core classes might require more maintenance over time, the client code will be easier to maintain since the code base will be much smaller, more expressive and readable.

Dating Patterns

anoras — Fri, 02 Dec 2005 22:54:00 GMT

I came across a book called Dating Patterns by Norwegian writer Solveig Haugeland at Amazon, and it is the ultimate Christmas gift idea for any geek singleton. It is unlikely that I’ll practice any of the patterns in the book since my significant other strongly disapproves “multi threading”, but I’ve been through many of them unconsciously during my bachelor days. I tried to come across a Cary Grant Helper, but at the end of the day I probably was more of a Half Bad Boy Plus Protocol. Thinking back, I’ve probably got plenty of material for a dating anti-patterns book of my own.