Advent of Computing - Episode 98 - The Canon Cat

Episode Date: December 26, 2022

This time we are looking at a somewhat obscure machine: the Canon Cat. Designed by Jef Raskin, the Cat is sometimes called the spiritual successor to the Macintosh. That's a nice little epitaph, but doesn't fully explain the tangled mess of things between Raskin, Jobs, Apple, and the Mac. Today we will try to untangle some of that mess as we examine a fascinating little computer that could have changed the world.   Selected Sources:   http://www.canoncat.net/ -- Everything about the Cat   https://archive.org/details/Apple_Mac_Selected_Papers_1980/ -- Raskin's Macintosh memos   https://www.digibarn.com/friends/jef-raskin/writings/millions.html  -- Computers by the Millions

One of the prophets of the personal computer industry, Alan Kay, has said that the true personal computer has not yet been made. I disagree. We have, as the ancient curse warns us, gotten what we asked for. We do indeed have computers being bought by individuals for themselves. They are personal computers. The problem is that many of us didn't want computers in the first place. Computers are merely boxes for running programs. We wanted the benefits that computer technology has to offer. What we wanted was to ease the workload in information-related areas,

much as washing machines and vacuum cleaners ease the workload in maintaining cleanliness. Jeff Raskin, from Information Appliances, a new industry. It can be really easy to get caught up in the how of computers. How do you make a faster processor? A better programming language? Maybe a cooler user interface? How questions are tantalizing and, at least usually, relatively easy to answer. You could speed things up by switching to some newer type of silicon doping. Maybe your programming language does need to use explicit typing after all.

And your interface, well, run some kind of focus group for that one. Why questions, on the other hand. Those suck. Back in my college days, I had a physics professor that would always tell us that scientists never try to answer why questions. Usually because it's very difficult and the answers will always be underwhelming compared to the work you put in. However, I think it's important for us to look at the why precisely because of this difficulty. The biggest why of all may be,

why do we use computers? Your answer will vary depending on who you are. A programmer uses a computer to program. An accountant uses a computer to run spreadsheets. A scientist probably uses computers to apply for more grants. But what about a quote-unquote what about a quote-unquote normal consumer? What about the people in the streets? Why would someone in 1979 just decide all of a sudden they want to buy a computer? Jeff Raskin would spend years of his life grappling with that question. The answer he arrived at was that most people wanted a type of labor-saving device, a new appliance powered by silicon. The answer would lead him down the path to developing a truly unique machine.

Welcome back to Advent of Computing. I'm your host, Sean Haas, and this is episode 98, The Canon Cat. Today, we're breaking one of my rules, but I think it's going to be okay. Usually, I only cover topics that occur in 1984 at the latest. That's kind of my cutoff. The official reason is that after the Macintosh, things seem to get a little samey. It's all recent enough that a lot of people remember events.

We all end up kind of using computers with a mouse and Windows on a nice bitmap display. The more technical reason is that I don't want to make myself feel old, so I try to keep my topics as firmly away from my lifetime as I can. This episode is going to bring us up to 1987, but with some good reason, and most of the episode is going to be well within my usual timeline. We're going to look at the Canon CAT. It's a fascinating computer that doesn't really feel samey at all. I think the CAT gives us a possible alternative path for personal computing.

It's just that it may have come a little too late to the game. So, what is the CAT? That's a surprisingly slippery target to hit. Some say it was the spiritual successor to the Macintosh. Some say it was what the Macintosh should have been. These claims are due to the fact that the cat's designer, Jeff Raskin, also designed the iconic Macintosh. At least, he was the one that started off managing the project. The actual history here, as with most Apple history, is a much more twisted web than you'd expect. According to others, the cat was just a word processor, simply a souped-up digital typewriter. In fact, it seems that a lot of consumers of the day saw the cat as just a fancy typewriter.

The machine was so much more than that, but it just couldn't get past perceptions. Or maybe it was sabotaged from the beginning. Canon discontinued the cat after just six months on the market, so few would actually meet this feline face-to-face. This combination of pedigree and elusiveness has made the cat something of an item of wonder. Usually when I cover a computer from this era, I get the urge to see if I can actually track one down. When it comes to a Mac or some old IBM machine, you usually can with some notable exceptions. But with the Cat, well, it appears to be unobtainium. There were just so few of these

machines made, and the ones that are still in existence are coveted by collectors. So, what really was the cat? Well, if we listen to Raskin, then it was an alternative take on personal computing. A third option that would eventually fall somewhere between the Macintosh and the PC, if you will. But what does that actually mean? How would you redefine the personal computer after, well, the PC? After the Macintosh brought the graphical user interface to the market, how could you compete with any other interface? Well, you'd have to get radical. You'd have to reimagine some old ideas and mix in some new magic. For this entire episode, we'll be following the life and times of Jeff Raskin, so a little background will probably go a long way. The easiest way to describe Raskin's pre-Apple

life is mixed. He had multiple degrees and almost degrees in fields ranging from math to physics to music to computer science. He taught art classes at the University of California, San Diego. Do note that this will be another case where an interdisciplinary background leads to interesting pursuits. Be advised that this is a pattern. Raskin would orbit around Apple for a number of years. Sometime in the mid-70s, Raskin formed a company called Bannister & Krum, although it was probably more an entity for convenience than an actual company. The two Steves would contract with Raskin to write the manual for the Apple II. That would have happened sometime in early 1977. The next year, 78, Raskin officially

