Posted by Andy Butland (IT Director)
A key date in Zone history came and went a week or so ago: the 10th anniversary of the launch of our first web application. Although many sites have come and gone since then, this one is still going strong. I’m afraid I’m not going to link to it, though, partly because it’s a client application, but primarily not to embarrass ourselves by revealing its clip-art-led design (for which I take full responsibility).
Although this post is a month or so behind all the other reviews of the decade that have been cluttering the media recently, it gives a good excuse to reflect on that period and to review the changes that have occurred from the perspective of a web developer at a digital agency.
Renaissance developers
While we’ve always looked to train developers to take on a wide range of responsibilities on a project - from requirements gathering and specification to development, testing and training - it’s become clear during the last year or two that we need to work across a number of different technologies. So having started the decade using Active Server Pages (now affectionately known as ‘classic’ ASP) for the majority of our sites and subsequently employing ASP.Net exclusively for several years, we now have projects using ASP.Net MVC, Drupal, Wordpress, Django, iPhone... the list goes on.
While partly coming from a desire to investigate and evaluate new technologies, the principal reason for this change was to satisfy our clients’ demands. In the early years, we were most often helping them with initial ventures online and so had a relatively free choice of platform. Nowadays, the solutions we provide usually need to integrate within an existing technical ecosystem. This means that, in the role of agency developer, the need to be jacks of all trades - at least as an organisation if not as individuals - becomes more and more important.
Abstractions and retractions
Having noted our wide range of technological skills, I would say that we have most experience with the Microsoft web development stack. And it’s been interesting to see how this has developed over the years. Initial ASP solutions without careful management could soon suffer from a lack of code re-use and the intermingling of different languages (HTML, script, SQL), leading to maintenance headaches. ASP has also required a different developer mindset for those used to produce desktop applications.
Microsoft attempted to address this with the release of their ASP.Net framework in 2003, which layered an abstraction over the web-specific nature of an online application in an attempt to replicate familiar desktop development techniques. This proved successful, of course, and with version 4.0 due in March, it will no doubt continue to be a key technology for us.
However, many developers, including Zone, have run into problems with this approach, notably around the control of HTML output, the clear separation of concerns and the support for unit testing. Reacting to these criticisms, Microsoft launched the ASP.Net MVC framework in 2008. This removes some of this abstraction layer and requires the developer to engage with the specific nature of developing for the web.
So it works... what else?
The effectiveness of our early web projects was judged on two key questions: Does it work? And, does it look how our designers intended it?
Although both are still important factors (of course!), as we have built up long-term relationships with our clients, their websites and applications, software quality has become more and more vital.
And while the significance of software quality varies according to the project, the key area for me is maintainability. In many cases, we’ve found that refactoring code that works - but which could be more efficient, easier to understand, better covered by unit tests or architected for re-use - proves to be invaluable when we subsequently return to a project.
Clued-up clients
Similarly, we have found that our clients have (quite rightly) become aware of issues that would have remained safely under the hood in the early years. Providing a functional, accessible and search-engine-optimised user interface has always been vital. However, it’s important now to deliver HTML built to conformant web standards, while features such as search-engine friendly URLs and progressively enhanced use of AJAX interfaces are seen as standard requirements.
Buy or build?
A debate we have often returned to - both with clients and internally - is whether to custom build or to make use of a generic package or framework to deliver a solution. We have generally come down on the custom build side of the argument, primarily for reasons of control and flexibility. With this approach, we know that we will never run up against the limits of a product. And, while customising an off-the-shelf solution can be productive in the early stages, it is often delivering the last 20% of features that leads to difficulties and attempts to stretch the product in ways it was never really intended.
However, as such products have matured during the last year or two, we have started to achieve the best of both worlds, where we have the productivity gains of building on a generic solution, with sufficient flexibility and extensibility that we aren’t restricted in what we can deliver. Both the Drupal and Umbraco open source frameworks fit into this category and are becoming the principal technologies for our content management solutions.
In summary, the main theme that emerges when looking back over the decade is that although we have learned great deal, changes in technologies, requirements and best practices mean we certainly can’t put our feet up thinking we’ve cracked it… But that keeps things interesting, of course.