Clean Code Principles and Practices

Clean Code Principles

• Readability First: Write code that is easily understood, even by newcomers.
• Keep It Simple (KISS): Avoid overcomplicating the design; use the simplest solution.
• Don't Repeat Yourself (DRY): Eliminate duplicated code by reusing functions, methods or modules.
• Single Responsibility Principle (SRP): Each class, method, and function should have only one responsibility.
• Open-Closed Principle (OCP): Code should be open for extension but closed for modification.
• Separation of Concerns: Divide the code into distinct sections, focusing on specific concerns.
• Minimize Dependencies: Maintain loose coupling between modules and avoid unnecessary dependencies.

Clean Code Functions and Methods

• Single Responsibility: Functions should perform only one task.
• Small Size: Ideally, functions should be 5-20 lines.
• Limited Parameters: Minimize the number of parameters, aiming for three or fewer.
• Avoid Side Effects: Functions should not alter the state of other parts of the system.
• Early Returns: Return early from a function to avoid deep nesting.

Clean Code Error Handling

• Graceful Error Handling: Handle errors using exceptions or validation.
• Meaningful Exception Handling: Avoid swallowing exceptions without appropriate handling; provide clear and specific error messages.
• Specific Exceptions: Use specific exceptions instead of generic ones.

Clean Code Memory Management

• Reuse Existing Objects: Avoid unnecessary object creation; reuse existing objects whenever possible.
• Resource Cleanup: Properly close resources like files, sockets, etc.
• Avoid Memory Leaks: Utilize weak references or caching when appropriate to prevent memory leaks.

Clean Code Version Control

• Frequent Commits: Commit code frequently with meaningful messages.
• Appropriate Branching Strategies: Use branching strategies suitable to the development team (e.g., Gitflow, trunk-based).

Clean Code Comments

• Purposeful Comments: Comments should explain why the code was written, not just what it does.
• Avoid Redundancy: Eliminate redundant (unnecessary) comments. Refactor code if comments are necessary to clarify the logic.
• Actionable TODOs: Use TODO comments sparingly and ensure they provide actionable steps.
• Remove Unnecessary Comments: Remove unnecessary comments.

Clean Code Naming Conventions

• Descriptive Names: Choose names that clearly indicate the purpose of the code.
• Avoid Abbreviations: Avoid abbreviations; use complete words for clarity.
• Consistent Case: Follow a consistent naming convention (e.g., camelCase, PascalCase).
• Meaningful Exception Names: Use names that specify the nature of the exception.
• Domain-Specific Names: Use names relevant to the application context.
• Avoid Noise Words: Use clear and concise names without unnecessary terms (e.g., customerData to customer).

Clean Code Refactoring

• Refactor Early and Often: Refactor to improve code readability and maintainability as early and often as possible.

Clean Code Checklist

• Are names clear and meaningful?
• Do methods perform only one task?
• Is code free of duplication?
• Are error-handling mechanisms implemented?
• Is formatting consistent?
• Are comments helpful and concise?
• Are there tests for critical parts of the code?

Jira Hands-on

• Create Epics: Identify and organize tasks/features of a project.
• Create Backlog Items: Detail the tasks/features to be implemented in Jira.
• Prioritize Backlog Items: Rank items by importance and feasibility.
• Plan Sprints: Break work into smaller and manageable tasks.

Jira Query Language (JQL)

• JQL: A specialized language to search, filter and locate issues within Jira..

This quiz covers essential principles of clean code, focusing on readability, simplicity, and responsibility in coding practices. Understand the guidelines for writing maintainable and efficient code, including key concepts like DRY and KISS. Test your knowledge on the best practices that lead to high-quality software development.