plotting - weird behavior of plot

Can someone provide an explanation for the following behavior?

I define a function:

a=2480.65;
n[x_] := (1/x^2)*1/(Exp[a/x] - 1);

Plot[n[y], {y, 100, 1000}]
Plot[n[a], {a, 100, 1000}]

The first plot generates this:

while the second one looks like this:

Trivially the first one is correct as this should be a monotonically increasing function. Is it something in the order of evaluation? How can I be careful not to stumble upon this point in less easily verified cases?

I'm using MMA 9, with mac

Answer

Plot and Table and others "effectively use Block to localize variables." Let's first look at your definition of n:

We can see that it depends on the (unevaluated!) global symbol a. That means when a changes its value, the function changes, too!

Block is used to temporarily change the value of a global variable. Observe the difference:

Block[{a = b}, n[a]]
(*  1/(b^2 (-1 + E))  *)

n[a]
(*  9.45746*10^-8  *)

In the first case, a is changed to b and then that is substituted for x in expression for n. So both a and x are changed to b. That makes the first code equivalent to

(1/b^2)*1/(Exp[b/b] - 1)

In the second code, it works as intended, since a retains its value of 2480.65.

The Plot command effectively evaluate the first code,

Block[{a = x}, n[a]]
(*  1/((-1 + E) x^2)  *)

except it does it with numeric values substituted for x. So effectively you're plotting a constant over x^2.

To avoid it, you should avoid having your function definitions depend on global variables, whenever possible. If the global variable is not intended to be a fixed constant, then you should make it an explicit argument of the function. (Such as David Stork has shown while I've been typing.)

n[x_, a_] := 1/(x^2 (Exp[a/x] - 1));

This is what probably should be done 99% of the time.

Sometimes it is intended to be a constant. If it is in a package, then it should be in a private context; see Contexts and Packages. Sometimes I'm lazy or the code is temporary, and the constant is a number that appears in several places. In that case, I might use one of the following two ways. First:

Block[{x},
 n[x_] = (1/x^2)*1/(Exp[a/x] - 1);
 ]

Second:

With[{a = 2480.65`},
 n[x_] := (1/x^2)*1/(Exp[a/x] - 1);
 ]

In both cases, we can see that the value of a appears in the exponent. In the first case the use of Set (=) instead of SetDelayed (:=) causes the right-hand side to be evaluated before the definition is stored; that is how the value of a is inserted. In the second, the value is injected with With; this rewriting of the rule causes the formal parameter x to be renamed x$; see, for example, Variables in Pure Functions and Rules. This is to protect the definition from having a value inject for x in the pattern x_, which would break the definition.