Two things you can do to make your code more readable is to use a reasonable naming convention, and to include reasonable spacing.

In writing Matlab code, the following is a suggested naming convention.

- Reserve m and n for matrix dimensions,
- Start all names of vectors with lower case letters,
- Start all names of matrices with upper case letters, and
- Start all strings with the prefix
`str`, e.g.,`strName`.

Insistence on using Hungarian notation would be excessive, but some ideas taken from it are quite reasonable.

Keep the history of the variable around. For example,
don't just us `m` and `n` for the row and column
dimensions of a matrix `A`, but rather indicate this by
prefixing `A` with `m` and `n`, respectively.

v = rand( 5, 1 ) A = rand( 5, 5 ); mv = size( A, 2 ); mA, nA = size( A );

If a matrix, vector, or scalar is the result of a simple computation on another matrix or vector, combine the operation and the name of the matrix or vector:

detA = det( A ); AB = A * B; normA = norm( A ); eigvalsA = eigs( A ); [EigvalsA EigvecsA] = eigs( A ); AT = A';

Note that when calling `eigs` with two output arguments
that the results are a pair of matrices, whereas if there is only
one output argument, the result is a vector.

If you're taking the difference of two vectors or matrices,
prefix the new name by `d` or `D`, respectively.
If the names of the matrices are short, and it makes sense to
recall where the difference came from, concatenate the two
names:

w = rand(1,5); dvw = v - w; B = rand(4); dAB = A - B;

If you feel eager, you can define any basic vectors to
be column vectors, and postfix the names of all row vectors
with `T`.

vT = v'; A * vT; A * v';

The benefit of this is that whenever you have a matrix
multiplied by a vector, the vector should either be postfixed
with a `T` or transposed.

Use spaces generously. In general, always place a space after any commas, and places spaces on both sides of any binary arithmetic or logical operators other than multiplication or division, though if spaces make this more legible, it never hurts to use them.

When making function calls, it helps to write `f( a, b, c )`
instead of `f(a,b,c)`.

Always indent the body of any control statement and place the end in the same column as the opening statement. Also, place blank lines around the control statement:

s = 0; for i = 1:10 if i < 5 s = s + i; else s = s + 2*i; end s = s + 1; end

The spacing allows the eye to quickly note the entire control structure as a whole. Compare this example with:

s = 0; for i=1:10 if i<5 s=s+i;else s=s+2*i;end,s=s+1;end

Be sure to use a consistent number of spaces for indenting.
In general, use either 2, 3, 4, or 8 spaces, or use a single
tab. Any useful editor will allow the user to set the value
of the tab stops. For example, in *vi*, you can issue
`:set ts=3` to set the tab stop to 3.

You can also use the continuation operator `...` to expand
code over multiple lines:

>> ( ... (3:(6 + 2):17) < 5 ... ) | ( ... ( ... (5:(2*3):(22 - 5*2)) > (19*4) ... ) & ( ... ~sin( 4:5 ) > 0.2 ... ) ... );

Note that matching parentheses appear in the same column.

Any text editor worth using will have parenthesis matching. For
example, in *vi*, pressing `%` on any parenthesis will
move the cursor to its matching parenthesis.