DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
Refcards Trend Reports
Events Video Library
Refcards
Trend Reports

Events

View Events Video Library

Zones

Culture and Methodologies Agile Career Development Methodologies Team Management
Data Engineering AI/ML Big Data Data Databases IoT
Software Design and Architecture Cloud Architecture Containers Integration Microservices Performance Security
Coding Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Culture and Methodologies
Agile Career Development Methodologies Team Management
Data Engineering
AI/ML Big Data Data Databases IoT
Software Design and Architecture
Cloud Architecture Containers Integration Microservices Performance Security
Coding
Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance
Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks

Generative AI has transformed nearly every industry. How can you leverage GenAI to improve your productivity and efficiency?

SBOMs are essential to circumventing software supply chain attacks, and they provide visibility into various software components.

Related

  • 12 Principles for Better Software Engineering
  • Software Specs 2.0: An Elaborate Example
  • The Cypress Edge: Next-Level Testing Strategies for React Developers
  • Creating a Web Project: Refactoring

Trending

  • Building an AI Nutrition Coach With OpenAI, Gradio, and gTTS
  • The AWS Playbook for Building Future-Ready Data Systems
  • The Twelve-Factor Agents: Building Production-Ready LLM Applications
  • Why Traditional CI/CD Falls Short for Cloud Infrastructure
  1. DZone
  2. Culture and Methodologies
  3. Career Development
  4. What Is the Real Root Cause of Your Problem?

What Is the Real Root Cause of Your Problem?

This article discusses how to identify and look into the real root cause of an issue in order to improve a project's needs.

By 
Sebastian Malaca user avatar
Sebastian Malaca
·
Apr. 05, 23 · Opinion
Likes (1)
Comment
Save
Tweet
Share
2.8K Views

Join the DZone community and get the full member experience.

Join For Free

There is a project. Code is written, everything is tested, coverage is high, and features get delivered. There are bugs from time to time, but incidents get fixed fast, and no one worries about the situation. Well, business as usual. 

Time passes...

From time to time, there are situations where people get nervous due to critical issues after the release. All hands on board, and after several stressful hours, things get fixed. 

Time passes...

The number of incidents gets bigger. Teams spend more time fixing them. And people start to wonder how to get back to comfortable times from the past...

Let’s Make the World a Better Place!

There is a decision to run a post-mortem to find a way to make everyone's life easier. Everyone wants to solve the problem, every developer, tester, manager, analyst, etc. What do you need more? 

The meeting is fruitful, and there are a lot of ideas:

  • add more tests;
  • analyze requirements more carefully;
  • invest more time in knowledge sharing.

Yet another productive meeting with a great outcome!

What Just Happened?

It is worth noticing decision teams made added more work. They need to write more tests, spend more time on analysis and run additional knowledge-sharing sessions. Like it or not, they just decided to increase their lead time. 

Of course, it does not have to mean they made a wrong decision. Sometimes it is worth doing so for a short period as an investment. The question is: are we talking about this scenario now? 

Did They Make a Good Decision?

Things are tricky because, on the surface, everything makes sense: more tests, better analysis, knowledge-sharing sessions — it does not sound like anything harmful. 

Yet, what is the missing part of this equation? 

When things get worse, the first step should not be to look for improvements but for the root cause of a problem. You should first look at things that changed. In our imaginary scenario:

  • the code coverage is still the same as it was when everything was fine;
  • developers were and are writing tests;
  • analysts are sharing requirements using the same practices they are using for years.

If this is true, why do we think we need to improve the good practices we are using for years? If the same exemplary techniques with the same quality are used, why do we think there's a problem in those areas?

Is the “Root Cause” You Found the Real Root Cause?

When you face a problem that was not present in past, you should first look for the things that changed. I'm not saying this is always the cause of the problem, but this is where you should start.

What did NOT change? The code is written in the same manner, the coverage and metrics are on the same level, the quality of devs, testers, and analysts is still the same, and the same techniques and practices are used to deliver new functionality.

What changed? The complexity of the project is different. Each feature, each new definition, and supported scenario is new knowledge. This is great, but this gets bigger over time. And this is where you should look for improvements. 

Instead of adding more tests, spending more time on analysis, spending more time on meetings, and adding more checks and validations, you should think about how to tackle the greater complexity of your project. Is that easy? Of course, not. But having that and fast delivery in mind, you can finally look for the improvements your project needs.

Root Cause Identified

Code coverage dev Testing Software development career

Published at DZone with permission of Sebastian Malaca, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

Related

  • 12 Principles for Better Software Engineering
  • Software Specs 2.0: An Elaborate Example
  • The Cypress Edge: Next-Level Testing Strategies for React Developers
  • Creating a Web Project: Refactoring

Partner Resources

×

Comments

The likes didn't load as expected. Please refresh the page and try again.

ABOUT US

  • About DZone
  • Support and feedback
  • Community research
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Core Program
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 3343 Perimeter Hill Drive
  • Suite 100
  • Nashville, TN 37211
  • [email protected]

Let's be friends: