What was your favorite assembly language?
+5
A:
Undoubtly, Z80. I even made a full TCP/IP stack on Z80 assembler.
Konamiman
2009-12-07 07:41:41
A:
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)
Joe Philllips
2009-12-08 03:58:34
+5
A:
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.
Mark Ransom
2009-12-08 03:59:32
Absolutely agree. I also liked the NS32000 though I never got to use it.
Rob
2009-12-08 14:48:05
68k assembly is beautiful. Once you've seen it, everything else is a drag...
dmckee
2009-12-10 04:19:19
+4
A:
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.
drhirsch
2009-12-09 13:45:18
+1
A:
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!
anon
2009-12-09 13:52:03
I never got used to the 6502 too. Three register IIRC? Can you spell "register starved architecture"? But it was fast in its time.
drhirsch
2009-12-09 13:58:00
I hated it so much I seem to have expunged all knowledge of its register set from my long-term memory. It was, as you say, fast. I implemented a complete VT100 terminal emulator and KERMIT protocol in it, and the 6502 version was faster than the one I did for the (then new) IBM PC.
anon
2009-12-09 14:07:11
Never had the pleasure of doing 6502, but wasn't page zero a way to get effectively 256 extra registers? And didn't it get a lot done in a single cycle? Intel processors of the time required at least 4 cycles to do anything. And the PC used a 16-bit processor with an 8-bit memory bus, what kind of joke was that? Gotta agree on the 6809, that might be my second favorite.
Mark Ransom
2009-12-09 23:02:15
@Mark Yes it was. Or to look at it another way, an architecture that required you to use globals. Implementing recursive solutions on the 6502 with the combination of zero-page and the 256-byte stack ... shudder.
anon
2009-12-09 23:29:00
A:
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). ;)
Anders Sandvig
2009-12-09 13:54:34
+1
A:
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.
n8wrl
2009-12-09 13:54:36
60 bit words, but 15-30 bits per instruction - oh what fun it was to add padding instructions to fill out to the end of a word, so you could get a boundary you could jump to. SB0 B0+0 anyone?
Mark Ransom
2009-12-09 22:56:49
@Mark: You worked on Cyber too? How about calling functions resulted in a 'JMP _returnspot_' placed in the first word of the function and then JMP Func+1 was executed. To return, you JMP'ed to the first word of your function!
n8wrl
2009-12-10 12:36:36
@n8wrl, I almost managed to forget that! It was so long ago. My favorite was putting a magic value at address=1 and finding the system had performed some request for you. First saw that trick in a FORTRAN program, before I knew assembler - blew my mind.
Mark Ransom
2009-12-12 04:19:41
+4
A:
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.
jfawcett
2009-12-09 13:57:30
A:
For teaching assembler: 8085 For personal projects: Z80 For serious business use: System 370
Rich H
2009-12-09 13:58:34
+1
A:
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).
MikeJ-UK
2009-12-09 13:59:28
Occam was a high-level language that the transputer could speak natively, no?
San Jacinto
2009-12-09 14:21:46
Yes, but the assembly language was somewhat Occam-like. And Occam wasn't very high-level, actually.
Mark Bessey
2010-06-02 09:32:14
A:
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.
San Jacinto
2009-12-09 14:20:13
A:
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. ;)
Bob Montgomery
2010-06-15 02:31:39