Advent of Computing - Episode 170 Thoroughbredos

Episode Date: January 11, 2026

I'm back to normal episodes, and I'm running out the gate with a weird one. Thoroughbred/OS was a multi-user and multi-tasking operating system for the IBM PC. It's mian interface was... BASIC of all things! What exactly is this oddity? https://winworldpc.com/product/thoroughbred-os/662 - Try Out Thoroughbred/OS yourself

I'm not a huge wine guy. I'm more of a Scotch man myself, but that said, I can enjoy a nice glass of wine. This is especially true if someone hands me, said glass of wine. About a month ago, I was down in Sonoma, celebrating one of my close friends' birthdays. We ended up at a wine tasting at one point. And, again, don't get me wrong, the wine was very good. I had a fabulous time. But I immediately recognized I was out of my depth. I can do the whole fruity, dry, sweet and oaky thing. That's easy enough, right?

My palate can detect when something tastes like a fruit, maybe not necessarily the difference between a fruit and a stone fruit. When someone starts talking about the differences in soil composition or undertones, well, I get a little lost. I've gotten pretty good at recognizing the difference between total mumbo-jumbo and things I just flat out don't have the context to understand. When I hear a Somalié talking for more than a few minutes, I know it's the latter.

I like to think of this as a sense for the unknown. I can tell the difference because I'm often on the other side of this conversation. When it comes to programming, I like to think I have a refined palette myself. I can talk for hours about the differences in implementations of basic, or how data typing affects what kind of code a programmer will write. And I, too, will run into blank stairs. I can make other people realize they're lacking a certain context. Even with all my experience in the field, I still get perplexed.

I still run into things where my unknown sense tingles. This episode is going to be one such occasion. There are just some languages, some tools, some programs, where I can feel the complete lack of context. I can see that something's missing, and I can kind of see the shape of that, but I can't always put my finger on it. I may know that a program seems pretty dry,

but there's something about legs? Terroa? Finding what's missing? Well, that is the real treat. Welcome back to advent of computing. I'm your host, Sean Haas. and this is episode 170, Thurrowbread OS. Today, we're in for a classic mystery episode.

We're looking at something that's truly an enigma. I first heard about Thurrowbred OS over at WinworldPC.com. It's a wonderful website that if you don't know about, well, you should. Winworld PC has a library of old programs and operating systems free for download and a forum. It was on that forum that I stumbled across an interesting article the site administrator wrote about Thurobred OS. Until then, I had no idea it even existed. Thurrowbread is an operating system for the IBM PC, and it's 100% compatibles that have hard drives. It's multitasking, which is odd for the PC.

It's multi-user, which is also kind of odd for the PC, and its main purpose is to run software-written in basic, which, say it with me, is odd for the PC. The operating system provides this weird mix of old and new. Multi-user and multitasking is pretty sophisticated for early PC hardware. This is first released in 1983, so we're talking about early days for the platform. That's the same year the IBM XT is released, which is when hard drives enter the picture. Basic is also a bit of a strange choice. The PC as a platform supported Basic from the GitGo,

but the focus ends up being around native applications that run under Microsoft DOS. Basic exists on the PC, but kind of is its own thing. Most users who wanted Basic would load up something like GW Basic or Q Basic, which ran as applications under DOS. But this pattern isn't. unheard of. Originally, Basic ran as a time-shared system. Those systems like Dartmouth or HP Basic were multi-user and multitasking. The difference here is those systems were larger machines, and were developed in the 60s and 70s. Bringing this older idea to a newer and much smaller

platform, well, that's interesting. That makes me want to know more. At the start here, I want to set some expectations. Therobread is about as obscure as it gets. So today, we're going to be seeing everything we can dig up. That, however, isn't wildly technical. A lot of today's discussion is going to be around corporate history and around the larger market and really the context and story around Thurowbride OS. I want to see what we can find out about its story. Was it viewed as an oddity at the time, or did it just die out to the dominance of Microsoft DOS? And what can Thurrowbride OS tell us about the decline of basic in the home in general? We're in for kind of a weird one, which is just where I want to be.

The origins of any of this is pretty difficult to tease out. This is one of the cases where I've had to piece together a corporate history, and basically every name involved in the story sounds fake. They run the gamut from Data Technology Industries Incorporated to Scientific Management Corporation, from Fortune Computers and their machine the Fortune 5,000, to Concept Omega Corporation. Even some of the human names sound fake,

like John L. Johnson, which is usually spelled as John Dash L. His friends called him John L. Things actually start with the man with the dash himself, John L. Johnson. In the 1970s, he ended up profiled in a number of newspaper articles, so we have a nice paper trail with short interview snippets. It's not quite an oral history, I know, but it's enough to give us some flavor.

