The 8-Bit Era's Weird Uncle: The TI-99/4A

https://en.wikipedia.org/wiki/TI-99/4A

Particularly it only had 256 bytes of RAM attached to the CPU but had (I think) 16 kb of RAM attached to the video controller which the CPU could read and write through I/O registers. You could use this for non-video storage but you couldn't access it directly.

Coding in BASIC could, at the very least, hide the insanity from you.

I enjoyed the sprites though, and that was something that was definitely different than Apple II, IBM, etc. at the time. Apple and IBM's graphics were definitely a step down.

C64 could do sprites with POKE statements apparently. But that was definitely not as nice as the TI.

Today, it has a F17A video processor that enables VGA output: https://dnotq.io/f18a/intro.html

And a FinalGROM99 cartridge, so I can have an SD card with all the program cartridges loaded. https://endlos99.github.io/finalgrom99/

There's still a community of fairly active development for retrogames, and some of them are quite good given capabilities of the hardware. My niece particularly enjoys a marble game called Skyway, try it on the online emulator at https://ti99ers.com

One kid entered a program that flashed colors and patterns on the color TV. Our teacher was epileptic, and this sent her into a seizure. Myself and another kid ran to get the 5th grade teacher who'd been a doctor at some point (don't ask, I dont know, I was 8) and he came running and attended to her. She was fine.

I'd always been interested in how things work, taking things apart, playing with my 30-in-1 electronics lab from Radio Shack. But this new computer thing... this was something. That experience flipped a bit in my 8 year old brain. All because of a TI-99/4A.

The TMS9900 didn't have any internal data registers. It only had a program counter, a status register, and a workspace pointer. Instead, it put the "registers" in that same 256 bytes of RAM. There were sixteen 16-bit registers which the workspace pointer pointed to.

