Prototyping vs Maintenance

Last two weeks I was thinking a lot about whole process where I have a client on one side and a working application on the other. Fist big thing is in the title of this post. Too often we prototyping instead of thinking what happens next.

Of course it’s human factor but when I’m thinking about reason why it’s happening I say modern frameworks. Rails, Symfony, Cake. Whole “MVC way of development” which is not bad but it’s also not everything. Anyway when you check tutorials for them it looks like that. It’s also an issue with dynamic languages. They are used for fast projects and it’s quite hard to force management to think about trivial things like architecture of the new application. Fast language doesn’t mean that we should code without proper preparation.

Sooner or later we have huge codebase and we are no longer prototyping. We maintain current code and create new features in current system. And we are doomed, because we have a lot of procedures in controllers, procedures in model and some in views. Even if there are some tests they are useless when everything is done in one place and cannot be pulled outside. One common thing which I noticed lately is creating pagination objects. OK, pagination is a service in Symfony 2 but most of the time we have pagination in application and in control panel. Why the hell we are copy/paste this code when we can outsource it and put different HTML on result? When we take a look on time most of it we spent on maintenance. So why we are not investing on the beginning in good and clear code?

Because it’s hard on the beginning and it takes time to create good object graph. Design patterns are moderate easy but they need, like everything else, practice to work smooth. It’s also more code. Simple triple if can take interface, chaining class and three implementations. Instead of few lines we have few files. Is it easier way? Not yet. It pays off in few days when another if is needed and all whets needed is one class with specific responsibility and this single responsibility rule is one of factors of maintainable code.

It’s also very important when new person join the project. Simple change in method which is returning bool after 5 lines of code is easy and safe for rest of code. It’s also very testable. By the way these day I realized why I didn’t liked TDD. Testing big procedure on framework level is a waste of time. What is the idea after testing controller with 20+ lines of code? Everything inside should be tested on lower level. Controller only takes what is needed for user in view and forwards data to template. Nothing interesting. Failed test is also worthless. There is plenty of things which could failed. Let’s think about failed test of dashboard. It gathers data from all around the system and renders some graphs and tables. If test failed it can be anything from malformed HTML markup to data inconsistency id database. Good luck with finding it in less than 10 minutes.

And time is the most precious thing in our job. We get payed for getting work done in time. So please stop wasting it. Think before, not after. It’s common knowledge so use it with your job.