Johnson grew up on a farm in Texas. In 1961, he enlisted in the U.S. Navy. That's where he got bit by the computer bug. While in the Navy, he saw the world, and he was trained to program. We've ran into some of these naval programmers before. Gary Kildall, the creator of the CPM operating system, taught at the naval postgraduate school for a number of years. He taught naval students how to program there.

Rear Admiral Grace Hopper did the same. In this period, there was a strong digital strain in the U.S. Navy. In 1969, Johnson left the Navy for a civilian life. As the story goes, he and four of his Navy friends pooled some cash to start a software company. All told, they put in about $500. The company they found was called Data Technology Industries. Now I know, I complain about names, quite a bit. But I mean, come on. That name's so generic that it's kind of impossible to search

for it. All I really know is that DTI initially wrote some software and later on help to manufacture computers in some capacity. That said, we do know just a little bit about the software side of things. It's just that reporting comes from pretty far after the fact. So check this out. This whole episode is a meandering paper trail. There was this computer company called Fortune Systems. They made Unix workstations in the 80s and early 90s. They had this newsletter called U-Slas Fortune. In the newsletter was a column titled The Basic Advisor,

that carried a lot of interesting firsthand gossip around Fortune's software and Basic in particular. But the column isn't always about basic. In 1990, that column ran a retrospective called A Fond Farewell to the 80s. It gives a timeline of a few business programs that were crucial to fortune users. This one weird source somehow has ended up being my Rosetta Stone to this whole episode. So here's the story. while at DTI, John L. Johnson, who went by John L with his friends, wrote two important programs.

Idle and Base. Idle, spelled IDOL, was a database. Base, well, it wasn't basic. BAS stands for business accounting software. From what I can tell, it was somewhat like an accounting package, maybe something like QuickBooks, but it also allowed users to make menu interfaces and edit and create screens and forms. Idle and base are usually spoken in the same breadth as idle slash base. The reason for this is base turned into a larger bundle of software.

It would function as the front end for a pile of other tools. That included the idle database for storing data, and sometimes this thing called business basic. So, base isn't basic, but you can use it to trigger the execution of basic code. The details on this all come from, again, my sources are fantastic this time, a lesson plan used at a workshop put on by Fortune Systems.

Seriously, I have just weird random scraps of paper this week, and I kind of love that. Just to be clear, or as clear as I can be here, this lesson plan I'm using is from the mid-1980s. By that point, base was hooked up to a lot of stuff. Business Basic comes into the picture a little late here. When John L. is laying down lines of code, he isn't working with Business Basic. So how does that connection happen? Well, it all comes down to a result of DTI's success.

After a few years, that little scrappy company was actually making tens of millions in profit. That's when Scientific Management Corp comes knocking. They buy out DTI for an undisclosed sum of cash. The smaller company is rolled into SMC's Software Proprietary Systems Division. That includes DTI's founders who, according to John L, sign on for a three-year term at S&S. This merger brings idle base into contact with Business Basic, another package that SMC had bought at some point. There's something funny there about a program called Base and a program called Basic running into each other as the result of multiple mergers, but I digress. Stranger Things have happened.

The merger goes down in 1980. SMC's business model was pretty standard for that era. They worked with OEMs and provided canned software. This let SMC be the software house for multiple different hardware houses. The benefit here was that hardware companies could focus on hardware without neglecting software. It turns out to ship hardware, you kind of have to ship software for it. I don't say that to be flippant. That's a fact that's bore out over and over again.

By 1980, there were established business models that worked around that market fact. Part of this business model involved source code. I don't know SMC's contract, but I know the general idea for these kinds of companies. The software house offers a license to their source code to hardware companies. The OEM, the hardware company,

then gets to modify the source code as needed. When an end user gets software from that OEM, it will be slightly different than the original code, that was licensed. That modification step was necessary because back in the day, hardware differed quite a bit between vendors. We weren't in the PC monoculture yet. For a software house to work under this model, there had to be room for these adaptations.

You can actually see this with OEM versions of Microsoft DOS, so this still does happen a little bit even during the PC monoculture. Microsoft had a special OEM kit that was sold to hardware companies. It had source code and tools for modifying DOS to work better with whatever PC mostly compatible was in question. It's also in 1980, I think, that Fortune Systems enter the picture. That year, they enter into a license agreement with SMC. I say, I think, because the timeline I'm working with is, is a little bit vague here. Now, Fortune does a few things with this license. First off,

