I've used assembly on 6 different processors. My favorite by far was the Motorola 68000/68020. I don't have any reason to use it any more, but it was glorious in its regularity - if you thought an instruction should exist, it probably did. Addressing modes up the wazoo, and 32-bit addressing long before its time. Just enough registers to be useful, without being overpowering.

Somewhere I probably still have the source that I wrote to a full monitor with disassembler.

Undoubtly, Z80. I even made a full TCP/IP stack on Z80 assembler.

By far the Motorola 68k family.

I have developed assembler code for the Z80, 68k and still doing all kinds of x86. If have done some minor routines for some other processors like ppc and mips.

The 68k had the most "natural" instruction set. Some RISC processors had an even more regular instruction set, but they usually suffered from the Reduced Instruction Set to much to make programming them fun. The 68k hit the sweet spot between CISC and RISC, despite being formally a CISC architecture.

By far the the worst is also undoubtedly the Intel x86 family. But over the ages I started getting used to its wrinkeled instruction set, the esoteric segments, the stack oriented FPU and the other atrocities Intel committed. Now, sometimes I almost feel a perverted kind of pleasure programming the x86.

6502: Beautiful.

I used to work at Boeing in the Engineering Flight Simulation group. We had the ability, through our simulation executive system, to edit the assembly for the simulation on the fly. We even had a work space of something like 500 NOOP instructions to use as a scratch pad. We would insert a jump to the scratch pad at the appropriate place in the function code, then execute the code we manually entered in the scratch pad, then jump back. We'd do this in the middle of a real-time run, under the eyes of our customers.

The OS was something called Vulcan on a Harris minicomputer. It was a pretty standard assembler, as far as I could tell (I had done a bit of X86 prior to that), with the exception of the fact that it used a 24-bit word. If you weren't careful, that could really screw you up.

It was really cool to work out the assembler for something like a complicated loop while everyone was watching, then enter the code into the scratch pad and make it work. Good times.

Favourite (out of 8080, Z80, 6502, 6809, 80x86 and 68K) would probably be Z80, but only because that's what I've written most assembler on - for an 8-bit chip, the 6809 had the nicest architecture. Least favourite, the 6502 - horrible instruction set, tiny stack, and that whole zero-page thing - yuck!

Macro-11 on the DEC LSI-11 series microcomputers. It might have been 27 years ago but I still have fond memories. I haven't used any other processors that allow you to do such weird things as CALL @(SP)+ (coroutine call).

Occam - Transputer

I have fond memories of the CDC Cyber series - 60 bit words, 15-30 bit instructions packed in there, NO stack! Big fun. Z80 is a close 2nd.

I don't have extensive assembly experience, but I have coded in HC11/HC12 and 8086. I also learned assembly on a fake computer created by Stanley Warford's students at Pepperdine. I can't really say that I love one over the other, but I can say that 8086 is easily the most difficult of those first 2.

The fake machine was a great way to learn assembly. I was a 16-bit system with an accumulator, an index register, and the usual addressing modes.

The HC11/HC12 has really intuitive and concise instructions and addressing modes. It has everything a growing boy needs, including multiply and divide, if memory serves me correctly. This makes it great to learn as a first architecture but is also powerful enough to not get unnecessarily bogged down in details (other than the fact that you're in assembly language).

The 8086 was an absolute pain for a while. It's certainly more powerful, having separate registers that point to code and to data sections, but I remember the memory schemes causing me headaches.

My favorite, by far, is 6502 assembly. It has its drawbacks (like almost-useless indexed indirect addressing, the small stack, and no indirect JSR), but it is fast, it's simple, and, I dunno, it's just fun. ;)

I don't have a lot of ASM experience, but I find MIPS to be a very nice assembly language, just because it's so damn simple.

I always preferred x86 assembly with Turbo Assembler syntax. Probably because that's what I started out with, but even after trying others (M68k, C64 and some virtual CPUs), I still think the Intel way makes more sense (to me, anyway). ;)

For teaching assembler: 8085 For personal projects: Z80 For serious business use: System 370

I've done assembly on the Motorola 68HC11 chip and it wasn't bad. Two 16 bit registers and two 8 bit accumulators (or one 16 bit accumulator, if joined)