started working for Apple as a full-on employee. This is, perhaps in a twist, where the story of the Canon cat actually starts. The new job dropped Raskin into Apple at a bit of a weird time. The Apple II had just struck it big, so the company was on the rise. The next step was to make some kind of follow-up. But what? There were a few projects floating around inside Apple at the time. Two of these projects would end in failure. One was a computer called Cero, which was eventually renamed the Apple III. This was essentially an upgrade to the older Apple II, but there were some changes. It turned out that those changes were, by and large, poor design decisions. Plus, the 3's higher cost ended up dooming it.

The machine had this reputation for not using fans for cooling, which resulted in, in some cases, in solder melting and the computer ruining itself by simply running. The more promising contender was the Lisa, Apple's first attempt at a graphical computer. It was largely a ripoff of Xerox's own graphical machines. The Lisa was a massive leap forward in the consumer space. It represented a whole new way of doing things on a computer. It was the first time a consumer would ever see a mouse. The leap was possible thanks to a blend of flattering imitation of Xerox and straight-up intellectual property theft.

But hey, it was still a jump in a promising direction. The Lisa, though, never struck it big. It was also mired by some poor design decisions and a huge price tag. Internally, Apple was pretty optimistic about the 3 and the Lisa, but the price issue was well known quite early on. It was decided that there should be a cheaper option in the mix. As early as 1979, a third project was started. It was called Annie, giving us a nice trifecta of codenames. The man heading up the Annie project was Jeff Raskin. The main goal of this project was simple. Create a $500 computer for the masses. It was a challenge that Raskin seemed excited for. The then-in-development Lisa would end up with a sales price just under $10,000, so the target price for Annie was

ambitious to say the least. By the last quarter of 79, a new machine was taking shape. This is also when we get a new name, from an internal memo penned by Raskin himself. To avoid using only female names on projects, it has been suggested that each major project be assigned the name of a variety of Apple. To begin with, what once was the Annie project is now called the Macintosh Project. End quote. Enter the Macintosh. A small, cheap, and easy-to-use machine meant for the masses.

If you're familiar with the production model, the retroactively named Mac 128K, then you already know very little about Raskin's original design. One of my first lessons while working on this episode was that the development process for the Macintosh was actually very well documented. Raskin kept numbered memos covering the project's progress. It's a lot to take in, but it gives us this great view into the early phases of the Macintosh. view into the early phases of the Macintosh. My second lesson was I seemed to like Jeff Raskin. The reason I say this is Raskin has a very particular voice that shines through in these memos. He's a real living character, and a pretty snarky one at that. By the time the project was fully named, Raskin had a pretty good outline of the machine. The Mac was

always planned to be an all-in-one computer, or as Jeff termed it, one big lump. However, the level of that all-in-oneness varied. For that to have full impact, let's talk about pits, the people in the streets. Pits were the market segment Raskin was designing for. He wanted the Macintosh to be a computer that anyone could buy and use. Truly a computer that could be sold by the millions. Reaching that goal would be difficult. The price target was one way to market towards pits. A cheap machine would entice more consumers. The other huge part to the strategy was simplicity. For a random person in the streets to accept a computer, it has to be easy to use. The machine has to be easy to set up

and easy to understand. The understanding piece here is what I find so interesting. We had pretty darn capable machines back in 1978. Even the Apple II could do just about anything a normal consumer needed. You could replace your entire office with a single device. with a single device. But there were complications to that view. You had to buy the computer, plus a screen, plus floppy drives, plus software, plus a printer, and maybe some extension cards, maybe some cables, an extra plug. You had to get a whole lot of stuff. An Apple II could be used to do your taxes, but you'd have to set the whole thing up first. A salesperson could point at a fully tricked-out Apple II and tell you it will replace your entire office. But what does that practically mean for an end-user?

To the uninitiated, it's just an expensive pile of parts. To the uninitiated, it's just an expensive pile of parts. There are a number of factors that go into making these early machines incomprehensible to pits. One easy example is the 2's floppy disk drive. A stock computer didn't have any form of external storage. For top-of-the-line functionality, you had to buy a Disk 2, Apple's own custom disk drive. But you can't just plug and play, oh no. Once you get the drives, you have to open up the Apple II, then install a Disk Controller Card.

That's a bare circuit board that slots into the machine, right into the motherboard. For an early adopter or a computer nerd, that's fine. We can figure out what's going on. We understand what's happening. But for someone with no digital experience, that's kind of scary. After that, you have to plug the drive's ribbon cable onto the controller card, close up your Apple II, then plug the other end of those ribbon cables into your new disk drives. That's a lot of futzing around to run VisiCalc or a word processor. A typewriter and some graph paper may not have

been as fully featured, but it would have been a lot easier to set up and a lot more approachable. This leads to an interesting inversion of usual design. Instead of going for a certain type of computer or certain hardware, Raskin started off with capabilities in mind. He was starting with a list of things the computer should do, and then figuring out the how. Those applications were really simple things, like text processing, simple accounting, education, scheduling, storing phone numbers, and programming. The Macintosh was intended to replace everything on a user's desk. A PITS should be able to buy a Mac, come home, and just clear off their entire desk.

To get that to click, the Macintosh had to do this all in an approachable way that consumers could make sense of. The most clear result of this line of reasoning is that Raskin called for an all-in-one design. And I don't mean all-in-one like the production model Macintosh. That thing is only partially integrated. Raskin's original plan put everything inside one case. The computer, screen, keyboard, and disk drives would all be one single unit. One lump with a handle that could be dropped onto a desk. In this formulation, there were only two acceptable cords. The power cord, and maybe a cord connecting to a printer. Even the printer was a bit of a contentious point.

You see, Raskin actually had a few options for how to better integrate the printer. This would have made the Mac an even more dense package. One option, the boring option, was to have an external printer. That's lame and it requires cords, something that Pitts would undoubtedly be confused by. The spicy option was to have a built-in printer. That is full integration. The computer is then an all-in-one office system. Raskin also proposed a bit of a compromise.

