The Rule of Least Power

The “The Rule of Least Power” bears directly on The challenge of having the levels in This Stack interact properly.

It seems that someone else has run into the challenge of building applications in levels similar to this stack.  The WWWC has a document which addresses this problem even though they may not know that they are addressing it. The principle they use is “The Rule of Least Power“.

In a nutshell the rule of least power indicates that if you write stuff in a simple enough language, the code becomes a repository of information and the information becomes reusable. The subject area is called information reuse and is a proper use of the word information.

This leads in a direction which is both different and similar to the
direction of This Stack.

Similar to This Stack

The direction that is similar is that This Stack adds levels onto levels below, each of which provides more and more power than the one below. Yet one challenge of this stack is to provide a simple enough API of what the levels below do so that this sort of stack building can happen. The Rule of Least power might be a good guide for building such ‘API’s. This direction is similar to the one of This Stack.

Different from This Stack

The direction that is different is the tendency to gravitate to the lowest level of this stack (RDB,XML,JSON,HTML etc), basically simple  data structure representations, and then do an end run around object orientation in order to produce information from the low level data. I see this direction as counterproductive, because you need to jump two or three levels in one ‘application’ rather than do things in two or three levels.

An Arithmetic Analogy

As a mathematical analogy, if you want to jump from 1 to 100 in one jump
it will cost you 100, but if you can do it in two jumps it will cost 10 + 10 = 20, as long as the amounts of work at each level are about equal. If you want to jump from 1 to 1000, one jump would cost 1000, two jumps would cost 32 + 32 = 64, and three jumps would cost 10 + 10 + 10 = 30. This Stack attempts to jump 6 levels. To jump this distance in one jump would cost 1,000,000 while to do this in six jump would cost 60.

I mention this because the second direction seems to be becoming predominant in software development whereas the first direction seems rare.

I will have to keep the first direction in mind as I build level interactions. In any case Information Reuse is a cool subject.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s