Friday, November 02, 2007

Spiral out


We have faced many paradigm shifts in software systems development. Starting from analysis and design and toward the actual coding methods. There seems to be a recurring pattern generated in each paradigm. We turn a process into a declarable entity. We make procedural or data abstractions. By doing this, problem understanding and solution definition becomes easier for us. By doing this, we are scaling the system, usually in space and downscaling time. By describing a process as an entity, we are ignoring the time it takes for that process to run and look at it as something with state in an instant of time. (a function name, instead of the procedure that it defines)

These paradigms started with pure machine code (specifying the lowest level procedures), followed by assembly (abstracting several machine code procedures into a macro command, an entity with name, callable), high level languages (abstracting assembly commands into a high level command, every entity covers more tasks, has shorten time even more), structured programming(embracing procedural abstractions in the form of functions, to turn a collection of high level commands into an entity), object oriented (several behaviors and state are placed in to an entity - object - and it represents a span of time and also has scaled in size even more), component based design (where the scale is even larger than before).

Recently there has been a lot of talk around Service Oriented Architecture and most recently Data Oriented Architecture which are trying to be the next paradigms for software development. Clearly what is happening is again scaling in size and reducing the sense of time for these systems. Converting some processes in to a declarable entity that doesn't show time in its definition.

If we look at it from the outside it seems like a spiral moving in time, repeating the same kind of pattern but in larger scales and for larger problems.

Now how come we have been able to shrink the time factors so much and still feel the same time is going by when we work with a software system? Well, clearly Moore's law has been the helping factor.

3 comments:

Tournesol said...

So what do you think of the next 20 years considering the Moore's law?

Also what do you think we are heading towards, from your personal point of view.

It would be rather interesting to see your comments in the future to come and compare your predictions to you observations. Please make sure you write them down somewhere so that you can compare them when the time arrives.

Amir H. Fassihi said...

...this is hard... but one thing is right now it seems like the processor speed increase has slowed down and there are some shift being done in parallel computations... so on a single device we might not be able to compress time as much anymore...unless ofcourse there comes a whole new technique for computation... something like quantum computing maybe??

gholo said...

According to the Wikipedia it is not expected to stop for a decade at least and perhaps much longer! ;)