Semantic Werks

Martin Fowler, respected senior figure in software engineering practice, has a post describing ’schools’ of software development. A school in this sense is a group of like-minded individuals who subscribe to common philosophies. For example, Fowler describes himself as belonging to the object-oriented, agile-practitioner school (although this is necessarily vague).

I like this notion, particularly because it seems to model the idea of software as craft. That is, software development is somewhere between art and engineering. Other crafts might include cabinetry, armor-making, carpentry, and so on.

Fowler’s post, however, seems to imply that all schools (or at least those that have some basis in practice and can enumerate their shared beliefs) are equally valid. As an aspiring software researcher, I would disagree (note that my response isn’t grounded in any empirical experience). My feeling is that in fact, there are better sets of practice (perhaps for certain situations) and worse ones.

Putting aside those schools that are clearly created merely to serve the needs of a particular vendor, it is my fervent hope that at some point, we can define measures of success that will enable us to say where, and when, a particular approach is useful. For example, is static, type-checked development always worse than interpreted, loosely-typed development? Is test-driven development always best? When is it useful?

My sense of reading the reports of practitioners, and the research literature and history of the field, is that we still do not have a good sense of how to even ask these questions, let alone answer them. For example, Fowler references a post of his, “We Cannot Measure Productivity“, wherein he makes the point that it is (impossible? difficult?) to measure how productive a programmer or team is. I agree. But still, that doesn’t mean that there isn’t the good old Gaussian (power-law?) distribution behind a series of software projects. Namely, there are good projects and bad ones, and a bunch of mediocre, ‘met expectations’ projects in the middle. So presumably there is some way to measure these outcomes.

I think there’s a hint to an approach to these issues — specifying measures of success, productivity, etc. — in Fowler’s statement that ”any true measure of software development productivity must be based on delivered business value”. Business value may be an even more vague concept, but at least there’s a starting point. I would apply the same standard to software schools. Your school is superior, in some context, if it can deliver more value to the customer than a competing methodology. While Fowler is pessimistic on our ever being able to accurately measure business value, I’m more naive. I think we can, and should try.

I’m working on a project with my brother. The idea is to be able to visualize results from microarray experiments he has done in the lab. I’m taking an image of brain regions and loading the microarray data. The expression levels for the various regions and genes can then be seen as you a)mouse over a region and b) select a gene. There are also sliders that allow one to refine the results (and there are a lot of them).

To develop the application, I’m using Flash. I tried Flex, the web application version of Flash, but the main need I had was designing a rich GUI (a labeled brain).

In Flex, you can create applications much like Flash, with the absence of heavy-duty focus on timelines, stages, etc. The main advantage seems to be an extensive and speedy library of rich components, with extension mechanisms. Flex can also talk to other tiers, middleware, database, etc. via Flex Data Services (all this is freeware, btw, unless you have a heavy need for data services, where it gets pricey).

However, Flex seems in many ways to duplicate the functionality of HTML forms. I don’t see the point of a set of UI components that are comboboxes, lists, and text-entry fields, since these are also present in HTML. What is useful is the ability to draw and diagram a non-standard component like my brain chart.  I’m still awaiting an application that can provide the rich graphical editing tools of Flash with the lack of timelines and scenes that Flex provides. There is a way to integrate a Flash component in Flex, but this seemed cumbersome.

For data access, I used Rails to serve up XML over the wire. It isn’t really REST style, but simpler than other approaches. I didn’t need to use Rails to do this — probably a direct SQL call would have been simple enough — but I wanted to try it out.

Why not AJAX? In some sense this is a false comparison. AJAX is a methodology, which Flex partly adheres to — asynchronous and XML, just not via Javascript. The main difference seems to be that one doesn’t need to muck around in Javascript and CSS/DHTML for the UI. Frankly CSS and HTML scare me with their complexities.  The resulting Flash movie is accessible to most browsers out there (although the broken context menu is annoying).

What is a RIA anyway? Many of these concepts seem to be drawn directly from good ole Applets, which to my mind are very much like Flash movies from an end-user POV (clearly less nimble, but still…). I suspect that for most applications, the simple suite of UI components that HTML defines are probably sufficient. It will only be for graphical charts and displays that Flash-like tools will be necessary.