Code Of The Week

Elegant Code

Ayende Rahien — Thu, 27 Mar 2008 09:03:13 GMT

I just finished writing this, and I find it very pleasing to look at:

public class EntitiesToRepositories
{
	public static void Register(
		IWindsorContainer windsorContainer,
		ISessionFactory sessionFactory,
		Type repository,
		params Assembly[] assemblies
		)
	{
		if(typeof(IRepository<>).IsAssignableFrom(repository))
			throw new ArgumentException("Repository must be a type inheriting from IRepository<T>, " + 
                                    "and must be an open generic type. Sample: typeof(NHRepository<>).");

		foreach (IClassMetadata meta in sessionFactory.GetAllClassMetadata().Values)
		{
			Type mappedClass = meta.GetMappedClass(EntityMode.Poco);
			if (mappedClass == null)
				continue;
			foreach (Type interfaceType in mappedClass.GetInterfaces())
			{
				if(IsDefinedInAssemblies(interfaceType, assemblies)==false)
					continue;
				windsorContainer.Register(
					Component.For(typeof(IRepository<>).MakeGenericType(interfaceType))
						.ImplementedBy(repository.MakeGenericType(interfaceType))
						.CustomDependencies(Property.ForKey("ConcreteType").Eq(mappedClass))
					);
			}
		}
	}

	private static bool IsDefinedInAssemblies(Type type, Assembly[] assemblies)
	{
		return Array.IndexOf(assemblies, type.Assembly) != -1;
	}
}

Tricky Code

Ayende Rahien — Mon, 31 Dec 2007 11:31:07 GMT

Without running the code, what is the result of this masterpiece?

class Program
{
	static void Main(string[] args)
	{
		DoSomething("a","b");
	}

	public static void DoSomething<T>(IList<T> set)
	{
		Console.WriteLine(set.Count);
	}

	public static void DoSomething<T>(params T[] items)
	{
		List<T> set = new List<T>();
		foreach (T t in items)
		{
			if (t == null)
				continue;
			set.Add(t);
		}
		DoSomething(set);
	}
}

It surprised the hell out of me until I figured out what was going on, then I was very amused. This code works exactly as it should be, to produce a very different result than the expected one.

Code that makes me laugh

Ayende Rahien — Mon, 17 Dec 2007 18:52:39 GMT

Going into a new code base

Ayende Rahien — Fri, 30 Nov 2007 23:46:52 GMT

I had a chance at DevTeach to just take an hour and start looking at a large code base. I made the claim several times in the past that no matter the quality of the developers and the quality of the code base, there is no way someone can just sit down on a code base and start working on that.

I tried to grok the code without help, and I failed. I could probably do that, but it would take several days. That was especially true since it was in Windows Forms, and that is not a field that I have done much at. Not knowing anything about the actual domain was a big issue as well.

After about 30 minutes of sitting down and going over the code with the developer, I got a whole new level of understanding about the application. How it works, how the structure is built. I look at a test and can work how this is used, etc.

I still have very little knowledge about that application works, but after 30 minutes, I am confident in my ability to both grok the code and work with it. In fact, after getting the introduction to the code base, I can say that this is probably one of the better code bases that I have seen.

One of the more interesting parts was that when I looked at each class, it was when I took a step back and looked at the interactions it gotten really interesting.

It was a pleasure to read the code.

Pushing the limits

Ayende Rahien — Mon, 17 Sep 2007 12:14:35 GMT

Okay, I just finished writing this piece of code, I am not quite sure how to treat this. It is either elegantly concise or horribly opaque.

I suspect both.

Somehow, you can probably wee that I have a C++ background, and even though the CLR doesn't give me the entire thing, you can still push it fairly far.

Of course, it still makes my head feel like this sometimes:

Can you figure it out? Functional caching

Ayende Rahien — Sat, 04 Aug 2007 12:44:24 GMT

Okay, here is a challenge, without running the code, what do you think should be the result of this program, and why?

