Yes, this thread reports a similar experience and some possible workaround.

If you mean the steps used by Maple, the detail of information that you could get is varied, possibly huge, depending on your needs. This is one example of what can be observed:

> kernelopts(opaquemodules=false):
> infolevel[IntegrationTools]:=3:
> trace(IntegrationTools:-Definite:-Integrators:-LookUp):
> 
> int(exp(-xi^2*b^2)*cos(xi^2*a*t)*cos(xi*x), xi = 0 .. infinity) assuming positive;
Definite Integration:   Integrating expression on xi=0..infinity
Definite Integration:   Using the integrators [distribution, piecewise, series, o, polynomial, ln, lookup, cook, ratpoly, elliptic, elliptictrig, meijergspecial, improper, asymptotic, ftoc, ftocms, meijerg, contour]
{--> enter Main, args = exp(-xi^2*b^2)*cos(xi^2*a*t)*cos(xi*x), xi, 0, infinity
, opts, [false, FAIL]
                                 answer := FAIL
                                 look := Table
                                 answer := FAIL
                               look := Algebraic
                                 answer := FAIL
                           look := IntegralTransform
IntegralTransform LookUp Integrator:   Integral might be a fouriercos transform with expr=cos(xi^2*a*t)*exp(-xi^2*b^2) and s=x.
                                 2   2
                1/2            b~  x~
answer := 1/2 Pi    exp(- -----------------)
                               2   2     4
                          4 (a~  t~  + b~ )
                                         2
                    a~ t~        a~ t~ x~         /    2   2     4 1/4
    cos(-1/2 arctan(-----) + -----------------)  /  (a~  t~  + b~ )
                       2          2   2     4   /
                     b~      4 (a~  t~  + b~ )
LookUp Integrator:   the specified integral found with the IntegralTransform look up method.
<-- exit Main (now in IntegrationTools:-Definite:-Main) = [true, 1/2*Pi^(1/2)/(
a^2*t^2+b^4)^(1/4)*exp(-1/4*b^2*x^2/(a^2*t^2+b^4))*cos(-1/2*arctan(a*t/b^2)+1/4
*a*t*x^2/(a^2*t^2+b^4))]}
Definite Integration:   Method lookup succeeded.
Definite Integration:   Finished sucessfully.
 
                          2  2                                       2
           1/2           b  x                        a t        a t x
         Pi    exp(- --------------) cos(-1/2 arctan(---) + --------------)
                         2  2    4                    2         2  2    4
                     4 (a  t  + b )                  b      4 (a  t  + b )
     1/2 ------------------------------------------------------------------
                                    2  2    4 1/4
                                  (a  t  + b )

No, the Standard GUI does not have a keyboard shortcut to execute the entire worksheet. The design of this GUI emphasizes the usage of the mouse.

I think that you are asking for a post-processor facility as $Post in Mathematica, see here. I am not aware of something like that in Maple.

There are two different meanings of the word function here. In mathematical sense, x-y may be a function (value) by e.g. (x,y)->x-y. But in Maple's computational sense, x-y is not a function, but an expression of type `+`:

> type(f(x,y),function);
                                      true
> type(x-y,function);
                                     false
> whattype(x-y);
                                       +

What currently is not available in stock Maple is an extension/overload of diff that admits as second argument an expression of type `+`. But a wrapper of diff for this purpose could easly be written.

Besides 2-D language quirks, the help page ?names warns about using names that start with an underscore:

Names that start with an underscore (with the exception of _Env) are used as global variable names by Maple and are effectively reserved for use by library code. Do not use a symbol beginning with an underscore.

A rather simple method that works for converting Documents with these arrow 2-D objects into the underlying 1-D constructs/commands is the export to a Maple Input .mpl file. It has diverse limitations/bugs though, so that it might not be very useful for a user not knowing enough the 1-D language. A complementary method is selecting the Document and pasting into a text editor.

Several internal routines of the package DifferentialAlgebra make external calls to a compiled C library. So, missing additional information, my primary candidate for the origin of this out of memory error is the external library. Another clue comes from the memory figures that you have given. The actual code would be needed for further investigation.

