º4. The cell bracket is highlighted when the Front End is waiting for the Kernel to finish a dynamic update. For instance:

Manipulate[
 If[TrueQ[y > 0],
  y = Sin[y],
  y = 1.];
 a,
 {a, 0, 1}
 ]

Because y is changed at each update, the updates continue indefinitely. It appears in the Front End that Manipulate[] is doing nothing, since the new value of y does not affect the output.

How to fix it? That's depends on the code. Adding the option TrackedSymbols :> {a} will fix this case. So does localizing y in a Module[] inside Manipulate[]. So does removing the If[] statement. In cases where this actually arises, localizing y defeats the purpose of remembering the value of y from update to update (should that be the purpose); and removing the code is usually not possible, either.

A more complicated example:

Updates indefinitely because data is changed:

Manipulate[
 SeedRandom[a];
 data = RandomReal[10, 100]; (* Mathematica treats Random*[] specially *)
 data = Sort@data^2; (* this causes the repeated updates *)
 lm = LinearModelFit[data, x, x];
 Show[
  ListPlot[data],
  Plot[lm[x], {x, 1, 100}],
  PlotRange -> {-21, 121}
  ],
 {a, 0, 1000, 1}
 ]

Minimal fix:

Manipulate[
 SeedRandom[a];
 data = Sort@RandomReal[10, 100]^2; (* data not trigger new update *)
 lm = LinearModelFit[data, x, x];  (* depends on data which does not need an update *)
 Show[
  ListPlot[data],
  Plot[lm[x], {x, 1, 100}],
  PlotRange -> {-21, 121}
  ],
 {a, 0, 1000, 1}
 ]

My better method (localized assuming I don't need to evaluate data or lm outside of Manipulate[]):

Manipulate[
 SeedRandom[a];
 With[{data = Sort@RandomReal[10, 100]^2},
  With[{lm = LinearModelFit[data, {x, x^2}, x]},
   Show[
    ListPlot[data],
    Plot[lm[x], {x, 1, 100}, PlotStyle -> Gray],
    PlotRange -> {-5, 105}
    ]
   ]],
 {a, 0, 1000, 1}
 ]

My preferred method (the extra dynamic means that data and lm won't be recomputed when the system changes $ControlActiveSetting from True to False when I let go of the a slider; only the plot needs updating when that happens):

Manipulate[
 SeedRandom[a];
 With[{data = Sort@RandomReal[10, 100]^2},
  With[{lm = LinearModelFit[data, {x, x^2}, x]},
   Dynamic@
    Show[
     ListPlot[data],
     Plot[lm[x], {x, 1, 100}, PlotStyle -> Gray],
     PlotRange -> {-5, 105}
     ]
   ]],
 {a, 0, 1000, 1}
 ]

If I need to use Dynamic[]/Manipulate[] to set a global variable such as data or lm, then I would use TrackedSymbols to expressly set the dynamic updating dependencies.

Hi Jay,

Try the first example again. Somehow I changed a comma to a semicolon in my original post. I've changed it back now.

In With[{x = expr}, body], no variable x is created. Instead each symbol x that literally appears in the code body is replaced by the value of expr. (If some part of the code in body evaluates to the symbol x, that part will not be replaced by the value of expr.) After the replacement, body is evaluated, which explains the parenthesis. The code With[{x = expr}, body] is similar to Function[{x}, body][expr].

In Module[{x = expr}, body], a variable x$nnn is created, where nnn is the current $ModuleNumber Each symbol x that literally appears in the code body is replaced by the symbol x$nnn. (Like With[], if some part of the code in body evaluates to the symbol x, that part will not be replaced by the value of expr.) After the replacement, body is evaluated, and the module variable x$nnn will be evaluated or changed according to the code in body. After the Module[] is finished, the variable x$nnn will be removed by the system unless there is a reference to it, in which case the variables and its definition (value) will be preserved. This can happen if the symbol x$nnn is saved in a global variable or in the output of the Module[].

Examples: These are modified from an example in the documentation. It is a typical use of With[] with Dynamic[] to inject the current value of a variable into Dynamic[]. Since Dynamic[expr] does not allow expr to be evaluated (in the kernel), the only ways to inject the value at the time of execution in the kernel is with With[] or Function[]; otherwise, the value used will be whatever it is when the front end performs a dynamic update, which might be in a completely different kernel session years from now.

Remove["j*"]; (* clean out variables that start with j *)
a = Range[5];
"D" -> Table[Dynamic[a[[i]]], {i, Length@a}]
"M" -> Table[Module[{j = i}, Dynamic[a[[j]]]], {i, Length@a}]
"W" -> Table[With[{j = i}, Dynamic[a[[j]]]], {i, Length@a}]
Names["j*"] (* Module variables that leaked out *)
Clear["j*"] (* clear Module variables that leaked out *)
a[[-1]] = 1000;
 (* try with & without the last two lines (all combos) *)

If you omit Clear["j*"], Module[] seems to work. But it's a ruse, as Clear["j*"] demonstrates.

I'm thinking about your other question. Dynamic[] is complicated and explaining it is complicated. For a thorough understanding, you pretty much have to bite the bullet and read the four lengthy tech notes on Dynamic[] and Manipulate[] linked in docs for Manipulate[]. For me, that was only a start. It's also not necessary to understand things thoroughly. Good rules of thumb are: If Dynamic[] demos work well enough, we don't need to make them work optimally. And the simpler they are, the easier they will be to fix...probably.