Skip to main content

Coding Standard

✨ Coding Standards for Snigdha OS Development​

To ensure that Snigdha OS maintains a high-quality codebase, it’s essential to follow these coding standards. These guidelines promote readability, maintainability, and collaboration while ensuring the code remains efficient and secure. 🚀

1️⃣ Consistent Naming Conventions​

✅ Use meaningful and descriptive names for variables, functions, and classes.
✅ Stick to a consistent naming convention across the codebase:

  • camelCase for variables and functions.
  • PascalCase for classes and constructors.
  • snake_case for constants and configuration keys.

2️⃣ Indentation and Formatting​

✅ Use consistent indentation (2 or 4 spaces preferred). Avoid using tabs.
✅ Follow a consistent formatting style (e.g., braces alignment, spacing).
✅ Limit line length to 80-100 characters for better readability.
✅ Remove unnecessary whitespaces and trailing spaces.

3️⃣ Comments​

✅ Add comments to explain complex logic, algorithms, or unusual decisions.
✅ Keep comments concise, relevant, and synchronized with code changes.
✅ Avoid obvious comments like // Incrementing i by 1.

// Good Example:
function calculateTax(income) {
  // Calculates tax based on progressive slabs.
  ...
}

4️⃣ Modularity and Code Reusability​

✅ Break down code into small, reusable functions or modules.
✅ Group related functionalities into classes or namespaces for better organization.

5️⃣ Error Handling​

✅ Use proper error-handling mechanisms like try-catch blocks or error codes.
✅ Avoid exposing internal logic in error messages.

try:
    result = perform_operation()
except ValueError as e:
    print("Invalid input. Please try again.")  # Avoid exposing "ValueError: details"

6️⃣ Code Readability​

✅ Write simple and clear code. Avoid unnecessary complexity.
✅ Use descriptive variable and function names instead of single-letter identifiers.
✅ Favor clarity over cleverness.

7️⃣ Consistent Code Style​

✅ Follow the style guide for the programming language used (e.g., PEP 8 for Python, ESLint for JavaScript).
✅ Adopt consistent practices for spacing, indentation, and braces placement.

8️⃣ Documentation​

✅ Document every function, class, and module with clear descriptions.
✅ Include parameter details, return values, and potential exceptions in documentation.

def calculate_area(radius):
    """
    Calculates the area of a circle.

    Args:
        radius (float): The radius of the circle.

    Returns:
        float: The area of the circle.
    """
    return 3.14 * radius ** 2

9️⃣ Testing​

✅ Write unit tests for all critical functionality.
✅ Aim for at least 80% code coverage.
✅ Automate tests where possible with frameworks like pytest, Jest, or JUnit.

🔟 Version Control​

✅ Use Git for version control. Follow branching strategies like Git Flow.
✅ Write clear, descriptive commit messages in the Conventional Commits format:

feat: add feature for user authentication  
fix: resolve bug in payment gateway integration  
docs: update README with installation steps

1️⃣1️⃣ Performance Considerations​

✅ Write efficient algorithms with optimal time and space complexity.
✅ Avoid unnecessary loops, nested loops, or redundant operations.
✅ Use lazy loading or caching for heavy computations or data fetching.

1️⃣2️⃣ Security​

✅ Sanitize and validate all user inputs.
✅ Use parameterized queries for database operations to avoid SQL injection.
✅ Regularly audit code for vulnerabilities like XSS, CSRF, or buffer overflows.

1️⃣3️⃣ Dependencies and Third-party Libraries​

✅ Use only necessary and trusted libraries.
✅ Keep dependencies updated to ensure compatibility and fix vulnerabilities.

1️⃣4️⃣ Internationalization (i18n) and Localization (l10n)​

✅ Design code to support multiple languages and locales.
✅ Externalize strings into resource files for easy translation.

1️⃣5️⃣ Accessibility​

✅ Ensure UI components follow accessibility standards (e.g., WCAG).
✅ Provide alternative text for images and ensure keyboard navigation.

1️⃣6️⃣ Concurrency and Thread Safety​

✅ For concurrent operations, write thread-safe code to avoid race conditions.
✅ Use synchronization mechanisms like locks or semaphores.

🔑 Key Principles​

1️⃣ Readability: Write code as if the next person maintaining it is you in six months.
2️⃣ Modularity: Make changes easier by keeping code decoupled and modular.
3️⃣ Consistency: Adopt a uniform style to avoid confusion and ensure maintainability.

Following these standards will not only improve code quality but also foster a collaborative and professional environment. Happy coding! 🎉👩‍💻👨‍💻