The humble parameter

As any software engineer will know, it is often easier and better to design a system that is too general for the particular task at hand and then to govern the actual behavior with a parameter. At one extreme you get sort functions with the comparator supplied as a parameter to the sort. At the other extreme you get entire policy-based frameworks where the parameters that govern the system are represented as rules.

A similar phenomenon occurs in mathematics: it is often simpler to solve a more general problem than to solve the particular problem. The more general solution is often parameterized in such a way that the particular solution falls out of the general case.

Recently, I learned of a use that Nature has put to the parameter, it seems that Finches’ beaks may also be governed by one or two genes (BMP4) which show up in many wildly different animals (Finches, fish, butterflies, …). I would suggest that what is going on here is that we have a general mechanism (the HOX genes) with a system of parameterization that is easily modified.

There seems to be a general principle at work here — that the pattern of having a general mechanism tied to a parameter to give particular instances — applies to many things and in many areas of the world. Perhaps this is one of those natural joints that philosophers love to carve.

Perhaps a Math grad student would be interested in designing an algebra of parameters?

The Perils of Meta

An age ago there was a time when the solution was “meta-level”, and “What was your question?” This was during the heyday of Logic Programming when it seemed that we were going to take over the world (when they woke up to it that is).

Meta-programming is extremely powerful, and it seemed that there was nothing that could not be solved using some kind of meta-level approach: compilers, debuggers, abstract interpretation, program transformation, utility programming; the list had no end.

Unfortunately there were, and are, some problems with meta-level programming. From a logic perspective a key problem was that you had to prove, again, the logical validity of the meta-level inferences that you made in your application. More pragmatically, there were issues with the ’standard’ way of reflecting from logical formulae to data structures in Prolog that caused logical and practical problems.

Like most Prolog-ers, I have been somewhat amused by the apparent enthusiasm for all things meta in the Java world. It has had a distinct been-there-done-that kind of feel about it.

Recently I came across one of the down-sides of the meta-fever. Wicket uses a lot of reflection to simplify programmers’ tasks. However, the down-side is that using a string to denote a method confuses most IDEs; making refactoring a tricky proposition.