• Take a parameter from the request, such as id
• Query the DB for a record that matches the param
• Redirect or throw a 404 exception if record was not found

Why do all this, when it could be simply a helper call?

A DB helper

Since I’m using Doctrine, I’m simply calling my helper CU_Controller_Action_Helper_Doctrine. If you’re using Zend_Db or something else, you could call it Your_Controller_Action_Helper_Db or whatever.

The idea is to make the multi-line operation of taking a parameter, querying the db and checking the result into a single line operation.

For example…

$id = $this->_getParam('id');
$record = $this->_helper->Doctrine->getRecordOrException('Article', $id);

Essentially, the above code would get an Article object with the ID from the parameter, or throw an exception if it wasn’t found, allowing you to, for example, display an error 404 page automatically.

Implementation

You can find source code for my implementation of a Doctrine helper at the svn.

Note that it throws an exception of type CU_Exception_NotFound, which you may want to change to your own class.

PHP testing

Naturally, you’d first off use PHPUnit and Matthew’s work on Zend Framework request testing to write unit tests for your models, controllers and library code.

Testing library code should be relatively simple, since most of it probably works more like “traditional” code: It does not output html, does not access the DB and things like that.

Testing models and controllers is a more complex thing. Models quite likely will access the DB, so how to make testing them simpler?

First, you could use the in-memory SQLite adapter with PDO (new PDO(’sqlite::memory:’)) to create a database that won’t mess with anything external. Then, if you’re using a library like Doctrine, you can let it generate the database for you based on the models. You would also want to write some fixtures with some dummy data that you can use in your tests.

Since Doctrine’s models should work most of the time, you may not want to spend time writing tests for them, but if you provide any custom methods in your models, you might want to make sure they do what they are supposed to.

Controller testing can be the most difficult part, and this is where you may need to perform some refactoring if your design is not suitable for testing. For example, you may have a lot of logic in your controllers, which might be better off in your models or library code. Testing the whole idea of getting out the correct output or redirects may be difficult, but the Zend Framework test case stuff Matthew Weier O’Phinney has been working on should help a lot there.

Other testing

In addition to testing the stuff that happens on the server, you may want to test what’s actually going on on the client side of things.

For this, there’s JsUnit, which is essentially similar as PHPUnit is for PHP but just for JavaScript. Also, there’s things like Selenium, which can automatically test a site in a browser to make sure they work correctly. I haven’t tried either of these though.

I think the canvas element is starting to get quite feasible for charting, since it now works in Internet Explorer using the great ExplorerCanvas script.

Feel free to use/take apart/break/something the canvas script in the example if you like. It should work out of the box if you just provide it with some custom data in a similar format as seen in the code.

I wanted to show my Dwarf Fortress to someone, but I didn’t just want to stack screenshots below each other like you’d usually do. Since dwarf forts can span multiple depth levels, it would be pretty neat to be able to show the levels on top of each other, with transparency too.

See it in action here.

It’s relatively simple. You point it at a div which contains the images you want to make layers of, and a div where it should display the controls, and it does the rest.

If you want to use it, feel free. Just copy the script file and write some similar CSS and HTML as shown in the example page. You probably won’t need all of the CSS styles, just take note of the #controls .selected one, as “selected” is the class used for highlighting the selected layer. Note that you will need to link to the Yahoo UI libraries, as it is used in some places in the code.

You could probably use that for a JS based image editor, to name other uses than fortress showcases.

Sounds complex? Yep. Is it complex? No. You might’ve even used it without knowing about the name.

Three styles

Let’s take a look at the three main styles of Dependency Injection, as listed by Martin Fowler, the simplest first:

• Constructor injection
• Setter injection
• Interface injection

Let’s say we have a class which uses another class to do some task:

class Example
{
    private $_helper;
 
    public function __construct()
    {
        $this->_helper = new MyHelper();
    }
 
    public function doSomethiong()
    {
        $this->_helper->foo();
    }
}
 
interface MyHelper_Interface
{
    public function foo();
}
 
class MyHelper implements MyHelper_Interface
{
    public function foo()
    {
        echo 'Foo';
    }
}

We’ll modify this class to use the three styles of DI…

Constructor injection:

The simplest of them all, simply uses a constructor parameter.

class Example
{
    private $_helper;
 
    public function __construct(MyHelper_Interface $helper)
    {
        $this->_helper = $helper;
    }
 
