A Graphical OS for the Atari 8-bit computers
atari8.co.uk
atari8.co.uk
Need to have a whole collection of articles for implementing HLL constructs and algorithms effectively in 8-16 bit systems. Maybe 4bit while we're at it to give these 8-bit show-offs a challenge. ;)
EDIT: Editing to add the interesting link below I found on 4-bit computing courtesy of Wikipedia's article on 4-bit. Interesting part was how manufacturers brought offer to developers as invite only. Wonder if they've since transitioned to 8-bit.
http://www.embeddedinsights.com/channels/2010/12/10/consider...
https://www.schneier.com/blog/archives/2015/09/understanding...
Much more interesting than I thought they'd be, though. :)
Nonetheless, the 8-bit stuff described here does make one wonder what people will do with raspberry pi's in 30 years. Might be really cool stuff. Two teams give me a hint at where it might go based on prior lightweight work:
http://web.syllable.org/Syllable/index.html
They both run with limited hardware. Moving things like graphics and audio to dedicated hardware as many SOC's do today will only expand what you can do with minimal processors.
- Single menu bar at the top of the screen
- System logo menu to the left of the application menus
- Clock on the right side of the menu bar
- Desktop icons arranged top to bottom on the right
- Trash icon in the bottom right
- Same medium grey dithered desktop background
- Same light grey dithered scroll bar fill
- Horizontal stripe pattern in the window title bar
- Centered window title text
- Identical window zoom icon placed in identical location
- Identical file browser window header and column arrangement
The system font is different (likely because it is smaller), the scroll arrows are different, and the Mac never had accelerator-key underlines in its menus, but it is very, very clear that the people designing this interface knew the classic Mac OS well and have purposefully based their design on it.I would like to see a description of that multi-tasking solution. A simple way to do it that I see is to give each of those 16 processes 16 bytes of stack space, but that would be very tight. You would have to carefully count your stack depth in every subroutine. An alternative is to go for a software stack, but that is slow.
This is pretty funny when you recall regions were a key part of the original Macintosh system software — as described in “I Still Remember Regions”:
http://www.folklore.org/StoryView.py?story=I_Still_Remember_...
See also “Busy Being Born”, currently on the front page:
http://www.folklore.org/StoryView.py?story=Busy_Being_Born.t...
Google text-only cache: http://webcache.googleusercontent.com/search?q=cache:http://...
Edit: I'm reminded of OS-9, but I don't believe that matches the bullet points from the article
MOS took engineers from Motorola who made the 6800 chip, cloned it and MOS 6501 was pin compatible with the 6800 and the 6502 changed two pins. Motorola sued and won over the 6501 but not the 6502.
The 6809 was a 16 bit chip IIRC. TRS-80 COCO used it. It was the original chip to be used on the $600 Macintosh project until Steve Jobs took it over and changed it to the 68000 CPU.
6800 cost $300 and 6502 cost $30, guess which ones the 8 bit video game consoles and computers wanted to use?
Apparently it is 8 bit with 16 bit features.
I had a friend in high school who upgraded from the TRS-80 COCO to the TRS-80 COCO2 and offered me his old computer. I already had a Commodore 64 and I told him no, to give it to another friend who didn't have a computer yet. I should have taken it so I could run OS9 on it.
I'm learning the 6809 for other reasons, it would be nice to be able to take a stab at something like this in a few years.
The extra RAM on those machines appeared in 16K banks that could be switched in and out by setting a control register.
Code in one 16K bank was totally isolated from code in other banks. Obviously code that wasn't located in that part of the address space could access anything that was in the currently switched-in bank, but there was no way for one bank to directly access another.
I wrote a primitive multitasking kernel (nowhere near as elaborate as this) using a C package that simulated a 16 bit machine by using multiple bytes of Page 0 as pseudo-registers. You just had to save those off before switching banks and jumping back to the other task.
It actually worked reasonably well, but not fast enough to be practical.
Yeah, I'm old.
http://atariage.com/forums/topic/154520-new-gui-for-the-atar...
What is especially heartening at this stage is that the 8-bit Atari can actually run a pre-emptive scheduler, and run it well – in spite of the 6502’s fixed stack.
Looks like it is.
[1] I can't find any trace online, except for some weird Word document of what must have been the original README file.
(In a lot of ways memory posed a bigger problem than CPU time back then.)