public class Program
{
	private static void Main(string[] args)
	{
		Fetch<int> method = Get;
		method = AddCaching(method);

		method();
		method();
		method();
	}

	public static int Get()
	{
		Console.WriteLine("Called");
		return 1;
	}

	public delegate T Fetch<T>();

	public static Fetch<T> AddCaching<T>(Fetch<T> fetch)
	{
		T cachedObject = default(T);
		bool isCached = false;
		return delegate
		{
			if (isCached == false)
			{
				cachedObject = fetch();
				isCached = true;
			}
			return cachedObject;
		};
	}
}

Did you know: Find out if an exception was thrown from a finally block!

Ayende Rahien — Tue, 19 Jun 2007 21:47:53 GMT

This is a big biggie for me, because it enables a much nicer syntax for a lot of stuff. But first, let us show this:

using(new ExceptionDetector())
{
	if(new Random().Next(1,10)%2 == 0)
          throw new Exception();
}

How can you tell, from the ExceptionDetector, if an exception was thrown or not? Well, conventional wisdom, and what I thought about until 15 minutes ago, says that you can't. I want to thank Daniel Fortunov, for teaching me this trick:

public class ExceptionDetector : IDisposable
{
    public void Dispose()
    {
        if (Marshal.GetExceptionCode()==0)
            Console.WriteLine("Completed Successfully!");
        else
            Console.WriteLine("Exception!");
    }
}

Amazing!

Understanding Bad Code

Ayende Rahien — Mon, 18 Jun 2007 20:36:52 GMT

Frans' contribution to the conversation about maintainable code deserve its own post, but I would like to mention this part in particular:

you will not [understand the code]. Not now, not ever. And not only you, but everyone out there who writes code, thus that includes me as well, will not be able to read code and understand it immediately.

You know what? That is not limited to bad code. I had hard time grokking good code bases, simply because of their size and complexity (NHibernate and Windsor comes to mind). Other code bases are as large, but they have easier approachability, probably because they are dealing with less complex domain an tend to have a wide coverage rather than deep (MonoRail comes to mind).

A while ago I was involved with an effort to migrate an ancient system to SQL Server 2005. The system compromised of over 100,000 lines of code, spread over some thousands of files scattered randomly in a case sensitive file system (you can guess why this is significant). The code base was about 85% SQL and 15% bash shell scripts. The database in question was a core system and contained slightly over 4,000 tables. One of the core tables was called tmp1_PlcyDma and was used to do business critical processing. That code base took data driven code generation to a level I have never seen before. I gave up trying to track down 7(!) levels of code->generating code->execute code->generating code->rinse->repeat

To say that the code base was bad is quite an understatement. To mention that the only place where I could run the code was by using a telnet console into a test environment that was not identical to production is only the start. I could mention no debugging, runtime of ~5 hours, test time of ~3 hours, etc. The code grew organically over a ten years period and you could track the developer progress from merely annoying to criminally insane (he invented his own group by construct, using triple nested cursors and syntax so obscure that even the DBA that worked with the system for the last 5 years had no idea what was going on).

Perhaps the thing that I remember most from this project that we had a bug that kept two people hunting after it for three weeks. The issue was a missing ';'. Oh, and the criteria for success in this project was successful migration, with bug-per-bug compatibility, and no one really knew what it did, including the authors(!).

But, you know what, after a month or so of looking at the code, it got to the point where I could look at something like pc_cl_mn.sql and know that it would contains the monthly policy calculation, and that this piece of code was doing joins manually via cursors again, that plcy_tr_tmp.sql was the "indexes priming" script, etc, etc.

The code was still a horror, but once you understood that the authors of this code had a... "special" way of looking at databases, you got to the point where you could get the point of the code in an hour instead of a day, and then move that to a saner approach.

So, what does this horrifying story has to do with Frans' point above?

The premise that you can read and understand code immediately is highly dependant on what you are familiar with. I know of no one that can just sit in front of an unfamiliar code base and start producing value within the first ten minutes. But on a good code base, you should be able to be able to start producing value very quickly.