they make the larger idle-based platform available on their Unix workstations. Secondly, they used the idle-based platform to write business software for their clients. This is the neat thing about this specific product. Idle and base is really just a set of tools. It's handy for any business user, but it's generalized. Fortune would offer more specific tools created using idle and base. Again, just tagging this here, this included Business Basic. So to give you the full photo here, we have Unix workstations running programs written in Basic that work alongside the specific database and this specific accounting entry tool, which is a single work. kind of strange. Third of all, Fortune made some modifications to idle base. I think this has to do

with the fact that Fortune was kind of modifying everything. Their workstations ran this modified version of Unix V7. This was initially called the Fortune operating system, but was later changed to 4 Pro. Part of the system was a menu-driven interface, which is where most users would be dropped. Now, I think that menu interface used base. I say that because one of the top-line features of base was defining screens and menus. Putting this all together, I think it's likely that Fortune was heavily modifying the inner workings of base, which was probably within their license agreement. And here's where we get the gossip. By 1983, relations with SMC were becoming strained. To quote, the

Basic Advisor, SMC, reasoning that Fortune had significantly altered their base software, released its own version of the original base under the name Thurrowbred business accounting. Rumors of bad feelings

between the two companies abounded, end quote. That's from, of course, my man, the basic advisor in his retrospective of the 1980s. Fortune was having issues with their business, and SMC was also having issues with their software division. Both were losing a lot of money in 1983.

But regardless, this is where the name Thurrowbred enters the picture. SMC was using it to sell their original software and bypass OEM sales. And that's around the time John L. Johnson would leave SMC. He only had to work three years after the buyout, so he was ready to get out. Apparently, he only stayed for one extra month before he quit. According to an interview with the Courier News, John L thought SMC was too conservative, too slow-moving. To quote, Nobody would shoot the ball.

They kept dribbling it. What I really like to do is shoot the ball a lot, or be associated with people who are shooting the ball, end quote. I can't do the voice right, but it's noted in all of these interviews that John L has a very thick Texan accent. Fed up with SMC and their lack of, quote-unquote, ball-shooting, John L left, and he found a new company called Concept Omega Corporation. Again, we get another name that sounds like a shell company to me. But I do like Johnson's scrappiness here. the dude kind of just liked starting businesses. He would use money from SMC stock to start Concept Omega.

And apparently that didn't sit well with some folk. From the Corrier News again, quote, Somebody said to me, Johnson, if this was your money, you wouldn't do this. When someone says that to me, I say, get a ringside seat and watch me, end quote. Again, to be clear, all delivered in a thick, notable Texan accent. I think next time someone says I have a bad idea, I'm going to tell them to watch me. Anyway, Concept Omega is a software company. They do, well, something involving software. It's a little bit fuzzy to begin with. By 1984, we know that Concept Omega is selling software

that works with Business Basic. These are plugins. The one that we do know about, is called spell concept. It's a spell checker that can integrate with word processors, presumably using Business Basic. Again, it's not that clear, which is a little frustrating, but what do you expect out of a company that has a name like a shell? In this early period, John L also brings more former SMC employees into his company. By 84, he has at least 12 former SMC employees at Concept Omega.

This is paving the way for a larger play, perhaps intentionally or maybe by accident. In 1985, Concept Omega buys out SMC's software division. That includes Business Basic, Idle Bass, and a number of old DTI employees that had stuck around from the previous merger. And just like that, John L. has vertically integrated his business and bought back his original software. This also brings in the thoroughbred name.

Technically, SMC had been selling Business Basic as Therobred Basic. And this is where we reach the mystery. In the years between SMC's acquisition of Idle Bass and Business Basic and the

concept Omega Buyout, a new product had been created. That product was Thurrowbred operating system. For the true strangeness to make sense, we need to take a bit of a step back to look at the larger picture. In the 1980s, there were a number of competing versions of basic designed for business applications. SMC was only one player in this space. What's kind of strange is many of these basics ran under Unix.

That's strange because Unix is the home of the C programming language. usually, if you're on Unix, you're right in C. So it's odd to see another language come up unless it's super special purpose. These business basics were just that, highly specialized. SMC's Basic worked with idle bass to create a larger platform for, well, boring back office tasks. If you remember our RPG episode, then this probably makes sense. Business users have oddly specific off-spec requirements for computers. They don't really want a computer for the compute power.

Instead, they need appliances that can do payroll. That's the niche we're in right now. As the PC enters the picture, we see a C change. And, well, a C change. There's a good joke in there, I swear. The PC isn't initially a C platform. It's kind of its own beast. There are many languages vying for space, and that does include Basic. The PC hits right in the middle of SMC's run with Business Basic, so the language gets ported to the new platform. Businesses were adopting the PC as a cheaper

