When I talk to software developers[1] I always stress that as professionals they have an ethical obligation to deliver good code quality. I’m not alone in this – people far more known and respected, like Ken Schwaber for example, keep on saying the very same thing for years now: if you are software professionals you have to act like professionals.
This obligation is very much linked to the so-called structural quality (how well the code is built), because this aspect of software has a great effect on our clients and future users of the software we produce, yet it is completely hidden from the clients. Clients can, for the most part, detect visible functional defects (application no doing what was intended, system ill-behaving etc.), but they are usually not equipped to assess how well the software they pay for has been built internally. However, in the long run it is the structural quality that has a higher impact on the total cost of ownership and other financial parameters of a software project. The customers are obviously not professionals in the field of software development, but they trust that developers they hire are. Therefore, clients have all the right to expect good quality (understood as well built, testable, extendable, maintainable code) even if it was not explicitly requested in the contract. However, for now software developers yield to pressure and produce horrendous code just to meet time constraints (commonly known as “deadlines”).
A good parallel is civil engineering. If we hire a construction company to build a building for us we expect it to be structurally safe, built from safe materials and adhering to widely accepted engineering standards. Clients are not expected to be civil engineers or construction foremans capable of personally ensuring it is the case – clients trust builders will do their job properly and by virtue of clients’ trust it is the builders’ ethical obligation. This ethical obligation is so widely recognized in societies, that is has became a legal obligation almost everywhere in the world.
It is only logical then that the same will happen to the software development profession at some point. What I wait for now is a lawsuit that will claim damages from a software development company for poor structural quality of a working software product “delivered on time and within scope”. A client will finally come to claim damages after they find out two years after delivery that while the product works its code is unreadable, it doesn’t have an automatic test harness (unit testes, automated acceptance tests etc.) and it is therefore very costly or impossible to extend it further. I am not a lawyer, but I do think it would be a winnable case.
I wonder if those in the software development profession really need such a wake-up call from the legal system before they will understand that it has their obligation to do things right – not just “on time, within scope”.
[1] By “developers” I understand everyone involved in building a software product – not only programmers, but also test engineers, DB gurus, usability designers etc. etc.