At Clocktimizer we try to keep our customers up to date with the many changes and improvements we make to our platform. This week, we look at why we have spent the last month working hard to upgrade our framework to ASP.net core. This seems like a lot of work for a change that many may not even notice. Here’s why we think it’s important to invest in repaying technical debt for the long term stability of our product.
So what is technical debt?
Programmers need to balance short and long term decisions. If programmers were only willing to deliver a product that is perfect, chances are that they would never manage to finish. So, often programmers will have to take shortcuts to make sure that they can deliver a product on time (or reasonably close to it!)
Whenever a programmer chooses for a short term solution, this will cause additional work in the future. The cost of this additional work is called technical debt. Just like with financial debt, if technical debt accumulates, interest will compound and may become a burden on the development process.
Can’t you just avoid having any technical debt?
One might argue that the best strategy would be to always choose for the long term and never incur any debt. But, as with most businesses, debt will allow some benefits to be moved forward. Postponing these benefits could cost the business the opportunity itself. Therefore, a certain amount of technical debt is not just acceptable but actually desirable.
Additionally, technology is a rapidly evolving subject. It may be that the proper long-term solution is not always known at the time of implementation. In this case, an imperfect implementation will allow feedback to be gathered and result in a better final product.
Although some technical debt may be necessary, this debt should not be allowed to accumulate indefinitely. Therefore, every now and then at Clocktimizer, we have consolidation sprints in which we reserve time to refactor our code so we can lower our technical debt.
Why we’re moving to ASP.net core
Software frameworks are a common source of technical debt. These days, programmers stand on the shoulders of giants: There are high quality frameworks available that handle many common tasks like databases, validation and authentication. By using a framework, a programmer gets a lot of functionality for free. By nature, these frameworks are used throughout the application and changing them is not trivial.
During the last couple of months, we repaid some technical debt by upgrading ASP.net MVC 4 to ASP.net core. ASP.net is a Web Application Framework: It sits between your browser and our code. ASP.net manages functionality like authorisation, authentication and error handling. It may not sound like much but without it, you wouldn’t be able to use Clocktimizer at all.
So what is new?
ASP.net MVC 4 came out almost 7 years ago and a lot has changed since then. This should come as no surprise to anyone still using a smartphone from seven years ago – technology moves quickly! The upgrade enables a lot of scenarios which were much harder to accomplish with MVC 4, including:
- On-premise single sign-on.
- More comprehensive pre-configuration.
- Better application lifecycle management.
- Creating an API so other products can work together with Clocktimizer.
Some of these things will improve the life of Clocktimizer users today; other improvements will enable scenarios that may not materialise for years. By repaying technical debt, we are making sure that we can keep on improving Clocktimizer for our current and future clients.
If you have any questions about the new functionality of our ASP.net core framework, or would like to schedule a demo to see what’s new with Clocktimizer then get in touch.
Illustrations by Tara Lingard