How to Write Clean Code: Naming, Classes, Functions, and Testing Best Practices

Why Keep Code Clean?

Unclean code accumulates over time, reducing productivity, causing crashes, overtime, higher costs, and even risking company failure.

1. Naming

Good names improve readability and reduce understanding cost. Bad examples include meaningless method names like public interface Animal { void abc(); } which give no clue about functionality. Meaningful names such as public interface Animal { void cry(); } or findOneById and findAll make intent clear. Consistent naming (e.g., using find or query uniformly) and avoiding redundant words also improve clarity.

2. Classes

Classes should follow the Single Responsibility Principle, the Open‑Closed Principle, and high cohesion. An example of a class with two responsibilities is shown below:

public abstract class Sql { void insert(); void countInsert(); }

Refactoring extracts the counting responsibility into a separate class:

public abstract class CountSql { void countInsert(); }

This results in many small, focused classes rather than a few large, monolithic ones.

3. Functions

Functions should do one thing, have descriptive names, few parameters, no side effects, and clear return values. A long method that validates, compresses, and returns a status can be split:

public String upload() { check(); compress(); return "0"; }

Bad practices such as Boolean flag parameters, output parameters, or returning error codes are discouraged. Instead, use separate methods or exceptions, e.g.:

public void sendShutDown() { try { tryToShutDown(); } catch (DeviceShutDownError e) { logger.log(e); } }

4. Testing

Testing verifies code correctness and should itself be clean. Introduce Test‑Driven Development (TDD) and the FIRST principles (Fast, Independent, Repeatable, Self‑validating, Timely). Use the given‑when‑then pattern:

@Test public void shouldReturnItemNameInUpperCase() { // Given Item mockedItem = new Item("it1", "Item 1", ...); when(itemRepository.findById("it1")).thenReturn(mockedItem); // When String result = itemService.getItemNameUpperCase("it1"); // Then verify(itemRepository, times(1)).findById("it1"); assertThat(result, is("ITEM 1")); }

Tools like SonarLint can automatically detect code smells, duplicated code, potential null pointers, and suggest improvements.

Conclusion

Writing clean code enhances readability, extensibility, development efficiency, and reduces overtime. Developers are encouraged to read "Clean Code" and continuously refactor to maintain high‑quality software.