    /* rest of the class is here */
}

Basically you just pass the helper implementation in the constructor. Could it be simpler than that?

Setter injection:

You might already guess this based on the above…

class Example
{
    private $_helper;
 
    public function setHelper(MyHelper_Interface $helper)
    {
        $this->_helper = $helper;
    }
 
    /* rest of the class is here */
}

So to use Setter injection, you simply need to define a way to set the implementation of the helper with a setter.

Interface injection

Finally, the most complex way of doing dependency injection, interface injection.

interface iInjectHelper
{
    public function injectHelper(MyHelper_Interface $helper);
}
 
class Example implements iInjectHelper
{
    private $_helper;
 
    public function injectHelper(MyHelper_Interface $helper)
    {
        $this->_helper = $helper;
    }
 
    /* rest of the class is here */
}

This is pretty much an interfaced version of the setter injection method.

In closing

So while Dependency Injection is often explained in long articles and so, it’s a quite simple concept.

By using these three methods, we remove the dependency of MyHelper from the Example class. Instead, depending on the environment, we could provide a different implementation of the helper, for example a mock object for running tests.

Well, it turns out to be a perfectly feasible task, and I have a working prototype too!

The idea and the implementation

The idea was to look at Microsoft Excel COM interop with ASP.NET - I had seen examples of generating spreadsheets using interop, but it seemed no one had actually done anything more.

Since I haven’t really done any ASP.NET stuff from the ground up, and it was mostly cobbled together to just see if it could be done, so it involved software development methodologies such as “Copy and Paste”.

There was initially a problem with talking to Excel, as the Windows version I’m using is in Finnish, and my Office 2007 is the English version. Every time I tried doing something to the spreadsheet, such as getting a value from a cell, it would throw an exception. Luckily some Googling gave me an answer to change the currently executing thread’s locale to en-US, which fixed it and let me continue.

Eventually I found ways to do all I needed: Getting and setting specific cells’ values and their formulas. Then it was on to creating a JavaScript-based interface for it, which is essentially a very bare-bones inline editable table, which sends the modifications to the server with Ajax.

A demonstration

I sadly do not have a server which can run ASP.NET, and it is not actually a very good idea to run it on a live server for real users either due to things I’ll tell you about in a bit… however, here’s a screencast I made of it, which should give you an idea:

From the screencast, you can see how it first loads the Excel spreadsheet’s current data into the grid, and then when edits are made, any changes that happen to the values in the spreadsheet are reflected in the grid as well.

So is this a Google Spreadsheets killer?

Well… Maybe.

As you can see from the above, it is a feasible concept. However, it has several issues, because Excel is not a “server” type of application.

Excel is built as something that the user interacts with directly, as in a desktop application. If you typed a formula wrong, it would show you a popup and you’d close it and things like that.

If you type a formula wrong in the JS grid, it will go to Excel, which will display a popup… but it will have no one to close it. It will effectively stop the whole app with the pop: It will not reply to messages until the popup is closed, and any actions done before that will throw an exception.

In theory you could set up the server so, that it runs an application which would automatically click any popups Excel shows to close them… but I’m not sure if that would work out so well.

Finally, if you want to play with the code, the code for Webxcel is available in my SVN. To run the code you’ll probably need Visual Studio 2005 Web Developer and Excel 2007. Run an instance of Excel first, and then access the webpage.

Argumentation

The arguments are usually as follows:

1. Desktop languages are more difficult than those used for the web
2. Web applications aren’t as complex as desktop applications
3. It’s easier to do a web-based user interface than a desktop UI, because HTML is easy

Not to offend anyone, but I think saying any of the above three only shows that you are ignorant of what’s going on in todays web-development world. Sure, it might’ve been a couple of quickly hacked together Perl-scripts and some HTML back in the day, but it’s a different story today.

Let’s look at the arguments.

#1: Desktop apps can be written in C++ which is definitely a more complex language than what you’d typically use for web development, but in todays desktop world there are other alternatives, like C# and Java - both of which you can use for web development as well. You could use C++ for web too, but is it really suited for that?

#2: This point really depends on the size of the application. A simple website is not very complex, just like a simple desktop application is not complex, but I think some desktop developers don’t realize that many web-developers work on complex sites too. This argument might’ve been true a while ago, though. A lot of things like unit-testing, n-tier architechture etc. was not very common in web-development not so long ago, while they’ve been around on the desktop for a much longer time.

