# Naming

# For functions

Use descriptive and meaningful names: Choose names that accurately describe the purpose or behavior of the function. Avoid generic names like doSomething"or processData that don't provide any context. Instead, use names that clearly convey what the function does, such as "calculateTotalPrice or validateUserInput.
Follow a consistent naming convention: Consistency is key in clean code. Choose a naming convention and stick to it throughout your codebase. This could be camelCase, PascalCase, or snake_case, depending on the language or coding style guidelines you are following. Consistency makes it easier for other developers to understand and navigate your code.
Use verbs for function names: Functions typically perform actions, so it's a good practice to use verbs in their names. Verbs like "calculate", "validate", "process", or "generate" can provide a clear indication of what the function does. This helps in understanding the purpose of the function without having to dive into its implementation details.
Be specific and avoid ambiguity: Make sure your function names are specific and unambiguous. Avoid using vague terms or abbreviations that may confuse other developers. For example, instead of using "processData", consider using "processCustomerOrders" or "processEmployeePayroll". The more specific the name, the easier it is to understand the function's purpose.
Keep function names concise: While it's important to be descriptive, it's also crucial to keep function names concise. Long and overly complex names can make the code harder to read and understand. Aim for names that are short and to the point, while still conveying the function's purpose.
Avoid using abbreviations or acronyms: Unless the abbreviation or acronym is widely known and understood in the context of your codebase, it's best to avoid using them in function names. Abbreviations can be ambiguous and may lead to confusion. Instead, opt for descriptive names that provide clarity and understanding.
Use consistent terminology: If your codebase uses specific domain terminology, try to incorporate that into your function names. This helps in maintaining a consistent and cohesive codebase. For example, if you're working on a banking application, use terms like withdrawFunds or transferMoney to align with the domain language.

# For Boolean

When it comes to naming boolean variables in clean code, it is important to follow certain best practices to ensure clarity and maintainability of the codebase. Here are some guidelines to consider:

Use descriptive names: Choose names that clearly convey the purpose or meaning of the boolean variable. Avoid using generic names like flag or status that do not provide any context. Instead, opt for names that accurately describe the condition or state being represented.
Use positive and negative forms: Boolean variables often represent a condition that is either true or false. To make the code more readable, it is recommended to use names that reflect the positive and negative forms of the condition. For example, if the variable represents whether a user is logged in, you could use names like isLoggedIn for the positive form and isNotLoggedIn for the negative form.
Avoid negations in names: While it is acceptable to use negations in boolean variable names, it is generally better to avoid them if possible. Negations can make the code harder to understand and can lead to confusion. Instead, consider using positive forms or alternative names that convey the same meaning without negations.
Be consistent with naming conventions: Consistency is key in clean code. Choose a naming convention for boolean variables and stick to it throughout the codebase. Whether you prefer camel case, snake case, or any other convention, make sure to apply it consistently to maintain readability and avoid confusion.
Consider using question-like names: In some cases, it can be helpful to use question-like names for boolean variables. This can make the code read more like a natural language question, enhancing its readability. For example, instead of using isAvailable for a variable that represents whether a product is available, you could use isProductAvailable.

Here's an example that demonstrates these best practices:

boolean isLoggedIn; // positive form
boolean isNotLoggedIn; // negative form

boolean hasPermission; // positive form
boolean doesNotHavePermission; // negative form

boolean isProductAvailable; // question-like name
boolean isProductUnavailable; // question-like name

boolean canEdit; // positive form
boolean cannotEdit; // negative form

# For number

