Clean Code

Every piece of knowledge must have a single, authoritative representation in the codebase.

Recognize hidden duplication and choose the right abstraction to eliminate it.

How the Toyota 5S manufacturing philosophy maps to professional software craftsmanship — naming, organization, cleaning, standardization, and discipline.

Understand what a framework does before using it — read the source, not just the docs.

Apply the F1–F4 heuristics to keep functions minimal, focused, and side-effect-free.

Keep high-level policy separate from low-level detail, and ensure base classes never depend on derived classes.

Apply the same pattern everywhere, avoid conceptual clutter, and never couple unrelated concerns.

Follow team coding standards religiously and replace every magic literal with a named constant.

Build systems that compile in one step, run all tests in one step, and never lie through suppressed warnings.

Use explanatory variables, precise names, and a deep understanding of the algorithm to make code speak for itself.

A method that spends most of its time reading another class's data belongs in that class.

Make all dependencies explicit, and replace if/switch chains with polymorphic dispatch.

Eliminate excessive information, dead code, and vertical distance to keep every file easy to scan.

Put every function in the class most interested in it, and keep static methods truly stateless utilities.

Boolean and enum selector arguments obscure intent — split them into focused, well-named functions.

A curated catalog of code smells and refactoring heuristics drawn from Clean Code chapter 17.

Code that tries to be clever is code that fails to communicate — density and brevity at the cost of clarity are not virtues.

Tests passing is not the same as understanding — clean code requires you to fully grasp why the algorithm works before you commit it.

Never let a module silently assume a value from another — make every dependency explicit and declared in code.

Three Java-focused heuristics: avoid wildcard imports, never inherit constants, and prefer enums over integer constants.

Safely transform tangled legacy code by adding tests first and refactoring in small steps.

Write names that reveal intent, avoid confusion, and make code searchable.

Apply the N1–N7 heuristics to write names that are accurate, unambiguous, and searchable.

Code is the only source of truth — comments lie as the code evolves.

Objects hide data behind behavior. Structures expose data. Mixing both creates hybrids nobody wants.

Quality is a professional responsibility — not something you deliver when time allows, but the non-negotiable minimum of your craft.

A pure function always returns the same output for the same input and changes nothing outside itself.

Use the Single Responsibility heuristics to detect and split overloaded classes and modules.

Apply successive refinement to the SerialDate class — test, rename, extract, and simplify.

A case study in reading legacy code critically — find the smells before touching anything.

Kent Beck's four rules, in priority order, for a design that is always ready to evolve.

Functions should do one thing, do it well, and do it only.

Code formatting is a communication act — structure files so any developer can navigate them in seconds.

Start with working code, then refactor iteratively — never write clean code in one pass.

Third-party code belongs at the edge — wrap it so it never pollutes your business logic.

Master the red-green-refactor micro-cycle: write a failing test first, then only the code needed to pass it.

Apply the T1–T9 heuristics to write complete, meaningful, and maintainable test suites.