alternative to Unix workstations, so SMC had to be in that space. Then, how does this turn into an operating system. And how does Concept Omega's new ownership matter here? In 1984, PCMag ran an article comparing different basics for business users. From that article, quote, SMC's entry in the race, Thurrow Bread Basic, is a fine example of a product produced by a much larger company. SMC is a large, large like Microsoft, not large like IBM, software house that has been writing business basic interpreters and other business basic products for some years. The article continues.

Instead of writing a language to run under MS. DOS, the company took the view that the PCXT is fully capable of being a multi-user small business system. To achieve this, SMC wrote an entire operating system, thoroughbred OS, that supports two additional stations on a PCXT. You can run the system on a regular PC, but it is of little value because floppies can support only primitive utilities with thoroughbred OS. It is really intended for a PC-X-T, watching three users work on the same diskette simultaneously is a site to behold."

That, on its own, makes SMC's product different. It's a full operating system. What does that matter? Well, let me count the ways. Most of these similar basic products run under another operating system. The same PCMag article compares ThurroBred OS to a product called Soft Gold Basic. That one runs as a Microsoft DOS application. If we look further feel, we find options like GW Basic, which is also an MSDOS program.

There's also the classic IBM Basic. Originally, the PC shipped with a version of Basic burned into its ROMs. If you boot up an IBM PC without anything in its floppy drive, you'll be dumped into a basic prompt. That, I guess, is technically an operating system, but it's not super capable. It's that capability piece that's key. If a program runs under an operating system, then it becomes subject to certain rules and regulations. I think the best way to explain this is to cover how Microsoft DOS loads a program.

Don't worry, this is pretty simple, and it's the most contact that software has with DOS. So let's say you want to run Doom. You boot up DOS and you type, well, Doom. DOS then goes and looks for a file that is named D-O-O-M with a suitable file extension. Specifically, it's looking on its disks. Those disks are formatted as some kind of fat, FAT. That's the file system that DOS understands. A little implication here is that the program files have to be stored in that file system. It's a subtle thing, but it will have an impact later. Once DOS finds the right file, it loads it into a specific location in memory. crucially, Das itself is also in memory, and it stays there while Doom or something else is loaded.

Then, Das jumps to wherever it loaded that program and starts running Doom. Once Doom is done with whatever it wanted to do, it calls out to tell Das everything's over, and then Das starts running again. A few important notes here. First of all, Das is always taking up some amount of memory. It has to. If your program ever overwrites that special memory, the computer could crash. More importantly, DOS registers a number of interrupts when it boots up. Those are used to hook into certain errors and events that can occur on the PC,

and to provide an interface for resident software like Doom to use. Most of that interface doesn't really matter. The services DOS provides to the programmer are pretty minimal. The one that's important is file system access. DOS provides helpers for reading and writing files from disk, but it's only for the fat file system. Why not just write your own code for handling files? Well, you could, but that leads to a bit of a problem with practicality.

Let's say you load off a floppy disk. That's using the fat 12 file system. If you want to use another file system, then you have to ask the user to switch floppy disks. That's annoying. It also means that you have to have all of your own code for handling files, which is pretty complex. If you're working off a hard disk, then you have more options. You can have a special partition, but then you start to get into pretty complicated setups. If you run under DOS, you really want to be working with fat.

and for that matter, you really want to not get too picky with memory or interrupts. That limits what you can do, but only on the edges. You need a really good excuse to break away and do your own thing. So what could make SMC break from DOS and create their own operating system? How can I even answer that question, really? What we do have to go off is how Thurrowbred OS was pitched, and a couple of manuals. That's about as good as we get this episode.

The short answer is that SMC had produced something significantly more sophisticated than Microsoft DOS. For that to really work, it had to run as its own operating system. It wouldn't have made a lot of sense for it to coexist with DOS and try to play nice. For the long answer, we need to look at the actual features of Therobred OS. to quote from a 1984 ad for the operating system. Quote, If you own an IBM PCXT or upgraded PC, why not multiply its usefulness

with Thurrowbred OS from SMC software systems? Thurrowbred OS is a multi-user operating system designed to provide true multi-user support by enabling three users to run three different applications simultaneously, yet independently. The ad copy continues. Applications developed under Thurrowbred OS are portable to Unix, trademark. Thus, you will never have to rewrite your applications, end quote.

The ad copy is not the most assertive here. But this is the core of the offering. Thurrobrad is multitasking and multi-user. It multiplies the power of your PC, in a way that Microsoft DOS just simply can't. Why is that so impressive? Well, allow me to explain. The IBM PC is a very single user kind of machine.

A pretty normal configuration for a PC includes a single monitor and a single keyboard. Those devices are hooked directly into the machine. The monitor is plugged into a graphics adapter that's memory mapped, meaning you have a special region in memory that stores what's on that screen. You have one special region in memory. That's not dictated by software, it's dictated by how the PC is designed to handle graphics hardware. You can't just plug in a second monitor into the PC and have it act totally independently. At least, not under normal circumstances.

