coding standards
1. Consistent Naming Conventions
� Variables and Functions: Use clear, descriptive names. Avoid
abbreviations unless they�re widely understood (e.g., id for identifier).
� Camel Case and Pascal Case:
� Use camelCase for variables, functions, and methods (e.g.,
calculateTotal, userAge).
� Use PascalCase for classes and constructors (e.g., UserProfile,
AccountSettings).
� Constants: Use uppercase with underscores for constants (e.g.,
MAX_ATTEMPTS, DEFAULT_TIMEOUT).
2. Comment and Document Code
� Function Comments: Describe the purpose, parameters, and return value
of functions.
� Inline Comments: Add comments in complex code sections to explain logic
or intent.
� Avoid Over-Commenting: Write self-explanatory code so that comments are
only needed for clarification.
3. Indentation and Spacing
� Consistent Indentation: Use either 2 or 4 spaces (or tabs) for
indentation across the entire codebase.
� Whitespace: Include spaces between operators (x = y + z instead of
x=y+z) and after commas for readability.
� Block Separation: Separate logical code blocks with a blank line for
visual clarity.
4. Avoid Hardcoding Values
� Use constants or configuration files to manage values that might
change, such as URLs, paths, and settings.
� Helps avoid errors when changes are required and enhances code
readability.
5. Write Modular Code
� Function Size: Limit functions to a single responsibility. If a
function grows too large, break it into smaller, reusable functions.
� DRY Principle: �Don�t Repeat Yourself��avoid duplicate code by creating
reusable functions or classes.
6. Error Handling and Logging
� Error Handling: Implement try-catch blocks in languages that support it
to manage exceptions gracefully.
� Logging: Log errors, warnings, and important events to help in
debugging and monitoring. Avoid printing sensitive information in logs.
7. Follow Language-Specific Guidelines
� JavaScript/TypeScript: Avoid using var; prefer const and let for block
scope.
� Python: Follow PEP 8 standards, especially for indentation, imports,
and naming.
� Java: Follow Oracle�s code conventions, especially for file structure,
naming, and access modifiers.
8. Optimize for Readability
� Avoid Deep Nesting: Deeply nested code can become hard to read.
Refactor to reduce nesting.
� Use Descriptive Variable Names: Avoid single-character names (except in
loops like i), and be descriptive to clarify their purpose.
9. Maintain Code Consistency
� Single Coding Style: Follow one consistent coding style throughout the
project to make it easier to read and maintain.
� Linting and Formatting Tools: Use tools like ESLint, Prettier, or Black
(for Python) to automatically format code consistently.
10. Unit Testing
� Write Tests: Ensure your code is covered by unit tests, especially
critical functions and logic.
� Maintain Test Coverage: Aim to write tests that cover as many edge
cases as possible, helping prevent bugs and regressions.
11. Avoid Magic Numbers
� Named Constants: Replace numbers with named constants to make code more
understandable (e.g., MAX_USERS = 100 instead of just using 100 in the code).
� Helps to convey the purpose of values and allows for easier updates if
values change.
12. Avoid Global Variables
� Scope Control: Keep variables scoped to where they�re needed. Avoid
using global variables that can create conflicts and bugs.
� Encapsulation: Wrap related variables and functions within classes or
modules.
13. Consistent Code Review Standards
� Code Review: Establish a code review process to ensure all code meets
the team�s standards.
� Feedback Process: Provide constructive feedback that aims at improving
code quality without personal criticism.
14. Version Control Practices
� Meaningful Commit Messages: Write concise, descriptive messages for
each commit.
� Small, Frequent Commits: Make small commits that address a single
change, making it easier to trace issues.
� Branch Naming: Use descriptive branch names based on the purpose (e.g.,
feature/login, bugfix/header-fix).
15. Maintain a Clean File Structure
� Organize Files: Group related files into folders based on functionality
or type (e.g., components, services, models).
� Naming Conventions: Use consistent naming conventions for folders and
files.
16. Refactor Code Regularly
� Refactoring: Regularly review and refactor code to simplify it, improve
readability, and remove obsolete code.
� Eliminate Dead Code: Remove unused variables, functions, or code that
no longer serves a purpose.
