Tangentially related: if you haven't already, I'd suggest dabbling in development for these "retro" systems. Not only will they teach you about memory management, &c but you will also be able to familiarize yourself with architecture of decades past. Much like a Shakespearean scholar doesn't just reader William's texts, but also attempts to understand the sociopolitical climate in which they were written; so, too, ought a proficient programmer see where she has come from to integrate not just "best practices" but an optimism which guides her progress.
Or one could just read Stack Overflow. shrugs
Much of the accessibility of the architecture is that it's a single address space, with no MMU interference to speak of (later models had MMUs, but where only used for a few enhancements here & there at best).
Besides, 680x0 code is much more pleasant to deal with than x86. But that's the case for pretty much any non-x86 ISA. ;-)
Modern computers, on the other hand, have to either up the complexity by quite a bit and keep the power ( trying to rewrite an old and simplistic DOS based mandelbrot set generator for modern system got me mostly battling my misundertanding of SDL: putting bytes in A000 was way simpler. ) or sacrifice power by going back a generation or two...
as an aside, the VR community right now in 2017 is in the very early Amiga stage. Theres Atari ST vs Amiga, ( Oculus vs Vive ). Also individual coders can have a widely played and adopted game / experience. The games are fun and not overly complex and there's some great early adopter communities ( /r/Vive )
I've coded a lot of asm, blitter and coppper on the Amiga but I don't recall ever using NMI's.
memory a bit hazy !
Learning the assembly sounds like it could be a fun weekend project, so thank you!
Intel should be ashamed of themselves for 20 years later still not having cleaned up their act.
68k and a lot of the other Motorola CPU's opcode layout looks far less organised to me; there's no common pattern among all the ALU ops, for example, and there seems to be plenty of undefined/unused gaps:
In other words: Not the x86 instruction set is bad, but the common assembly language(s) (there is Intel and AT&T syntax) that are used to describe it.
>there's no common pattern among all the ALU ops, for example, and there seems to be plenty of undefined/unused gaps:
Presumably there is a pattern and that is why the gaps exist.
The 68000, which was essentially a contemporary of the 8086 (something like 6 month difference in market availablity IIRC), was clean and orthogonal, and they kept it kludge free at least through the 68040 (which was the last one I used, and which was contemporary with the super-ultra-kludgy 486).
I don't disagree with your statement, but I think it gives the impression that Intel did a reasonable job at any given time subject to compatibility constraints, and in my opinion that is not so.
I was less impressed than others with the orthogonality of the 68000 when it came out. I was used to the PDP-11 instruction set, which was genius in its orthogonality and simplicity.
Worse is better.
It indeed was. I don't understand why Intel at least didn't try to be inspired by the good bits here.
> turns out that making a performing OoO implementation was impossible with the transistor budget of the 90s. Not so much with the much uglier but simpler x86.
Yup. This killed the Amiga, and this was what forced Apple to move to PowerPC. Motorola just couldn't deliver fast enough chips at a reasonable cost.
No reason not to praise them for what they did do right though.
Business reasons (i.e. Commodore's collosal incompetence) aside, the fact that screen image was represented as bitplanes (instead of a byte/bytes per pixel) was also a major problem. It made 3D games very computationally expensive, hence no Wolf3D, Doom etc. on Amiga.
Convince me to be wrong, but to my knowledge the 68k was more comfortable to program since
* it simply had more general purpose registers available (this "register shortage" was only reduced in x86-64)
* at that time x86 was in DOS particular used in real mode (which is not very comfortable to program for), though protected mode was theoretically available from 286 on
* there are some commonly instructions that had/have to be used with specific registers, which made the x86 instruction set feel "rather unorthogonal" (though in my opinion it was better than its reputation). For example the "MUL" instruction (unsigned multiplication) only accepts some specific register(s) as destination
This was IMHO much worse in real mode, since for example
- there in/out were common instructions for writing DOS applications
- you could not address relatively to the stack pointer sp in x86-16 bit code (cf. https://reverseengineering.stackexchange.com/q/11442/12822), so that you had to write introns and outrons like
mov ebp, esp
mov esp, ebp
mov esp, 0
Seriously, X86? Who came up with that?
dest := source;
memcpy(dest, src, size);
Some have load/store instructions where the memory is always on one side:
load [r1], r3 ; --> direction
store [r1], r3 ; <-- direction
This is the Intel syntax and it is the most popular for doing x86 assembly.
The other syntax, the AT&T syntax, works the other way ("mov $0, %esp" puts 0 into esp).
movl $1, %esp
> Update 9.10.2015: exec.library base address is stored in
> memory address $4. The library base address itself is not $4.
I learnt 68k assembler for the Amiga in high-school and made _exactly_ this mistake. After many "guru mediations" (the flashing red and black box) and much head-scratching I finally realized the problem.
It was a big breakthrough in my early days as a programmer and taught me a solid lesson about indirection and pointers.
In the early 1990s I purchased an Amiga 2000, then a couple of years later an Amiga 1200. A few years after that, Commodore "died" and I moved to a 486 and Windows (though I had used a DOS-base laptop prior to that). A few years later I move to Linux.
I still have my Amigas, and my 1080S - but I have no idea if any of it still works; they haven't been booted in over 20 years (though I have kept them stored well). I've thought about getting them running again; maybe someday (I've got more actual retro hardware than I have time and space for, honestly).
The Amiga community is 100% alive and well, with new software and hardware being developed all the time. If you were a fan of the Amiga then now is a great time to jump back in and see the fun stuff that the community is doing.
I'm looking to get an Amiga mainly to run Octamed and get that Paula chip sound. Can someone suggest a model to buy?
Edit: Realised that Facebook search is rubbish, this is the actual group URL: https://www.facebook.com/groups/CommodoreAmiga/
Not sure how much resources Octamed requires though.
An A1200 with CF hard disk + ACA board seems like a safe bet
IIRC, AGA chipset (Amiga 1200, 4000) is also capable of up to ~56 kHz sample rate.
OCS/ECS is just up to 28 kHz.