Translate This Page
Q1
In the current agile environment, we hear a term called “Technical Debt” very often, what is this and what are the causes this?
A
Technical Debt: is a concept in software development that reflects the implied cost of additional rework caused by choosing an easy solution at present time instead of using a better approach that would take longer to implement.
Technical debts are caused by many reasons, some of these or many of these will contribute to the context referred. The possible reasons are as followed.
o Insufficient up-front definition, where requirements are still being defined during development, development starts before any design takes place. This is done to save time but often has to be reworked later.
o Business pressures, where the business considers getting something released sooner before all of the necessary changes are complete, builds up technical debt comprising those uncompleted changes.
o Lack of process or understanding, where businesses are blind to the concept of technical debt, and make decisions without considering the implications.
o Tightly-coupled components, where functions are not modular, the software is not flexible enough to adapt to changes in business needs.
o Lack of a test suite, which encourages quick and risky Band-Aids to fix bugs.
o Lack of documentation, where code is created without necessary supporting documentation. The work to create any supporting documentation represents a debt that must be paid.
o Lack of collaboration, where knowledge isn't shared around the organization and business efficiency suffers, or junior developers are not properly mentored.
o Parallel development on two or more branches accrues technical debt because of the work required to merge the changes into a single source base. The more changes that are done in isolation, the more debt is piled up.
o Delayed refactoring – As the requirements for a project evolve, it may become clear that parts of the code have become inefficient or difficult to edit and must be refactored in order to support future requirements. The longer that refactoring is delayed, and the more code is added, the bigger the debt.
o Lack of alignment to standards, where industry standard features, frameworks, technologies are ignored. Eventually, integration with standards will come, doing sooner will cost less (similar to 'delayed refactoring').
o Lack of knowledge, when the developer simply doesn't know how to write elegant code.
o Lack of ownership, when outsourced software efforts result in in-house engineering being required to refactor or rewrite outsourced code.
o Poor technological leadership where poorly thought out commands handed down the chain of command increases the technical debt rather than reduce it.
o Last minute specification changes; these have potential to percolate throughout a project but no time or budget to see them through with documentation and checks.
Q2
What is “Cultural Debt” ?
A
“Cultural debt is compromising company culture to speed up growth and transformation, which results in significant repayment in the future.”
In other words, “Cultural debt” occurs when cultural considerations are disregarded or deferred in favor of growth and innovation.
In addition, the cultural debt incurs when there is no solid framework that supports a positive culture within an organization. It occurs when organizations take the shortcut to suffice the current need, impacting your company culture in such a way that it damages trust, morale, and communication.
Cultural debt can happen due to many reasons, such as:
• Silos become impenetrable (fiefdoms)
• Companies hire the wrong people
• Employees don’t feel empowered
• Employees don’t feel their contributions matter
• Peoples’ contributions aren’t acknowledged
• People aren’t given the time or resources needed to make improvements
• Feedback loops are negative or non-existent
• Information is hidden
• People put what’s happening today over investing in the future