LSL Style Guide

Cleanliness

default
{
state_entry()
{
if (x==1)
llSay(0, "X is: "+(string)1);
}
}

default
{
     state_entry()
     {
          if (x == 1)
               llSay(0, "X is:" + (string) 1);
     }
}

• Put spaces between operators and after commas (,).
• Separate lines longer than about 80 characters. (Lines that wrap around).
• Don't mix coding styles. When editing code you didn't create, stick with the existing style (or change the style throughout).
• Functions should be short and sweet. A good rule is that a function longer than a screen height or two should be refactored into multiple functions.
• Avoid excessive comments. Well written code explains itself. For more complicated functions, put general comments concerning what you are trying to do at the top of the function. Leave comments out of the body of the function.
• Don't be lazy when it comes to variable names. For example, 'message' is better than 'msg'. With good names, you won't need as many comments, so less typing over all. Also, if you use whole words, you won't have to remember your particular abbreviation later on in the code. Make your names describe the role of the data, not the type. With properly factored code, the type declaration won't be far off. Boo... msg is essential in things like listen events. You can declare event parameters with any name you want. 'Message' is much more descriptive, unless of course you're talking about Monosodium Glutomate.
• Start global variables with an indicator (most LSL script I've seen uses interCaps style variable names with a lower case 'g' at the front for globals). Declare globals at the very top of the script unless they are part of a code snippet intended to be copied between many scripts. In that case , make sure the snippet is cleary marked at the beginning and end and put the globals at the top of the snippet.
• When coding a snippet, prepend an appropriate name to all the global variables and functions. For example: if the snippet has to do with fuss, name its variables like gFussListen instead of gListen. This way your code snippet will be less likely to step on names a user might place in their regular code. Local variables defined inside functions don't matter through the graces of scope.
• Use brace ({}) for conditional statements. If it's only a single if condition with a single very short statement, put it on one line with no braces. If there's an else statement, or the conditional is closely nested in other conditionals, always use braces--even for a single statement.
• Stick to one naming style, either interCaps or under_scores, not a mix of the two. This way you won't have to remember which form a particular variable takes when you want to use it. Most code in SL uses interCaps. Or, you can have a *nix fetish and have it all lowercase. "Constants" are usually capitalized and separated by underscores, e.g. CHANNEL_NUMBER.
• Use correct spelling in variable names. For example, 'mesage' should be 'message'. Proper spelling and capitalization are very important to good clean-looking code.

Speed

• Using x++; is slower than using ++x;, x += 1;, x = x + 1 or x = 1 + x.
• ++x;, x += 1; and x = x + 1 result in the same bytecode; x = 1 + x just swaps the order that the values are pop'ed into the stack but is otherwise the same.
• Evidence: bytecode, script & annotated bytecode

• If you've entered in debug code such as if(DEBUG)llSay(0,"testing");, that will slow your script down. Comment it out or remove it when it's no longer needed.

• Keep function calls to a minimum. If you have results from functions that don't change, its best to store them in variables instead of repeatedly calling functions to get them.

• Hoist loop invariants out of the loops yourself; the compiler doesn't do this for you. For example, for(i = 0; i < llGetListLength(list); i++) calls llGetListLength() mutiple times, but this does only once:

integer len = llGetListLength(list);
for(i = 0; i < len; i++)

• The LSL compiler is not an optimizing compiler.
• It will not...
• inline functions
• unroll loops
• convert your recursive functions to iterative functions using tail end recursion
• remove unused functions or variables
• recycle memory space for local variables (each local variable gets its own unique memory space)
• free local variables after their values are no longer needed

• The 'list' data type is downright awful. As near as I can tell, it seems to be some sort of implementation of a linked list. Since LSL is a strongly typed language without parametrized type support (templates), lists have to use dynamic typing to keep track of the data they contain. The result? Each node has about a 20-40 byte overhead to keep track of the data stored therein. In addition, there is no iterator object so looping through a list is an O(n^2) operation. As if this wasn't bad enough, it gets worse. If you want to update an object in your list you have to reallocate and deallocate the entire thing twice on the stack using the insertion and deletion operators.

string letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*() []{}-=_+;':,.<>/\|`~";

string stack = "";
integer s = 0;

//Push back an integer
push(integer val)
{
     stack += llGetSubString(letters,val,val);
     ++s;
}

//Pop off a value
integer pop()
{
     if(s)
         return llSubStringIndex(letters,llGetSubString(stack,--s,s));
     return -1;
}

• There is a mysterious sleeping period after each loop iteration. This probably done so the server can catch it's breath and update other objects. However, if you can put off the next loop iteration as long as possible your script can get more done faster. Here's an example of the trick:

default
{
    state_entry()
    {
        llSay(0, "Timing normal loop");
        string s = "";
        integer i;
        
        float t = llGetTime();
        for(i=0; i<1000; i++)
            s += (string)i;
        t = llGetTime() - t;
        
        llSay(0, "Time: "+(string)t+" seconds.");
        
        llSay(0, "Testing unrolled loop x10");
        string q = "";
        
        t = llGetTime();
        
        for(i=0; i<1000; )
        {
            q += (string)(i++);
            q += (string)(i++);
            q += (string)(i++);
            q += (string)(i++);
            q += (string)(i++);
            q += (string)(i++);
            q += (string)(i++);
            q += (string)(i++);
            q += (string)(i++);
            q += (string)(i++);
        }
        
        t = llGetTime() - t;
        llSay(0, "Time: "+(string)t+" seconds.");
    }
}

Counter Opinion: Tweaks Considered Harmful