This document describes formatting rules and guidelines for software source code. Note that this document does not cover best programming practices or techniques. It is solely concentrating on source code formatting and conventions.
Java coding guidelines are largely based on SUN official Java coding conventions: http://java.sun.com/docs/codeconv/html/CodeConventions.doc.html. Below are the only exceptions, clarifications and additions to this standard that are specific to Apache Ignite development process.
Rational
Studies have shown that 80% of development time spent on software maintenance which involves software source code understanding, refactoring and support. Established and enforced code formatting rules and guidelines improve source code readability, promote team code ownership, allow engineers understand new code more quickly and thorough as well as simplify maintenance.
String s = null; s = "GridGain";
String s = "GridGain";
Use shortened form of boolean expression where it does not compromise the readability.
Use shorter form of "callbacks" are allowed now where it does not compromise the readability:
collection.add(new A() { @Override public void m() { // Do something. } });
Use a shorter version of Javadoc (mostly for Javadoc Tag only):
/** * {@inheritDoc} */ public void m() { ... }
/** {@inheritDoc} */ public void m() { ... }
Except for types (classes, interfaces, enumerations and annotations) and semantic constants names all other names should start with low-case letter. Types names should start with an upper-case letter. In the both cases a camel style should be used. Symbol '_' (underscore) should be used only to separate upper-case letters in the names. Constants (final class attributes that have constant semantic and not just made final because of inner class access or performance considerations) should all be upper-case. For example (class comments ommitted):
class Window implements ScreenObject { /** */ private int currIndex; /** */ private int serialUid; /** */ private static final int MAX_INDEX = 10; /** * @param uid UID. * @return Class name. */ public String classNameByUid(Long uid) { . . . } }
Types and methods names are NOT abbreviated except for well-known cases such as EOF, Fifo, etc. See Abbreviation Rules for list of currently accepted abbreviations.
K&R bracing and indentation style should be used. { starts on the same line as the opening block statement. For example:
while (true) { if (false) body(); else if (true) { } else { } }
Braces are required in all cases, even if not required by syntax, except for the cases when next statement is one-liner. For the latter, braces must not be used, e.g.:
if (someCondition) a = b + c;
4-space characters should be used for both tabulation and indentation.
When multi-line operator (try-catch, anonymous class instantiation, etc) goes after some condition it is required to use braces:
if (someCondition) { try { invocation(); } catch (Exception e) { e.printStackTrace(); } }
All javadoc commetns should be approximately 80 characters long. Always keep in mind that we create Javadoc for people to read - it should be easy to consume and easy to understand.
Every type should start with at least minimal Javadoc comments including description and author information in the following form:
/** * Type description. * * @author @java.author * @version @java.version */
Every method, field or initializer public, private or protected in top-level, inner or anonymous type should have at least minimal Javadoc comments including description and description of parameters using @param, @return and @throws Javadoc tags, where applicable. For example:
/** * Decsription. * * @param i Integer parameter. * @param f Float parameter. Long comment, foo * bar, foo bar, foo bar. * @return Double value. */ public double foo(int i, float f) { }
/** Array index. One-line comment is only allowed for fields. */ private int index;
/** * Some meaningfull comment. */ static { }
NOTE: multiline comments in Javadoc tags should be idented by 4 or 5 characters depending on configuration of IDE. In most IDEs the single TAB click will produce only 1 character identation which is not enough for readability. Second click on TAB will shift it to (1+4) 5 characters. This is the only exception from 4-characters tabulation rule.
It is ok to have empty (/* /) or auto-generated Javadoc comments for code elements that are "work in progress". However, it is not allowed to not have a Javadoc comment at all, i.e. every field, method, initializer or type regardless of visibility scope should have at least empty Javadoc with minimally required Javadoc tags (see above).
Description must be separated by one blank line from Javadoc tags.
/ / or // comments should be avoided in between methods, fields or types. Such comments in most cases should be used within the methods.
All comments should follow English grammar and punctuation including starting with upper-case letter and ending with '.'. No technical jargon is allowed in the comments.
All identifiers in the Javadoc comments must be placed within <tt></tt> or linked to, if possible, using {@link ClassName} or {@link ClassName#method} constructs.
Note also that only fields allow one-line Javadoc comments.
Source code has special spacing rules (mostly inherited from Sun's Java source code guidelines and mentioned here for better clarity).
In comma-separated enumerations there is always a space between comma and the next element in the list. For example, foo(p1, p2, p3) Notice spaces between comma ',' and the next parameter.
There is always a space in between operands and binary operation itself. For example:
a += b; b = a; a * (c + b) / d
There should be no space between unary operation and its operand. For example:
!a, ~b, -b, b++
Notice also that all assignments by this rule should have space around '=' symbol: int a = b
Comments should be separated by space from "// ", "/ , "/** "* or " */". For example, / Notice the space. /
Only package level importing is allowed (per-class importing is NOT allowed). In case of the naming conflict - use fully qualified names (FQN). Use imports instead of FQNs in Javadoc links.
The source code should be broken into minimal semantic units and all such units must be separated by one empty line. To simplify the recognition of semantic units, the every line of the source code should be separated by one empty line except for the following cases:
Source code line should not be longer then 120 characters (to be visible on most conventional monitors). 4 space characters should be used for tabulation and indentation. IDE should be configured to replace tabulation with spaces (to properly see source code on the platforms with different tabulation sizes).
Single empty line should be used to separate types, methods and initializers in the type. Single empty line should also be used for separation of semantical units in the method or initializer body. Note that single blank line SHOULD NOT be used for the mere decoration of the source code. Avoid using double empty lines.
Blanks space (1 space character) should be used before opening ( or {. { and } should always be the last tokens in the line (except for the possible comments). However, blank space should not be used between method name and opening (.
For example:
/** * Class definition example. * * @author @java.author * @version @java.version */ class Foo { /** * Example method. * * @param i Example parameter. * @throws MyException Thrown in case of any error. */ public void method(int i) throws MyException { if (i > 0) { // Do recursion. try { for (int j = 0; j < 10; j++) method(i--); } catch (MyException e) { e.printStackTrace(); } } switch (i) { case 10: return i - 1; case 11: i += 2; i /= 10; break; default: assert false; } // No javadoc for anonymous classes. MyInterface itf = new MyInterface() { @Override public int myMethod(int p) { return p++; } }; if (i < 0) { // Exit now. System.out.println("Woo-hoo"); return; } } }
If source code line gets longer than 120 characters it should be broken. The rule is to start consequent line 4 spaces to the right relatively to first line. All other lines 3rds, 4th, etc. (if overall line gets longer than 120x2) should start on the same indentation as 2nd line. No other decorative rules are allowed.
In other words, the current line should never be indented more then 4 spaces to the right from the previous line.
The line should be broken on the last '.' or ',' character that fits into 120 character margin.
All output debug/logging output including toString() methods and exception messages should follow the next BNF:
output: prefix | prefix ": " postfix | prefix '[' nv-pairs ']' ; nv-pairs: pair | pair ", " pair ; pair: name '=' value ; prefix, postfix, name, value: java.lang.String ;
For example:
throw new CacheException("Invalid type [type=" + type + ", xid=" + tx.getXid() + ']'); throw new WorkflowException("Invalid rule: " + rule.getName());
Note that all prefix, postfix, name, value should follow English grammar, in particular, start with upper case and end with the dot '.'.
If it is necessary to output error message (e.g. from exception) as name-value pair it should have err
name. For example:
throw new GridException("Failed to instantiate bean [type=" + GridConfiguration.class + ", err=" + e.getMessage() + ']', e);
Do not use error
, errMsg
, etc.
Java5 added many additional useful features that significantly improve quality of code.
All annotations must be placed on a separate line, except for @Nullable and @Override, as in the following example:
/** {@inheritDoc} */ @SuppressWarning("foobar") @Nullable @Override public String toString() { return "something"; }
@Nullable and @Override annotations should be in the same sequence as shown in the example.
We do not use @NotNull annotation.
Don't use statement warning suppression.
public static <T> T[] newArray(Class<T> type, int length) { //noinspection unchecked return (T[])Array.newInstance(type, length); }
@SuppressWarnings({"unchecked"}) public static <T> T[] newArray(Class<T> type, int length) { return (T[])Array.newInstance(type, length); }
When correctness of code depends on some preconditions or expectations (including values of the call arguments) they should be expressed explicitly using assert statements. In public API methods functions from GridArgumentCheck class should be used for argument check instead of assert.
Capsule(State state) { assert state != null; this.state = state; }
public SomePublicConstructor(int max) { A.ensure(max > 0, "max > 0"); this.max = max; }
If a class overrides toString()
method, this method goes last.
If a class overrides equals()
and hashCode()
methods, they should go before toString(), if it is present, or last.
Getters and setters should be implemented without get/set prefixes in internal APIs.
Use next format for TODOs.
// TODO: IGNITE-xxx, <description of what should be done>.
It's mandatory to use related JIRA tiket number.
We try not using commented out code. If there is no another option and code have to be commented then TODOs (with related JIRA ticket) have to be added before commented out code.
In order to configure IntelliJ IDEA for Ignite code style follow these steps:
incubator-ignite\idea\ignite_codeStyle.xml
to <user_home>\.IdeaIC14\config\codestyles
ignite
in IDE Settings -> Code Style
Configure IDEA to stripe trailing spaces and add blank line to the end of file.
We try to not use commented code. So, in case if test(s) is broken the test should be muted on TeamCity with a related to JIRA ticket comment which describe a reason of fail.
If test hangs or works too long then
fail("https://issues.apache.org/jira/browse/IGNITE-1113");
method should be added as first line of the test.
To disable all tests in *Test class use
/** {@inheritDoc} */ @Override protected void beforeTest() throws Exception { fail("https://issues.apache.org/jira/browse/IGNITE-1113"); }