Use descriptive names: Choose names that accurately describe the purpose or meaning of the number. Avoid using single-letter variable names or generic names like num or value. Instead, opt for names that provide context and make the code more self-explanatory. For example, if the number represents the total sales for a month, a good name could be monthlySalesTotal.
Be consistent: Establish a consistent naming convention for numbers throughout your codebase. This helps improve readability and makes it easier for other developers to understand and maintain the code. Stick to the chosen convention and avoid mixing different styles or abbreviations.
Avoid ambiguous abbreviations: While abbreviations can be useful for brevity, it is important to avoid ambiguous or cryptic abbreviations that may confuse readers. For example, instead of using amt for amount, use the full word to make the intent clear.
Use meaningful units: If the number represents a quantity with a specific unit, consider including the unit in the name. This helps provide additional context and avoids confusion. For example, if the number represents a distance in meters, a good name could be distanceInMeters.
Consider the scope: When naming variables or functions related to numbers, consider the scope in which they are used. If the number is only relevant within a specific function or block of code, use a local variable with a concise name. If the number has a broader scope and is used across multiple functions or modules, consider using a more descriptive name to indicate its purpose.
Avoid magic numbers: Magic numbers are hard-coded numeric values that lack context or explanation. Instead of using magic numbers directly in your code, assign them to named constants with meaningful names. This improves code readability and makes it easier to understand the purpose of the number. For example, instead of using the number 7 directly in your code, define a constant named DAYS_IN_WEEK and use it instead.

Here's an example of clean code that follows these best practices:

# Calculate the average of a list of numbers
def calculate_average(numbers):
    total = sum(numbers)
    count = len(numbers)
    average = total / count
    return average

In the above example, the variables total, count, and average are named descriptively, providing clear meaning and context. The function name "calculate_average" also accurately describes the purpose of the function.

# For time

Use meaningful and self-explanatory names: Avoid using generic names like time1 or temp for time-related variables. Instead, choose names that clearly indicate the purpose of the variable. For example, if you are storing the current time, a better name would be currentTime or currentTimestamp.
Be consistent with naming conventions: Stick to a consistent naming convention throughout your codebase. This helps improve readability and makes it easier for other developers to understand your code. For example, you can use camel case notation for variable names (currentTime) and snake case notation for function names (get_current_time()).
Include units of measurement: When dealing with time-related variables, it is often helpful to include the units of measurement in the name. For example, if you have a variable representing a duration in seconds, you can name it durationInSeconds. This makes it clear what the variable represents and helps prevent confusion.
Avoid abbreviations and acronyms: While it may be tempting to use abbreviations or acronyms to save typing, it is generally best to avoid them when naming time-related entities. Abbreviations can be ambiguous and may not be immediately understandable to other developers. Instead, opt for descriptive names that provide clarity and improve code maintainability.
Use verbs for functions: When naming functions related to time, it is a good practice to use verbs that describe the action being performed. For example, if you have a function that calculates the time difference between two timestamps, a suitable name could be calculateTimeDifference().
Consider time zone and format: If your code deals with time zones or specific time formats, it is important to include that information in the naming. For example, if you have a variable representing a date and time in UTC, you can name it utcDateTime.

# for Array

Use descriptive and meaningful names: Choose names that clearly convey the purpose or role of the array in the context of the code. Avoid generic names like "array" or "list" that provide little information about the data it holds. Instead, use names that reflect the specific data or objects the array contains. For example, if the array holds a list of student names, a good name could be studentNames.
Be consistent with naming conventions: Follow the naming conventions used in the programming language or framework you are working with. This helps maintain consistency across the codebase and makes it easier for other developers to understand and work with your code. For example, if the language uses camel case for variable names, name your arrays accordingly (e.g., studentNames instead of student_names).
Avoid abbreviations and acronyms: While it may be tempting to use abbreviations or acronyms to save typing, it can make the code harder to understand, especially for new or unfamiliar developers. Instead, opt for descriptive names that provide clarity and avoid ambiguity. For example, use customerAddresses instead of custAddrs.
Use plural nouns for arrays: Since arrays typically hold multiple elements, it is a good practice to use plural nouns for array names. This helps indicate that the variable represents a collection of items. For example, use employees instead of employee for an array that stores employee objects.
Consider the scope and lifetime of the array: If the array is only used within a specific function or block of code, it is a good practice to include the scope or context in the name. This helps prevent naming conflicts and provides additional clarity. For example, if the array is used within a function to store temporary data, you could name it tempDataArray.
Avoid using generic names: As mentioned earlier, avoid using generic names like array or list as they provide little information about the purpose or contents of the array. Instead, choose more specific and descriptive names that accurately represent the data it holds.

Here's an example of how these best practices can be applied:

// Good naming example
String[] studentNames; // Array to store student names

// Poor naming example
String[] arr; // Unclear and generic name
String[] stdNames; // Abbreviation used instead of descriptive name

← Clean code overview Managing Dependencies →