There are some edge cases where you can have a multi-monitor set up with a PC, but it's very fringe. You also can't just plug in a second keyboard. That, well, that just doesn't work at all. There's one keyboard plug and it's soldered directly into the PC's motherboard. You don't have an option there. Then, how can you have multiple users? Why, using terminals, of course.

Thurrowbred OS turns a PC into something much, much more. It makes the machine closer to a server. you throw in a few serial cards to add extra serial ports, then you hook up some terminals to those ports. Now, three people can use a single computer. Hopefully that answers the question of why this couldn't run under DOS. This is a completely different beast than Microsoft DOS, and it needs a lot of resources.

But how useful is this? Well, that gets complicated. This is very, very similar to older time-sharing systems. Those work by slicing a computer's time up into multiple segments. If you have three processes running, then the computer switches between those three processes. If done correctly, then each process gets one-third of the computer's time. Each process gets a third of a computer. That should sound like a bit of a mixed bag.

You don't ever have a guarantee of the computer's full power. Things get better if when you add the human into the mix. A user doesn't spend 100% of their time running a program. You take a wild type. You sit at a terminal thinking and worrying. You get up and you grab a snack. None of those processes actually involve computing power. And your view of time is a lot more slow than the computers.

To the computer, an instant is made. measured in thousands of a second. That's too fast for us to notice. So the initial proposition of sharing third slices of a machine actually gets a little better. There's flexibility. In practice, this just means each user will have at least one-third of the computer's time at any given moment. You can end up with the whole machine's attention pretty often. But this is complicated. Consider the platform in question. Most time sharing systems were on larger machines. We're talking IBM System 360s, PDP 10s, PDP 11s, HP, some things. Here we're talking about the IBM PC. So how much power is there to share? And more importantly, how much power in the context of other time sharing machines

are we talking about? There are a lot of possible factors of play here. So let's just ignore all of and pick a nice magic number. I'm going to use instructions per second, usually expressed as MIPS, millions of instructions per second. That's just how fast a processor can run through instructions. It's a very rough measurement of speed, not necessarily performance. For that, you'd need benchmarking, but good luck finding applicable benchmarking for time sharing on the IBM PC versus time sharing on a mainframe. That's just not out there. The Intel 8088, the processor inside an IBM PC, was clocked at 4.7 megahertz. In that configuration, it ran a whopping 0.33 million instructions per second.

0.33 MIPS. That's kind of garbage. It's actually slower than some contemporary Intel processors. Some IBM 370s made in the same period performed at 0.7. Mips. A deck Vax 11 is closer to one Mips. A Xilog Z80, an 8-bit chip from the last generation of processors even outperforms the 8088. The Z80 has 0.58 Mips. So your one-third share of a PC is actually not a whole lot. Doing the math, you end up with worst case, 100,000 instructions per second. That's not exactly exciting. What I'm getting at is this. The value proposition here is a little

off. If you run the numbers, then you do save some money by buying an IBMXT with two terminals and two serial controller cards. This setup is possible, but it's not really how IBM designed the PC to be used. These were personal computers, not underpowered minis. If you're running them as just a personal machine, they have some respectable oomph,

but when you start sharing them, that kind of evaporates. It just doesn't line up with the design. Sure, you could do it, but at the cost of performance. There's also a bit of an elephant in the room here. That's the second part of SMC's sale pitch in that ad. Software written on Thurowbride OS can run on Unix.

This, I think, is key to getting us closer to an understanding of what's happening. Thurowbrad OS really does one thing. It runs these larger Business Basic applications. It runs Thurowbride Basic, aka Business Basic plus Idol and Bass and some other tools. SMC and later Concept Omega sell a version of ThurroBred Basic and all of these same tools that run under Unix. At one point around, I think 86, John L even claims that Unix software makes up a near majority of their sales. So that's the compatibility aspect. Basic is basic is basic, at least in this one product line. So Basic written on Therobride OS will run on Unix.

But think about that statement for a second. Who are they selling that compatibility to? Let's go back to that PCMag article I mentioned earlier. The reviewer suggests that Thurrowbride OS is useful for new businesses that want to tap in to existing business basic software. Put another way, it flips the script. It's not that a user would want to use Thurowbride OS to write software to run on a Unix machine. Rather, that Thurrowbred OS lets a user run all this existing software that was written

