10 Best Practices of Code Commenting & Formatting

Code commenting and formatting are all about code understandability. Code understandability is very relevant to code maintainability. So, small details about programming may help maintainability. In this context, some practices about commenting and formatting will be told here:

Commenting

Comments may be thought as part of the code, so they are really important. E.g. a commentless code library will be useless in a short time with high probability. Even though there are some approaches which suggests self-documenting code over code documentation, we suggest (self-documenting code + code documentation).

1. Use comments "as required". 
• Unnecessary over-commenting in each line will reduce readability:
• int count = 0; // assigning zero as initial value to the count (?!?)
• Lack of commenting will increase maintenance time. Also, variable/method names should be understandable and self commenting
• int s = sqrt(v1) + v2 / v3 + fread(s). getChar(0)  //(?!?)
• List<int> getVal(int val, int len, String op) //(?!?)
2. Don't write uncorrect comments. Uncorrect explanations are worse than no-comment. 
3. Write comments for variables which are important and non-selfdocumenting.
4. Writing comments (e.g. JavaDoc declaration) for all public methods is a good practice. Of course, these comments should be "really necessary" and "as required".
5. Document "gotcha"s and "todo"s instantly when detected. These items may be remembered for that day but may not for tomorrow when not documented, so a buggy code will be inevitable.

Formatting

Formatting rules can be detected automatically by most tools (e.g. maven checkstyle) and applied automatically by most IDEs (e.g. Eclipse Code Formatter ctrl+shift+f). But there may be little differences between company formatting rules, so these tools should be configured before applying formatting.

1. Use brackets consistently. You may choose opening a bracket at the end of the current line or at the beginnning of the new line. Choose one of them and use consistently in the whole application.
2. Use blank lines consistently and as required. Blank lines may be used for separating  code lines or line groups semantically for readability. E.g. 3 blank lines at the end of a method, no-blanks on whole code or one or two blank lines between each line of code reduces readability and not good for eye pleasure.
3. Pay attention for indentation. Correct indentation for grouping statements is as important as using brackets and blank lines.
4. Character count of a line should be limited for readability. This limit is generally 80 for most developers, but may change a little due to some other development parameters. 
5. Using space chars in code should also be consistent in whole application. Generally, situations below are suitable for using spaces:
• Between operators and operands: 
• a += b , c = 0; (a == b)
• Between statement keywords and brackets: 
• if (value) {, public class A { 
• After ';' char in loops: 
• for (int i = 0; i < length; i++) 
• Between type casters and operands: 
• (int) value , (String) value