### Interlude in the Key of Introspection

I have looked at two different approaches to handling “the stages of the data” problem. The container approach described in Containment Strategies can be fairly simple in its implementation. The multiple parallel classes approach described in Intersecting Parallel Lines gets to be much more complex. The question is, is there a way to think about this problem that reduces the complexity but still provides the necessary flexibility.

This reminds me of an analysis which I heard a long time ago. As I remember it, the analysis was something that was attributed to Steve Jobs, but I have not been able to establish a scholarly link to reference material that would prove that. It doesn’t really make a difference: the analysis is still true and that’s why I remember it. The analysis concerns the quality of the engineering as an engineer approaches a particular problem. In the beginning, the problem seems to be a relatively simple and the beginning or incompetent engineer will come up with a solution that addresses that apparent simplicity. In reality, there are always some pesky little edge conditions that complicate the problem. The simple solution might work in most cases, but inevitably one of these edge conditions will occur and the solution will fail. The engineers will add additional functionality to deal with these edge conditions, sometimes to the point of producing a very complex solution, with secondary and tertiary systems to handle the various situations. An engineer who comes up with this kind of a solution is considered to be a good or competent engineer. But that’s not the end of the story. A great engineer steps back and looks at the problem and with a little luck realizes that there is a different way of thinking about the problem that leads to a new simplicity.

An example of this kind of greatness is reflected in the invention of the integrated circuit. Before this, electronics was built with discrete components. From the perspective of the functionality, combining all these discrete components into a single integrated circuit did not change much. There were adder and multiplier logic and all that sort of thing, but the transition opened up all sorts of other possibilities.

Obviously, there is the possibility of an infinite regress. No matter what solution we come up with, there’s always the possibility of re-examining it and seeing if there isn’t some other solution that is even more elegant. This is not exactly “paralysis by analysis” but it comes close. Still, there is the potential payoff and I think it is appropriate to spend just a few minutes thinking about this.

The question is, is there a different way of looking at our “stages of data” problem that would open up possibilities for us? More important, how would we go about finding how to look at the problem in a different fashion. In any real-world problem there are a variety of possible viewpoints that we could examine. These include such things as authentication, authorisation, auditing, performance, maintainability, extensibility and so on. I think the trick is to try to take a look at the problem from those perspectives to see if anything “pops out” that points us in a different direction. And that is what we will do in the next entry.

## 0 Comments:

Post a Comment

## Links to this post:

Create a Link

<< Home