Recently, I found myself in a captivating yet challenging scenario with a new client. I had to revive a floundering software project inherited from a previous software team.
Between the spaghetti code infused with all possible bad practices and the virtually nonexistent documentation, the software project resembled nothing short of a dumpster fire.
Fortunately, every chaotic situation presents an opportunity for growth and a chance to catalyze transformation.
Here are some tips you can look into to bring your software project from tragic to magic.
Codebase Health Check
The first crucial part of rehabilitating a project in trouble is understanding its health. This is where tools similar to RubyCritic, developed at Whitesmith, come into play. RubyCritic provides a comprehensive analysis of your codebase, you can use tools like this to focus your attention on the critical sections of the codebase, you should look first for areas with high complexity and churn.
Going further on our analysis we can use the Skunk score, popularized by Ernesto Tagwerker. This score combines code quality with test coverage, helping to pinpoint high-risk areas that demand immediate action. Together, these metrics provide a roadmap for de-risking your project.
The Eye of Sauron
Moving on from codebase health, another step is your “Eye of Sauron” - the all-seeing monitoring system. Here are some key areas you should keep under surveillance:
- Server Metrics: CPU usage, memory consumption, disk I/O, and response times are the lifeblood of your system’s health. Tracking these will save you from unexpected surprises.
- Error Rates and Exceptions: Regularly monitoring error rates will help you troubleshoot issues quicker. A sudden surge in HTTP 500 errors or database connection failures could indicate problems with a recent deployment.
- Application Performance: Monitoring application response times will provide very good performance insights
Project monitoring is a very important part of a successful project because it allows us to detect and resolve issues sooner, preventing them from escalating, and reducing the impact they might have on the project’s success and roadmap.
Charting the Course
Another important part of a successful project is prioritization and planning. The key is to align the most urgent issues with the project’s deliverable tasks.
First, it is important to deal with security issues and critical bugs, after that, it’s all about understanding which changes add the most value to the project. Sometimes, addressing technical debt or fixing a bug will bring more value than a new feature. Therefore, it’s essential to communicate and collaborate as a team with all stakeholders to establish a common understanding of value.
A framework that I really like for identifying valuable work is the cost of delay model. It will help you figure out what should be done next by comparing the costs of delaying different tasks.
This step is all about leveraging DORA metrics as a guidepost for team performance by focusing on delivering small but frequent batches of work. Remember the age-old proverb about how to eat an elephant? Same principle here - a project in disarray can be intimidating, but breaking it into small parts makes the journey manageable.
You could also consider using tools like Scientist, created at Github, for testing in production, which allows you to run experiments - alternative code - in parallel with existing code, without modifying the existing behaviour. This is particularly important - and handy - when you inherited a poorly designed project and lack some context around it.
Strive for an iterative approach, add tests and improve the codebase as you progress throughout the different areas of the project. Consistency is key, and every effort brings you closer to success.
- Assess codebase health using tools that measure things like complexity and test coverage.
- Set up project monitoring tools to prevent issues from undermining your success.
- Prioritize tasks properly with your framework of choice, and focus on the value being added.
- Work iteratively and don’t forget to gradually improve the code quality and test coverage.
Good luck reviving your next software project; let’s hope a phoenix rises from those ashes.