A printer that physically attached to the back of the Macintosh. So when a user decided to upgrade, all they would have to do is plug the printer into the Mac, just slam them together. All is still one, it's just become a slightly larger one. Raskin had a number of good reasons for this lump-based design. One was simplicity, yes, but there were more. Another was portability. In the same main design memo, Raskin said it would be cool if the Mac could hold enough batteries for two hours of use on the go. I can't help but think this is due to some outside influence. There were already a few highly integrated computers on the market at the time. The best known was probably the IBM 5100, which

was announced in 1975. It fit a screen, tape drive, keyboard, and computer into one package. It also has a handle. There is a closer comparison to make. The Xerox Notetaker. This was one of the wild sci-fi machines that was built at Xerox in the 1970s. The Notetaker was a project spearheaded by Alan Kay, so it has some truly visionary DNA. We're essentially looking at a somewhat portable version of the Alto. This was a fully graphical machine with a mouse and a bitmap display. The thing even ran on batteries. To cap it off, a prototype of the Notetaker was completed in 1978. According to folklore, this prototype was even used on an airplane mid-flight. this prototype was even used on an airplane mid-flight.

This would certainly line up with Raskin's work on the Macintosh. Plus, Apple was taking a lot of cues, so to speak, from Xerox during this era. Some cues were bigger than others. So we have a graphical computer built for ease of use that's portable and even has a battery, plus a handle. It's a prototype at a company that Apple was familiar with. Raskin even wrote glowingly about Alan Kay during this period. Seems like the note-taker was an obvious inspiration. Well, not so fast. Kay and the note-taker don't actually show up in Raskin's Mac memos. These memos cover the period from 79 to 80.

That's when the portable take on the Mac was fully conceptualized. The omission here is enough to make me discount a direct connection. There's also a fun timeline issue. Bruce Horn, one of the Xerox employees who actually worked on the Notetaker, was hired by Apple and worked on the Macintosh project in 1981. There's also the inconvenient fact that the Notetaker never moved out of the prototype phase. This is going to be an episode of failed projects, the Notetaker is just the first one that we come across. This prototype was shown to Xerox's board,

but they decided to drop the project. It's very unlikely that anyone outside Xerox would have known about the Notetaker. That information would take a few years to travel around, partly spurred by now ex-Xerox employees like Bruce Horn. It would be really nice to just draw a connection between the note taker and the Macintosh, but I don't think we really can. Okay, that was a bit of a tangent on portable computers, so let's get back to the main thread. Remember how we were talking about this all-in-one approach? Well, there's another fun reason for that. Raskin hated cords, and he hated user-accessible parts. This was actually a large part of his critique of the Apple II. Users could crack open the case and dig around in the machine's guts. In many cases, the user was expected to do this. Raskin believed, perhaps rightly so,

that this scared prospective users away from the Apple II. An all-in-one design is nice and clean, and it can also be used to enact this type of ultimate control. This may sound like a hostile approach to take towards the end user. I know I certainly get angry when I can't crack open a case and destroy my own machine. I mean, I bought the thing. I should be able to rip out its guts anytime I feel like it, especially if my hands are dripping wet and it's still plugged in. anytime I feel like it, especially if my hands are dripping wet and it's still plugged in. Raskin's hostility towards user maintenance wasn't coming from a place of spite or hand-wringing evil. Instead, it was all in service of creating a simple-to-use and simple-to-understand machine. When you get down to it, Raskin wasn't setting out to build a traditional computer.

He was at times calling the Macintosh a, quote, appliance computer. This is a term that shows up in a number of places, especially around early Apple. The idea is that consumers don't want one of these fidgety big computers. They want a tool that fills a set of rolls. Something like a really fancy washing machine. When you go to wash dirty clothes, you don't worry about the plumbing, or what kind of pump you have installed, or the type of wiring. You load it up, maybe think, oh gosh, there's a lot more mud on this than I

thought. You add some soap, you hit a button, and you run. You walk away and you stay away until it's over. Ideally, you should only need to hit one button before you leave the room. A washing machine is, in practice, a dead simple tool. The reason for this simplicity, I think, is pretty clear. Everyone can benefit from a washing machine. We all make dirty clothes. We all get more mud on our pants than we initially thought. But very few people are washing machine scientists, aspiring or otherwise. So it would be kind of dumb if you need a lot of education to use a washing machine. That sort of defeats the purpose. It wouldn't make a very useful tool, and it would severely limit who could benefit from the machine. Raskin was attempting to apply

the same philosophy but to a computer. Most people could benefit from some quality software, but few are actual computer scientists. This leads to some interesting takes, but I think they make sense in the appliance context. For instance, from another one of these 1979 memos, quote, there must be a plethora of configurations. It is better to offer a variety of case colors than to have variable amounts of memory. It is better to manufacture versions in early American, contemporary, and Louis XIV than to have an external wire beyond a power cord. And you get 10 points if you can eliminate the power cord. End quote. Raskin really didn't like cords. This might all sound a little weird for computers, but it's a reasonable thing to say about appliances. A refrigerator is a

useful tool in the home. It only has a power cord. You can get them in stainless steel, ceramic, cream, black, blue, with windows, with side-by-side doors, and all kinds of configurations. What if the same logic was applied to a computer? You don't have a new Altair 8800 with an 8K expansion card and a deck terminal. You just have a computer you bought at the store. So far, we've hit two of the design choices Raskin made, cheap and all-in-one. But this goes a lot deeper. We may have a bit of a long episode on our hands here.