#3: Do you need to test a desktop application with at least 4 different Windows (or some other OS) versions to make sure it displays things the same in each? No? In the web-world, if you’re serious about your website, you want it to work correctly on at least Internet Explorer 6 and 7, Firefox, Safari and probably Opera too, despite its smaller user-base. In the desktop-world, you can also use a WYSIWYG editor to lay out your UI with much less problems than what you’d encounter on the web when doing that.

In addition to these, it should be considered that today to make a website you’re going to need at least four different languages! HTML, CSS, JavaScript and some server-side language, and SQL if you want a database. Do a desktop application, and you’ll need maybe one or two. Granted, HTML and CSS are not very complex, but you have to understand how to do things with them efficiently, how to work around browser bugs, and things like semantic markup etc.

Also, while discussing this with Jason Eisen, he mentioned that web applications have to be built with high performance on the mind, as they will have a lot of concurrent users.

So is it really so?

I’ve recently witnessed a very important web-based application developed by a big company with big money halt and crash because of too many concurrent users. I’m not sure of the exact numbers, but the estimates I heard were quite small for a web site. The application itself was written in JSP, and was basically for doing queries to an Oracle DB and producing different looking results from that.

If anything, the big company should’ve been able to push out an excellent web-based system, especially if web-development was so easy… but seeing how the app was late to begin with…

As far as I know, this company is very well versed in more traditional desktop client-server solutions and database applications. So seeing this, they should’ve aced the web application too, right?

Well, guess it isn’t as easy to develop a web application as you might think.

Let’s look at some good habits I took from Django and started using in PHP, that could benefit you too.

URL generation

In Django, you can define a method called get_absolute_url to your models, which should return an absolute URL to the model in question.

You usually might just type the URLs manually, perhaps putting some variable from the record as a parameter to the URL, or if you’re using something like Zend Framework, you probably would be using the URL helper. In any case, you would be hardcoding some values in your views.

Using an URL generation method in the model is a great idea. It takes away this hardcoded feature, in case your URLs change, and they might. It can also reduce the clutter of your views when you don’t need to put params to urls in long syntax and such.

Here’s an example with Zend Framework and Doctrine:

<?php
class MyModel extends Doctrine_Record
{
    /* the usual setUp and setTableDefinition stuff here */
 
    public function getAbsoluteUrl()
    {
        $helper = Zend_Controller_Action_HelperBroker::getStaticHelper('Url');
        return $helper->url(array(
            'module' => 'example',
            'controller' => 'mycontroller',
            'action' => 'show',
            'id' => $this->id
        ), 'default', true);
    }
}

Of course, it might be even better idea to use a named route and only passing in the ID or some other property of the record.

Models to strings

This is more of a small convenience than anything else, but I think it’s still a nice idea. Django encourages you to put __unicode__ methods in your models, which should return a human readable text representation of the record - similar to what you can do with PHP’s __toString.

This is quite useful if you need to output textual representations of models, without necessarily knowing what kind of model you’re dealing with; if you don’t know what model it is, you don’t know what fields it has. By simply adding a method that outputs something meaningful, you can overcome this problem:

<?php
class MyModel extends Doctrine_Record
{
    public function __toString()
    {
        return $this->name;
    }
}

I think __toString is an often overlooked PHP feature. It isn’t really used anywhere, so people don’t think of it. In languages like C#, ToString is used more, starting from the Visual Studio IDE, to display useful representations of things.

Application structure != URL structure

Since I’ve been using Zend Framework a lot, I had already fallen into it’s way of thinking about URLs. By default, ZF gives you the following URL scheme: /module/controller/action. This means it’s very easy to get nice URLs without doing anything except naming your modules, controllers and actions in a fashion that makes the URLs look good.

In Django, there are no predefined URL behaviors. You will need to define all URLs by hand, and at first it felt that it must be a lot of work, but in reality it is not that much.

While Zend Framework’s way of giving you default URL behavior can speed up getting started, it can also make you think of your application in terms of your URL…

“I want this list of big robots fighting in space show up under /japan/big-robots/in-space, so I’m going to put it in the Japan module, under BigRobotsController’s inSpaceAction”

So while it would be quite obvious where the code for the URL is if you ever wanted to edit it, it might be a much better idea to create a CategoryController and add a listAction to it, which would take big-robots and in-space as parameters.

