The name of the global context is "Global`". Context names always end in a backtick. The * is a "wildcard" that matches any characters in a symbol name. It is similar to the Unix shell wildcard * — and wildcards on other systems, I'm sure, but I learned computers on a multi-user Unix system before PCs were available. It is explained in the details section near the top of the documentation for Remove. Thus "Global`*" matches all symbol names in the global context. And "Global`q*" would match only symbol names that begin with q.

I use Quit[], which quits and restarts the kernel, instead of Remove["Global`*"], with an empty kernel init.m. Quit[] is usually slower (a few seconds) than Remove[], I think. How slow seems to change from version to version. Restarting the kernel seems closest to what you get when you run a compiled program (just system definitions, no prior user-defined values). As an interpreted environment with persistent definitions from one shift-enter to another (and a shared kernel for all notebooks), it's never exactly the same, though.

There is also the CleanSlate package, which some people use to do a bit more cleanup than Remove["Global`*"].

So much for dealing with clean runs of programs. As for the complexity of the programming environment, as I said in my first post, I don't have a quick answer.

Hi,

Numerical solvers in Mathematica usually analyze the symbolic form of the objective function. To do this analysis, NMinimize[] evaluates radpatt[xx] (in the OP at the top). This analysis may be used for method selection, singularity handling, and perhaps other adjustments. Mathematica is designed to do this automatically and to allow for users to override its automatic choices. It uses heuristics that are not always perfect. Symbolic processing takes time. So user-overrides sometimes are needed and can speed things up when the user knows what they are doing.

Using _?NumericQ in defining the objective function prevents symbolic analysis, and the automatic choice of method is more likely to be less than optimal. Symbolic analysis mainly done on formulas, as far as I know. So if your objective functions calls a numerical routine, such as NIntegrate[] or FindRoot[], then you do not lose much by using _?NumericQ. And if you need to specify singularities or method, you can do that through options. (One irritating-to-me exception: Plot[f[x], {x, 0, 1}, WorkingPrecision -> 32] evaluates f[x] on a machine-precision number at the beginning, and sometimes this causes problems.)

Below are variations on an example. The method, speed, and quality of the result are altered by using _?NumericQ in obj[]. Also the last variant shows that the superior method may not be used on obj[].

(* Uses Couenne NLP *)
NMinimize[{Cos[x] - Exp[(x - 0.5)  y], x^2 + y^2 < 1}, {x, y}] // AbsoluteTiming
(*  {0.03809, {-1.60047, {x -> -0.657103, y -> -0.753805}}}  *)

(* Ends up using diff. evol. after rejecting Couenne *)
obj // ClearAll; (* I always start function definitions this way (or ClearAll[obj] *)
obj[x_?NumericQ, y_?NumericQ] := Cos[x] - Exp[(x - 0.5)  y];
NMinimize[{obj[x, y], x^2 + y^2 < 1}, {x, y}] // AbsoluteTiming
(*  {0.154981, {-1.60046, {x -> -0.657221, y -> -0.753698}}}  *)

NMinimize[{obj[x, y], x^2 + y^2 < 1}, {x, y}, Method -> "Couenne"]
(*  NMinimize::unproc: Could not process the objective and constraints in a form suitable for Couenne.  *)
(*  NMinimize[{obj[x, y], x^2 + y^2 < 1}, {x, y}, Method -> "Couenne"]  *)

If you want to know how I know what is going, here are some undocumented ways to peak under the hood of NMinimize/NMaximize:

Optimization`Debug`SetPrintLevel[2]; 
Block[{Optimization`NMinimizeDump`$DiagnosticLevel = 2},
 (* Uses Couenne NLP *)
 NMinimize[{Cos[x] - Exp[(x - 0.5)  y], x^2 + y^2 < 1}, {x, y}]
 ]
Optimization`Debug`SetPrintLevel[0];

Optimization`Debug`SetPrintLevel[2];
Block[{Optimization`NMinimizeDump`$DiagnosticLevel = 2},
 (* Ends up using diff. evol. after rejecting Couenne *)
 NMinimize[{obj[x, y], x^2 + y^2 < 1}, {x, y}]
 ]
Optimization`Debug`SetPrintLevel[0];

A user-supplied objective function for NMinimize or FindMinimum needs to be "protected" from premature evaluation when given symbolic input. Therefore, use a definition like this

radpatt[x1_?NumberQ] := (Print[x1]; x1 )