On release day, one of the Macintosh's distinguishing features was its use of the mouse. This would be the second high-profile outing for this new pointing device. We've all become pretty used to the humble Puck, but in 1984, there were still some growing pains to get over. There's this great story that, I will admit, I can't remember where it came from. So, take this from my fuzzy recollection. Apparently, at least one person walked up to a demonstration of the Macintosh, was very impressed by the little machine. Then, they went to use the mouse. Instead of rolling it across the desktop, they picked up the mouse and started moving it around midair. Nothing happened. They subsequently left.

This could be apocrypha, or it could just be a misremembering of folklore. But Apple was at least afraid of this type of confusion. To try and stem the tide of angry users, Apple bundled something interesting with the Mac, a small educational package. This included a manual on how to start the Macintosh, a program on a floppy disk that taught users how to use their new mouse-driven computer, and a cassette tape that walked them through the whole process. The cassette is my favorite part since it seems silly at first, but it's a pretty smart fix.

A new user may not know what a floppy disk is, but they probably know how to handle a cassette. The tape tells them how to use the disc and from there provides some nice audio commentary while they run the educational software within. That all sounds pretty complicated. So let me ask you a question that I believe you're now equipped to answer. Was the mouse part of Jeff Raskin's original Macintosh design? I'll give you a minute. Pause the episode if you want to think about it.

Are you back? Alright, the answer is no. No way. Give yourself one point if you were right. Interestingly enough, I don't think Raskin initially hated the mouse or anything. He's usually pretty vocal about his opinions in his memos. Instead, he just didn't think a mouse was that useful. It complicated things, which ran counter to his core design goals. The Mac was intended to be a keyboard-only affair. Yeah, Raskin was impressed by what was going on at Xerox. Everyone was, but he just didn't want to use a mouse on the Mac. It complicated the computer considerably, which went against the core mantra that he was all about. It also meant another cord, another peripheral, and it meant that the computer would be more expensive.

And it meant that the computer would be more expensive. There's also just that whole confusion factor, a very real concern that Apple had to spend time and money addressing once the Mac went into production. No one knew how to use the mouse. At least, the usual pits didn't. When faced with a mouse, a user's first instinct was confusion. What is it? There's no analog outside the digital world that makes sense. A keyboard, on the other hand, is a very known quantity. Most folk had seen some typewriters, or Gasp even used a typewriter. A keyboard is literally just a digital version of that very well-known machine. You press a key, and it either types the letter or does what the key says.

That's easy to understand and very approachable. The mouse also incurs this whole new cost to the project. It's not just a peripheral device, it's also totally custom. Now you have to spend blood and treasure designing a mouse, getting molds made for its housing, testing it, doing quality assurance, the list just goes on. The mouse alone becomes its own side project, and that's just not worth it. Raskin was still trying to build to a cost. So for all those reasons, the mouse was out. This means that the whole interface for the Macintosh was based around the keyboard. Your first assumption may be that this means a traditional text interface, a simple shell,

but that's not the case. Raskin envisioned this mix of graphics and text. Some commands would be typed out in certain places, while other controls were handled by keystrokes and special buttons. In this way, Raskin was hearkening back to a bit of an earlier system, something like NLS, which only really used a mouse to move a cursor. In NLS, most operations were done by selecting something with the mouse, then punching in a command on the keyboard. The Mac would end up having a cursor, it just wouldn't be moved via a mouse. The early Macintosh was also intended as an easily programmable machine. That might seem a little counter to the whole person-in-the-streets marketing thing, but stick with me. Raskin had a very ambitious view of

computing. At the beginning of this whole project, Raskin wrote an article titled Computers by the Million. It was a discussion of what it would mean to bring millions of computers to the market. One of the outcomes Raskin proposed, in fact, an important part of digital adoption, was that everyone would need to become a programmer. To quote, This is not the place to discuss techniques for easing the average user into programming, but it can and must be done. If not, the computer will become a mere appliance, at best performing a small number of possibly related tasks. What is desired is for the computer to become an appliance, but not a mere appliance.

Its presence must be taken for granted by its user, but in the long run, the act of programming itself must be taken for granted as well. The needle would have to be moved. The best interface for using a computer isn't a mouse, or a slick graphical interface, or even hypertext, but programming languages. Once you get down to that lower level, you can do anything you want. You just need a little bit of practical know-how. To really get computers rolling at full force, pits would need to be converted into computer nerds. To make that possible, Raskin planned to make the Macintosh self-hosting. That is,

he wanted a programmer to be able to develop Mac software on a normal Mac. No special software required. This isn't just the sentiment of an old crusty man. Raskin isn't bemoaning how all kids these days don't know how to program. He raised a darn good point here. Programming is the best way to control a computer. It allows you to extract more utility, more usefulness from your investment. It makes sense even on a basic economic level. But here's the cool part.

If everyone is a programmer, or at least if a lot of users are also programmers, that will make computing better for everyone. Programmers tend to strike out and solve problems they run into. This is done using the one tool they have at the ready, programming. The result is that programmers will have piles of projects, some even completed, that do pretty neat little things that solve little problems for you. Multiply that by a large user base, and you wind up with a massive collection of useful software. We can see this pretty clearly in the overall Linux environment. Most Linux users are bespectacled

nerds who love to program, myself included. As such, you can usually find a Linux program to solve any problem you run into. If not, then you can at least find the start of a solution somewhere out on the web. Raskin was looking at the Macintosh as the cornerstone of a larger change in consumer-grade computing. This new personal computer would draw on some old practices, repackage them with a friendly facade, and bring the world into the larger digital fold. Part of this end-user-to-programmer pipeline involved the system's premier programming language. Raskin's memos are really granular on this, oddly enough. They actually have line items going over possible choices. He wanted to have some consistent language, or set of

