Rapid Robust Application Development
Software application development has been facing multiple challenges created by our insatiable desire for robustness, features, scalability, performance and fast development speed.
The performance is mainly about choosing the right platform, choosing the right language and using smart algorithms. Performance of an application is an index of its developers' knowledge, experience, intelligence and objectiveness and openness of their minds. Very often, developers choose a path leading to poor performance of their products out of egos, ignorance or political fanaticalness. It is a multi-discipline task to address the performance issue.
Software engineering for a long time has been addressing the dilemma: the scale and features of software have been increasing while more robustness and faster development are demanded. Software design and programming have gone through procedural, modular and object-oriented methodologies. Object-oriented methodology has become norm in present software development. On top of it, componentization and extreme programming (XP) have emerged to further address the dilemma.
The best strategy of software development depends, to certain degree, on the type of the developers. There are four major types:
Type I - Passive programmer. They treat software development just as a job to make a living.
Type II - Coding addict. They are obsessed with programming. Coding is a shear joy for them. They tend to be fanatical about certain aspects of programming
Type III - Goal oriented passionate developer. They know clearly what the ultimate destination is and strive hard to reach it by utilizing whatever is the best.
Type IV - Goal oriented passive developer. They also know clearly what problems need to be solved and unfortunately for them, some software development work, which they are not interested in, is needed to solve the problems. They use whatever is handy to get the software work done quickly and painlessly.
Modern software methodologies (such as XP) mainly address the development work by Type I and II developers. They have to consider the user-developer interaction that ranges from pleasant communication to furious fight, and the turn-over rate of programmers that can be very high sometimes.
For Type IV developers, many software vendors are turning out more and more user friendly graphical development tools that eliminates text-based programming as much as possible.
This note proposes the software development strategy for Type III developers. It can be summarized by one phrase:
Object-oriented Componentization and EvolutionThere is nothing new in this strategy. It is essentially the extraction of the major components of modern software development methodologies and put it in a very simple way. It is supposed to be very simple for this type of developers. The whole software development process can be simply described as follows:
1. Pick an appropriate platform and a development tool with robustness, scalability, productivity and support in mind. This is like choosing a right planet to start the evolution.
2. Quickly write a prototype that can accomplish a meaningful task. The is the amoeba that will evolve to a superior species.
3. Start the evolution by adding features one by one and see the results (or rewards) instantly. Restructure the software when necessary.
4. In the long evolution, coding should be object-oriented. When the cost is justified, componentization of certain function(s) should take place. This is where Type III developers have significant advantages over other developers because they see the whole picture and future very well. They can make sound judgments in terms when a class should be created, when a component should be made, and when a room should be left for future scaling up. A lot of code or component reuse minimizes wasting work.
The end result of the above process is a robust software application evolving very quickly in the right direction.
(Originally written on the author's birthday in 2001)