Here's another scripting habit I recommend:

Choose a coding style and stick to it.

There have been ongoing coding "style wars" for decades. The most important thing is that you choose a consistent readable style, and if you're working with others, make sure your style is consistent with theirs. Often, established software companies will have their own "house style" which usually closely matches industry standard style guidelines for their particular language

These are some of the basic styles I stick to:

Use proper indentation and add whitespace for readability.

Many decent code editors will auto-indent as you type, and offer a retro-active autoformat tool too. I don't care if the braces come on the same line, or on the next line, as long as the indentation is correct! Use brackets even if your 'if' or loop has only one statement inside. Read about Indent Styles on Wikipedia.

Bad:

function FeedAnimals () {
for (var animal in Animals) {
if (animal.diet == Diet.Carnivore)
{
animal.Feed(new Meat());}
else
{
animal.Feed(new Fruit()); }
}
}

Good:

function FeedAnimals () {

 for (var animal in Animals) {

     if (animal.diet == Diet.Carnivore) {
         animal.Feed(new Meat());
     } else {
         animal.Feed(new Fruit());
     }

 }

use comments, but use them sparingly

Write your code as if comments didn't exist, and only then add comments if extra clarity is required, eg, to give a "title" to a block of code, or to explain something particularly unusual or obscure.

For example:

// feed each animal its appropriate food
for (var animal in Animals) {
    if (animal.diet == Diet.Carnivore) {
        animal.Feed(new Meat());
    } else {
        animal.Feed(new Fruit());
    }
}

I don't think any other comments are necessary in this block. The names chosen for the variables, and functions lead to comprehensible code. Which leads me to my next point...

Name your classes, functions and variables sensibly

These are all guidelines, and there will be exceptions, but try to bear these in mind. Use PascalCase and camelCase appropriately.

Function/Method names should usually:

• use PascalCase
• be verbs, or verb phrases (eg "Fire()", "ApplyDamage()", "CollectPowerup()")

Class names should usually:

• use PascalCase
• be nouns or noun phrases (eg, "Enemy", "Bullet", "Player" )
• not have redundant suffixes like "Control", "Script", or "Object"
• be singular, even if you're going to instantiate lots of them!

Variable names should usually:

• use camelCase
• be nouns (but with exceptions, eg booleans often need verb phrases)
• be plural if the value is an array/collection (eg, enemies, bullets, people)
• not contain information about the type of data (unless it's an index/counter)
• not contain abbreviations (unless generally well understood like MPH, Max)

Bad:

function bullets() {... // (...not a verb or verb phrase, and not PascalCase)

Good:

function FireBullet() { // (...describes what the function does)

There are many other areas of programming to which particular styles can be applied and argued over, and this answer should be considered a very basic introduction to the idea. For more information see "Programming Style" on Wikipedia and you might also be interested to read some of the more detailed C# programming style guides out there.

Well, for starters, changing variables directly in your code will cause it to recompile after you save, so it's generally a good habit to expose all the variables that you are likely to change a lot, just because it saves time. However, if you're simply getting a reference to a gameobject at runtime, you should make that kind of variable private. Nearly much all variables changed or created at runtime should be kept private. Of course, that depends on what you're trying to do.

The pros and cons of if statements in collisions:

Here are two scripts, kindly provided by unknown(google) to debate the pros and cons of sending messages to every gameobject touched:

The first script uses if statements to detect what it collided with and send messages accordingly:

function OnCollisionEnter(c : Collision) { 
    if (c.gameObject == player) { 
        player.TakeDamage(5); 
    } 
} 

This second script doesn't use if statements. It merely sends damage to all collisions:

function OnCollisionEnter(c : Collision) {
    SendMessage("TakeDamage", c.gameObject, damageAmount); 
}

The first script checks if the gameobject collided with the player. The second damages all gameobjects that are collided with. There several are reasons why the first script is more desirable. First of all, the second script calls a damage message on everything it touches. This may not be a good idea, because if the enemy is walking towards you, it'll constantly be sending messages to the floor about damage. The first script checks if the collider is a player, so if the enemy is walking around, it won't be sending damage messages to the floor, which, with multiple enemies, will end up taking up extra memory.