- As Sandneil said you don't need to learn a lot to start, you can do quite a few things with just 10-15 opcodes, if that.  Learning a full set isn't really useful until you get into optimisation.

- I've linked a couple of good tutorials but they're machine specific.   For 6502 I used TMR's The Hex Files which is based around the c64.   For 68000 Photon's recent Amiga video tutorials have explained the basics quite well though it is very amiga-centric.

- When looking at a new assembly language I'm basically looking for these things:
1) How do I get this value into that register?
2) How do I read that value back?
3) How do I compare one value against another?
4) How do I react to that to jump around my code?
5) How do I do some basic maths on there?  (add/dec/and/ora/shift etc)
6) How do I do loops?

After that you get into the machine-specific things like which registers control timing, put stuff on screen etc.  But those 6 things above are all you need to control the machine really.

- Always comment your code. In the beginning, it's a good idea to comment every line. After a few days of not looking at it, even the most well-written asm code tends to present itself as an inprenetrable jungle.

This should be tattooed in our hands.

obveiously you still need a memory map and opcode list but you dont need to store them inside your head, they put themselves there after youve got stuck for the 100th  time

One more important thing that came to my mind: Hang out in platform specific online communities, that's where you'll learn the most.

• Read up on the features of the platform. Read loads of memory maps, learn about the chips, the architecture.

• Learn the operation codes of the CPU(/s). At least get a good idea of what kind of instructions are available.

• Get into a comfortable assembly/build setup

• Experiment with the platform features, memorizing code patterns as you do.

• Figure out how to do things you'd typically do with a high-level language. Conditional execution, loops, array indexing, pointer passing, functions etc.

• Learn the features of the assembler you're using.

• Build a library of macros or just code snippets that you can use for otherwise repetitive tasks.

This is not so much a "crash course" as a long term plan for fully understanding the system and the whole development chain.

I don't think assemblers are a good way to learn the fundamental concepts of software design, so you should probably have a good idea about that before you take on a larger project. Spend a great deal of time considering what a compiler would do when you're writing. Break down problems into unproblematic parts.

A very good exercise since you are already programming in Java is to write an assembler. It's probably easier with something like the PC Engine CPU than the 68k, which has tons of addressing modes and registers.

Your starting kit should include an accurate emulator with debugging capabilities, a modern cross-assembler (preferably one that can link binaries into target-specific executables/roms/whatever), and a text editor that can show line numbers (and maybe even supports syntax highlighting for your asm flavor of choice). It's also a good idea to have opcode list for your target processor at hand, for quick reference.

Do you have any suggestion for a cross-assembler?  WLA DX seems to support most of the things I'm interested in, except the 68k.  vasm supports the 68k, but I haven't heard much about it.  Unfortunately, all the assemblers I can find are windows only which is a problem for the time being!

Thank you so much!  Very helpful!

So if you're interested in PC Engine and Neo Geo, you'll have to learn 65SC02 and 68k assembly, respectively. I think 68k is somewhat easier for beginners, since it has a fairly straight-forward instruction set and loads of registers to play with.

Your starting kit should include an accurate emulator with debugging capabilities, a modern cross-assembler (preferably one that can link binaries into target-specific executables/roms/whatever), and a text editor that can show line numbers (and maybe even supports syntax highlighting for your asm flavor of choice). It's also a good idea to have opcode list for your target processor at hand, for quick reference.

A couple of tips I learned the hard way:

- Always comment your code. In the beginning, it's a good idea to comment every line. After a few days of not looking at it, even the most well-written asm code tends to present itself as an inprenetrable jungle.

- You'll have a lot of different files floating around, so organize your working directory well.

- Familiarize yourself with batch and/or shell script. Automatizing the build process with scripts will save you a lot of time on the long run.

I can't really point you to any good sites for programming PC-Engine and Neo Geo. I'm afraid a lot of good documentation might be in Japanese only. In any case tutorials for other systems won't be so helpful, especially not for SMS and GB. Might be good for a start, but otherwise you'll be wasting your time, because there are huge differences in programming the various 8-bitters.

http://www.smspower.org/maxim/HowToProgram/Index

Thanks!