languages, that could be used throughout the Macintosh. That would just make things easier. The options he outlined were assembly language, Pascal, and fourth. Assembly was an obvious inclusion. Everything needs some assembly at some point. You just don't get the choice. Pascal is another choice that makes some sense here. The Apple Lisa actually ran a custom Pascal programming environment for software developers, so Apple had some in-house know-how bubbling around at the time.

But Forth? That's the odd one out. It wasn't really used inside Apple. It wasn't even that popular. For now, just know that Forth is in play somewhere inside Raskin's head. The final set of details to fill out here is the price. We've already talked about how the Mac was supposed to be cheap, but how do you accomplish that? Well, the Mac had to be built to a cost, and at $500, that was a pretty low cost. Raskin spilled a lot of ink on this and probably lost a few nights of sleep. One of the core considerations here was the microprocessor, the heart of the machine. There were quite a few options. The Lisa was using this newfangled Motorola 68000, a big 32-ish bit processor. It was fancy and powerful, and it had a price tag that matched. The chip alone was $90 when Raskin was laying his plans.

This would immediately blow the budget. Luckily, there were other options. One was the now venerable 6502, the same chip that powered the good ol' Apple II. That processor was cheap, it was a well-known quantity in Apple, but it was also pretty thin soup at this point. The compromise was the newer Motorola 6809. Compromise was the newer Motorola 6809. This was an almost 16-bit chip that had been announced in 1978, so it still had that new shine to it. Best of all, it cost just $12 per unit in 1979.

That's well within Raskin's slim budget. It didn't address as much memory as the 68000, it still used 8-bit registers, but it would have made a good workhorse. The processor was really the big cost saver in this early design. A cheap processor was backed up with a modest 64 kilobytes of RAM, simple disk drives, a small CRT display, and some in-house parts. It would have been pretty tight, but Raskin figured a $500 bare-bones Mac was possible. The biggie was the release schedule. Raskin wanted to go to market at the end of 1982. If this wasn't a family show, that would have been a great time to swear. I think that if the Macintosh as designed by Raskin came to market in 1982,

it would have totally dominated. As written, it was just a strictly better IBM PC at a better price point. It would have been user-friendly, cheap, and very capable. Just take the price. On launch in 1981, an IBM PC cost over $1,500. That's three Macs. Better yet, that cost is just a bare-bones PC without disk drives. Or a keyboard. Or a monitor. Frankly, it's a bad price point. The PC market only became such a huge thing once companies started building compatibles. thing once companies started building compatibles. The Compaq Portable, the first clear and legal PC clone, hit the market mid-1982. It still had a hefty price tag,

but it presaged things to come. But here's the thing. A $500 Mac in 1982 would have been the thing to come. That would have broken the computer market. I don't think anyone could have competed, especially at that price point. Instead, Raskin's plans were ruined. The story is long and complicated. It all comes down to the worst of the two Steves. And yes, that will always be Jobs to me. As early as 1979, Jobs was already interfering with the Macintosh.

This turned into a full-on hostile takeover in 1981. That's the year Jobs was kicked out of the Lisa project. Who knows if Raskin would have actually made it to market in time without interference from Jobs. That's one of the mysteries that we can never really solve. But by 1981, Jobs was now in charge of the project, and things had to change. In 84, Apple unveiled the Macintosh. It had 128 kilobytes of RAM. It ran off a Motorola 68000. It used a mouse, and it was fully graphical. It was an in-house knockoff of the Apple Lisa. And it sold for $2,400. The machine did prove to be a watershed moment. It was a huge deal. It changed how many consumers viewed computers

and many saw it as Steve Jobs' biggest gamble yet. A gamble that paid off. The Macintosh was important. Don't get me wrong on that point. But Raskin's design would have been just as big of a gamble. I think if the map flopped, we would forever be looking at Jobs as a failure, and Raskin as a genius wronged by dark corporate machinations. But the graphical Mac won both inside Apple and outside the company.

Raskin wouldn't stick around to see his work contorted. He left Apple in 1982 to form his own company called Information Appliances Incorporated. For brevity, we can just call this outfit IAI. Raskin would see his vision through to the end, with or without Apple. The first attempt at realizing this was, perhaps surprisingly, an expansion to the Apple II. What can I say? Raskin knew the platform. I guess the first question on your mind at this point should be, when are we going to start talking about the Canon CAT? Well, surprise!

We have been all along. The secret is that Raskin's CAT is actually an iteration of the original Macintosh design. At Apple, the text Mac made it as far as prototypes. Then at Information Appliances, it reached a new stage. This next step towards the phone machine was a curious little thing called the Swift Card. Now, this is a pretty weird device. We're going to be hearing the Swift name a lot going forward. That was the moniker that Raskin gave to the devices that carried on his TextMac plans. They all shared a very similar design, similar interface, and sometimes some of the same software. The goal

here was just to get Raskin's idea out there in some form or fashion. The Swift card was the earliest and perhaps most offbeat go at this plan. That said, all the Swift stuff is a little out there to begin with. The card was a simple expansion board that slotted into an Apple IIe computer. At the time, circa 85, the II was still a very popular machine. The Mac may have been on the market, but do recall that adoption is always a slow process. Targeting the 2e was just a reasonable thing to do. So what exactly is this thing? A 1985 ad in Byte claimed the following, quote, you've never seen an Apple 2e do word processing, filing,