The original idea was that this made for fast context switches, instead of dumping all registers to stack (it doesn't even have a stack pointer), just update the workspace pointer to point at a new set. But I have to assume this wasn't really used on the TI-99/4A, as there just wasn't enough RAM. Because your only other ram was locked behind the video controller, that 256 bytes had to contain all your registers, any your dynamically loaded code and any data you wanted rapid access to.

The TMS9900 is weird, because it's the only CPU of the early home computer era that wasn't designed for microcomputers. It's actually an implementation of the TI-990 mini-computer on a single chip and is actually used in later versions of the minicomputer. Those minicomputers had more than enough fast 16-bit memory to take advantage of this fast context switching.

Every other commonly used microprocessor of the 70s (8080, 6800, F8, 6502, RCA1802, Z80, 6809, 8086, 68000) was explicitly designed to target the low-cost microcomputer market.

I'm surprised now to see it was a 16-bit CPU -- I had no idea. I assumed 8-bit as most home computers were (6502, Z80, etc).

Two things I remember:

Saving and loading programs on cassette tapes (where are they? I'm jealous of another poster who still has their TI99/4a).

It was insanely easy to reboot it accidentally -- I had to look it up again but apparently it was by pressing Shift-Q [1]. I lost some work several times, until I got the muscle anti-memory.

[1] https://www.99er.net/994.html

Motorola's 68000 was the single most prolific microprocessor of the 16-bit era. Yet all the registers are 32-bit, and all the instructions easily operate on 32-bit values [1]. About the only claim to being "16-bit" is the 16-bit wide data bus.

If we go by that metric, then the IBM PC (with its 8088 hobbled by an 8-bit data bus) is clearly just another 8-bit microcomputer.

BTW, this is absolutely the way that Motorola sees it. The 68008 is just a 68000 hobbled with an 8-bit data bus, and they label it as a 8/32-bit microprocessor.

[1] And if anyone dares to point out that the 68000's ALU is only 16-bits wide, then I have bad news about the Z-80: It only has a 4-bit ALU, so I guess it's actually a 4-bit microprocessor

Having a 16-bit ALU in theory would make the 9900 a 16-bit processor as much as the 8086. The TI-99/4A is definitely weird (and slow!!) but it does fit the definition of a 16-bit system.

98% of what I did on it was just play cartridge games, but I did have a year or so of trying to type in Basic programs from library magazines. None of them ever came close to working since they were never for TI's weird dialect of Basic and I didn't know anything about the differences. Mostly what I did was CALL COLOR instructions for some pretty colors. I think the furthest I ever got with Basic was the "higher/lower" guess-the-number game. Eventually then we got a Tandy 1000 with GW-Basic and I moved on to that.

Parsec still rocks hard though. I've rolled over the score on it: http://dos486.com/misc/parsec.jpg

https://parkscomputing.com/page/compute-magazine-archives

Hah, that’s a bit of special effort into making Christmas a little bit more magic. Was she a tech person of some kind?

RISC-V is a bit better off, as it has a special encoding for 20 bit immediates, while Alpha and PowerPC are the same as MIPS, stuck with 16-bit immediates.

For anyone that didn't get the context, it's the 99/4 design that has this weird RAM layout. The 990 architecture itself can use any (16-bit) word in memory as the starting point of the 16 registers. Developers have been known to use and abuse the workspace pointer to slide around the "window" on the registers.

The window itself also uses the top three registers to link back to the previous workspace, status, and PC, if you use the proper instructions to branch and return. While there is no stack*, you can still crawl back through those references and get the state of each call.

It's a really cool little architecture, hobbled by the 16-bit address space and how slow it was to keep the registers in RAM. Nowadays I can pick up a 1MB memory chip that's faster than the native bus speed for a few bucks, but that wasn't anywhere near the case in the late 70s and early 80s.

*: The 990/12 minicomputer features the PSHS and POPS instructions, which take a pointer to a definition of where the stack lives and how big it should be. These instructions are not implemented in any production processor, but the platform makes it possible to emulate these instructions in software transparently... as an actual explicit instead of accidental feature in the later few iterations. The 990/12 itself was microcoded on a set of four daisy-chained programmable 4-bit bit slicers so they didn't need any of that nonsense.

It failed the requirements and was then repurposed by TI?

But that is the very way that they are defined through our historical understanding. The 990 platform, established in 1973, not the 80s, is 16-bit, with 16-bit words and 16-bit pointers.

Source: David Pitts, who worked on the platform. https://www.cozx.com/dpitts/ti990.html

It was our family computer. We rented games for it, and that was fun. I learned BASIC. I tried to create things with it, as advertised, and sort of only semi-succeeded repeatedly.

My parents saw that I was running into the limits of the system, and got me both the Extended Basic and Terminal Emulator II cartridges. I dug into Extended Basic, and was able to write "games" with actual sprites that could be manipulated! There they were, flying around, those sprites. That being said, these games always ended up being quite bad, and there wasn't a clear path for them to being much better. We were part of a users group, and the Extended Basic games others were making were perhaps more refined but also honestly not much better.

At the same time, Atarisoft were releasing epic cartridges for the TI. A strangely OK Donkey Kong and Ms. Pac Man, as good or better than on the other home computers. It was clear there was no path at all from whatever was going on with the Extended Basic cartridge to whatever magic voodoo allowed for the TI ports of these arcade games. (To be honest, I still don't really understand it, other than something to do with... GROM? Assembly?)

On the other hand, Terminal Emulator II, which my parents bought me so I could fool around with the TI's speech synthesizer, taught me about the need to connect to online services via a modem. I asked my parents about getting a modem, and they were like... "no".

My pre-teen brain was like "I need to buy myself a modem as soon as I can!"

I bought a 1200 baud modem out of Computer Shopper for mere dollars when I was 16. It changed my life. I got on boards, and then the Internet, before most - and probably you. I learned networking and architecture. No regrets.

But I still have no idea whatsoever how those TI programmers bridged the gap between my horrifically bad Extended Basic programs, where I felt I had maxed out the capabilities of the computer, and the magnificent games and arcade ports available via cartridge. It sort of haunts me. What even?

Fast forward to buying the later TI-99/4A in the beige case in 2023. Booting it up into the Basic prompt gave me a nice flashback to learning Basic in High School on the Radio Shack TRS-80 Model I.

I've also bought its cousin the TI-74 BASICALC. Given hindsight, the TI-74 is my favorite TI-99 for retro computing, even though the similarity is limited to a subset of the TI Basic from the TI-99 family. The TI-74s are rugged and available. It's very useful as a desk calculator.

Once I saw how fun that was to actually run and show friends (which I think was the big draw for me in the 80's), I created an English to Pig Latin translator, which was more based on an official example, but I remember putting more work into it, including a trigger for certain "bad words" my friends would definitely enter, and giving them a surprise flash and warning. Not sophisticated in any way, just a bunch of IF statements for specific words, then a fall through for anything not matching to be translated.

I used to have a book on experiments using a 6-volt battery, and I got my son one of those 30-in-1 kits, and we had a lot of fun with it. I was more easily able to move from the electronic kit to software with him, having had interest in both, and now he's picked up the software itch.

National Instrument's PACE- I've never seen one used in anything: https://en.wikipedia.org/wiki/National_Semiconductor_PACE

but its bit-slice precursor, the IMP-16 was used in Aston Martin's Lagonda https://sprague.com/peter-sprague/aston-martin/

https://opposite-lock.com/topic/90934/lagonda-dashboards

General Instrument's CP1600, used in the Intellivision (a video game console yes, but there was a home computer keyboard attachment).

http://spatula-city.org/~im14u2c/chips/GICP1600.pdf

Its co-processor, the CP1640 is famous for evolving into Microchip's PIC microcontroller.

Anyway, the question is: Who actually coined the term "fairware"? I did some preliminary research in old periodicals and books, but I never came to a satisfactory answer. The closest I found it that it might have been one of the sysops of the TI conference on ... I think either Compuserve or GEnie? Either way, I never found any smoking gun, and this is one of those bits of historical trivia where not knowing the answer irritates me greatly. I tried asking around on the Atari Age forums, but I guess the right kind of graybeards don't hang out around there. Maybe someone here will know the answer?

Dad ended up buying an Atari 800 instead of a 99/4A. It was a good decision.

I got on to my local public library (in the US) with an 800 baud modem on the Atari 8-bit. There was barely any security, which was all bypassed by "password". I could check out books for individuals, alter the amount they owed in late-fees, or erase that someone had a book and then erase that the book ever existed. I have always been more of a white/grey hacker, as far as I don't always report an exploit, but I don't abuse it either. Now that I'm older, I am happy to report exploits confidentially.

I quickly found the BBS in my area were not as usable at 800 baud, and moved to a 286 with a modem slightly higher baud. Until my family got a 386, it was a bit slow, but I was still sitting there like an addict consuming my digital fix! Even in the mid-90's I was amazed at the speed of modems coming out. I believe in 1997/early 1998 I had saved enough money to buy myself my own PC, and had a faster modem. I'm not sure what the speed was back then, but it was good enough to play Quake 1. I started to lose touch with the low-level of computers around that time, but also saw the value in higher-level programming. I think having understood lower-level computers in my early years helped me to understand things like memory management in current days, where a lot of my co-workers have no concept of running into memory problems until they hit a wall.

First I made a text-based "cave explorer" deal, with significant randomization, various choices that might lead to pits, monsters, rockfalls, and the like, with warnings and the ability to "back up." Also, some character creation business for Dungeons and Dragons (doing all of the attribute rolling, then selecting an optimal class, then doing the hitpoints, then some money, and on to one of twenty convenient "equipment packs" I designed), right on out to the printouts. Math drills.

I made a fairly dumb video game that drew in an uninspiring manner from Berzerk and Pac-Man and the like, which was quite slow due to the various walls and pits and such which had to be checked for in many lines of tedious IF THEN ELSE statements ... but then I hit on the idea of merely drawing all of these items and then checking the video register to see what was there, resulting in a massive speedup, or as much as one could manage using doubly-interpreted BASIC.

After I got the Speech Synthesis module, I revisited some of my dumb little games and added some voice bits, not much more than your Sinistar "I hunger!" bits.

My last was Black Cat, wherein your titular cat had to cross traffic (like Frogger) on one screen, navigate various screens of terrain, visit a child at school, and eventually find your way home, hopefully bringing with you a bird or mouse as a trophy for bonus points.

I only ever played Temple of Apshai on the Commodore.

When I was a little older I would borrow books at the library to write games in BASIC. Basically key stuff in that the book told you to write, and since a lot of it was for the C64 or TRS-80 I had to figure out how to “port” it to the TI. I wrote notes for my changes in pencil in the library books so I wouldn’t get in trouble with the librarian. Invariably I’d check the book out again a few weeks after I’d returned it. I was probably the only person who read my notes, but I like to think someone got some use out of my addenda.

Contrast that to the PDP-10 [1] which had a 36 bit word and a 20-bit address space and could access 256k words for a total of 1152 kilobytes.

The use of 8-bit bytes for characters I think killed off any word size other than 8-bit because otherwise it would be awkward to work with characters. [2] To be efficient you have to pack multiple characters into a word, it's something that comes up common enough you could create some special machine instructions for it, but if you want to support a C compiler you need a char. It's easiest if native pointers point to a byte. If it was otherwise you could make up a char that consists of a native pointer plus a pointer to the char inside the word, but boy what a hassle. [3]

Modern computers get many of the benefits of a larger word size (wider pipe to suck data through) by having a cache system that decouples the memory interface from the CPU, so a CPU could ask for 32 bits and get it retrieved 8 bits at a time, or it could ask for 32 bits and get the surrounding 128 bits stored in the cache so they don't need to be retrieved next)

[1] https://en.wikipedia.org/wiki/PDP-10

[2] DEC had a system of 6-bit characters, which divides nicely into 36, but you have the same problem

[3] That PDP-10 did have deep pointers that could point to a specific range of bits inside a word, that's what you need if you want something like that to be reasonable to program. I've been thinking about a fantasy computer to run inside Javascript and came across a 48-bit word size to use doubles efficiently to store words. That thing would have 24-bit address spaces, plus it would be possible to make 'deep pointers' that have 6 bits of offset and 6 bits of length (with the possibility of 0-length to point to a specific bit) and could be extended to 'wide pointers' by putting a few bits in front that would reference particular address spaces (might be video RAM, or a unit of memory protection, or made contiguous to represent a larger address space) I think I'd want enough to make a 1GB word address space so it could outdo a 32-bit machine and then let the rest be used for flags just to make it as baroque as possible... And that's why you only see 8-bit words today!

Except TI-BASIC is a hell-riddled double-interpreted language. I had a 99/4A at the age of 6, learned how to use all of the TI-BASIC language by 8, and said screw that, hardware it is for me, dad's buying me a 286 for Christmas, time to learn how to build that!

Funny enough, now as part of my job, I advise TI on various upcoming power ranges for various lighting types, and they do on occasion make an IC based on my specs for general production.

I used to lay down in the living room and transcribe BASIC from COMPUTE! magazine into it, and customize them, and that's how I learned to program.

> "ST" officially stands for "Sixteen/Thirty-two", referring to the Motorola 68000's 16-bit external bus and 32-bit internals.

via https://en.wikipedia.org/wiki/Atari_ST

Quite an impact for a graphics chip coming from a rather unsuccessful computer. I never played around with or even saw a TI-99 but from my understanding the CPU needing to use VRAM as data storage (because the system RAM was way too low for the time), accessed through IO ports, really hampered the machine.

While it lacked the hardware scrolling, massive master palette and display list tricks of the Atari machines, it displayed multi-color high-resolution graphics with ease. Being able to set a different color for each line of a background tile allowed for really detailed art.

Only 4 sprites per line like the Atari (not counting the weird missiles), but the TI-99 sprites are 16 pixels wide and high-resolution, rather than 8 fat pixels wide, and there's 32 to work with in total rather than needing to use raster splits to multiplex sprites.

Way ahead of its time. MSX homebrew games like Mini Ghost, The Cure, Invasion of the Zombie Monsters, etc. really show what it can do.

Too bad that at the time, TI actively discouraged third party developers from developing software for the TI-99/4(A) - they were selling the machines below production cost (because of the difficult market and the competition from cheaper mostly Commodore models) and hoped to recoup the losses by selling software (according to https://en.wikipedia.org/wiki/TI-99/4A#Lack_of_third-party_d...).

Great memories of Parsec too.

That's the biggest "what if" omission of the TMS9918 for me - I wonder how the 8-bit landscape would have evolved if it had even minimal support like the scroll registers of the VIC-II...

Hell yes it does. Good shot commander!

Turns out there was a variant called SBP9900 which was hardened for military use.

https://www.youtube.com/watch?v=ejGlI0yxqGA

Over at https://js99er.net/ there's a fair bit of software available right from the web interface, as well.

I mainly wrote basic games for my friends. Most popular was a two player competetive snakes variant, a bit like Tron but with traces only growing as you gobbled up food. I also wrote a 'defender' like game that enjoyed some success amongst friends.

I had no periperals or cartridges as that was too expensive. The living room TV was my monitor. It was quite a while before I got a cassette tape player, so in the early days a computer session started by retyping all code from my notebook.

I later got a ZX Spectrum which was far more powerfull, but the TI (and a HP41cv) are what got me into programming.

I had TI Forth, the huge accessory box, a disk drive, the works. It was fun, I learned quite a bit and have forgotten most of the Forth that I learned.

- 01965: IBM 1130

- 01966: HP 2116A, the first model of the HP 2100 series

- 01969: Nova

- 01970: PDP-11

- 01971: IBM System/7

- 01973: Alto (not shipped. NEVER shipped)

- 01973: TI-990 (the 990/3, according to https://cozx.com/dpitts/ti990.html)

- 01974: HP 3000

- 01974: PACE (which was from National Semiconductor, not National Instruments)

- 01975: CP1600

- 01976: TMS9900 (what the TI-99/4A used)

- 01976: Tandem (first Tandem/16 shipped to Citibank)

- 01978: 8086

- 01979: 8088

- 01981: TI-99/4A

Since there were plenty of 6-bit, 8-bit, 12-bit, 32-bit, 36-bit, 60-bit, and 64-bit CPUs in the 01950s, you'd think there would be some 16-bit CPUs then too, but I can't think of any. I'd even forgotten about the HP 2100 until I went looking just now.

What a diverse selection of personal computers!

I was starting to program back in those halcyon days (BASIC and fortunately for my later life, Fortran), so my dad got me one. Probably because it was cheap. Cheap it was, and slow. Like, my friends VIC20 seemed faster (but then, he had a floppy, more on that later). And the games were mostly inferior to anything on something like the C64. And they were games none of my friends had, or more importantly, my friends had games I couldn't. And the business apps, according to my dad, were 'just shit'.

OK...I will give the thing one huge props: it had a relatively cheap voice synthesizer "sidecar" thing, that my dad actually sprung for. It. Was. AWESOME. Write a little BASIC program and a robot voice would call your friend a 'butthead' or something. For a couple of days I was the most popular kid in the neighborhood and everyone had to see (hear) this thing. And then...they all went "cool man, but we're gonna go and play Fargoal or Double Dragon or whatever that you don't have and don't know how to play". So back alone with my 99/4a calling my friends 'butthead', but now in a sad way.

But dad bought it for me to program on, so let's do that. The BASIC was...okay, I guess, but since it was some TI thing unrelated to MS BASIC used by pretty much everyone else at the time I couldn't compare notes with and get help from my friends with sane parents who had gotten their kids a C64, Atari 800 or TRS-80. The Logo cart was actually pretty fun, but it was also it's own thing and more of a toy to play with; moving the turtle around the screen got old quick. I probably should have gotten the assembler cart, but I didn't know that was probably the only way to really have fun programming the thing. Nut anyway...I'm a couple of BASIC programs in, and a floppy sure would be nice (read: required). Oh, you want floppy? You have to buy the giant expansion box, which is 5 times bigger than and costs more than the computer. And then buy the floppy. And probably a memory expansion.

At this point dad realized he'd been sold a bill of goods, did the math, knew what a sunk cost is, and went out and bought a TRS-80 4P for a lot more than the TI. Added CP/M, Turbo Pascal, 123 and Wordstar and a modem and I was off to the races. Got me all the way to my second year of college or so.

At some point in the '90s, a buddy showed me around his new job (manufacturing) and we spent some time on the TI-990 minicomputer he was in charge of. I remember thinking "if this is what is possible with a 9900, they had to have worked hard crippling it for the 99/4a".

The IBM 360 had 24-bit addresses, 8-bit words, and 16 32-bit registers.

8-bit words were thoroughly established by 1980s for general purpose computers, I think because of the use of 7/8-bit ASCII characters. I mean, you could pack ASCII characters into larger words in different ways but the most comfortable (portable) way to handle them is to have a char* which requires either 8-bit words or some way to address subwords.

The PDP-10 was probably the most loved heterodox architecture with a 20-bit address space and 36-bit words. It had pointers that could point to specific bits inside a word so it was possible to port C to it with char*'s. The user space was 256k words and 1152M bytes. (If an architecture like the PDP-10 let you access bits in the next word you could even point something like a char* at a variable sized UTF-8 char if you don't mind pointer arithmetic being limited to scans)

Some of the 8-bit micros had 16-bit registers such as the 8086/8088 and the 6809. The word size doesn't have to be related to the size of the data bus: the 8088 had an 8-bit data bus and the 8086 had a 16-bit data bus, it just pumped twice if it needed 16-bits. The 68k series had 32-bit registers and a 32-bit address space (like the DEC VAX which was the first modern computer) but had various bus sizes as low as 8-bits in the 68008.

With a cache the data bus could be larger than the word size.

Programming really isn't fun if you don't have index registers at least as large as the address space. There were numerous attempts to extend 8-bit architectures to a 24-bit address space that didn't provide large enough index registers, the 65816 is probably the most famous. The eZ80 on the other hand, extends the registers to 24-bits so it's easy to write programs that use the whole address space.

[1] which I'm just going to call word size

It always amazed me that the 99/4A had such a vibrant community (that is still creating hardware and software around the machine) and so many outlandish ways to expand the machine.

I was disappointed in what the embedded basic could give me...it was slow, it had sprite-only graphics exposed (couldn't draw a vector from X,Y to X,Y) and my parents only bought touch typing tutor.

and in my boredom, I'd slot and pull the cartridge which made it do -interesting- things...dumping memory space to what would eventually be called a frame buffer...and when it did, it would show cycling bitmaps at a much higher speed than you'd ever be able to do with Basic.

So you could see the potential, but a 12 year old with nothing but a tape drive and one cartridge couldn't and didn't know how to touch it.

And 4 months after spending $350 for it, Sears was closing them out for $50. Which was why, a few years later, when I wanted an Amiga, Dad bought an XT clone. It's support and software cpabilities was much improved over the TI.

I still wonder... Could TI have made a non-crippled TI99 at the time that wouldn't have been vastly more expensive?

I know there was the planned, prototyped, and cancelled TI99/8:

http://www.99er.net/998art.html

http://www.99er.net/998.html

64kB RAM, Extended BASIC as standard, expandable to 15MB.

But that would have cost a fortune at the time.

I'm just wondering if a TI99/4 with 32kB of RAM attached directly to the CPU and maybe a better BASIC would have been achievable for not much more?

The 99/8 never shipped but the Geneve 9640 shows what the architecture could do.

https://en.wikipedia.org/wiki/Geneve_9640

My dad bought it with the stated intent of writing a program that would display ASCII art associated with a keypress, to help me learn the alphabet and reading (e.g., pressing "A" would have brought up an ascii art apple). He claimed that he was only able to make it halfway through the alphabet before running out of storage on the cassette tape.

He would later go on to be a sysadmin at Cleveland FreeNet (as a hobby), and in the early 1980s was the first principal to put a "computer lab" in our local high school.

I have many fond memories of playing Munch Man (and, I think, Parsec) on this home computer.

For actually usable development you could buy a TI expansion box, 32K RAM expansion, and 5 1/4" floppy drive. This cost the equivalent of like two thousand bucks today. Less than an Apple ][, somewhat more than a base C-64, but a lot more than the TI-99 itself.

My parents were very indulgent in this. Once I had this setup, I bought a third-party Forth and coded my own Forth assembler vocabulary, and finally had a reasonably capable dev env, for maybe a year before leaving for college. But still had basically no way to share my work (wasn't online).

Lost all of that code because my 99 system got stolen a few years later.

This is awesome. I don't have a TI-99, but I do have an MSX that would hugely benefit from this.

anything 6502 SBC -- hex code / assembly, later BASIC, etc. Timex Sinclair -- disabled screen for run so CPU could save screen code cycles TRS-80 CoCo -- poke 65535,65536, 65537 -- clock 1x, overclock 2x, 3x TI99/4a -- sprites + cartridges + accessible PC Jr + Turbo Pascal -- first compiler in

It also has no disassembler. I spent many many hours dumping the ROMS using easy-bug and disassembling them by hand. Many happy hours.

(All I remember is reading the docs of the filesystem calls and thinking "hm, could you do thus-and-so" and being a bit surprised it just worked.)

The assembler cartridge was nearly as useless as the BASIC cartridge for the Atari VCS. (Not that I ever tried the latter, but similar problems of very limited memory holding text you'd typed in, the assembled program, and whatever data it's processing at runtime -- and needing to save to cassette tape before you can start on anything else.) However, the CPU architecture actually did give you a nice clean assembly language once you had enough of a system to really code in it.

Being away from the mainstream... isn't an advantage but I'd have to call it part of my development as a programmer. I had to get into Forth for a reasonably powerful system.

> Each source statement you enter is immediately assembled into object code and stored into memory. Some source code is retained in a nine-page text buffer. You can scroll the screen to review previously entered lines of source code by pressing the Up- and down-arrow keys.

I gave up on this system pretty quick -- with so little space for your code, it just wasn't worth so much trouble.

Oh man! I remember playing 'Hunt the Wumpus'[0] with my cousins on my grandfathers TI-99 in the mid 80's. Probably the first computer I ever touched!

In the spirit of HN pedantry, should the plural be Wumpi? I will concede that wumpuses is way more fun to say..

[0]https://en.wikipedia.org/wiki/Hunt_the_Wumpus

I still booted my system up occasionally when I had it to remind myself that you didn't have to write HUGE programs to do stuff.

Now, I want to write a text adventure game again. Where are my Turbo Pascal disks?

Anywho... this isn't a critique of the OP or @phire, it's a reminder for the community at large that tech decisions that seem bad in retrospect often had non-idiotic motivations at the time.

It was not until years later I actually understood what I was doing. The little dancing guy was magic when I did it the first few times. Now I see it as a boring little program that loads up a bitmap into memory and then hangs out in a loop. I think the 'magic' may be gone :)

A interesting 12-bit microcontroller I just learned about is the "Toshiba Transistor Works" TLCS-12 for Ford's engine control module (1973). I'm trying to find a full datasheet for it:

https://www.shmj.or.jp/english/pdf/ic/exhibi739E.pdf

https://en.wikipedia.org/wiki/Ford_EEC

https://www.cpu-world.com/forum/viewtopic.php?p=304576

So we bought a 99/4. Pretty sure we got the friends and family discount. Many don't remember the original 99/4 released in '79, but it was definitely a weird beast. In retrospect it was very clear TI couldn't decide whether it was a console gaming system to compete with the Atari VCS or a personal computer to compete with the Atari 800, Apple ][, TRS-80 or Commodore PET. Peripherals were originally (large) boxes that chained off the side of the main unit. We had a speech synthesizer, memory expansion, RS-232 interface and floppy controller, so we wound up buying a special cable to let us move the chain to a different part of the desk.

To a modern audience, the most interesting part of the confusion between being a personal computer or game console might have been TI's attitude towards 3rd party software developers. If you wanted to write software for the 99/4, the first thing they wanted you to do was to give them $10k. And this was back in the late 70s, when $10k was a chunk of change. Companies like Milton-Bradley ponied up the cash for a license and a dev system (which I think was a $25k 990 system.) I wrote a couple games for the Apple ][, put floppies in a zip-lock and sold them through the local ByteShop. I think I sold 10 copies. For a kid in Jr. High, the $50 in profit I made was real money. I could not even conceive of where I would get $10k for a license to make anything for the 99/4.

In '81, TI released an upgraded version called the 99/4A, which was mostly identical, but had the upgraded video chip (the 9918A vs the 9918) and lower case characters (actually small caps, but who cares.) Even though there was plenty of data to suggest this Nintendo-esque approach to 3rd party software was more of a games console thing than a personal computer thing, TI stuck with it. I think the beige models of the 99/4A that started coming out in '83 before they exited the market included scrambled entry-points to various OS calls to make it harder for people to make unlicensed software (didn't AtariSoft run afoul of this? or maybe it was ActiVision. I know one of the "big names" didn't want to pay for the license and thus didn't get the "secret" information about how to properly call I/O functions on the beige machines.)

My uncle participated in researching a book on TI's corporate history in the late 90s / early 2000s. I helped him out a bit and one day called the main corporate library asking for any public info they might have on the 99/4. They claimed TI never made a machine called the 99/4 or 99/4A and I must be thinking about the TI-84 calculator. Maybe they just wanted to forget the whole thing or maybe I had reached the calculator library. In any event, most of the people I talked with who were involved in the project thought it was a failure and don't seem to want to share their memories. This is kinda sad. I loved my little 99/4, quirks and all.

And at the end of it's life, the local Base Exchange was selling them for $50 along with a $99 rebate voucher. The offer didn't last for long, though my brother scrabbled enough cash to buy 5 of them, got the rebate checks and wound up making money on the deal. But then he had 5 99/4As that he couldn't even give away.

It was a bit of a crap-fest handicapped by bizarre corporate strategies from TI and a "baroque" internal architecture. But it was DURT CHEAP compared to "real" computers like PCs/clones, Apple ][s or CP/M devices.

(Not arguing with the fact that in 1983 when TI pulled out of the market, it was clear it was ready to move to a computer farm upstate. But none of us knew any better in '79 when the 99/4 was originally released. And besides, BILL COSBY was the spokes-person, so it COULDN'T be a bad machine!)

TI definitely had a defense oriented business up until the late 90s when they sold their Defense Semiconductor Engineering Group (DESG) to (I think) Raytheon.

https://forums.atariage.com/topic/373742-ti-960-texas-instru...

so maybe I'm mis-remembering it. But wasn't the 990 already planned as being a cost reduced version of the 960 and 980? Though in those days it seemed like a lot of computer systems were being built for specific customers. The story I heard about the 8008 and TMX1795 were they were built exclusively to win the DataPoint terminal contract.

More info on the TMX1795 from Ken Sherriff: https://www.righto.com/2015/05/the-texas-instruments-tmx-179...

Thx for the reference in your post, but it doesn't say anything about the 990 being developed for a Hotel Chain (though I have a distinct memory of it being used as a prop in the TV series "Hotel" -- https://starringthecomputer.com/computer.html?c=578 ) Maybe you saw the hotel reference on a different page?

I think it was certainly possible for SOMEONE to have come up with a better design targeting the nascent PC market. Also remember the 99/4 was pretty cheap compared to "real" computers. A typical CP/M or Apple ][ machine would have cost somewhere around $2500-$3500 in 1979. The 99/4 was a "bargain" at $1150. You have to think a 9900-based system that had a front-panel, floppy disk, RS-232 interface like contemporary CP/M machines wouldn't have cost too much more than a CP/M device. It may be a scratch more expensive cause you would likely want a bit more memory than the 16k that was common in the Altair or IMSAI machines at the time.

Every now and again 99/8 prototype systems will surface on eBay and sell for THOUSANDS of dollars. I just saw a CC-40 Plus system go for about $3500. Alas, I can't really justify that many dollars for these old systems. When TI got out of the business, they had the 99/8 and CC-70 in development. Assuming they were able to sell them for a decent price, they couldn't have been as bad at the 99/4 and CC-40.

But yes. Old games. They rock.

I used a similar system in a 6-bit CPU I designed.

(I used Wycove Forth in 40-column mode, though I have a dim memory of trying something like your 3x7 font...)

I asked my parents for a modem the same year Matthew Broderick's "Wargames" came out. My mom forbid me from ever using one because she had seen a movie about what happens when you have one of those things...

TI-99/4a and Jello Pudding. Truly halcyon days!

As proud owner of one, this isn't exactly right.

Turns out one of their factories was in Portugal, so until the 128 K models took off, many Portuguese homes had a Timex instead of the real ZX Spectrum.

And while it was incompatible in default mode, it had an eprom bay that extended its capabilities in various ways, including a being copy of Spectrum 48.

A cartridge that most folks owned as well.

In its incompatible mode, it had a great sound chip, for its time.

The factory was so relevant for Timex culture in Portugal during the 1980's, that there is even a museum.

https://loadzx.com/en/

> And learn - in case you don’t know it yet - about the important role that Portugal played at the TIMEX factory when this phenomenon started in the 80s.

It gets celebrated, not forgotten.

Loved this game https://en.wikipedia.org/wiki/TI_Invaders

They bought this machine because it was the best value for the hardware specs. I didn’t realize TI actually lost money on the hardware until reading this article

Usually "word size" means "register size" and a "16-bit architecture" is one with a word size, in that sense, of 16 bits; that is, one whose architectural registers are 16 bits wide. That describes all the CPUs in my list, I think. The definition necessarily gets a bit ambiguous on machines with multiple register widths like the CDC 6600, the 8080, the 8086, and the 80386. But usually on this basis we say the 6600 was 60-bit (despite its smaller address registers), the 8080 was 8-bit (despite its 16-bit register-pair instructions) and so was the 6809, the 8086 was 16-bit (despite AH, AL, etc.) and so was the 65816, and the 386 and 360 and 68k and VAX were 32-bit.

I suspect that standardizing on 8-bit byte addressability was largely due to the influence of the 360, which didn't use ASCII. ASCII (a 7-bit code) was probably a significant influence, but it fit as nicely into 9-bit PDP-10 bytes as into 8-bit bytes, with space for a 512-character character set.

One minor quibble on the PDP-11: though addresses were 16 bits, as you probably know, later PDP-11 models supported split instruction and data spaces, with separate code and data segments. This doubled the memory available for a normal user program over what an Apple ][ could manage without bank switching. Later versions of PDP-11 Unix required this capability for some larger programs, though I don't remember which.

I think the status of the VAX as "the first modern computer" is pretty debatable. Other defensible candidates might be the IBM 801, the IBM PC, the SUN workstation, the Alto, Berkeley RISC I, Stretch, the CDC 6600, the IBM 360, the IBM 360 Model 91, the IBM 360 Model 67, and the Acorn Archimedes. But the VAX definitely has a plausible claim to that title.