Hi - Axe is great, isn't it?  I just discovered it last week.
I have a few questions though:
1) How do pointers work?  I think I understand the basic concept, but I'm not entirely sure what the difference is between doing this 5->A and 5 ->{A}2) Also, I tried using the routine in the User's Manual to try to copy an external variable, but I keep getting this weird sort of hexadecimal thing
"varG"->Str1
GetCAlc(Str1)->P
Disp {P}[sup]r[/sup]>DEC          (The triangle with the DEC to the right)And this gives me weird values - especially if I try storing decimals, large, or negative values to G.  Am I doing this wrong? 

I apologize if any of these questions are stupid... 

I'm not an expert with Axe, and I haven't tried the external variables thing, but I believe the difference between the first two are storing a value to a location and storing a location to a pointer.  (Am I right?)
the first one stores the value to the pointer, while the second one puts the pointer at the location 5 on RAM.
And don't worry about asking questions you think may be stupid, because we are all here to help.

If I'm wrong about this, will someone please correct me?  I find myself having trouble with pointers as well, this may or may not be why. 

The way I read that code is:
store 5 to A
and
store 5 to at A

Because first stores it to the variable A (which is just a location in ram [L1-54 iirc])  and the second one stores to the location of A.  So if A is 666, it will try to store 5 to the location 666

just wanted to add in that with external var support, you should generally stick with storing to Strings and appvars. lists, matrices and real variables have complicated formats so they can hold large numbers and decimals.

as for pointers, maybe this will help. imagine RAM as like a train. and each segment of the train is numbered: 0, 1, 2, 3, 4, 5 etc. It's very orderly. to get a segment of the train, you use curly brackets {}. {0} would return whatever number is in the first box of RAM. as quigibo said, do not overwrite this data, as the OS uses it, and you could easily screw up your calculator by just filling random addresses with numbers. However, quigibo has "safe RAM" areas in axe, which you can modify as you wish, as DJ said, they're L1-L6. L1-L6 are called "pointers". i personally like to call them in my head as "markers", since to me they mark segments of the train. each safe RAM segment contains a certain number of boxes. so 5->{L1} stores 5 into the box at L1. now i've been using the term "box" to describe each segment on the train, aka each segment of RAM. for the record, each segment of RAM is 1 byte. i won't get technical, but basically that means you can store between 0 and 255 into each box. if you try 256->{L1}, the numbers loop back around. so L1 will hold the value 0. 0=256. 1=257. i know. crazy. however, variables A-Z+theta can hold up to 65535.

variables have always intrigued me at first, as i never understood them in Axe. one more long paragraph:

A-Z+Theta are pointers. they point to a box number. 0->A does not store the value 0 into A. it tells A to "point" to RAM address 0. remember how L1-L6 are just "markers" on the train of RAM? same thing with variables. basically, you should rarely use curly brackets {} around just a variable, as that will usually turn out to be some information that the OS uses to run, and if overwritten, may RAM clear. basically, variables are like markers of RAM addresses.

you're somewhat right. you can treat A-Z and theta as normal vars as you would in BASIC (just don't go over 65535, negatives are a little trickier to figure out, and don't try to store a floating point). if you do 5->A, A will be a pointer to the RAM address 5. it's not really necessary to understand this. but you should know that doing Expression->{A} is generally bad, because you're overwriting RAM that the OS may need to function.
curly braces are your friend, if you're using L1-L6 and static pointers (GDB, Pic, Str). quick code example. say you have a list of 5 numbers. 2,12,38,25 and 3. how might you create this list?
.HEADER
[020C261903]->GDB1    .Stores the data as hexadecimal
Data(2,12,38,25,3)->GDB2    .Stores the same data in GDB2.
For(A,0,4
Disp {GDB1+A}>Dec,i       .imaginary i. GDB1 can be replaced with GDB2 for the same results.
End

alright. for starters, what are GDB1 and GDB2? they are static pointers. they basically mark some data. each piece of data is only one byte (two bytes is more advanced). curly brackets return the byte that the pointer points to. this is another way of saying that a curly bracket takes the marker (GDB1) and returns whatever is inside of it (2). since data is stored linearly in RAM, we can add one to GDB1 to get the next byte. {GDB1} will return what's at GDB1 (which is 2) and {GDB1+1} will return the next byte (12).

hopefully that helps. it takes awhile to get used to.

and yes, when you're using external variables, strings and appvars are the easiest to deal with.

3) yes. FF is one byte. F is a half-byte (also known as a "nibble"). a bit is either a 0 or a 1. a byte is 8 bits. meaning, a byte is 8 1's or 0's. since there are two possible values a bit can hold (a 0 or a 1), and a byte has 8 bits, a byte can hold 2^8=256 different values. 0-255.

4) in the Commands document, the lengths of L1-L6 are defined. using L1 is the safest to use, so i'd say that L1 is probably the best to use.

5) i kinda explained this above, but to reiterate. A-Theta are pointers, but the RAM they point to can be changed. Str, Pic and GDB are static pointers. that means you tell them what data to point to at the beginning of the program, and they will point there throughout the program. using curly braces around Str, Pic and GDB is definitely ok.

6) curly braces are used to get a value from a pointer. it's very useful for lists of numbers, such as map data. i'm not sure what other things pointers can be used for, a computer/ASM programmer probably uses them more creatively.

Interrupts are something the calculator generates at a fixed rate. The normal speed is about 110Hz, or 110 times every second.
FnOff will turn these off. This gives you slightly faster speed, and you can do some stuff you normally couldn't because the OS would mess with it (Like linking). However, you cannot use the normal getKey, but you instead have to use getKey(9) et al. (Well, if you use fnInt( you can't. But otherwise it would just turn them back on anyway) FnOn turns these back on.
fnInt( can be used to make your own interrupt. The normal interrupt is the OS's and does stuff like check for keys, link activity, etc. To use your own interrupt, you use fnInt(LB,F), where LB is the subroutine you want to execute on the interrupt and F is how often to execute it. It can be 0, 2, 4, or 6 and must be a constant, not a variable.
Say you had a subroutine I. To make it an interrupt that executes as often as possible, you can use fnInt(I,0 to set it up.
The routine I will execute at 110Hz. Note that you shouldn't use DispGraph or either of its modified versions in an interrupt.
In addition, DispGraph^rr might need an FnOn after it because it disable interrupts.

I'm not entirely sure about the variables in Axe either.

I was trying to code a basic gravity simulation using a single pixel as a ball. What I ended up writing was:

.AA
ClrDraw
47->X
5->Y
0->V
Rect(0, 60, 96, 4)
For(A, 0, 200)
DispGraph
V-9.8->V
Y+V->Y
Pxl-On(X,Y)
Pause
If Y+2V>60
-V->V
End
End
When the code is compiled and run, it displays the initial graphics and then runs the rest of the program without moving the pixel. Looking at the documentation accompanying Axe, I can see that the included Pong program uses similar variable assignment, so I'm unsure of what exactly the problem is. Any help would be greatly appreciated. Axe takes a bit of getting used to, although the speed is a breath of fresh air after TI-BASIC.

No decimals? I suppose that I'd have to approximate with 10, then. That works, although it appears that I'll have to modify my formulae to get a more realistic "bounce." This simulation would be a lot more suited to a mathematically inclined language like TI-BASIC. Oh well, what's a challenge if not a chance to learn [and clear your RAM in the process]?