Skip to content
Tutorials Center
My learning

Topics

Lesson 2 of 50 ยท What Software Engineering Is

Qualities of Good Software

Learn the main qualities of good software: correctness, reliability, maintainability, performance, security and usability, and how to trade them off.

"It works" is the lowest bar for software. A program can produce correct answers and still be useless if it crashes every hour, takes a minute per click, leaks customer data or cannot be changed without breaking. These properties are called quality attributes (or non-functional qualities, or "-ilities"). They describe how well the software does its job, not what the job is.

This lesson names the main qualities, shows why they conflict, and gives you a simple technique for choosing between designs. The runnable examples are plain JavaScript stand-ins: they model the decision, they do not measure real systems. Real measurement uses tools such as profilers, load tests and security scanners, covered later in the course.

Six core qualities

Correctness Does the right thing.
Reliability Keeps working.
Security Resists misuse.
Performance Fast and efficient.
1 / 2

The main qualities

Correctness means the software meets its specification: given valid input it produces the required output. Correctness depends on having a specification at all; see functional and non-functional requirements. You cannot prove a large program correct in practice, so you gather evidence with tests and reviews.

Reliability is the probability that the software runs without failure for a given time in a given environment. A correct program can still be unreliable, for example when it works until the disk fills up. Related ideas are availability (the share of time the system is usable) and fault tolerance (continuing to work when a part fails). Reliability is usually expressed in numbers, such as "99.9% availability", which allows roughly 8.8 hours of downtime per year.

Performance covers response time, throughput and resource use. "Fast" is meaningless without a number and a situation: "95% of search requests answer within 300 ms with 500 concurrent users" is a requirement you can test. Scalability is the ability to keep performance acceptable as load grows.

Security protects data and operations against misuse. The classic goals are confidentiality (only authorized people read data), integrity (data is not altered improperly) and availability. Security is easiest to build in from the start and very hard to add at the end; ethics, security and licensing returns to it.

Usability is how effectively and pleasantly real users reach their goals. It includes learnability, error prevention, accessibility for people with disabilities and clear feedback. A feature nobody can find does not exist for them.

Maintainability is how cheaply the software can be understood, fixed and extended. Most of a successful system's total cost is spent after the first release, so this quality quietly decides budgets. Readable code, tests, modular structure and documentation all serve it. Related qualities are portability (moving to another platform) and testability (how easily behavior can be checked).

Qualities conflict

Most qualities cost something in another. A few typical trade-offs:

  • Security versus usability. Strong authentication and short sessions protect accounts but annoy users.
  • Performance versus maintainability. Hand-tuned code is faster and harder to read and change.
  • Reliability versus cost and speed of delivery. Redundant servers and extra testing cost money and time.
  • Flexibility versus simplicity. Making everything configurable adds code, options and bugs.

There is no universally best design. The engineer's job is to find out which qualities matter most for this product and make the trade-offs on purpose. A hospital device and a game prototype need very different priorities. A practical way to make them explicit is a quality attribute ranking done with the stakeholders: "If we must choose, what do we protect first?"

flowchart LR
    A["Stakeholder needs"] --> B["Pick the top 3 qualities"]
    B --> C["Turn each into a measurable target"]
    C --> D["Evaluate design options"]
    D --> E["Record the trade-off decision"]

Qualities become useful once they are ranked, measured and used to compare designs.

Making qualities measurable

A quality you cannot measure is a wish. Compare:

Vague Measurable
"The app should be fast" "The product page renders in under 2 seconds on a mid-range phone on 4G"
"It must be reliable" "At most 45 minutes of unplanned downtime per month"
"Easy to maintain" "A new developer fixes a typical bug in under a day; unit-test coverage of core logic above 80%"
"Secure" "All passwords stored with a slow salted hash; no critical findings in the quarterly scan"

The coverage number is a proxy, not a guarantee; TDD and code quality practices explains why such numbers must be read carefully.

Comparing designs with weighted scores

A simple and honest way to compare design options is a weighted decision matrix. You list the qualities, give each a weight that reflects project priorities, score each option, and sum weight times score. It does not remove judgment (the scores are opinions) but it makes the opinions visible and discussable.

JS Rank designs against weighted qualities

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Change the weights and watch the winner change. If maintainability weighs 1 and cost weighs 5, the cheap single server may win. The matrix is only a tool for talking: when the result surprises you, find out why before trusting either your gut or the number.

Checking a quality target

Once a quality has a target, checking it is a yes or no question. The second stand-in compares measured values against the targets from the table above. Real systems get these measurements from monitoring and tests; here they are typed in.

JS Do measurements meet the quality targets?

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The failing reliability target tells the team where to invest, which is the point: quality attributes turn "could be better" into a prioritized list.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. A program returns correct results but crashes after running for a day. Which quality is weak?

    Reliability is about continuing to work over time. The results can be right while the program keeps failing.
  2. 2. Which requirement is measurable?

    It has a number, a percentile and a load condition, so a test can say pass or fail.
  3. 3. Why do engineers rank qualities for a project?

    Security can reduce usability, tuning can reduce maintainability, and so on. A ranking makes trade-offs deliberate.
  4. 4. What does a weighted decision matrix NOT do?

    The scores and weights are still opinions. The matrix just makes them explicit and easy to challenge.

Summary

  • Quality attributes describe how well software works: correctness, reliability, performance, security, usability and maintainability, among others.
  • They conflict with each other and with cost, so teams rank them for each project.
  • A quality is only useful when it has a measurable target.
  • A weighted decision matrix compares design options openly, but its numbers are opinions and need discussion.
  • Maintainability often dominates lifetime cost because most work happens after release.

Next: Software Processes and the Life Cycle.