Introduction

Technical Debt is a term that is commonly used in agile-scrum team process. Technical debt is used for the work which team or an individual didn’t prioritize upon while pushing the deliverable, and  either left some unwanted code in various project artifacts, such as – .cs, .config, .cshtml, .js, .sql etc. or didn’t use the right technique to accomplish the goal. But in real world software development process this is expected and totally fine as long as team takes the responsibility to pay off the Technical Debt.

How is Technical Debt created?

Technical Debt is like financial $$ debt; if you don’t pay off previously owned $ amount but keep borrowing more than you are getting into messier situation. I assume you are not the one who like debt that much; whether it is technical or financial. Anyways, just to be aware; if you don’t take good care of the following items then you are potentially seeding “Technical Debt” situation in general, later on which needs to be paid off.

  • First and foremost poor coding style and standards.
  • No unit test cases.
  • Not following OO design principles.
  • Developing long monolithic classes and code libraries.
  • Not envisioning on proper candidate technology, architecture or approach and then hitting a wall. I.e. when application is little bit mature you start to feel the hit on User experience, performance, scalability, code maintenance etc.
  • Over engineered application. I.e. things which can be done in simpler way are done using very complicated mechanism. For instance, to do encryption data, custom code is written or taken from internet which causes a lot of security holes and performance hits.
  • Code files has a lot of comments. I.e. code is completely documented. Many developers write few lines of comment for each line of code.
  • Code is not self-documented. I.e. Classes, functions, variables etc. are given improper names. For example, a function is named Salary instead of EmployeeSalary or a variable is called double sal instead of double employeeSalary.
  • Shortcut approach is taken to push the functionality to meet the code complete deadlines. Such events trigger further refactoring to be performed later. For instance, created one thick bulky Model class with a lot of classes within. Or hard coded various paths and endpoints into the .cs code rather than putting those into a web.config and reading web.config Key in the code for the related value (key-value pair).
  • Dead code in project. You must have seen or left some commented code in various code files. This is dead code and needs to be cleaned up.

Based on above mentioned points, now you will be able to understand that why Technical Debt is also known as Code Debt or Design Debt. In addition, anything in your software development work; which slows you down or looks odd, or can be improved is a “Technical Debt”.

How to handle Technical Debt

First step is, not to cause any technical debt from your end; if at all possible. However, in agile development it’s common to have some technical debt accumulated over the period of time, if so then move to second step. Second step is to report any technical debt which you have either caused or came across.

Please don’t get into blame game or point finger to any individual. Let’s say you come across some code blocks in a file you are working on and then you see some dead code. Rather than start cleaning it up, I recommend create a Technical Debt item and let the team decide.

How to Report Technical Debt

Technical debt items are usually reported as Issues or as a “New Product Backlog Item”. Also, Technical debt items are supposed to be logged in a separate backlog. I.e. don’t report those to Production or sprint backlog. In many teams and as per my experience with agile-scrum I have always worked on a separate dedicated “TechnicalDebt backlog”

Having a separate TechnicalDebt Backlog allows the team to stay focused on Sprint backlog and don’t interfere with business requirements which are logged in the Product Backlog.

Creating Technical Debt backlog

Creation of backlog and modifying process templates etc. are usually done by an admin on your team project. In an agile team setting this duty is usually performed by the scrum master.

If your team doesn’t already have a Technical Debt backlog, then it’s time create one.

  1. Go to VSTS (Visual Studio Team Services) Team Project’s Web Portal and in control panel under work, click on Areas.

  2. Under the “Areas” click on “New child”

  3. Name it as “TechnicalDebt_<YourTeamProjectName>”. TechnicalDebt prefix helps you differentiate it with other areas and makes it self-explanatory.

  4. It will now appear under your Team Project as an area.

 

Let’s see it from Developer’s angle

Developers usually interact via Team Explorer from within Visual Studio IDE.

Select Work Items and then click on “New Work Item” and based on your team process template; usually either Agile or Scrum, you can select Product Backlog Item or Impediment or Issue as item type to report the Technical debt.

Filling in the details

Usually, any item in any backlog needs to have ample information to describe what the issue is. In the below example, it is briefly pointed out that some classes need code cleanup. Some questions might still be unanswered and those will be discussed during backlog grooming and sprint planning.

When to work on Technical Debt

Just like Product and Sprint backlogs, Technical Debt backlog also needs to be groomed I.e. each “Technical Debt” item needs to be reviewed and groomed by the team to identify its validity, impact on overall team’s development experience and software quality team is producing. Once, team is in agreement to pay off a technical debt item or items then those items are transferred to Sprint Backlog and many times a new User Story is created for each technical debt.

Many Agile experts say that a team must not carry Technical Debt beyond a sprint, just like you should not carry Credit Card balances over to next pay period. I.e. pay off full Credit Card debt in the same billing cycle. But, it’s not always possible, so it doesn’t happen in software world for Technical Debt as well.

Summary

I personally recommend that as a developer you should not cause any technical debt due to the code you have written or currently writing. Be honest, about any improvements your code might need and explicitly call out what changes can be made to make it better. Avoid any over engineering or unwanted design patterns and technology implementations to be called out as Technical Debt. If you are not sure whether a particular code / technique is Technical Debt or not, call out a short brain storming session. In today’s software development industry it’s not easy to avoid technical debt, we all live with it, but be aware that you have to get rid of technical debt to achieve complete Technical Freedom.

Please do Comment, Like and Subscribe to my Channel.

Watch YouTube Vide Here…

Abstract

