Ten Essential Characteristics of Good Code and How to Achieve Them

Writing good code starts with improving one’s taste for quality; many engineers lack a clear standard for what constitutes good code, focusing only on correctness and ignoring other crucial aspects.

1. Solid and Robust – Code must handle errors and exceptional cases from system calls, functions, and components, as error‑handling often dominates product‑level programs.

2. Fast – Efficient programs use minimal resources (CPU, storage, I/O) and require solid data‑structure and algorithm knowledge.

3. Maintainable and Simple – Logic should be clear and easy to maintain; simple solutions are preferred over complex, obscure ones.

4. Small – Keep code concise; however, brevity should not sacrifice readability.

5. Testable – Correctness must be verified by tests; practices like Test‑Driven Development help ensure testability.

6. Re‑Usable – Reuse existing frameworks and libraries to avoid reinventing the wheel, encouraging shared codebases within organizations.

7. Portable – Code should run across multiple operating systems, often achieved via abstraction layers or portable languages such as Python, Java, or Go.

8. Observable / Monitorable – Online services need mechanisms for continuous monitoring of program state.

9. Operational – Operations focus on cost, efficiency, and stability; design decisions must consider operational requirements.

10. Scalable and Extensible – Systems should support capacity growth and future feature extensions, often via plugin architectures or protocol buffers.

These ten standards can be grouped into four broader categories (see Table 1 in the original source).

Bad Code Examples – Illustrations of poor function names (e.g., do(), myFunc()), vague variable names (a, b, temp), lack of comments, functions with multiple purposes, bad layout, and code that is hard to test.

Where Good Code Comes From – Good code results from a full lifecycle: requirement analysis, system design, coding with unit tests, integration testing, deployment, and continuous operation. Coding alone accounts for only about 10 % of project effort; the rest is spent on analysis, design, testing, and maintenance.

Investing heavily in early phases (analysis and design) yields greater returns than focusing on later coding and testing stages, because errors introduced early propagate costly rework.

Modifying documentation is generally cheaper than modifying code, as design documents capture high‑level logic while code changes affect both high‑level and low‑level details.

Requirement Analysis vs. System Design – Requirement analysis defines the black‑box behavior (what the system should do), while system design defines the white‑box mechanisms (how and why it works). Clear separation prevents mixing of concerns.

The article concludes that high‑quality code is a product of disciplined engineering practices, thorough documentation, and a balanced focus on all stages of software development.