Creating different kinds of URLs like this is definitely possible in ZF, but especially beginning ZF-devs seem to be falling for the easy default URL handling.

In closing

I can say it is definitely useful to look into other frameworks and languages than the one you’re usually dealing with. There’s a lot of things you can learn from them.

Page2Rss and Yahoo Pipes are two very useful services, almost like tailor made for the purprose of adressing the above problems!

Custom feeds made easy

Page2RSS is a service which monitors websites for you and creates an RSS feed of it with the updates. Yahoo Pipes could be called a “mashup tool” - you can use it to combine, filter, edit etc. various sources on the net: Websites, RSS feeds, web services and such.

Creating an RSS feed for some specific URL couldn’t be any easier with page2rss: Simply put the URL to the box on their page and they’ll generate a feed for you. Combine it with Yahoo Pipes and the result is greatness. In fact, combining any RSS feed with Yahoo Pipes is great.

Pipes

I personally like the Pipes UI: It’s good looking and quite intuitive, but it can be a bit confusing at first, and the tools can be difficult to use if you aren’t a programmer. It’s a two sided sword - it gives you a lot of power but you need knowledge to be able to properly utilize it. Luckily there’s a help page for each component you can use, so if you just put some time in, you can learn to use it.

A good demonstration of the power and usefulness of the Pipes service is the custom feed I made for Control-Alt-Del. It’s a great web comic, but why do I have to always visit their site to read the comic? I would much rather just see the image in my feed reader. Also, there are sometimes other non-comic posts in the feed which I don’t really care about.

With some smart usage of Pipes, you can strip out the non-comic posts and even link the comic image to the feed itself. First, use the Fetch Feed component to load the feed, then use the Filter component to block out all items that contain “News” in the title. Now we have a feed without the newsposts.

Then, after some looking at the feed and the comic image names, I figured out a way to extract the name of the image from the link to the comic. So then I used the Rename component to copy the link to the description (the content) of the item and finally the Regex component to perform a search and replace operation on the description, replacing the link URL with a HTML img element to the image itself.

Now I only see the content that is relevant to my interests. All without closing the feed reader, too. It may sound like nitpicking, but if you have lots of feeds, it does save you time when you don’t have to delete or mark read things that you don’t even find interesting to begin with.

You could use Pipes for much bigger jobs too. You could combine multiple feeds into one, for example from various news sites and perhaps filter that so that it only contains posts that are about kittens.

In any case, it’s definitely a very useful tool for mucking with feeds.

What bothers me to no end, though, is that editing spreadsheets does not work in Opera at all. Why is it? It works in Internet Explorer, which means there can’t be any totally hardcore (like Gandalf-level) JS magic or other stuff going on… I’ll just say that Google is plain and simple lazy.

Being a programmer myself, using such an impressive web app naturally got me thinking how much work it would be to build something similar to Google Spreadsheets…

Clone Excel in JavaScript

Basically the task would be to clone Excel in JS. That’s what Google Spreadsheets does. Now, I’m not sure how much of the magic they are doing in JS, and how much of it is actually being done on the server and then updated on the client with Ajax.

Spreadsheets works surprisingly quickly even when using formulas, although updating them sometimes takes a while, which would lead me to believe they’re actually doing the major legwork on the server. Doing all the stuff Excel does, be it in JS or at the server with some other language, is a lot of work. Of course, I’d like to simplify the task as much as possible…

What if you could just put Excel on the web?

You know, get the Excel application running inside the browser. Well, there’s probably some ActiveX thingy for IE for doing that, but we’d like it to actually work in Opera too. And maybe Firefox, if we’re not feeling lazy

With ASP.NET you actually can control an Excel instance! There’s information on the web about generating Excel spreadsheets through ASP.NET, and what if we could apply that info, create some Google Spreadsheets -style JS grids… and we’d have an online poor man’s Excel in no time!

You could simply use the JS grid in the browser and send all the stuff the user types in the columns to the server, along with info like which column this was etc.. The server would then talk to Excel, modifying the columns in the spreadsheet. Then, Excel would do its magic, and the server would simply reply back, telling the client which columns changed, what data is in them now and things like that.

At least in theory the above could work. I haven’t used ASP.NET Excel interop, but seeing that you can generate Excel docs, this should be very much doable, too. Sadly I don’t have access to a server where I could test this… but perhaps some day, when I also have more free time to play with interesting things like this