communicating, and calculating the way it does with a Swift card. Steve Wozniak calls it revolutionary, adding, if I had thought of the Swift card while creating the Apple II, I would have built it in. That's high praise, and from a Steve, no less. The Swift card was supposed to do a lot. It could turn an Apple II into a productivity powerhouse. Perhaps it could even make an aging machine more useful than a Mac. The card itself wasn't all that complicated. It was simply a ROM board with some extra software burned onto it, and a little extra circuitry for dealing with printers. Easy stuff. It's the kind of thing that could have probably been sold purely as software,

but that would have undermined a bit of the Swift's polish. With the card installed, your Apple II would boot directly into a text editor-like interface. You got a screen ready and waiting for input. At first, it's a little underwhelming. The secret to the Swift card's interface was all in the keyboard. The interface didn't show any menus to speak of, just a screen waiting for text, a blinking cursor, and a line showing which page of text you're viewing. To actually drive the Swift, you had to use special key combinations. The card actually came with a set of stickers to place on your keyboard, with the manual showing a nice little drawing of a hand peeling back tiny stickers.

Those special keys included things like LEAP, PAGE, LEAP AGAIN, INSERT, DISK, and USE FRONT. Suitably cryptic for a do-it-all device. If you've used Emacs before or are just handy with keyboard shortcuts, then you'd probably feel right at home in Swiftville. keyboard shortcuts, then you'd probably feel right at home in Swiftville. The core idea is that you can just type things out normally. When you need to do something more complicated, like formatting text, saving files, or moving around, you use key combinations. This is done by holding down a special key, followed by hitting another key to fire off a command.

The simplest example is the Use Front key. Once you applied all the stickers, some keys would have little labels on their front portion, you know, the chunk of plastic that faces directly towards you on each key. The Use Front button allowed you to run those commands. For instance, if you wanted to insert some text, then you'd hold U's front and hit the A key. It's the kind of thing that would take getting used to, but once you adjusted yourself, it would become second nature. The more complex bit here are the leap forward and leap backwards buttons. On the Apple IIe, these were the open and closed Apple buttons,

which were located on either side of the spacebar. Think control keys. But to get into leaping, we should probably just make a leap of our own. You see, the Swift card was really just a warm-up for a larger machine. The interface would remain almost entirely the same, so I think it would be fine if we just skip over this and start looking at the machine that would actually be sold as the Canon CAT. During this same period, we're talking 1985 or so, IAI was working on another machine. The naming here kind of sucks. Everything over at IAI was Swift this, Swift that. But the big one was just called the Swift. That's spelled S-W-Y-F-T. This was a full incarnation of the text-based Mac that Raskin had dreamed up years prior.

A changing market meant that the prices for parts had adjusted. As such, the Swift was powered by a hefty Motorola 68000. This made it immediately on par with the production Macintosh, at least in terms of raw computing power. It also sported 256 kilobytes of RAM, a 3.25-inch floppy disk drive, modem, fully custom keyboard, and a 9-inch black-on-white CRT display. It would be easy to look at this bill of parts and call it a Macintosh clone. The Digibarn, a wonderful little resource for all things computing history, has a prototype of the Swift in their collection.

This gives us some insight into where Raskin was headed with his design. The entire machine is actually off-center. It's not symmetrical down the middle. Its generous display is off to the left side and angled slightly up with a bit of a tilt. It's also a little strange to see a screen just jutting up from the case, almost like a weird square bump. On the right side of things is a little door that opens up to allow access to a floppy disk drive. In front there was, of course, the keyboard, which was molded into the case itself. The effect is pretty stunning, I think. You get this nice little package that you could just plop on a desk, plug in, and start using. There's just something I really like about it. It draws you in and almost beckons you to use it.

The final flourish is a handle. The front part of the case tapers down into a sort of keyboard rest, a place for your wrist to lie. The middle part of that rest is molded into this small plastic handle. You were meant to carry around the Swift and plop it down on a desk. That was all part of the bigger plan. So far so good. The Swift has parts roughly comparable to a production-run Macintosh, sans the mouse. It has nice physical qualities. So what's inside? The software side was essentially a refinement

of what we saw with the Swift card. This is why I only really brushed on that device. It was very much an opening act for the larger Swift computer. So now is probably a good time to get back to those Leap keys, huh? You navigate around the world of Swift using Leap Forward and Leap Backwards. You might think that Leap would just move the cursor forward and backwards. Well, it's a little more complex than that. Leap is actually a pattern matching operation. To jump to a specific chunk of text, you hold down a leap key and then type in the pattern

you're looking for. Your cursor will automatically move to the first occurrence of that pattern. If you hold down the forward leap key, it searches forward. If you hold down the backwards one, it searches back. There's one more key that completes this whole leaping affair. Leap again. This is a pretty simple one. When you leap, the Swift stores the pattern you were searching for. Leap again just looks for the next occurrence of that pattern, either forward or backwards depending on how you originally leaped. This is how you get

around inside your document, but it's also how you select chunks of text. The select is a little strange, too. You leap, then immediately press both leap keys together. So to use the Swift, you have to get familiar with this weird leaping thing. To me, this seems like a double-edged sword. Leaping sounds neat. It seems like a pretty natural way to navigate a document, at least in a vacuum. We humans don't think about text in terms of line and character numbers. We remember, oh yeah, I'm looking for that paragraph where I talk about birds. Leap as an extension of text reckoning sounds like a good idea. The issue, for me, is that arrow keys just seem like an easier-to-understand solution. Pressing the up arrow

moves the cursor up. The left one moves it left. It's right there on the key as a pretty universal symbol. You could use the leap keys to move left and right one character at a time, but you're actually missing the up and down movement. That said, my unease could be a product of modernity. Nowadays, keyboards are pretty standardized around the so-called T-nav, or sometimes the inverted T as it's called. That's where you have the up and down arrows in the middle and the left and right arrows on either side. This layout seems to have hit the scene in the early 80s on some terminal keyboards, but adoption, well, it's always slow. adoption, well, it's always slow. The IBM PC's original keyboard doesn't have a TNAV. Instead,