Agile is a software development methodology which I becoming popular day by day. It defines the mind set of many software development teams working across the globe. This article will walk you through the entire agile-scrum process and how as a developer you can contribute in agile way and deliver value. BTW, agile means ability to move quickly.

Agenda

  • Life Cycle of a Developer
  • Barriers to value delivery
  • Agile Adoption
  • Plan Driven Vs. Value Driven
  • Agile Manifesto
  • Scrum – End-to-End Process
  • Agile Estimation
  • Scrum Status Board
  • Agile Tools
  • Conclusion

Life Cycle of a Developer

 1st interaction a developer have is with BA, they are responsible to document, track and describe the user requirements. But many times there are gaps in understanding the needs; which causes issue by various means.  Image below shows what user wanted and what happened when it is implemented.

Stop the blame game

In many team settings, a developer is considered to be responsible for everything, right from understanding requirements to code to support testing, help in deployment and then resolve production issues. Well, I always believed that entire software development is a team effort. But at the end, in most cases developers bear most of the blame. So its no longer a Developer’s responsibility to own everything rather team owns it.

Team Barriers = Value Delivery Impediments

All .NET Development teams want to deliver value but on realistic grounds what are barriers which stops a team to deliver value.

Every team has dependency within and on people outside, the communication gap and lack of understanding of common goal is the root cause of Value Delivery Impediments.

Impact of Team Barriers

Well, most of the issues any software teams runs into has following outcomes:

Increased Cycle Times – This means that you have to work longer to get work completed.

Increased costs – More time means more money.

Dissatisfied users & Stakeholders – End user missed the milestone of feature being available and so it raises concerns for stakeholders as well.

Lost value opportunities – You are potentially not going to have more work from same client.

Agile Adoption

 

Agile-Scrum is most widely accepted methodology of Agile development. Term scrum is taken from sport rugby in which whole team works get the possession of the ball.

Plan Driven Vs Value Driven

 

Plan Driven (waterfall approach) is an old school which defines software development life cycle. Many teams are still doing that though but in waterfall plan takes precedence over value.

Value Driven (agile approach) is new way of building software, it gels teams, stakeholders and user very well and help them team receive early feedback and fail fast.

Manifesto for Agile Development

17+ people gathered in a ski resort and they came up with agile manifesto.

Understanding Type of Backlogs

In agile-scrum there are two type of backlogs

  1. Product backlog
  2. Sprint backlog

Product backlog is larger list of work items (in agile world known as User Stories), it is like a “Functional Specification Document” or System Requirement Specification Document or “Business Requirement Document” or whatever your organization likes to call it.

So whatever user requirements we have, all are stored in Product Backlog, backlog.

Sprint Backlog, Sprint is defined time, teams work on to deliver certain items from product backlog. But before teams start working on those items (User Stories), those need to be properly defined.

Scrum – End -to-End Process

Agile Scrum Ceremonies

Team works on a sprint for anywhere between 1-4 weeks. Ideal sprint duration is 2 weeks. So from Product backlog some User Stories are moved to Sprint Backlog and then team works on those for 2 weeks. During those two weeks following ceremonies are performed.

Sprint Planning, this is 1st thing which takes place before any work can begin. In this meeting team looks at User Stories which Product Owner thinks team should work upon in the next sprint. Team looks in detail at the given requirements, brainstorm, define/review acceptance criteria or the work, estimate and assign the work to team member(s).

Daily Stand-Up, this is status meeting among team(s) members, in this meeting each team member gives status on three criteria’s.

  1. What I did yesterday.
  2. What I will do today.
  3. Am I blocked?

Sprint Review, this takes place after each User Story is completed, so Product owner can accept the work.

Sprint Demo, this given an opportunity to the whole team and larger group of users to see all the work team has completed and see end-to-end functionality.

Sprint Retrospective, this gives opportunity to the development team to discuss three things

  1. What went well?
  2. What went wrong?
  3. What we want to improvise?

Agile Estimation

Agile offers two type of estimations:

  1. Story Points, this is most commonly used agile estimation technique.
  2. T-Shirt Sizing, some teams estimate User Stories in T-Shirt sizing.

Scrum Status Board

Agile, enforces daily status reporting and so many teams use various ways to track and show the progress on each user story. I found that a detailed board like following provides more visibility and track each task/activity related to a Sprint Item.

Agile Tools

There are many tools available for agile-scrum teams, but I have found TFS and rally widely used in industry. Both work on similar agile-scrum concepts and are very user friendly. Below are the screenshots of TFS.

Sprint View in TFS

Workflow for Task Status

Drag and Drop support for ease

Conclusion

Though agile seems very easy to understand and implement, but it’s very challenging to apply it correctly and many organizations are not in agreement with what agile brings and its way of delivering things. Startups are usually known to follow agile rather well established companies at organization level. I.e. In a company a team might be doing agile but various other teams or company’s mindset might still be waterfall based.  But agile is an amazing methodology to deliver more value; regardless of you are working in agile team or not it’s worth knowing about agile-scrum process.

We are uncovering better ways of developing
software by doing it and helping others do it.
Through this work we have come to value:

Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

That is, while there is value in the items on
the right, we value the items on the left more.

Kent Beck
Mike Beedle
Arie van Bennekum
Alistair Cockburn
Ward Cunningham
Martin Fowler
James Grenning
Jim Highsmith
Andrew Hunt
Ron Jeffries
Jon Kern
Brian Marick
Robert C. Martin
Steve Mellor
Ken Schwaber
Jeff Sutherland
Dave Thomas

Source : http://www.agilemanifesto.org/