Comment, comment, comment. Put a lot of comments in your program. They tell other programmers what you did, and they also tell you what you did.

Use the “KISS” principle (Keep It Simple, Stupid). Clear and simple is better than complex and wonderful.

Avoid side effects. Use ++ and -- on lines by themselves.

Never put an assignment inside a conditional. Never put an assignment inside any other statement.

Know the difference between = and = =. Using = for = = is a very common mistake and is difficult to find.

Never do “nothing” silently:

// Don't program like this
for (index = 0; data[index] < key; ++index); 
// Did you see the semicolon at the end of the last line?

Always put in a comment:

for (index = 0; data[index] < key; ++index) 
        /* Do nothing */;

Practice coding. Practice is crucial for people involved in almost every other profession that requires a significant level of skill and creativity (e.g., artists, athletes). Help others learn to program. It’s good practice for you to go over what you already know, or think you know.

If you come to a choice between a relatively “quick hack” or a somewhat more involved but more flexible solution, always go for the more flexible solution. You’re more likely to reuse it or learn from it. You’re also more likely to be thankful later on when requirements shift a little and your code is ready for it.

Never trust any user input to be what you expect. What would your program do at any given point if a cat walked across the keyboard, several times?

Watch out for signed unsigned conversions and overflow/underflow conditions.

Put variable declarations one per line and comment them.

Make variable names long enough to be easily understood, but not so long that they are difficult to type in. (Two or three words is usually enough.)

Never use default return declarations. If a function returns an integer, declare it as type int.

Always put a default case in a switch statement. Even if it does nothing, put it in:

switch (expression) { 
    default: 
        /* Do nothing */;
        break;
}

Every case in a switch should end with a break or a /* fall through */ statement.

Always put parentheses, ( ), around each constant expression defined by a pre-processor # define directive:

#define BOX_SIZE (3 * 10) /* Size of the box in pixels */

Put ( ) around each argument of a parameterized macro:

#define SQUARE(x) ((x) * (x))

Surround macros that contain complete statements with curly braces:

// A fatal error has occurred.  Tell user and abort
#define DIE(msg) {printf(msg);exit(8);}

When using the #ifdef / #endif construct for conditional compilation, put the #define and #undef statements near the top of the program and comment them.

Whenever possible, use const instead of #define.

The use of inline functions is preferred over the use of parameterized macros.

A single block of code enclosed in { } should not span more than a couple of pages. Split up any bigger blocks into several smaller, simpler procedures.

When your code starts to run into the right margin, it’s time to split the procedure into several smaller, simpler procedures.

Always define a constructor, destructor, and copy constructor for a class. If using the C++ defaults, “define” these routines with a comment such as:

class example {
    public:
        // Example -- default constructor

Always create a Makefile so others will know how to compile your program.

When compiling, turn on all the warning flags. You never know what the compiler might find.