The Pillars of Clean Code

Code is read far more often than it is written. Therefore, making your code easy to read is as important as making it work. This involves using clear and descriptive names for variables, functions, and classes, employing consistent formatting, and organizing code logically. Imagine explaining your code to a colleague; if it's easy to explain, it's likely readable.

Example:

// Unclear
function proc(d) {
  let t = 0;
  for (let i = 0; i < d.length; i++) {
    t += d[i] * 1.15;
  }
  return t;
}

// Clearer
function calculateTotalPriceWithTax(prices) {
  let totalPrice = 0;
  const taxRate = 0.15;
  for (const price of prices) {
    totalPrice += price * (1 + taxRate);
  }
  return totalPrice;
}

The simplest solution is often the best. Avoid unnecessary complexity, over-engineering, and premature optimization. Focus on solving the problem at hand in the most straightforward way possible. Complex code is harder to understand, debug, and maintain.

Think: Is there a simpler way to achieve this result?

Code that is easy to change and update over time is maintainable. This is achieved through good design, modularity, and adherence to principles like DRY (Don't Repeat Yourself). When a change is needed, it should be localized and impact minimal parts of the system.

Key Practices:

• Modularity: Breaking down code into smaller, reusable components (functions, classes).
• DRY: Avoiding redundancy. If you find yourself writing the same code multiple times, abstract it into a function or class.
• Testability: Writing code that is easy to test (unit tests, integration tests).

Clean code is inherently testable. Writing unit tests and integration tests not only verifies the correctness of your code but also serves as a form of documentation and encourages modular design. If code is hard to test, it's often a sign of tight coupling or lack of clear responsibilities.

Benefit: Confidence in your code and a safety net for refactoring.

While clarity is key, avoiding verbose or redundant code is also important. Write code that expresses its intent clearly without being overly wordy. This doesn't mean sacrificing readability for brevity, but rather finding the most expressive way to communicate your logic.

Strive for: Code that is as short as possible, but no shorter.