Miscellaneous

Linting using ESLint

Maintaining consistent code style and identifying potential issues early are crucial for building robust and maintainable applications. We use linting and code formatting tools to enforce coding standards and automate code style checks.

ESLint is a popular JavaScript linting tool that analyzes your code to identify stylistic and potential code quality problems. It helps enforce coding conventions, catch errors, and improve code readability. ESLint Documentation

Code Formatting using Prettier

Prettier is a code formatter that automatically formats your code to adhere to a consistent style. It handles details like indentation, line length, and spacing, ensuring that your code looks clean and uniform. Prettier Documentation

Clean Code Fundamentals

Writing clean code is essential for creating maintainable, readable, and scalable software. Clean code is not just about aesthetics; it's about making your code easier to understand, debug, and modify, which ultimately saves time and resources in the long run. Here are some fundamental principles of clean code that we adhere to:

1. Meaningful Names:

   • Use descriptive names: Choose names for variables, functions, and classes that clearly convey their purpose. Avoid abbreviations or single-letter names unless they are very obvious in their context (e.g., loop counters).
   • Be consistent: Use the same naming conventions throughout your codebase.
   • Avoid misleading names: Don't use names that could be misinterpreted.

   Naming Conventions

   • Folders: Use lowercase and hyphens for folder names (e.g., my-folder).
   • Files: Use lowercase and hyphens for file names (e.g., my-file.tsx).
   • Variables: Use camelCase for variable names (e.g., myVariable).
   • Constants: Use uppercase and underscores for constant names (e.g., MY_CONSTANT).
   • Functions: Use camelCase for function names (e.g., myFunction).
   • Server Actions: Use camelCase for server actions and add the action type as a suffix (e.g., fetchDataAction).

2. Functions:

   • Keep functions small: Functions should ideally do one thing and do it well. Smaller functions are easier to understand and test.
   • Use descriptive names: Function names should clearly describe what the function does.
   • Minimize arguments: Functions with fewer arguments are easier to call and test. Consider using objects as arguments if you have many related parameters.
   • Avoid side effects: Functions should ideally not modify anything outside of their scope. This makes your code more predictable and easier to reason about.

3. Comments:

   • Use comments sparingly: Code should be self-explanatory whenever possible. Overuse of comments can make code harder to read.
   • Explain the "why," not the "what": Comments should explain the reasoning behind the code, not just what the code does.
   • Avoid redundant comments: Don't comment on obvious code.

4. Error Handling:

   • Handle errors gracefully: Don't let errors crash your application. Use try-catch blocks to handle exceptions and provide informative error messages.
   • Don't ignore errors: Ignoring errors can lead to unexpected behavior and make debugging difficult.