Why Clean Code Matters: Practical Tips for Naming, Classes, Functions & Testing

Why Keep Code Clean?

Unclean code gradually reduces productivity, leads to hard‑to‑extend code, crashes, overtime, higher costs, and can even threaten a company's survival.

Start Clean from the Beginning

Avoid the "later" mindset; refactor messy code as soon as it appears.

Naming

Use meaningful names that convey intent. Avoid meaningless or redundant names, keep naming consistent, and do not use boolean flag parameters or output parameters.

<code>public interface Animal {
    void cry(); // clear intent
}
</code>

Inconsistent naming example:

<code>public interface StudentRepository extends JpaRepository<AlertAll, String> {
    Student findOneById(@Param("id") String id);
    List<Student> queryAllStudent(); // should be findAll
}
</code>

After refactoring:

<code>public interface StudentRepository extends JpaRepository<AlertAll, String> {
    Student findOneById(@Param("id") String id);
    List<Student> findAll();
}
</code>

Classes

Apply the Single Responsibility Principle, Open/Closed Principle, and high cohesion. A class should have only one reason to change.

How to decide if a class is short enough? If its name cannot precisely describe a single responsibility, the class is likely too large.

Example of a class with multiple responsibilities:

<code>public abstract class Sql {
    // SQL operation
    public abstract void insert();
    // Statistics operation
    public abstract void countInsert();
}
</code>

Refactor by extracting the statistics part into a separate class:

<code>public abstract class CountSql {
    public abstract void countInsert();
}
</code>

Functions

Functions should do one thing, have descriptive names, clean parameters, and appropriate return values.

Long function example (pseudo‑code):

<code>public String upload() {
    // validate image (80 lines)
    // compress image (50 lines)
    // return status (5 lines)
    return "0";
}
</code>

Refactored version:

<code>public String upload() {
    check();
    compress();
    return "0";
}
</code>

Separate command and query:

<code>public void addElement(Element e) { /* command */ }
public boolean isAdd(Element e) { /* query */ }
</code>

Prefer exceptions over error‑code returns to avoid deep nesting.

Testing

Testing validates code correctness; test code should also be clean.

TDD

Test‑Driven Development writes a failing test before production code, then refactors until the test passes.

FIRST Principles

Fast

Independent

Repeatable

Self‑validating

Timely

Given‑When‑Then Pattern

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

Conclusion

Writing clean code improves readability, extensibility, development efficiency, reduces overtime, and raises a developer's skill level. Everyone should read "Clean Code" to enhance coding ability and mindset.