10 Essential Habits Every Programmer Should Adopt

I summarize ten good habits for programmers to improve reliability and efficiency.

1. Rely on Official Documentation When Introducing New Technology

When adding new JARs or middleware to a project, always consult the official documentation. Online articles can be unreliable, so the official docs serve as the gold standard. For example, when unit testing SpringBoot2 code with JUnit 5, you do not need the @RunWith(SpringRunner.class) annotation.

@RunWith(SpringRunner.class)

The official docs state that this annotation is unnecessary with JUnit 5 and may cause conflicts.

2. Quietly Ensure Your Code Works Before Delivery

Reliable programmers deliver products with few bugs, which is judged by others, not self‑assessment. Even if your code isn’t perfect, thorough self‑testing before submission reduces low‑level bugs and builds a strong reputation.

3. Log Input, Output, and Duration Whenever Possible

Logging aims to locate problems, which are either logical or performance‑related. Printing inputs and outputs helps pinpoint logical errors, while timestamps and performance data enable quick detection of bottlenecks through log analysis or monitoring tools.

4. Master Git

Git is essential for team development. Poor Git usage leads to unnecessary bugs during merges and releases. The following Git handbook, authored by a GitHub employee, covers best practices and underlying principles, suitable for beginners and advanced users alike.

5. Prioritize Functionality Over Premature Performance Optimization

New developers often worry about performance too early. Early optimization can waste effort. Focus on implementing features first, then profile real usage and optimize the truly critical parts.

6. Implement Clear Requirements First, Defer Ambiguous Ones

Prioritize requirements based on certainty. Clear requirements should be built first, providing a solid framework that makes later discussions of vague requirements easier.

Well‑defined requirements from product managers.

Vague requirements that become clearer after initial implementation.

7. Proactively Identify Project Issues and Propose Solutions

Finding and solving problems during development creates momentum and personal growth. Each resolved issue contributes to project progress.

8. Allocate Buffer Time in Development Schedules

Unexpected changes—requirement shifts, team turnover, optimistic estimates, legacy code modifications, cross‑team collaboration, or last‑minute feature requests—necessitate extra time. Buffer time is not slack; it ensures steady progress.

Requirement changes

Team member turnover

Over‑optimistic estimates

Legacy code modifications

Cross‑team collaboration

Unplanned small features

9. Turn Learning Into Code, Not Just Reading

Practical implementation solidifies knowledge. Simply reading books can create a false sense of mastery; writing code with new technologies reveals real challenges and nuances.

10. English Is Important for Technical Growth

Most innovations and official documentation are in English. Understanding English enables access to cutting‑edge tools like Kubernetes and high‑quality resources. Even with limited English skills, developers can use translation tools and community help to stay current.