So you have a Maple accessible through the web (like on this site). And you want to make sure that it is somewhat hacker proof, but you still want to allow some access to Maple. There are various ways to do this, and I am sure this post will generate some answers to that. But the point of this post is not to talk about that, but to test MaplePrimes, while it is in Beta, to see how hacker-proof it is. So let's test it (first is the input in <code> and then the same in <maple>):

`ssystem("tail /etc/passwd")`

ssystem("tail /etc/passwd")
`3+2`

3+2
`ssystem("ls")`

ssystem("ls")

And the first tests worked fine -- the easy hacking is not possible. OK, so we get a bit more creative. Let's see if there are CPU restrictions. Computing 3!!! is easy, and returns right away:
`3!!!`

3!!!
And the above tells me something I did not know - automatic simplication occurs, but evaluation **does not**. Now why is that not in the documentation? ;-)

On the other hand, if evaluation does not happen, then what happens when you make a mistake? Let's see:
`sum(1/n^s,n=1..infinity)`

sum(1/n^s,n=1..infinity)
`sum(1/n^s,doh,n=1..infinity)`

sum(1/n^s,doh,n=1..infinity)
`x/`

x/
Neat, eh? Clearly the input is fed straight to the pretty-printer, which tries to cope with incorrect input (since it is not checked by Maple), and thus produces garbage. Like
`sum(NULL, NULL = NULL .. NULL) `

sum(NULL, NULL = NULL .. NULL)
`sum(``, "" = tau .. `!`) `

sum(``, "" = tau .. `!`)
or
`sum( , = .. ) `

sum( , = .. )
That was clearly just getting warm. What about some truly evil things? Let's try!
int(Sum( int( sum(``,``)/ int(``,``), ``), ``), ``)
I won't show the code for that, let it be a puzzle for the readers. Derivatives show something interesting too:
`diff(f(x),x,x)`

diff(f(x),x,x)
`diff(diff(f(x),x),x)`

diff(diff(f(x),x),x)
The two are mathematically equivalent, of course. And the first gets translated to the second by Maple's kernel automatically (at least it did until Maple 9.5, and I doubt backwards compatibility would survive such a change; why it does this is a funny bit of antidiluvian Maple history). But again, because these are not passed by the kernel at all, one gets at the raw pretty-printer, and the results are quite fascinating. While we're at it, let's try one more thing:
`diff(Re(theta), theta$infinity, xi$I, zeta$Pi,Xi$infinity)`

diff(Re(theta), theta$infinity, xi$I, zeta$Pi,Xi$infinity)
and the reader who is still with me is not surprised at all by the results!