under Unix. See where we're going? The value proposition here is very similar to that of something like Xenix or some other PC Unix. By using this magic operating system, you gain access to all this pre-existing code. It opens the door to all kinds of possibilities. And since everything is sent around its source code, well, you can even edit all that software. But the timeline makes things kind of break down. By 1984, the year this OS drops, the PC is already a very popular platform. That means the PC has a lot of its own software. Lotus 1,23, the premier spreadsheet program on the PC, is a year old at this point.

Wordstar, a pretty well-loved text editor, has been ported. to the platform for a number of years. There's another more subtle factor at play here. All of these programs were distributed as binaries. As to say, you didn't get the code. You as a user would get Lotus 1-2-3 as a program file that ran under DOS. It was already compiled down to bits. That was the standard distribution method on the PC.

Software came as binaries that ran under Microsoft DOS. That's part of why the compatibility aspect of thoroughbred OS doesn't really take off. It just doesn't really make a lot of sense in this climate. And this isn't limited to thoroughbred. I think this also extends to Unix on the early PC.

DOS software came as binaries and it came very quickly. Very early on there was some power behind the idea of tapping into existing code. But as the PC ecosystem grew at a rapid pace and as binary software became the default, compatibility, well, it wasn't as exciting.

Pair that with the power of DOS being the default operating system on the PC, and, well, I think that paints a pretty convincing picture for me. And that's what's so weird about Thurobred OS. It has all the pitfalls of early PC Unix, plus basic for some reason. Now, you may be inclined to think I'm saying Thoroughbred OS is a basic themed Unix, or that it's very Unix-like. That's not true at all. I'm saying that the circumstances around Thurowbrad on the PC feel similar to those of Unix on the PC.

Technically, Thurrobride OS is very much its own thing. I wish we had something like an oral history or interview with some developers here. The best we have is a set of manuals for Thurrowbred OS version 6.6.2. But that's enough to see that, well, thoroughbred is its own thing. The tasking model is an easy example. Initially, Thurowbred supports just three simultaneous users. By version 6.6.6.2, it's up to 16. And from what I gather, you can technically run 37 tasks at once.

Those tasks are broken into three possible types. System control tasks are higher priority tasks that manage low-level processes. Those can be user-initiated, and it sounds like they have higher privileges. User tasks are the normal processes that a user runs. This is where something like Thoreau-Bred's text editor would run, or idle base would process business data. Ghost tasks are background tasks, those that aren't bound to turn. terminal and all that. These aren't just names for different ways processes can act. These are actual technically distinct things. In the Unix world, each process has a thing called a process ID or

PID. That's a number that's assigned to a process when it starts. In Unix, those are just plain numbers, zero through, well, however tough your computer's feeling that day. In Thurrowbred OS, users' tasks are defined as T0 through TF, with T0 reserved for the system task. Ghost tasks are identified as G0 through GF. Then there is some special identifier called SY for the quote-unquote synchronous communication task. That's just different. Under Unix, or most multitasking operating systems for that matter, a process is just a process

is a process. Any special treatment is handled by metadata. Maybe you have some higher or lower priority processes, but that's just noted in the big process table. Everything is still just one type of entity. But that's not the case for thoroughbred. The operating system also has its own file system. Now, the details aren't really clear. We just have the manual, but I can guarantee it's not like other file systems. The Winworld PC Spotlight article describes the file system as 10 configurable directories that work almost like mounted disk drives. If that's too technical, then, well, let's just go back to Thurobred OS being its own thing. This is where we reached that unknown sense that I talked about.

There are these things called language products, and they've always been really weird to me. Therobred Basic sounds like this kind of software, but I'm not entirely convinced. So what is a language product? Well, these are programming languages and tools that you buy from a vendor, you know, with money. I'm so used to a world where compilers and assemblers and debuggers are all free. My favorite assembler is Nassum, the net-wide assembler. Now I know I'm outing myself as an Intel syntax.

dude. Nassim is free. It's an open source project. You never have to pay a cent to use NASM. The same is true for tools that I use professionally. VS code, my development environment of choice, is free and open source. Vim, my other development environment of choice, is also free and open source. I've never paid any money for a single programming tool in my life. This lovely lifestyle of mine is possible because of the rise of free and open source software. That's free isn't freedom, not free as in beer. That matters because programming is ultimately egalitarian. At least that's the point of it, right? If you have a computer, you should be able to program whatever you want just as well as anyone else. I think that's super important to the integrity of the field.

It's an important idea that we should strive for, and it's one that currently exists. That hasn't always been the case. I'm getting to a point, so just let me ramble here. Have you ever heard of the great unbundling? Long-time listeners, true evidence of computing fans have. This was an action taken by IBM in the late 1960s to muddy an antitrust trial. Way back in the day, IBM used to bundle, hardware, software, and service. If you leased an IBM mainframe, you got free software and free