rails:ConditionalRender - still trying to get WebForms to work right

Ayende Rahien — Wed, 06 Jun 2007 19:51:40 GMT

Well, as it turns out, there are some things that you can do to make WebForms more palatable. Smart use of ITemplate and some additional magic can take you a fairly long way. I am still severely limited (splitting behavior between markup & code behind is extremely annoying) in what I can do, but it is good to know that it is possible:

<rails:ConditionalRenderer runat="server" 
    Condition="<%# ((Policy)Container.DataItem).Expired %>"
    DataItem="<%# Container.DataItem %>" >
    <WhenTrue>
        Policy has expired!
    </WhenTrue>    
    <WhenFalse>
        Policy is valid until <%# Eval("ExpiryDate") %>
    </WhenFalse>
</rails:ConditionalRenderer>

I am using it inside a repeater to keep the presentation logic in a single place.

The code to make this happen is something like this (typed from memory, you need about 80 lines to get it right).

[ParseChildren(true)]
public class ConditionalRenderer : Control, INamingContainer
{
    public bool Condition { get { .. } set { .. } }

    [Templatecontainer(ConditionalRenderer)]
    public ITemplate WhenTrue { get { .. } set { .. } } 
    [Templatecontainer(ConditionalRenderer)]
    public ITemplate WhenFalse { get { .. } set { .. } }

    public object DataItem { get { .. } set { .. } }
    
    public override void EnsureChildControls()
    {
        if (Condition)
            WhenTrue.InstansiateIn(this);
        else
            WhenFalse.InstansiateIn(this);
    }
}

Unmaintainable Code

Ayende Rahien — Mon, 21 May 2007 15:08:24 GMT

I have several ways of categorizing code. Production quality, test, demo, and utilities. When I am talking about utilities, I am talking about little programs that I use to do all sorts of small tasks. There I rarely worry about maintainability, and today there was a gem here:

public delegate Control BuildSpecialCase(TextBox textbox);

private BuildSpecialCase GetSpecialCaseControl(string name)
{
if (name.IndexOf("ConnectionString", StringComparison.InvariantCultureIgnoreCase) != -1)
{
  return delegate(TextBox t)
  {
   Button change = new Button();
   change.Click += delegate { t.Text = PromptForConnectionString(t.Text); };
   change.Dock = DockStyle.Right;
   change.Text = "...";
   change.Width = 30;
   return change;
  };
}
if (name.IndexOf("File", StringComparison.InvariantCultureIgnoreCase) != -1)
{
  return delegate(TextBox t)
  {
   Button change = new Button();
   change.Click += delegate
   {
    OpenFileDialog dialog = new OpenFileDialog();
    dialog.Multiselect = false;
    dialog.FileName = t.Text;
    if (dialog.ShowDialog(this) == DialogResult.OK)
    {
     t.Text = dialog.FileName;
    }
   };
   change.Dock = DockStyle.Right;
   change.Text = "...";
   change.Width = 30;
   return change;
  };
}
if (name.IndexOf("Folder", StringComparison.InvariantCultureIgnoreCase) != -1 ||
  name.IndexOf("Dir", StringComparison.InvariantCultureIgnoreCase) != -1)
{
  return delegate(TextBox t)
  {
   Button change = new Button();
   change.Click += delegate
   {
    FolderBrowserDialog dialog = new FolderBrowserDialog();
    dialog.SelectedPath = t.Text;
    if (dialog.ShowDialog(this) == DialogResult.OK)
    {
     t.Text = dialog.SelectedPath;
    }
   };
   change.Dock = DockStyle.Right;
   change.Text = "...";
   change.Width = 30;
   return change;
  };
}
return null;
}

Can you figure out what is going on?

As long as we are talking about unmaintainable code, here an example from code meant for production that I just wrote:

IDictionary<Customer, IDictionary<string, IList<Policy>>> namedPoliciesByCustomers = new ...;

But for that I have tests :-)