Can WebApps Be Engineered? In a virtual roundtable published in these pages in September 1998, I staked out my position with regard to Web engineering:
It seems to me that just about any important product or system is worth engineering. Before you start building it, you’d better understand the problem, design a workable solution, implement it in a solid way, and test it thoroughly. You should probably also control changes to it as you work and have some mechanism for ensuring the end result’s quality. Many Web developers don’t argue with this; they just think their world is really different and that conventional software engineering approaches simply don’t apply.
This leads us to a pivotal question: Can software engineering principles, concepts, and methods be applied to WebApp development? I believe that many of them can, but their application may require a somewhat different spin.
But what if I’m wrong? What if the current ad hoc approach to Web development persists? In the absence of disciplined process for developing Web-based systems, there is increasing concern that we may face serious problems in their successful development, deployment, and maintenance over the long term. In essence, the application infrastructure that we are creating today may lead to something that might be called a “tangled Web” as we move further into this new century. I use this phrase to connote a morass of poorly developed Web-based applications that have too high a probability of failure. As Web-based systems grow more complex, a failure in one can and will propagate broad-based problems across many. When this happens, confidence in the entire Internet might be shaken. Of course, there is another view. Some
argue that the application of software engineering principles (even if they are adapted to accommodate the unique characteristics of WebApps) is simply wrong-headed; that software engineering doesn’t really work very well in the rapid-fire world of WebApp development. I contend that software engineering principles always work. It’s never inappropriate to stress solid problem solving, good design, and thorough testing (not to mention the control of change, an emphasis on quality, yadda, yadda). A specific software process might fail because it is overkill, or the work products it requires are unnecessary or burdensome, or a person or team becomes overly dogmatic in the application of the process.But history is on the side of a solid engineering approach.