Scalable Software Development – High Quality, Low Cost

Writing a 10 lines program is child’s play. Writing a 100 lines program is harder. It’s harder than writing 10 programs of 10 lines each.

As the scale increases, the coding effort and the demands on programmer’s skill increase exponentially. Someone who can easily write a 100 lines program just may not be equipped to write a 10000 lines program. The later requires a completely different mindset. methodology and skills. Today’s programs are substantially complex and multi-disciplinary and most students and junior developers find it difficult to handle the challenge.

We have devised a way to break a complex software into completely independent smaller modules. Each module is rigorously unit tested, for maintaining high quality. This opens up various possibilities:

1. Programmers with lower skills can now contribute to a full sized application — one part at a time. Some parts may be a little difficult, but most other simpler parts may be tackled even by students / junior programmers.
2. One can specialize. For example, someone who is working on fetching the data from database does not need User Interface development skills.
3. The modules can also be seen as a learning vehicle. When one is learning a technology, using it in a small module is easy and gives requisite confidence to take on more complex problems.
4. Individual modules, tested independently, can create a more robust program. The errors are localized to modules and are easy to fix.
5. The same modules may be reused across various software applications.

These possibilities opening up have a couple of attractive business implications:

• The software development becomes distributed and scalable. There is a large pool of freelancers / freshers available which can be used to get the modules developed. The IP remains protected as the developers do not have visibility into the complete application.
• Software development can become more cost effective, as junior resources cost less.
• Software maintenance over long term also is easier – quick and cost-effective. Bugs can be quickly localized to individual modules. These modules can then be corrected or even replaced.

An interesting experiment on this topic is underway and is close to completion. We plan to publish its results once it is completed.