What Makes Code Truly Good? Essential Principles and Practices

One-sentence Summary

Effective code quality metric: WTF/min – Robert C. Martin

Many developers feel that after weeks or months their own code looks like a mess, prompting the question: what constitutes good code? Good code must be clean, readable, and maintainable, serving both machines and future human readers.

Characteristics of Good Code

Clean code is a prerequisite for good code. It should exhibit high cohesion, low coupling, strong readability, and ease of maintenance.

High Cohesion & Low Coupling

These concepts are measured by several object‑oriented design principles:

Open‑Closed Principle (OCP)

Single Responsibility Principle (SRP)

Dependency Inversion Principle (DIP)

Law of Demeter / Least Knowledge Principle (LKP)

Liskov Substitution Principle (LSP)

Interface Segregation Principle (ISP)

Composite/Aggregate Reuse Principle (CARP)

Applying these principles yields code with high cohesion and low coupling, which can be used as a benchmark for quality.

Readability

Beyond cohesion, code must be easy to read. Consider the following aspects:

Naming : Names should be self‑explanatory, concise, and distinguishable without needing comments.

Formatting : Use vertical formatting (one statement per line, blank lines between logical blocks) and horizontal formatting (proper indentation and spacing) to enhance clarity.

/**
 * Days since creation
 */
int daysSinceCreation;

The above naming is clearer than a vague variable like int d;.

Classes and Functions

Classes and functions should be short; functions should perform a single responsibility and have as few parameters as possible. Overly long functions or large classes hinder readability and maintainability.

Comments

Comments should add information not evident from the code, explain intent, or warn about pitfalls. If a comment feels necessary, consider refactoring the code instead.

Error Handling

Error handling must be centralized, isolated from business logic, and provide sufficient context (class name, key data, environment) to aid debugging. Techniques like Null Object can reduce null‑related errors.

Code Smells (What Is Not Good Code)

Common indicators of bad code include:

Duplication

Overly long functions or classes

Excessive parameters

Scatter‑shot changes (multiple unrelated modifications in one class)

Attachment (functions operating more on other classes than their own)

Data clumps (repeated groups of fields across classes)

Excessive if…else or switch statements (consider polymorphism)

Addressing these smells typically leads to cleaner, more maintainable code.

Conclusion

Good code starts with cleanliness: high cohesion, low coupling, and strong readability. Understanding both the positive attributes and the negative code smells helps developers write code that is not only functional but also elegant and maintainable.