Solving technical debt with open source

Download Report

In a new Linux Foundation paper, Technical Debt and Open Source Development co-authored by Ibrahim Haddad, Ph.D. and Cedric Bail, M.Sc., the causes and consequences of technical debt are explored in detail. It includes discussions on identifying technical debt, how to minimize it, the role of open source development, and strategies to address the issue at scale.

The authors worked together within the Open Source Group at Samsung Research and directly experienced minimizing internally carried technical debt via working with upstream open source projects. That experience covered dozens of open source projects used across multiple products and business units with varying degrees of involvement and expertise with upstream development.

The definition of technical debt

Technical debt, a term used in software development, refers to the cost of maintaining source code that was caused by a deviation from the main branch where joint development happens.

A broader interpretation of what constitutes technical debt is proprietary code by itself:

  • A single organization has developed it.
  • It is source code that the organization alone needs to carry and maintain.
  • In some cases, the organization depends on a partner’s ability to maintain the code and carry that said debt.

The following symptoms can identify technical debt:

  • Slower release cadence Time increases between the delivery of new features.
  • Increased onboarding time for new developers Onboarding new developers become highly involved due to code complexity where only insider developers are familiar with the codebase. The second manifestation of this symptom is the difficulty in retaining developers or hiring new developers.
  • Increased security issues At least, experiencing more security issues than the main upstream branch.
  • Increased efforts to maintain the code base Maintenance tasks become more time consuming as the body of code to maintain becomes larger and more complex.
  • Misalignment with the upstream development cycle illustrated in the inability to keep pace, be aligned with the upstream development and release cycles.

Consequences of technical debt

Creating and carrying technical debt will have several negative effects on development efforts, including:

  • The higher cost of code maintenance.
  • Slower innovation and development cycles.
  • Paying interest on the debt — payment of technical debt is in the form of additional development needed to keep up with the main branch, the competition, and the rest of the world.
  • Possibly missing on new features in the main branch or having to backport all new development into the forked branch internally.
  • Duplicate work with the main branch arising due to the delta between the internal and public branches being too large.

The worst possible consequence is the effect on the long term maintainability of the code base where organizations often find themselves maintaining their fork.

In many cases, tech debt is unavoidable short term. Carrying technical debt is mostly a decision that developers need to make all the time. The long term goals of any engineering effort should be to minimize and eliminate any tech debt resulting from any development effort. With proper policies, processes, training, and tooling, organizations can help mitigate and guide the engineering efforts towards lowering tech debt.

Open source has a significant role, and aligning your development efforts with upstream open source projects can result in a direct positive impact on the amount of the tech debt an organization carries. Just as financial debt involves paying interest, technical debt has a different kind of interest that needs to be carried: It’s not interest-free!

Technical debt is hindering your development and preventing your new growth, transferring your technical debt to become part of the open source world infrastructure, lowering it, and building on the giant’s shoulder that keeps growing.