What Makes Code Truly Good? 10 Essential Traits Every Engineer Should Master

Good Code Characteristics

1. Robust (Solid and Robust) Code must handle errors and exceptional cases, not just execute correctly; error handling often dominates production‑level programs.

2. Fast Programs should use minimal resources (CPU, storage, I/O) and apply appropriate data structures and algorithms.

3. Maintainable and Simple Logic should be clear and easy to maintain; avoid overly complex solutions when a simple one suffices.

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

5. Testable Correctness must be verified by tests; adopting Test‑Driven Development helps expose testability issues early.

6. Re‑Usable Leverage existing frameworks and open‑source libraries to avoid reinventing functionality and reduce development cost.

7. Portable Design abstraction layers to hide OS differences, enabling cross‑platform execution (e.g., Python, Java, Go).

8. Observable / Monitorable Provide mechanisms for continuous runtime monitoring, including state collection and external reporting.

9. Operational Focus on cost, efficiency, and stability; design with operability in mind from the start.

10. Scalable and Extensible Support both capacity scaling and functional extensions, often via plugin architectures or protocol buffers.

These ten standards can be grouped into four broader aspects (see the table below).

Bad Code Examples

1. Bad Function Name Names like do() or myFunc() convey little meaning.

2. Bad Variable Name Single‑letter or generic names (a, b, temp) are acceptable only for tiny scopes.

3. No Comments Lack of comments raises the cost of understanding code.

4. Function Lacks Single Purpose Functions that mix multiple responsibilities become hard to maintain.

5. Bad Layout Ignoring formatting (e.g., compressing C code onto one line) harms readability.

6. Not Testable Code that cannot be reliably tested is difficult to guarantee quality.

Where Does Good Code Come From?

Good code results from a series of disciplined steps rather than merely writing code.

1. Analysis and Design Proper requirement analysis and system design are often neglected but are crucial.

2. Coding and Unit Testing Writing both code and unit tests is essential; testing is not solely a tester’s job.

3. Integration, Deployment, and Ongoing Operations These phases consume significant effort, especially monitoring and iterative improvement.

Investing more resources in the early phases (analysis and design) yields greater returns than focusing solely on coding.

4. Cost of Modifying Code vs. Documentation Modifying documentation first reduces costly code changes later; code changes often affect many hidden details.

5. Difference Between Requirement Analysis and System Design

Requirement Analysis : Defines the black‑box behavior (what the system should do).

System Design : Describes the white‑box mechanisms (how and why the system works).

Understanding this distinction prevents mixing concerns in documentation.

Excerpted from the book "The Art of Code: Driving Software Development with Engineering Thinking".