Skip to content

Everyone Touches Everything?

One aspect of some of the agile methodologies that has been bothering me, is this insistance that everyone needs to be involved in every aspect of the system from one end to the other. For example, in developing a web application, the idea would be that each developer (or pair of developers as the case may be) does the webpage, the middleware and the database work for a single webpage or feature of the application. While I can see how this cuts down on the immediate need for coordination among developers, it leads to long term entropy in each level of the system. Things are done differently by different developers, and even if you have rigid standards (which is a whole other issue), people think differently and therefore the actual implementation will be different. Inconsistency reigns within each level of the application and eventually you have a big mess. Take databases. Properly developing a large, consistent database that is good enough and fast enough to be useful in a large production system is not a task I’d let every Tom, Dick and Harry in on. You need a DBA to do it right. You need people at every level at the application who know a lot about what they are doing in order to do it right.

It is like building a house. You have framers, electricians, plumbers and other trades people, all of whom are highly skilled in the layer of the house they are responsible for. Imagine what a mess would ensue if we just took a bunch of moderately trained trades people and each gave them a single room to build. There would be duplication of effort, wasted money, and general inconsistency in the core layers of the house. You’d end up with twice as many pipes and wires, three small furnaces, five huge bathrooms and staircase to nowhere. It would be unthinkable to run a building project with this amount of inconsistency and waste and it should be equally unthinkable in a software project.

It comes down to whether you want vertical stability (stability at each level of the application) or horizontal stability (stability in features cross-cutting components) in your system. With properly defined interfaces, vertical stability is much more viable in the long term because each level of the application is consistent with itself, which should be one of the first things we strive for within a large software system.