Feature Delivery vs Code Quality

In this era of competitive startups, MVP’s (Minimum Viable Products) and features are delivered in months, few even in days. Production issues and bug fixes happen in a fire fighting mode. When the highest priority of the team is to get features out, certain long term considerations may be overlooked unless the team of developers are experienced. This post throws some light on taking design decisions and maintaining code quality easing development efforts.

Solution design - While architecting a solution, design should be considerate of future code enhancements structuring the solution in a way for easy adoption of future modifications/extensions and easy debugging. The solution should be arrived through team brainstorming rather than a single architect driving it. This ensures that every individual understands the problem/solution and also ensures that a variety of ideas are brought onto the table. Every solution should embrace immutability and idempotent.

Code review - This is a very important step towards maintaining the code quality. Every line of code should be reviewed by a peer before it translates into a feature. Review process should enforce that the code is in accordance with the standards set by the team/company.

Unit tests - No feature is devoid of bugs. But a lot can be prevented by a safety net of unit and integration tests. Test should not just cover the positive scenarios but should be touching upon the negative scenarios as well. Tests should be self contained to break even a small code change and should ensure that the developer fixes the test along with the code.

Technical debts - Each new person joining the team brings with him/her a set of best practices and finds existing code to be not inline with them. This is especially prevalent with experienced developers. The choice of code refactor would vary on various parameters like criticality of the feature under scanner, effort involved vs delivery timeline, team composition. This is where technical debts come into existence. Such debts should be picked during slowdown of feature pipeline. The team needs to ensure that the actions are taken against the debts rather than just recording them.

Continuous integration - The process of code movement in various stages i.e) from development to production should be automated pushing all the grunt tasks out of developers bucket. This ensures that any bugs or code breakages are captured early on. This also reduces the developer’s effort helping them to focus on the problem at hand.