This Dev For Hire

Fluent interfaces and code readability

Fluent interfaces. Sigh. They help sometimes, they really do. In fact I don’t have anything against the idea, it’s the actual use that makes me uncomfortable.

Let’s start with the example first. The nicer one, that is. And to make my case stronger, I will use an example taken directly out of the blog of Mike Naberezny - Fluent Interfaces in PHP. Mike’s a renown PHP authority, so it should make you think:

    $customer->newOrder()
        ->with(6, 'TAL')
        ->with(3, 'LGV')
        ->with(5, 'HPK')->skippable()
        ->priorityRush();

It’s clean and pretty and sexy and all that, all right. You may be even tempted to say it’s more readable, but is that so in reality? I don’t think so. The problem here is you don’t know if skippable() method returns an order object or not. It may return something radically different like a totally different object or, even worse, a boolean. Furthermore, you can’t know what type of object the priorityRush() method is executed on. And THAT makes the code much harder to read.

You still don’t believe me? Take a look at the Mike’s blog and read a comment by FGM (4 Nov 06). Maybe that will open your eyes.

When one writes software only for himself it pays to type less. Some of the time, but still. When you know your code by heart and when you maintain the software yourself then there is a fat chance you will not be hindered by this. But in a corporate environment one writes software that is mainly read. By many different people. You write the software and then there are bug fixes, additional features, upgrades, etc. A lot of people have to browse your code in order to get a grasp of what the code in fact does. And then they modify. I assure you this is far more easier to comprehend later on:

        $order = $customer->newOrder();
        $order->with(6, 'TAL');
        $order->with(3, 'LGV');
        $order->with(5, 'HPK')->skippable();
        $order->priorityRush();

See? I have even left one use of fluent interface. It’s pretty clear that skippable() is executed on the object with() method returns. And it won’t make anyone browse through the “Order” source to understand. I agree, it is a little more to type and you have to sacrifice a couple of CPU cycles. But it pays when the code is forgotten and has to be modified later on.

And now the horrific use in my eyes:

        $view = new Zend_View();
        Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer')->setView($view);
        Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer')->view->doctype('XHTML1_TRANSITIONAL');

The major problem here is that the most important stuff is far on the right, so far you can loose focus before you get there (and even have to scroll it on my blog). Basically? It’s a readability hell. Not to mention it probably takes a lot more to type (216 key strikes). Oh, now you though Copy & Paste! Please, don’t get me started on that :)

Isn’t this way more readable?

        $view = new Zend_View();
        $view->doctype('XHTML1_TRANSITIONAL');

        $renderer = Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer');
        $renderer->setView($view);

Well? You exactly see what’s happening now and important stuff is taken to the front so it’s easier to spot. The line is shorter so you will get the meaning quicker. Oh, and it’s 169 key strikes with additional white-space making it even better.

Don’t rape the fluent interfaces from now on, please.