In the Coding phase, different modules specified in the design document are coded according to the module specification. The major purpose of the coding phase is to use a high-level language to code from the design document created during the design phase and then to unit test this code. 

Code standards are a well-defined and standard style of coding that good software development companies expect their programmers to follow. They frequently create their own coding standards and rules based on what works best for their company and the types of software they create. Maintaining coding standards is critical for programmers; else, code will be rejected during code review.

The Reason for Coding Standards 

• A coding standard offers the programmes created by different engineers a consistent appearance. 
• It increases the code’s readability and maintainability while simultaneously reducing its complexity. 
• It aids in the reuse of code and the detection of errors. 
• It encourages good programming habits and boosts programmers’ productivity.

The following are some of the coding standards

1. Limited use of globals 

These rules specify which types of data are allowed to be declared global and which are not. 

2. Common headers for different modules

The headers of distinct modules should follow a standard structure and information for better understanding and maintenance of the code. The header format must have the following items, which are often utilised in different companies: 

• The module’s name 
• Module creation date 
• The module’s creator 
• History of changes 
• The module’s synopsis describes what the module performs. 
• The module supports a number of functions, each with its own set of input and output parameters. 
• Module-accessible or modifiable global variables

3. Local variables, global variables, constants, and functions have the following naming conventions 

The following are some of the naming conventions: 

• The use of variables with meaningful and intelligible names makes it easier for everyone to understand why they are being used. 
• Local variables should be named in the camel case, with a small letter at the beginning (e.g. local data), but global variables should be named with a capital letter (e.g. GlobalData). Only capital letters should be used to form constant names (e.g. CONSDATA). 
• It’s preferable to avoid using digits in variable names. 
• The function names should begin with small letters and be written in camel case. 
• The function’s name must clearly and succinctly describe why the function is being used.

4. Indentation 

Appropriate indentation is critical for improving code readability. White spaces should be used properly by programmers to make their code readable. The following are some examples of spacing conventions: 

• After a comma, there must be a space between two function arguments. 
• Each nested block should be indented and spaced properly. 
• Each block in the programme should have a proper indentation at the beginning and finish. 
• All braces should begin on a new line, and the code following the braces should begin on a new line as well.

5. Error return values and exception handling conventions 

To make debugging easier, any functions that encounter an error condition should return a 0 or 1. 

Coding guidelines, on the other hand, provide some basic recommendations for a coding style to be followed in order to improve the code’s understandability and readability. The following are some of the coding guidelines: 

6. Use a coding style that isn’t too tough to comprehend 

The code should be simple to comprehend. Maintenance and debugging are difficult and expensive due to the sophisticated code.

7. Avoid using the same identifier for different purposes

Each variable should have a descriptive and meaningful name that explains why it is being used. When one identifier is used for several reasons, this is not possible, and the reader may become confused. Furthermore, it makes future enhancements more difficult. 

8. Code should be fully documented

The code should be well-annotated so that it is easy to understand. The code is made more understandable by adding comments to the statements.

9. Functions should not be excessively long

Functions are difficult to comprehend. As a result, functions should be tiny enough to perform minor tasks, and larger functions should be split down into smaller ones to complete minor tasks. 

10. Avoid using the GOTO statement 

Using the GOTO statement causes the programme to become unstructured, making it difficult to comprehend and debug. 

Coding Guidelines Have the Following Benefits 

• Coding rules improve the software’s efficiency while also reducing development time. 
• Coding rules aid in the early detection of problems, lowering the extra costs spent by the software project. 
• When coding rules are followed correctly, the software code becomes more readable and understandable, reducing the code’s complexity. 
• It lowers the software development’s hidden costs.