Software RoadMap

History

Not long ago, programming was an art, practiced by those with the commitment to understand and work within a unforgiving logical environment that is the computer.
To develop software one not only had to turn the problem into a sequence of instructions that the computer understood, but also had to make it all fit within limited resources.
This meant that the programmer had to have a high degree of skill to meet all the constraints put upon them, least of which are the customers expectations.

Warp to the New Millennium

Now computers have resources exceeding all but the most complex of programs reserved for computing the likes of the answer to life the universe and everything.
The excess of computing resources has allowed the programmer to develope new techniques for creating programs. Rather than working at the lowest level, the programmer now uses tools that translate high level constructs into the low level command that the computer understands.
We now stand poised to get computers to work for us with great efficiency, or so you would expect.

The Standard Approach

These new development tools make programming simple tasks childs play. So much so, that school children can develop applications at the click of a button.
The software supplies wizards that make decisions based on simple responses from the user, that used to require a skilled programmer to understand. So now programmers are employed with 1 or 2 years training to use these new Point and Click development tools.

Most software development is done by following the prompts, and filling in the questions as requested by the template that the development tool provides.
Now the programmer is locked into following the way the development tool dictates, and not the way their normal train of thought would take them.
Once the wizard has done it's job there are all the details to fill in that now have no prompts to follow.

The programmer then resorts to the low level facilities that the development tools provides for interfacing with the high level components. This is where it all starts to fall apart. The programmer has been isolated from the internal workings of the tools by the wizards and templates. They therefore need a high level of understanding and skill to interface to the parts of the software that have been created for them by the wizards. Unfortunately without the years of experience the programmer has nothing to draw on to help them.

Having being forced into coding with low level constructs in a way dictated by the development tools, there is no choice but to write large amounts of code to implement the required functions.
The enthusiasim soon wanes, deadlines slip, and the number of bugs escalates.

The Solution

The first requirement to fixing the above, is to have a complete understanding of how the system works at it's most fundamental level.
The second requirement is to use the best development tool to solve the problem. Currently this is the brain. By relying on wizards you are using the skill of the person that wrote the wizard and not your own. In most cases the skill of the wizard is limited to simple problems.

In order to get to the essence of a problem you must throw out the paradigms and methodologies, and concentrate on the end result. Once the result is determined the best path to achieving the result can be specified, and the job can then progress.
In laymans terms the process is as follows:

Cut through the crap.
Understand the problem.
Identify the result required.
Select the tools to do the job.
Progress until complete.

This may not be a politically correct way of expressing the problem, but empirical evidence would suggest that it is a most efficient one.