the number pad doubled as a set of arrow keys in this cross-configuration. Apple IIs used a weird line nav, which was an option, but maybe not a good one. The Mac had no navigational keys on its keyboard at all, so it's very likely that someone using a Swift would have had no exposure to a nice T-shaped cluster of arrow keys. If they had never used a computer before, then hey, all the better. No arrow exposure at all. Leap would have seemed like something totally novel, not a solution to a known problem. That could have made it easier to learn. The Swift's main interface is this text editor. Unlike the earlier Apple II card, the full Swift does have a bit of pomp to its interface. You get a status bar across the top of the screen. It shows a ruler for aligning your text, plus standard indicators for status things like page number. It's simple, but it's workable. Another nice touch is that the

interface uses black text on a white background. It makes everything look like printed text. Once again, it's a nice little touch that would make the Swift more approachable. In general, you can just assume that Raskin threw in a whole pile of these little touches. There's a fun sort of polish to the entire design. Another example is how the Swift saved documents. Instead of saving files, the machine just saved the entire state of memory to a disk. That way, when you load up from disk, you get everything. You could pick up exactly where you left off and you didn't even need to think about

file names. A user doesn't even need to know the idea of a file in general. That does introduce some possible problems, but as a standalone platform, I think this is another way that the Swift made things easier on its users. It's at this point where we reach a big problem that would haunt the Swift, though. It sounds like this machine is just a text editor. I mean, it boots up into a text editor. That's the interface. You can use it to write documents and print them. Seems like a text editor. That's the interface. You can use it to write documents and print them. Seems like a text editor to me. The Swift can do so much more, but its features, its cool power, isn't immediately apparent. Everything is hidden behind those pesky Leap Keys, you see. To access extended functionality, you had to first highlight a

chunk of text. Depending on what that text was, how it was formatted, what it contained, and so on, the Swift could run a special function. If you highlighted a mathematical expression, the machine would calculate a result and print it after your text. If you highlighted a phone number, the Swift could dial out on its modem, printing any data it got back on screen, so you could use it for remote terminal sessions. All inputs and outputs had to flow through this continuous text interface. So on the surface, it may just look like a text processor, but it's doing a little bit more. but it's doing a little bit more. This is certainly a unique way to structure an interface.

You end up with a situation where you have active commands and inactive text living side by side. It's a weird solution, one that makes me a little bit uncomfortable. Usually when we talk about user interfaces, we have two paradigms in mind. Text and graphical. A text interface is most often some kind of shell. You type in a command, the computer buzzes and beeps, and then it returns some text for your perusal. A graphical interface will be some sort of WIMP. Windows, icons, menus, and pointers. The Swift's interface is neither. This can make the Swift a little hard

to wrap your head around. You can't draw easy parallels to other systems that we all know. You have to get pretty far afield to find similarities. Mathematica, for instance, a programming environment for mathematics, does a somewhat similar thing. You can have text and equations next to each other in these long documents. You can even highlight and execute commands. That's probably the closest common thing I can think of, but it doesn't quite feel the same, and it's still a pretty niche interface. If we want, we can also get really far out. Plan9's Rio interface, for instance, does the whole mixing of text and commands inside its windows, but doesn't go as far as the Swift. If you want perhaps the deepest cut possible, then Terry A. Davis's TempleOS has a combined

terminal and text editor interface that supports hyperlink-like macros. That comes really close to the Swift, where the interface is kind of this big rambling tableau of text, but TempleOS wasn't doing this feature combination in service of usability. That wasn't really Terry's thing. Thus, we have to look at the Swift interface as its own design. And while it might not jive with me, I can see where Raskin was going with it. A new computer user wouldn't be familiar with menus in Windows or shell prompts, but they would be familiar with something like a fancy electric typewriter. That's an analogy that makes sense. Highlighting something you want to execute, well, that could also make sense in this kind of vacuum. You write down a phone number, oh that's

something I want to call, you highlight it, and it does it. Maybe that is a reasonable way to look at an interface for someone that's never used a computer before. But of course, there is another trick here. The Swift could do much more than run some numbers. It could run full programs typed right into its text editor. You had two options here. The big surprise one, at least for me, is you could actually execute 68000 assembly language by simply highlighting it. This sort of implies that somewhere inside the Swift, that code was assembled into an executable,

then actually executed somewhere in the background. That speaks to a really shocking level of sophistication that I wouldn't have expected out of this machine. We get one more left-field language, and it's the primary language that was used in the Swift. A fourth. That's right, it came back. We're actually looking at a fourth machine.

I covered fourth a while back on the show. It's a really neat little language. It's highly minimalist, the syntax is small, and so is the standard array of operations. This, along with some other design choices, makes Forth a really lightweight system. Its environment takes up kilobytes, if that. If you want to get the full rundown on Forth, adren of computing style, of course, then you can go back and listen to episode 89 in the archive. It's a bit of an idiosyncratic language. It's pretty unique looking and has a unique set of features to boot.

But here's a little nugget to point out. Forth is, by design, a multitasking language. It natively supports multiple concurrent threads. That means that the Swift computer may appear to be a simple text editor, but it can multitask. Given that and the backing hardware, we're actually dealing with a computer that is feature for feature every bit as capable as a contemporary

Macintosh. This thing really is the successor of the original Mac's design goals. We're looking at a computer with a dedicated purpose, one that would be relatively easy for newcomers to pick up and hopefully cheap too. But this machine also had room to grow. Down the line, it could be running all kinds of software outside the realm of text. It had the power to do so, and it had a great design to back that up. The Swift was even built to allow for third-party software. Some outside programmers were already lining up to supply said programs. But sadly, not everything is meant to be. The downfall all started when IAI tried to bring the Swift to market.