The origin of the error is that frontend does not freezes products by default, a third argument is used for this purpose, see ?frontend > Parameters. So, you may try something like:

> frontend(coeff, [k, U[x]*U[x, x]],[{},{}]);
                                       0

I get quickly:

> evalindets(HE,specfunc(anything,Int),x->int(op(x),method = _d01amc));
             [-0.004579906646    -0.2072734459    -0.007934121876]
             [                                                   ]
             [ -0.2072734459     -11.86633928      -4.760461971  ]
             [                                                   ]
             [-0.007934121876    -4.760461971      -8.453773359  ]

I think that, as implemented, the only association of help pages with packages is through the choice of their indexing data, as shown here.

One thing that might be easier and you could try is the (poorly documented) extension mechanism for indefinite integration, as used in this toy example, where the integral for g(u) is added to the system:

 
> int(g(u),u=0..1);
                                     1
                                    /
                                   |
                                   |   g(u) du
                                   |
                                  /
                                    0
> restart:
> `int/g`:=proc(x)
> op(1,x)^2:
> end proc:
> int(g(u),u);
                                        2
                                       u
> int(g(u),u=0..1);
                                       1

Certainly, this behavior arises in the conversion to rational form of the "equation" part only here:

> showstat(solve,73..76):
solve := proc(eqs::{`and`, `not`, `or`, algebraic, relation(algebraic), {list, set}({`and`, `not`, `or`, algebraic, relation(algebraic)})}, vars::{algebraic, {list, set}(algebraic), {list, set}(equation)} := NULL, {[AllSolutions, allsolutions]::truefalse := FAIL, [ConditionalSolutions, conditionalsolutions]::truefalse := FAIL, [DropMultiplicity, dropmultiplicity]::truefalse := FAIL, [Explicit, explicit]::{posint, truefalse} := FAIL, [MaxSols, maxsols]::{posint, pos_infinity} := FAIL, [SolveOverReals, solveoverreals, real]::truefalse := FAIL, [SymbolicSolutions, symbolicsolutions, symbolic]::truefalse := true, [TryHard, tryhard]::truefalse := FAIL, [UseAssumptions, useassumptions]::truefalse := false, domain::name := ':-default', parameters::{list, set} := {}, parametric::{truefalse, identical(lazy,proviso,full)} := false, split::truefalse := false}, $)
local d, i, pw, qq, r, rt, s, sol, t, tmp, RO, T2, TT, XX, XX0, YY, YY0, Args, exArgs, newr, nosp, r_conds, r_eqs, teqns, tvars, backsubs, discarded, lmaxsols, oldmaxsols, Solutions_are_sets, Variables_in_list, TrigRO;
global `solve/split`, _X, identity, _SolutionsMayBeLost, `solve/SubsRootOfPower`, _MaxSols;
       ...
  73     if hastype(Args[1],'float') then
  74       exArgs := Args[1];
  75       exArgs := subsindets(exArgs,`^`,z -> op(1,z)^convert(op(2,z),':-rational'));
  76       exArgs := convert(exArgs,':-rational',':-exact');
           ...

Which appears in the code of solve since Maple 10. Now ?solve > Parameters states for "variables" (set/list of) names, not functions. In this sense, it could be said that functions are not admissible. And this piece of code makes sense only in this context. However, the type check allows functions...

So, there is a bug (or more than one), but its nature is ambiguous.

An option using an alias for the polar form:

> alias(j=polar(1,2*Pi/3)):
> eq:=(evalc=(x->x))~([j,j^2]);
                                  1/2                     1/2    2
            eq := [- 1/2 + 1/2 I 3    = j, - 1/2 - 1/2 I 3    = j ]
> s:=[solve(z^3=lambda^3, z)];
                                  1/2                          1/2
    s := [lambda, (- 1/2 + 1/2 I 3   ) lambda, (- 1/2 - 1/2 I 3   ) lambda]
> subs(eq,s);
                                             2
                         [lambda, j lambda, j  lambda]

So, see ?CodeGeneration,Fortran .