iModernize - The Profound Logic Software Blog

What is Technical Debt?

Posted by Tim Losee on Sep 12, 2017 2:51:40 PM

You might have heard the term "Technical Debt" floating around your office. It has become one of IT's newest buzz words and has some people scratching their heads as to what it means. The official definition of Technical Debt is: A concept in programming that reflects the extra development work that arises when code that is easy to implement in the short run is used instead of applying the best overall solution. Technical debt is commonly associated with extreme programming, especially in the context of refactoring.

Clearly Technical Debt can be a hindrance to your companies future, and can keep you from accessing not only future tools and techniques, but also future developers as well. If you are using extra man power to work on short term issues, you are holding yourself back from innovation and thus closing off your supply line of new developer talent that might come.

Today we want to take a look at What Technical Debt is, what causes it, and some solutions that might help you!

What is Technical Debt?

Earlier we got the definition of what Technical Debt is, but what does it really mean to you and your company?

Technical debt is also known as design debt or code debt and is a software development concept that refers to the cost of work by developers caused by choosing a "quick fix" solution instead of choosing the best approach to a problem that might take longer. Essentially you are creating "debt" by not fixing your issues fully and only solving the issues in front of you. 

If your Technical Debt is not repaid, then it can quickly accrue "interest," this interest makes it harder for your company to be agile and implement change over time. You may not see the immediate impact of technical debt right away, but you will over time. Now, Technical Debt is not always bad... proof-of-concept technical debt for example is required to move certain projects forward. But for the most part Technical Debt can be a hindrance for your companies future. 

There are certain types of Technical Debt that a company can take on; Deliberate, Inadvertent, Reckless, and Prudent:

Deliberate/Reckless - "We don't have time for a new GUI design... just stick with what we have."

Deliberate/Prudent - "The time table is too short to be able to accomplish that redesign before our next event."

Inadvertent/Reckless - "What is modernization? Why would we need that?"

Inadvertent/Prudent - "Now we know why we should have modernized our 5250 screens last year."

As you can see, there are many ways to take on Technical Debt (some of which are not on purpose), being aware of those types of Technical Debt can help you avoid it or at the least keep from taking on more of it.

What Causes Technical Debt?

Technical Debt can be caused by many different issues (sometimes a combination of multiple issues). Below we have compiled a list of common causes:

  • Lack of Process or Understanding - Businesses can be blind to the entire concept of Technical Debt. They then make business decisions without considering the implications.
  • Lack of Test Suite - Which encourages quick and risky "band-aids" to fix a companies bugs.
  • Lack of Collaboration - When knowledge is not shared within the same company, thus efficiency suffers and newer developers aren't given the atmosphere to grow properly. 
  • Insufficient Up-Front Definition - New requirements are needed during development; development starts before a sufficient plan and design is set in place. Many times this is done to save time, but later has to be reworked.
  • Last Minute Specification Changes - These changes can come throughout a project, but without a time table and budget for these unknown changes, they can be put off and extend a project time table.
  • Lack of Documentation - Code is created without creating supporting documentation along with it. This causes more "debt" down the line.
  • Tightly-coupled Components - When functions are not modular, then the software is not flexible enough to adapt to changes in business needs.
  • Lack of Alignments to Standards - Ignoring standard features and technologies can cost you more in the long haul.
  • Delayed Refactoring - As projects continually evolve, parts of the code can become ineffective or difficult to edit. The more changes that are done with out refactoring, the more debt you will gain.
  • Parallel Development - When two or more branches accrues debt because they have failed to merge together into one single source.
  • Lack of Knowledge - Developers not knowing how to write elegant code.
  • Lack of Ownership - After out sourcing efforts, in-house developers have to refactor or rewrite that outsourced code.
  • Poor Technological Leadership - Poorly thought out development plans are passed down the chain of command can increase the Technical Debt.

What Are the Technical Debt Solutions?

The simple answer is avoid the above causes of Technical Debt. If you can avoid these causes, you can avoid creating more Technical Debt for your company. Avoidance is the best solution, but sometimes you can't avoid Technical Debt. Sometimes you accrue debt without knowing it, sometimes you must acquire Technical Debt to complete a project. For these circumstances you want to make sure that you have an adequate plan to help reduce the debt over time, or a plan to assess the debt you may have acquired without knowing. 

The biggest thing you can do is to not be afraid of modernizing your business. Opportunities will arise to help make your company more efficient and effective. Don't be afraid to take the time to create long term solutions for yourself, and avoid those quick fixes.

A great example is, Profound Logic has a solution for all your green screen modernization efforts. Creating beautiful new desktop and mobile applications using your RPG, PHP or Node.js. You can select only the applications you need to modernize. By converting your legacy RPG code you can avoid using old green screens that continue to increase your technical debt. Easy to use modern Web applications can help you avoid Technical Debt as well as begin to pay it off.

When you have a clear understanding of what Technical Debt is and what causes it you can avoid putting your company in the red.


Our second annual Profound Logic User Seminar (PLUS) is coming up! Register today to reserve your spot for this three day seminar that includes: hands on workshops, key Profound Logic speakers, and both Basic and Advanced learning sessions. The Seminar takes place November 15th-17th. Register Today!


 

Topics: Node.js, Profound.js, IBM i applications, IBM i, RPG Development, RPG, Application modernization, AS400 modernization, IBM i Modernization, Agile modernization, green screen modernization, 5250

Subscribe to Blog Updates

...and get the The Node.js for Enterprise
IBM i Modernization White Paper!

Node.js cover page option 2-1.png

Recent Posts