Initially, the company was planning to make and sell the Swift themselves, but the board of the company decided it would be better to contract out with someone more established. This isn't too unheard of, and it probably seemed like a reasonable idea. In this arrangement, IAI would pass along the design, reference hardware, and software to a third party. That third party would handle manufacturing, marketing, and sales. IAI would get a kickback, either as a lump sum on units sold or some combination thereof. The third party of choice was... Canon. You know, the camera and printer company Canon. Now, I can't, for the life of me, find a source that says why Canon specifically was chosen. They were probably the highest bidder

at some point, at least that's my guess. The fact that Raskin hasn't spread around the reason makes me think it was some higher business machinations going on inside IAI. At Canon, the Swift would undergo a bit of a transformation. This was the transformation from prototype to product, and it was a little harsh on the machine. This all starts with a new name, the Cat. See? We finally reached the namesake of this episode, only an hour in. The outer housing also morphed into a more conformist style. Gone was the half-tilted display and tiny handle. Instead, we end up with what I can only describe as mundane.

The Canon CAT is just shaped like a little box with an attached keyboard. Don't get me wrong, there's still some style to it. There are little angles thrown in that make it somewhat sleek, but it looks less like future technology and more like something released in 1987. From there, everything went downhill. Raskin summarized the debacle in a 1997 article called Swift and the Cat. We've already seen all the good, so I'd rather not linger on the machine's downfall. Here's how Raskin himself explains the issue, and it's better than I could put it. Quote,

According to information from Canon Inc., about 20,000 cats were sold. While the cat was, in fact, a bitmapped computer with a Motorola 68000 microprocessor with the same screen size and inherent power as contemporary Macintosh computers from Apple, Canon chose to sell the cat through their electronic typewriter division and limited the use of graphics to those that could be reproduced by the daisy wheel printer that they sold with it, namely none. Nor did they realize the importance of third-party software, though Information Appliance had begun to get third-party development started, though most customers never knew of or benefited from the cat's full capabilities. End quote. Canon had a powerful machine on their hands, but they sold it as a typewriter.

The price tag was also steep, coming in just under $1,500. It was still cheaper than a Mac, but far from the $500 wonder Raskin had dreamed of back in 79. Ultimately, a lack of vision doomed the cat. That, and maybe a conspiracy. Okay, so this is totally unsubstantiated, but I want to share it anyway. It's fun, and I think it ties a nice bow on the whole story, so take it as a bit of folklore sourced from around the net. Canon only sold the cat for six months. That's a pitiful market lifespan. One theory I've seen floated around comes down to bad blood between Raskin and Jobs. You see, Jobs wasn't just kicked from the Lisa project. He had a rocky go at Apple in this period.

go at Apple in this period. In 85, he was fired from the company entirely. There were some disagreements between Jobs and the board, to say the least. While on the outside, Steve decided to start his own company. Again. This time, he called it Next. Over the next few years, the company started showing promise. They were working on these neat workstations that were going to run a slick Unix-based operating system. Anyway, here's the rumor bit. Around 1987, Next was looking for its next round of investment. So they were selling shares in the company. These are pre-sale stock kind of things. One of the buyers was Canon.

The theory goes that Steve would only sell shares to Canon if they agreed to discontinue the cat, thus boiling Raskin one final time. Did this really happen? Who knows, but it certainly sounds like a frustrating end for a fascinating machine. Alright, that brings us nicely to a close. I guess we could just call this one the Jeff vs. Steve cycle. This machine went by many names, the Canon Cat, the Swift, or the Proto Macintosh if you want to go for the deep cut. In all those incarnations, Raskin presented a very different take on personal computing. I think his analysis was right for the time.

Consumers don't necessarily want a computer. They instead want something like a super appliance. A machine that they can use to write letters, read the news, file taxes, and balance their checkbook. That doesn't need to be a computer in the traditional sense. It can instead be a type of information appliance. This is a very measured approach, but it has a fatal flaw. It's not very flashy. Back in 79, Raskin was looking for a way to deliver this appliance for a good price point. That led to a Macintosh that didn't look very groundbreaking on paper. It wasn't fancy. It wasn't full of new technology at all.

But it was backed by some very well-thought-out choices and some new ideas. I will still stand by the theory that this text Mac, if launched in 1982, would have been a huge success. A cheap machine that rivaled the PC, that would have sold like hotcakes. The clone market would prove that in the coming years. But we still didn't get to see this machine in the flesh until 1987. By that time, it was simply too late. The production model, the Canon CAT, just didn't have any wow factor when compared to more graphical computers. It was full of good ideas, but it just couldn't grab much attention. It was full of good ideas, but it just couldn't grab much attention.

Canon's decision to market it as a typewriter didn't help matters. It all feels like a case of too little, too late. Thanks for listening to Advent of Computing. I'll be back in two weeks' time with another piece of Computing's past. And hey, if you like the show, there are now a few ways you can support it. If you know someone else who'd be interested in the history of the computer, then please take a minute to share the show with them. You can also rate and review on Apple Podcasts. If you want to be a super fan, then you can support the show directly through advent of computing merch or signing up as a patron on Patreon. Patrons get early access to episodes,

polls for the direction of the show, and bonus content. You can find links to everything on my website, adventofcomputing.com. If you have any comments or suggestions for a future episode, then go ahead and get in touch. I'm at adventofcomp on Twitter, and that's still probably where I'm the most active

for the time being. And as always, have a great rest of your day.