Well, I learned a bit from various tutorials, but I actually learned most of the stuff I know from the people at MaxCoderz and by just fiddling around with stuff.

With great difficulty and frustration.

When did you learn asm?

I learned TI-82 z80 ASM from karma.ticalc.org It's really worth it, and I think it's the best tutorial out there for Ash/CrASH.

I learned both Z80 and 68k from one book on microprocessors. That book also has the instruction tables for the 8088, 8051, and a few others. I learned the instructions this way.

I also learned a lot from reading other peoples' sources, looking at Small C compiler output, and other stuff like that. I learned techniques this way, and I still learn more all the time.

ooooooooooh!

What book??????

It's called "Microprocessors: Principles and Applications" by Charles Gilmore (ISBN 0-07-023411-6). You will probably have a hard time finding it anywhere (I found it at http://isbn.nu). It was a book my high school was trying out (I don't know how long ago), and my electronics teacher just gave it to me. I was kind of the teacher's pet in that class. :-)

I really don't like ASM (4 the 83+) too much..... the debugging is, well, a hassle! Yeah, VTI can help, but still....
It's just wierd because it's not really like BASIC at all... plus, try using an 83 tutorial for 83+ Ion.... now that's not fun. And the math!! What the heck are those OP1 things?? Why can't we just use × and /???
OK, OK, so you get great calc control, everything works at the speed of light...but still, BASIC will never be overrun by ASM in my opinion.

Yeah, more hassle (or whatever) usually comes with more control. That applies to almost anything, not just to programming and computers. Once you understand it and get the hang of it, assembly is not so bad. In fact, it's really nice to have the power and control it provides.

By the way, you can't just use * and / in ASM because ASM is very low-level -- it's not interpreted like BASIC is. It uses things like OP1 and calls to math functions. In more detail, OP1 is one of several floating-point operands used to do calculations in assembly (they are also used to hold the name of a variable to find its address and stuff like that in assembly). Each operand is, I think, 10 bytes long. To do any kind of math in assembly (even just integers), you should first understand what RPN (Reverse Polish Notation) is and how to use it. It's really nice, actually, since it uses a stack, and so it doesn't require any parentheses, even for the most complicated expressions.

Here's an example of RPN and the equivalent in standard algebraic form:

2 3 + 5 * x -
is the same as
(2 + 3) * 5 - x

One last note: I agree with you that BASIC will not be overrun by ASM. Although I am a huge ASM advocate/fan, I still use BASIC quite frequently. Each has its place. I wouldn't try to write a huge fast-paced game in BASIC, nor would I write a small, complicated math program in ASM.

That's just my $1/50 worth.

I learned from AsmGuru, and EZAsm (a great alternative language by Joel Seligstein). I made a small game in EZAsm and looked at the z80 it produced compared to the EZAsm code. Shortly after I was staring at a tutorial in AsmGuru and everything just clicked!

EZASM is an alt lang? Hmm, where did you find it?

Yes it's right here at ticalc.org

I linked it in the optional URL.

How can you have an alternative language to asm?

Wouldn't every language that isn't asm be an alternative? What do you mean?

click the link for the homepage sorta thing...

I meant something that was low-level (I'm assuming it is), something that isn't like BASIC, but is as powerful as ASM... it just didn't sound possible for a while... I don't know, my mind works in weird ways :)

Well, TIGCC doesn't compile directly from C to machine code, you know. It goes from C to 68K ASM to machine code (the non-mnemonic, hexadecimal version of 68K ASM, pretty much). EZASM is basically the equivalent of TIGCC; a language that compiles *first* into ASM, then into machine code. So it's not as low-level, but it still goes through an assembly-based stage. All compiled languages (except for VM-based ones) do so.

The EZAsm language is easier to understand because it does not use mneumonics at all. Also, it is set up like VB and C, so it is really eazy to code for. The compiler writes the EZAsm language into .z80 assembly, and then into TI-83 and TI-83+ native calc language. There are several drawbacks, though.

-The language does not fully support every command in asm (the worst part is that you cannot use the registers without using the #Asm...#EndAsm command which allows the programmer to program in native z80 Assembly).

-The resulting z80 code is considerabley more inefficient when compared to a program that was written from scratch in z80 asm.

-The compiler only programs for Ion and Ion-compatable shells.

-The compiler seems to be good at only one thing: game programming.

The compiler does, however...

-support fast graphics and key responses.

-allow the programmer to program very quickly.

-allow the programmer to modify the z80 assembly file that is written by the compiler.

-compile for both TI-83 and TI-83+ calculators.

-save the user the time of writing the header and defining memory locations.

The cool part about the language is that the programmer can teach his or herself z80 by comparing their EZAsm program to the resulting z80 assembly program. Also, people who already program in z80 assembly can use the language along with z80 asm because the compiler has a command called the #Asm...#EndAsm that allows the user to write fully in z80 asm in the ... space. This can allow the programmer to make his or her EZAsm program more efficient.

The one intimidating part of the program is that the sprites must be defined in assembly in the Sprite window.

Ah well, it sounds nice :)

I primarily learned ASM by simply looking at source codes. This way you get to see the structures of programs, when you get the hang of that...It's time to learn the meaning of codes by using either ASMGuru or IONGuru. Or...you can learn ASM by using MY tutorial, it will soon be available at ticalc.org...i hope (I posted it 3 weeks ago!).

greetz Autolycus.....

I agree, looking at other's source code is always helpful, if you already have a slight knowledge of the language.

You must have learned a lot since I last helped you through e-mail to be able to produce a tutorial. Congrats!