Kristian Soares

More Than Just Style

13 Feb 2025

The Importance of Coding Standards: More Than Just Style

When people hear the term “coding standards,” they often think about little things like whether to use spaces or tabs, or if curly braces should be on a new line. While these details do matter, coding standards are way more than just style choices. They help make code more readable, maintainable, and even teach new programmers how to write better code. If I had to choose just one software engineering practice to improve code quality, it would be following good coding standards.

Coding Standards as a Learning Tool

One thing that surprised me is how much coding standards actually help in learning a programming language. At first, I thought they were just a set of annoying rules, but after using ESLint in VSCode for a while, I started to see the benefits. ESLint doesn’t just point out mistakes—it helps enforce best practices. According to Martin Fowler, “Any fool can write code that a computer can understand. Good programmers write code that humans can understand” (Fowler, 1999).

For example, consider this JavaScript function:

function addNumbers(a, b) {
   return a + b;
}

This looks fine, but what if someone calls addNumbers('3', 5)? Instead of throwing an error, JavaScript will convert ‘3’ into a number and return 8. This could cause unexpected behavior in a larger program. A linting tool like ESLint can catch these issues and suggest using explicit type checks to avoid such problems.

The Pain (and Gain) of Fixing ESLint Errors

Getting rid of all the ESLint errors can be frustrating at first. It’s like having a super strict teacher constantly correcting your work. But after a while, I noticed that I was making fewer mistakes and writing cleaner code from the start. Instead of seeing the warnings as annoying, I started seeing them as helpful. It’s kind of like learning grammar rules in English class—at first, it feels pointless, but later you realize how much it improves your writing.

Robert C. Martin, in his book Clean Code, emphasizes that “clean code is simple and direct. Clean code reads like well-written prose” (Martin, 2008). When ESLint warns about inconsistent spacing, like this:

if(foo === bar){
  console.log("Hello world");
}

The lack of spaces after if and before the curly braces makes the code harder to read. A proper coding standard would enforce better spacing:

if (foo === bar) {
  console.log("Hello world");
}

These small details make a big difference when working on large projects.

Why Coding Standards Matter Beyond ESLint

Even outside of ESLint, coding standards make a huge difference. Imagine working on a group project where everyone writes code in completely different styles. It would be a nightmare to read and debug! Coding standards ensure that everyone is on the same page, which makes collaboration way easier. They also make it easier to go back and understand your own code weeks or months later.

For example, in Python, it’s a common convention to use snake_case for variable names and PascalCase for class names. If one person names a function calculateTax and another names it calculate_tax, it can cause confusion, especially in a large codebase. Following a standard naming convention helps keep things consistent and readable.

Another example is error handling. Without a standard way of handling errors, one part of a program might use try-catch blocks while another part relies on returning error codes. This inconsistency can make debugging a nightmare. A coding standard that enforces structured error handling (like always using try-catch for critical sections) helps make the code more reliable.

Conclusion

At first, I didn’t think much about coding standards. They just seemed like a set of rules that made things harder for no reason. But after using ESLint and seeing how it improved my coding skills, I’ve changed my mind. Coding standards aren’t just about making code look nice—they help prevent mistakes, make collaboration easier, and even teach you better programming practices. So, while fixing ESLint errors might be frustrating, it’s worth it in the long run.

Good coding standards are like good habits—they might seem annoying at first, but once you get used to them, they make everything easier. Whether it’s following indentation rules, writing clear function names, or using consistent error handling, these small things add up to create better, more maintainable code. So the next time you see an ESLint warning, instead of ignoring it, think of it as a free coding lesson!

I used ChatGPT to help me organize my essay better and give me a basic layout.

References