So you think you really want to know what Maple does? Are you *really* sure? Well, here is how old-timers do it. [I do not claim that this is either the best or the modern way to do it, just that this is how people with over 10 years of Maple experience do it].

First, one needs to know the following 2 magic (but documented!) incantations: `interface(verboseproc=3);`

`kernelopts(opaquemodules=false);`

The first lets you see the body of procedures (and their remember table), the second lets you see into modules. Second, now we get into the old timer stuff. Imperative: get out of the GUI! Any GUI - even old reliable Classic will not behave well under this kind of torture. So get yourself a decent text editor, some kind of console window and find out how TTY maple works on your platform (see `?maple`

for details). In your text file, insert ` printlevel := 1000; # the commands that piqued your curiosity, eg int( (sin(x)/x)^8, x); `

and then in your shell execute `maple < input.mpl > output.out`

What does this `printlevel`

thing do? Essentially it gives you a trace of everything that Maple does (up to a certain depth; see the help page for details). This tends to produce **copious** amounts of output. This can make really good text editors strain. So I repeat: do not try this with any GUI! The format is essentially as follows:

{--> enter XXX, args=.....

x := ...

y := ...

{--> enter YYY, args=.....

<-- exit YYY (now in XXX) = .... }

<-- exit XXX (now at top level) = .... }

This gives you, in a nested way, that the computation entered XXX (with some arguments), assigned x then y, called YYY (which returned some value) which then XXX used in a final computation as its return value. The pairs of {} are *extremely* handy because any decent text editor that does parens-matching will allow you to jump between matching brackets. This allows you to skip over uninteresting bits. In the int example above, this produces a mere 5711 lines of output (in Maple 10.06). I have frequently seen well over a million lines. So leafing around that output, one sees that the routine that gets the actual integral is called ``int/xsincos``

. So this is where one does go back to a GUI where, with the two magic incantations in hand, `print(`int/xsincos`);`

gives a listing (sorry, no comments) of the source code. From the printlevel output, you know that the arguments are -8,8,0, so a little tracing leads first to ``trig/tfourier``

and then to ``tfourier/sin``

. And lo and behold, right there in those 3 routines, one can see a closed-form for the original question! So, deep in Maple, the actual answer to the full symbolic question is there, yet Maple can't do the problem symbolically. Sure, the output would be a big piecewise function, but so what? Anyways, there is one wrinkle to know about regarding high-printlevel output: some genius decided to use { for pretty-printing "piecewise". So if there are piecewises in your output, parens-matching will not work because there will be tons of open { with no matching }. Very annoying.