Scott Myers' Effective C++ Rules
From his book, ISBN 0-201-26364-9

    1. Use const and inline instead of #define.
    2. Prefer iostream.h to stdio.h.
    3. Use new and delete instead of malloc and free.
    4. Prefer C++ style comments.
    5. Use the same form in corresponding calls to new and delete.
    6. Call delete on pointer members in destructors.
    7. Check the return value of new.
    8. Adhere to convention when writing new.
    9. Avoid hiding the global new.
    10. Write delete if you write new.
    11. Define a copy constructor and an assignment operator for classes with dynamically allocated memory.
    12. Prefer initialization to assignment in constructors.
    13. List members in an initialization list in the order in which they are declared.
    14. Make destructors virtual in base classes.
    15. Have operator= return a reference to *this.
    16. Assign to all data members in operator=.
    17. Check for assignment to self in operator=.
    18. Strive for class interfaces that are complete and minimal.
    19. Differentiate among member functions, global functions and friend functions.
    20. Avoid data members in the public interface.
    21. Use const whenever possible.
    22. Pass and return objects by reference instead of by value.
    23. Don't try to return a reference when you must return an object.
    24. Choose carefully between function overloading and parameter defaulting.
    25. Avoid overloading on a pointer and a numerical type.
    26. Guard against potential ambiguity.
    27. Explicitly disallow use of implicitly generated member functions you don't want.
    28. Use structs to partition the global namespace.
    29. Avoid returning "handles to internal data from const member functions.
    30. Avoid member functions that return pointers or references to members less accessible than themselves.
    31. Never return a reference to a local object or a dereferenced pointer initialized by new within the function.
    32. Use enums for integral class constants.
    33. Use inlining judiciously.
    34. Minimize compilation dependencies between files.
    35. Make sure public inheritance models "isa."
    36. Differentiate between inheritance of interface and inheritance of implementation.
    37. Never redefine an inherited nonvirtual function.
    38. Never redefine an inherited default parameter value.
    39. Avoid casts down the inheritance heirarchy.
    40. Model "has-a" or "is-implemented-in-terms-of" through layering.
    41. Use private inheritance judiciously.
    42. Differentiate between inheritance and templates.
    43. Use multiple inheritance judiciously.
    44. Say what you mean; understand what you're saying.
    45. Know what functions C++ silently writes and calls.
    46. Prefer compile-time and link-time errors to runtime errors.
    47. Ensure that global objects are initialized before they're used.
    48. Pay attention to compiler warnings.
    49. Plan for coming language features.
    50. Read the ARM.

we specialize in Intelligent Business Rule Management Systems (iBRMS) - the same thing that used to be called rulebased systems by the AI companies.