servicing, or at least it was all bundled into one fee in your bill. If you need an accounting package, IBM would give you one on the house. If you needed some special purpose program for running a new kind of CNC machine, IBM could write that for you on the house. That was free, but free isn't beer, or at least free like the beer your buddy hands you. When the first 4-Track compiler was developed, it was distributed this way. IBM customers got a free compiler.

They got access to a new programming tool on the house. This was actually illegal, or rather, how IBM handled this was a violation of antitrust law. You can see my System 360 series for the long story. basically IBM unbundled because they knew they were about to be sued by the Department of Justice for antitrust violations. They cleaned the house right before the lawsuit because they knew that they were going to get hit.

The knock-on effects of the great unbundling were for-profit software companies. IBM was now selling software, like the Fortran compiler that used to be free. It sold for a real dollar value. that meant that other companies could spring up and compete in that sector. Thus, you could sell software. That gets a little odd once you get into the concept of a language product. When you buy Fortran from IBM, you get a manual and a compiler. But does that sale include the defined programming language itself?

Or is the language its own thing? You're buying the tool that converts code in some language, into a binary. Does that sale include the concept of Fortran? Can anyone own a language? What makes these questions a little bit moot is the fact that different compilers and tools spring up and all support their own language. Basic is the perfect example. Different versions of basic runtimes support slightly different versions of Basic. Dartmouth Basic isn't entirely the same as HP Basic, which isn't entirely the same as Altar Basic. Plus, whenever folks start claiming they can own a programming language, things tend to go poorly

for them. Case in point, Calvin Moors was pretty sure he could own the specification for the track language. His actions to prove that kind of led to no one using track. All this is to say, language products fit a very odd niche. There's only really a limited period where, language products are viable as, well, products. It's between the unbundling and when we hit this point where free and open source software really picks up steam. And even then, there's a limited audience. Take Unix as an example.

When you install Unix, you get a C compiler. That's a free language tool. It's totally open source. Even before that was a real concept. It also comes with a debugger. And a text editor? Why would anyone buy a compiler on Unix when you're handed a free one by default? The only reason would be if someone had a language that you wanted more than C.

We see the same thing on early home micros. You buy an Apple 2, it comes with Basic. That's a free language tool. Why would you ever buy another tool for the Apple 2? Well, it would have to be basic at something. We can also look at the Altair 8800. That came with no tooling. You had to program the thing with switches and blinking lights.

A front panel is cool, but it's not a tool. Microsoft was able to sell their basic interpreter for the Altair 8800 because it offered a value proposition and a good one. It was a language product that beat the Altair's front panel. How does Therobred fit into this structure? Thurobred feels kind of like a language product, at least at first glance. There are two sides of the picture. The thoroughbred series of software includes idle, base, basic, and then this whole weird operating

system thing. All that software was, for the most part, meant to run under Unix. We know from interviews that Unix software made up a large part of concept Omega's sales. We're talking specifically 45%. We don't know about the SMC period, but I assume it had a similar split. We also know that those Unix users really liked thoroughbred products. How do I know this? Well, allow me to reintroduce Fortune Systems and the Basic Advisor.

Fortune computers ran Unix and were bundled with Idle Bass and Business Basic. The Basic Advisor is actually on the reporting beat when Concept Omega buys out SMC's software division. The reaction developed slowly. At first, the Basic Advisor says he called John L on the phone and had a good talk and got, quote, good vibes about the deal. By 1990, we see a more rosy picture. The Basic Advisor sings the praises of Concept Omega for two reasons. One, they bridge the divide between Fortune's modified version of idle bass and thoroughbred software.

Concept Omega helps make Thurrowbred the default version for all these packages. And second, Concept Omega actually provides support for the community. That includes hosting conferences. The key part here is that Concept Omega takes a more active role supporting their OEMs and users. That matters because this is all part of the larger value proposition. On Unix, these thoroughbred packages have to fight against C. Why can they even have market share against a free tool? It's because they have a niche.

Thurrowbread is targeted very specifically at business users, and they keep courting those business users. There is one more factor that I've been keeping a little hidden, and I think it makes the whole picture a lot more clear. You see, it may be unfair to think of Thurrowbred OS as basic at all. That's kind of just the headline. But check this out. Concept Omega doesn't really describe ThurroBred OS as just a basic language product.

If you look back at the SMC ad for the operating system, it actually only says basic twice, and it says so offhandedly. Each time it just says, oh, Thurrowbred OS can run Basic. How neat is that? It's a multi-user multitasking operating system that runs on your PC, and it can run basic. Thurrowbread OS is sold as a business package. Just like the rest of the thoroughbred line, it's a programming tool, but it's also something different. You have to go to page two to get a better description. I mean that figuratively. The ads only one page. In contemporary articles, thoroughbred is often described as a 4GL. That, my friends, ain't C. 4GL. 4GL,

