Inside software quality: Big picture and little details

Inside software quality: big picture and little details

In our previous six part series, we explored software quality, from concepts to benefits as a part of the development process. Now, what if we were to build a tool that supports these concepts, and delivers these benefits for efficient monitoring? Let’s begin a new exploration called “Inside Software Quality”, pointing out the essential qualities this tool should have.
And to begin at the beginning, what do we need to look at? The answer is, as often, contrasted: the big picture and little details.

Little details are where raw quality data live

Deep down, quality assessment uses metrics. And these metrics are attributes for every single component of the project. For example, in the source code portion of the project, we work with functions, described by:

A single source code function
  • Metrics: lines of code, effective code, statements, nesting depth, etc.
  • Checks: Coding rule violations, duplication and cloning detection, etc.
  • Links: Associated tests, requirements or even bugs

A quality model will use all these raw data to compute and prioritize meaningful indicators.
And since we eventually act on specific components, our actual work is done at the finest level.

Imagine the project was a tree, and to enhance quality we need to access all the leaves.
This means code elements, but also tests, requirements, bugs and more.

The big picture is where quality gets smarter

As we just saw, we need details to efficiently act on project components, that’s where the work is done.
But the big picture level can also provide useful insights.

The quality model aggregates raw data from all project components. If we use the tree analogy, the quality of each leaf impacts the quality of their branches, all the way to the root.
The further we travel towards the root, the more knowledge we can obtain from these quality indicators.

From a higher point of view, we no longer deal with raw data, but we can see invisible things at the lower levels, thanks to:

  • A synthetic view:
    • Grouped components (“A class of functions”, “A Test suite of test cases”)
    • Typed components (“All source files”, “All requirements”)
    • Whole project (“Project ‘A’ has Code and Tests”, “Project ‘B’ has Requirements and Tests”)
  • Analysis possibilities:
    • By component filtering (“What functions have newly failing tests?”, “What requirements were added without tests?”)
    • By quality indicators analysis (“What critical functions are badly covered?”)
A project is more than the sum of its parts

At the big picture level, we can make decisions based on an aggregated quality assessment.

Big picture + little details = More confidence

As a conclusion, both angles are essential to a confident approach of software quality monitoring:

  • The big picture angle helps us to decide where quality needs attention:
    You know why an action is required
  • The little details angle helps us to act on the relevant components:
    You know where an action is needed

An efficient monitoring tool should combine both angles: while assessing quality, and also while displaying it.

So, we know we need to zoom in and out on the quality data. But where do these data come from in the first place?
I can’t resist using the tree analogy one last time: in the next post, we will explore how to feed our software project tree!

Further readings


Legal Notice

This text is the intellectual property of the author and is copyrighted by You are welcome to reuse the thoughts from this blog post. However, the author must always be mentioned with a link to this post!

Leave a Comment

Related Posts

Int code overflow - coderskitchen
John Paliotta

Why is everything an int?

In C/C++ applications, most scalar variables are defined as ‘int’.  Do these applications deal with lots of large numbers that need 32-bit integers?  Not likely,

Flavien Huynh

Measuring and monitoring technical debt

The technical debt concept has been around for some time now. We can find it in international conferences, in scientific articles, books, and even here

Improving code quality
Flavien Huynh

Software quality: To the rescue!

In this post we’ll show what a healthy relationship with code quality looks like. After our introductory post, software quality (‘SQ’ for friends) might seem

Software quality - origin story - Coderskitchen
Flavien Huynh

Software quality: Origin story

Software quality is a vast field, which has been the subject of many studies, standards and tools for a long time (if we think in

Hey there!

Subscribe and get a monthly digest of our newest quality pieces to your inbox.