What Makes Software Good?

Photo by Daniel Schaffer on Unsplash

Writing good software is hard. There’re many things to think about. But everyone will appreciate good software.

In this article, we’ll look at the qualities of good software.

Characteristics of Software Quality

There’re many characters for good software. They include the following.

Correctness

Correctness is important for good software. There shouldn’t be faults with specification, design or implementation.

Usability

Users should be able to learn and use a system easily.

Efficiency

The less resource a piece of software uses, the better. Processor, memory and disk space usage should be minimized.

Reliability

A system that can perform the required functions stably is important. Failures should be as rare as possible.

Integrity

Security should be taken into account. Our software should let attackers access unauthorized resources.

Also, data validation is important so that bad data can’t be saved into the system.

Adaptability

A system that can be used without modification for different situations it’s good.

Accuracy

The accuracy of its outputs is good. This measures if the software outputs the right results for users.

Robustness

If a system is still working after getting invalid inputs and stressful environmental conditions, then it’s good for our system.

Maintainability

The ease in which an existing system can be changed is important. The easier that we can make changes, the better.

Portability

A system that operates in different environments from which it’s originally designed makes it good.

Reusability

The more reusable parts that a piece of software has, the better.

Using reusable parts means that we don’t have to reuse them from scratch.

Readability

Easy to read code is easy to change code. If we understand them faster, then we can make changes faster and in a less error-prone way.

Testability

Making our software system testable is critical. If our code is easy to write unit tests for, then that’s good.

Understandability

The ability for us to understand our system in a global view or at the detailed code level is important.

Easier to understand systems are more coherent.

With good software, it’s harder for us to create defects, and it’s faster to make changes.

Software-Quality Objectives

Setting objectives for maintaining software quality is a good way to increase quality.

It gives us something to work towards.

Explicit Quality-Assurance Activity

Quality assurance is always important. Without it, users will see the defects since no one is catching them.

It makes us more stressed and our reputation is worsened because of it.

We got to make our priorities clear and developers will respond accordingly.

Testing Strategy

To test software systematically, we need a testing strategy. Otherwise, our testing becomes inconsistent and unpredictable.

It’s easy to miss things if we test different things at different times.

Software-Engineering Guidelines

Having guidelines for software engineering will make things easier for us.

Technical Reviews

Code reviews and design reviews make everyone’s lives easier.

They expose flaws and allow people to check for sloppy practices.

We can just chat informally about issues.

Change-Control Procedures

Uncontrolled changes are unpredictable. Therefore, we should have some procedures to make them predictable.

For instance, we may document the steps to complete a feature, write code, and releases them to production.

Measurement of Results

We got to have some numbers to show whether our plan is working.

Quality attributes that we mentioned above live correctness, usability, etc. can also be measured.

Photo by MARK ADRIANE on Unsplash

Prototyping

Prototyping lets us make decisions easier by letting us fiddle with something that may become reality rather than just something on paper or in our brains.

Percentage of Defects Detected

We can check the rate of defects in our system to see how well it’s working.

Then we can use that to work towards improving our system if necessary by looking at the defects that are in our system.

When to Do Quality Assurance

We should do quality assurance for most things.

Since design affects every part of the system, we should think twice about it.

Defects can creep in anywhere. Therefore, we should emphasize quality assurance every step of the way.

Also important to note is that if we work on our code less, then there’s less risk that arises from changing code, and the risk of creating new defects will also be lower.

Conclusion

There’re many aspects of software quality assurance. They include the accuracy of our system, adaptability, and robustness, etc.

We got to make sure that we check for quality each step of the way.