stands for fourth generation language. Well, what in the world does that mean? That tells you nothing, right? Let's do a crash course. First generation languages are machine code, the raw hexadecimal you feed into a computer. Second generation languages are assembly languages, slightly abstract, but still very low level. Third generation languages are, well, what you would usually think of as a programming language. C, JavaScript, Python, Java, Lisp, that kind of stuff. 4GLs are even more developed, higher level, so to speak. A 4GL is usually specialized, usually closer to natural language, and usually meant to be

easier to program in. SQL, structured query language, is probably the best known language in this category and the only one that many people will ever encounter. Normally on the show, I don't use these generational terms. This is, in part, because this type of generational classification fell out of style by the 1990s. I don't really like this system because it doesn't make a lot of sense. As an aside, it's probably a neat topic for another episode. The system makes sense in the context of, well, really only one generation, 4GLs. It makes sense to have some special category for these types of languages. 4GL, as a term, does that, but it also kind of sucks because it implies that you can fit

every other language on this generational scale. That doesn't really fit well because languages tend to be slippery. SQL is a really good example here, so let me run with that. Going down the list, SQL is special purpose. It's only used to manipulate data in a very specific type of database. Another way to put this is that SQL is highly domain-specific and it's tied to an application. You can't use SQL to do everything. In practice, SQL is often used just for data management in a larger program.

So you'll often see a program that uses, say, C++, and SQL at the same time. SQL has English-like syntax. How do you get a list of databases that you can access? Why? You just type, show databases. Want to use a specific database? That one is use database. Simple.

SQL also uses very limited non-alphabetic characters. But another way, you can basically read an SQL statement like an English sentence. I've often shouted SQL statements over phone calls, in fact. 4GLs also tend to blend language and tool. SQL in isolation doesn't work. It has to be used in conjunction with a specific kind of database program and a specifically structured dataset.

So it's a language with all this other stuff around it. Thurrow bread as a series of software fits this mold very well. It's a database, a tool for making screens and menus, and a programming language. That's classically 4GL stuff. What's neat here, and the reason this is so perplexing to me is basic. Thurrowbread's language is a version of basic. So it's easy to just say it's basic when actually the basic here is just a complete. component of a larger 4GL system.

See the extra weirdness here? Is Basic a 4GL? This is exposing what I don't like about the generation classifications. Basic is most often called a third generation language, a 3GL. It's not specialized, it's not domain specific, but it does use English-like syntax. In fact, you can read a line of basic aloud as if it were an English sentence. So where does basic land? Well, it's a, it's a 3GL with some aspects of a 4GL, so why are we doing this dance exactly?

The generation thing feels, to me, like a handy thing to put on programming language trading cards, or, again, just to have a big bucket for all of these 4GLs, but let me digress. Thurrow bread in general feels weird because it doesn't fit into an established mold in modern computing. 4GL still exist and are in use, but they're very domain-specific. Most programmers will only ever run into SQL. So when you see a 4GL system, if you're the average programmer, you're going to get confused. It's going to look strange and not make a whole lot of sense. Basic is this further complication.

When you see Thurrowbride OS, it's an operating system that runs Basic on the IBMPC. That's shocking and strange. But it's more complicated than that. Basic here is used as a programming tool and an interface that's part of a 4GL system. So is Thurrowbred OS a language product? Yes.

It's also a database. It's also a system for creating menu-based user interfaces in form. It's a collection of tools that only are really possible in this very specific period, and this is kind of at the tail end of the period. That makes it perplexing and fascinating. If someone tried to sell this today, I don't think they could get very far, but it's interesting to see that it ever existed. All right, that's the end of the episode, but not the end of the story.

Thoroughbred OS remains pretty mysterious for a few reasons. We only have disk images for one version of the operating system, first of all, and secondly, we don't even really know who wrote the thing. We just know it was part of SMC's holdings when they were bought out. So here is my call to action. You can go to Winworld PC and download disk images for Thoroughbred OS. They're in a custom file system so you can't extract them easily. But you can load them into an emulator and run the operating system.

I was cruising the images with a hex editor, and they do contain a bunch of basic code. It should be possible, somehow, to extract that code. I'm willing to bet if you read enough of it, you could find information on its authors, or at least some mark left by the programmer. We programmers love to leave little tricks and signatures. So I really think there's some fertile ground to till there. Anyway, that's it for now. Thanks so much for listening to Advent of Computing.

I'll be back in two weeks with the next episode. You can find links to everything at Aventofcomputing.com. And as always, have a great rest of your day.