|Deletions are marked like this.||Additions are marked like this.|
|Line 1:||Line 1:|
|## page was renamed from CodingConventions|
Back to the HomePage.
Information for developers
We use Mercurial, following the task-based workflow explained here. All significant development should be in response to an issue in the tracker, let's say issue1000. Then the usual development process involves two roles, "developer" and "reviewer" (usually Malte), and works as follows:
Developer creates a new branch issue1000 in their own repository, usually branching off the newest revision in default. Note the exact spelling of the branch. Being consistent here allows us to automate some of these steps in the future.
Developer resolves the issue in the branch. (Developer does not close the branch or push the changes to the master repository.)
- Developer sets the status of the issue to "reviewing".
- Reviewer pulls the issue1000 branch into their own repository.
- Reviewer reviews the code. If reviewer is not satisfied, go back to step 2.
- Reviewer closes the issue1000 branch.
- Reviewer merges the issue1000 branch into the default branch.
- Reviewer pushes the issue1000 branch and its merge into the master repository.
- Reviewer sets the status of the issue to "resolved".
The first line of the commit message should consist of a self-contained summary and be no longer than 67 characters.
All other lines should be below 80 characters.
We follow PEP 8.
This is not meant to be a complete description of our coding conventions. When in doubt, follow the example of the existing code.
To keep the size of this page reasonable, the following parts have been broken out to subpages:
/C++Formatting: line length, how to break lines, where to put spaces, etc.
We generally follow the recommendations in the book C++ Coding Standards: 101 Rules, Guidelines, and Best Practices by Herb Sutter and Andrei Alexandrescu. In the tracker or elsewhere, a mark of the form [SA x] is a reference to a rule in that book. For example, [SA 9] refers to Sutter and Alexandrescu's rule 9: "Don’t pessimize prematurely".
- Every subdirectory should correspond to a namespace.
- Avoid nested namespaces or subdirectories of subdirectories.
Namespaces follow the same camel-case naming convention as classes, while directory names follow the naming conventions for methods and variables. For example, file my_subdir/my_class.h would be expected to contain a definition of class MySubdir::MyClass.
- Namespaces should have short, single-word names if possible. (The previous example only uses an underscore in the subdirectory name for sake of illustration.)
Header file guards
Macro names for header file guards follow this algorithm:
- Take the filename, including subdirectory name if in a subdirectory.
- Convert to uppercase.
Replace all "." and "/" with "_".
Example: learning/state_space_sample.h becomes LEARNING_STATE_SPACE_SAMPLE_H.
Guard blocks should look like this:
That's all. In particular, don't add comments to the preprocessor directives and don't add further underscores.
Use const methods whenever appropriate.
Pass strings by const reference.
When overriding a virtual method, mention virtual again in the declaration (i.e., virtual int foo(); rather than int foo();).
Don't write NULL for null pointers. Write 0. (The latter is slightly preferred in C++, unlike C. C++ 0x will change that, but we're not there yet. In any case, it's not good to mix styles.)
Don't write (ptr != 0). Write (ptr).
Don't write (ptr == 0). Write (!ptr).
Don't write (seq.size() == 0). Write (seq.empty()).
Don't write (seq.size() != 0). Write (!seq.empty()).