Advent of Computing - Episode 178 - The Programma 101

Episode Date: March 22, 2026

The Olivetti Programma 101 isn't quite like any other machine. On first glance it looks like a big desktop calculator. Inside, it's a purebred computer... but strange one. It uses twisted spring steel for memory, has no addresses, and it's machine code looks more like a spell than a program. It's existence is due, in no small part, to a man being very mean to GE engineers. Like Advent of Computing? Then check out the after show! Adjunct of Computing is now LIVE: YouTube Spotify Apple Podcasts

At certain critical moments in life or career, the craziest decision ends up being the most conservative. And perhaps more than reason, its instinct that dictates it. This must have been our case. Having nothing left to lose often leads us to the right path. Pierre, Giorgio, Peroto. Around 1964, Peroto decided to make a small computer. What do we mean by small here? At the time, the smallest machines you could buy were mini-computers. Micro processors simply didn't exist. 1964 was the year the first integrated transistor packs hit the market. These were some of the first commercial integrated circuits. That should tell you how early this is. Computers still had to be built using fully discrete transistors and diodes. This is the same year the deck PDP8 was released.

that was probably the smallest computer that money could buy, but it cost nearly $200,000 when adjusted for inflation. There really was no such thing as a small computer in a way that we would conceive of that term. The technology needed for that kind of machine barely existed. To make matters worse, Peroto wasn't working at some huge computer company or in some high-tech laboratory.

He was working in an electronics division of a typewriter company, and his division had just been sold to cover loans. So when he decided to make a small machine, well, that was a wild idea coming from a truly wild place. The finer details of the story just make it all the more crazy. Having nothing left to lose would lead Peroto down a very strong, strange path indeed. Welcome back to Advent of Computing.

I'm your host, Sean Hasse, and this is episode 178, The Programma 101. Before we get started, I have a very exciting announcement to make. Advent of Computing now has an official after show. This has been in the works for a while, and I'm very excited that it's actually public now, and I can share it with all of you. The after show is called Adjunct of Computing, and it's hosted by myself, of course, and Joe Marlin. It's done as more of a casual Q&A-style conversation about each episode of Advent of Computing. It serves as a place to talk about any questions that might be left on the table by the show,

any odd tangents I didn't go into, and anything I left on the cutting room floor. The first episode, working as an after show for the RSX-11 episode, is already out. You can find it anywhere you listen to podcasts. I'll put some links in the description for this show and probably in the description for all shows moving forward. The plan is for them to come out about a week after each mainline episode. So if you've ever listened to a show and thought, hey, Sean, I have some questions for you, then adjunctive computing is just the thing for you. Give it a try.

I think you'll really like it, and it's going to be available in audio and video. If you've ever longed to see me fidgeting in my office when I speak, then, well, this might be just the thing for you. So let's get back to the actual episode. The concept of a computer is a little, well, it's a little odd to me. I know I talk endlessly about what exactly is a computer. I'm going to keep doing that.

You literally cannot stop me. The definition of a computer is very cut and dry, but that's also a very limiting definition. Technically, a computer is any device that can conditionally execute operations. As we've seen on the show, that definition breaks down around the edges, both the conceptual and temporal edges, go far back enough and machines get harder to classify, and modern classification becomes less meaningful. At the same time, I think it's easy for us to look at a machine and tell if it's a

computer or not. There's an instinct there, maybe like a vibe check. At least many of us have some kind of instinct for this classification. So let me pose the question. Is a programmable calculator a computer. I came face to face with that question while I was at VCF SoCal recently. One of my favorite exhibits every year is Larry's table. He has an FPGA clone of the LGP30 that he's always showing off. This year, his LGP30 was actually running some brand new software, but that's a different story. Most of his table, physically, was taken up by a huge desktop calculator.

the Olivetti Programma 101. Now, I'm not a big calculator guy. There is, I assure you, a part of the retro scene that is very, very into old calculators. I'll go down that path one day. Not right now. It would be a bit of a commitment to get up to speed with calculators, and I haven't carved out the time for that quite yet. Larry, however, assured me the Programma 101 wasn't a calculator. It was a computer. And what can I say? I'm always excited when my expectations or assumptions are challenged. The Programma 101 isn't just a computer, is a very unique computer.

To fully understand a thing, I think you have to push at its outline. Today we're going to be doing that. The story of the programmer should give us a bit of everything, including faces new and old. We haven't talked about Olivetti on the show at all, but we can't. but we have talked about one of their most famous alumni, Federico Fajin. Along the way, we also get to see corporate wheeling and dealing, General Electric, and nerds possibly lying to their bosses. What more could you want? For this story to work, we do kind of have to start at the very beginning.

So let's do a speed run of Olivetti's corporate history. The company was founded as a typewriter company in 19, 2008 near Turin, Italy. Two things to note here. Some of my favorite red vermouth comes from Turin. Second, we aren't dealing with an American company. So much of the history that I cover takes place in the States, so this is a nice departure.

It means we'll be a little bit removed from the usual beats, and maybe I'll have a nice Manhattan while I'm writing this. Anyway, Olivelli isn't initially a computer company. They make mechanical typewriters and eventually electric typewriters. In the 1940s, Olivelli starts manufacturing desktop calculators. In the 50s, they add their first computer, the Elia, to their product lineup. How does a typewriter company get into computing? Well, we've seen this before.

The first step is simple. A desktop calculator is actually just a little bit more complex than an electric typewriter, or, I mean, you can drop electric from that. It's just a little more complicated than a typewriter. You need a few more parts, but it uses the same supply chain, the same assembly method, and basically all the same components. So the jump is simple. If you can make typewriters at scale, you can make calculators at scale.

The jump from calculators to computers is more interesting. At least, to me it's more interesting. Making a full-on digital computer requires specialized know-how. However, that know-how can be acquired a few different ways. There are a lot of different machines that have many computer-like qualities. And those machines, if you have experience in them, will help you nudge into the digital world. One example of a nudge factor is radar. In the States, many researchers working on radar transitioned pretty seamlessly to working on computers.

Both systems used vacuum tubes for logic and had a concept of memory. Delay lines, one of the earliest forms of computer memory, are taken directly from radar technology. Another route is the ever-humble punch card. This was roughly the route that IBM went, at least in terms of manufacturing. A punch card tabulator is very, very similar to a computer. The only real difference comes down to how procedures are represented and a few doodads about those procedures. But manufacturing-wise, if you can make a tabulator, you can probably make a simple computer.

Olivetti roughly followed this route, but their path to computing is more composite. In the late 40s, the company partnered with Bull. This was a French concern that manufactured, what else, punch card equipment. Elizabeth Amory, writing in IEEE Spectrum, explains this part of the saga well. Bull didn't have a distribution facility in Italy, and Olivetti wanted to gain access to punch car technology as a precursor to building a computer. So a deal was struck, and Olivetti started. selling bull hardware in Italy.

But this was only one prong of a larger strategy. In 1955, Olavetti became involved with the University of Pisa. At the time, the university was trying to build a research computer. Olivetti was eager to contribute because, well, it was basically an investment in the company's own future. By helping the University of Pisa now, Olavetti stood to, in the course of a few, years, have the precise institutional knowledge needed to make a computer. In 1955, Olavetti started development of the Elia-N-1.

I planned to do a more in-depth episode on this computer another time. Suffice to say, it's somewhat unique. It was one of the first transistorized computers in the world. Its memory is unique because it was organized into six-bit characters. It's what would be called words on other machines. instructions indicated how many characters of data to operate on. Now, those few little characteristics aren't super wild, but they are diagnostic. It should be pretty clear to see if a computer is related to the Elia, so tuck that away for later.

Things were looking up for Olivetti's digital future. The 9,001 was refined through a series of prototypes, and, in 1958, went into commercial production as the 9,03. About 40 machines in total were produced. The 6,001, a further refinement hit the market in 1961 and would sell 150 units. Olivetti was becoming a computer company. That said, there was major strife within Olivetti. In 1960, Adriano Olivetti died of a sudden heart attack.

The firm had been founded by his father, but Adriano had driven Olivetti. towards electronics and eventually computing. The digital Olivetti was Adriano's project. The other side of the digital revolution was one Mario Cho. Adriano had met Cho in 1954. At the time, Cho was teaching at Columbia University. Adriano specifically chose Cho to lead the development of Olivetti's first computer. Joe was the technical force behind the Elia and whatever would come next.

In 1961, he died in a car crash. And like that, Olivetti was left adrift. This could be a story of the danger of relying on charismatic or genius leadership. But instead, I think what we actually have is a lesson in the importance of navigating a transition. Adriano and Cho had set Olivetti on a course. It was up to the rest of the company to figure out how to correct and sail without them. The results would be, well, they'd be equal parts interesting and chaotic. In 1960, Federico Fajin graduated from a technical high school

and immediately started working at Olivetti. He was just 19 years old. Here, I'm working off two oral history interviews with Fajin. one from the Computer History Museum, and one from I-Triple-E. This doesn't give us the whole story, but it gives us a wild glimpse of what was going on inside Olivetti. Fajin didn't invent the program of 101, but he witnessed firsthand as Olivetti grappled with its future. We had these interviews for a simple reason. Fajin became famous. In 1970, after immigrating to the United States, Fijin was hired by Intel.

There, he led the design of the 4-004, Intel's first microprocessor, the world's first commercial computer on a chip. That feat made Fijin a legend. So his life in times have been chronicled. He's been interviewed many, many times. This highlights an issue I often face and sourcing. The big stories are well covered, as are the big figures. Stories deemed less important or less well-known get less coverage, less veneration. There is little written about Olivetti. There are even fewer interviews with their employees much less material in English. That makes these interviews with Fijin all more valuable. About a year after he came to Olivetti, Bajin wound up in charge of designing the firm's next computer, to quote,

I got a project by luck because the guy who was in charge of the project had to go to military service. And so he left the project, just started, and he was developing a computer and I took over. And under the guidance of an engineer, I started working on that. Then this engineer got into a car accident and the project was mine. And so I actually completed the design of the computer and built the computer on my own, with five technicians that were working for me." Not entirely sure, but I'm willing to guess that car accident was the one that killed Cho.

The new computer project started in 61, so the timeline would fit. The tale speaks to Fagin's ability, but also to the instability within Olivetti in this period. A hot shot was able to succeed, partly because there was a sudden space. for him to succeed in. This project was to create a small computer. A study to see how simple a machine you could build, as Eugene explains. The machine that came out of this was a 12-bit computer that fit on a single equipment rack. A computer the size of a refrigerator instead of the size of a room.

The computer was small using just a thousand logic gates. The scant information does make me think of my beloved LGP30. A machine with just enough computing power for a single person. Where did this small project go? Well, there's the difficulty. Olivetti's next commercial machine was the Programma 101. A very small computer. There's been a lot of ink spilled about it, but not in English.

In 1995, Pierre Giorgio Peroto, the main designer, of the Programma 101 published a book, simply called Programma 101. Peroto wrote the book in Italian, because he's an Italian engineer that lives in Italy, and worked for an Italian company. I cannot read Italian.

I've been awkwardly translating chunks of the book. I actually wrote a script to do paragraph-by-paragraph translation, but even with modern software, that's not super good. I have enough to fill in a little bit of the bridge here. However, I don't have full text search that actually works. I'll often use text searches to figure out how events connect up. If you have keywords or names, you can line things up pretty easily. But the earlier machine that Fagin worked on had no name.

This book is in Italian. I have poor machine translations. And Peroto doesn't mention Fagin by name. anywhere in the text. The story of how the programma 101 actually begins is a little odd. It's a little vague. One version of the story is that Fasgine's nameless project contributed directly to the creation of the programma. I'm not sure that's the case. Fagin himself doesn't claim this.

He went back to college as soon as his small computer was running. To quote, with my leaving, it was basically left alone. I was told it actually inspired the programa 101, end quote. Vague third-hand news is not super useful for me. It's possible that Fijin's machine contributed to the development of the programma somewhat indirectly. Peroto's version of events is pretty clear.

Starting around 1962, he was dreaming of a new kind of computer. He was captivated by, quote, the dream of a machine that emphasized not only speed or power, but rather functional autonomy, capable not only of performing complex calculations, but also of automatically managing the entire processing process, yet under direct human control, end quote. Again, computer translated. Not the cleanest, enough to get the idea across, though. In this period, computers were still hulking bees.

Peroto described the relationship between human and machine as one of subservience, with humans forced to contort to the whims of the machine. He started to think it would be possible to reverse that dynamic, and would have to start with a new kind of computer. If there's a connection between where Fagin's work ends and where Perot's dreams began, I think it could be found in the culture at Olivetti. Vigin shows that even in uncertain times, there was still space to dream. Small computers don't come out of rigid places.

Take the LGP30 as the prime example. That machine came out of one person working alone. It comes about as a reaction to a survey of existing computers, the realization that not everyone needs a big machine, and then the space and flexibility to jump to the next step. The link, another small machine in this period, follows a similar pattern. A group of researchers at MIT wanted a small machine to use in their lab. They quickly found out there was no option on the market.

They had the space to tinker. They had the parts. So they decided to make their own computer. It sounds like there was space inside Olivetti for big dreams. But that space wasn't stable. There was another tragedy waiting in the wind. Back in 1959, Olivetti bought an American typewriter firm. That company, Underwood, proved to be a bit of a toxic asset. This set up the final piece of our three-act tragedy. Underwood's American factories

were hopelessly outdated. To even turn a profit, Olavetti would have to make a substantial investment. Adriano made a bad call, pure and simple. He had hoped. that buying Underwood could give Olavetti a better foothold in America. It could, but the price was higher than initially thought. Adriano died just as the Underwood sale was turning into a financial disaster. That made things tricky. The electronics division of Olivetti, the actual internal organization that made computers, was new and untested. Developing new machines takes a huge investment. It can pay out, but that's assuming you have the initial capital to invest. As the 1960s started,

Olivetti was in dire need of funds. The company didn't need another hole to throw money into. They didn't have the money to throw away. Adriano never viewed the electronics division this way. He viewed it as a sound investment, as the future, but he was gone. What happens next is, well, it's corporate politics. The full tale is explained pretty well in Merrill Seacrest's book The Mysterious Affair at Olivetti. To make ends meet, Olivetti decided to sell off their entire electronics division to General Electric.

The path to that decision is a long one. It involves math about shares owned by the Olivetti family, dealings with fiat, and bids from a number of other electronics firms. In 1964, the sale to GE was fined. olivetti would drop their entire electronics division. GE would take on all the products and people that were in that division. Olavetti would be reduced back to a typewriter and desktop calculator company. That didn't sit well with Perotto.

He was an old-time writ Olivetti. He joined the firm all the way back in 57. He watched firsthand as Olivetti became digital. He even worked on the Elia project under Cho. Peroto was a dreamer and a true believer in the future of computing at Olivetti. By 64, he had already started work on the programmer 101, his small computer. That project, being a computer project, was under the electronics division. That put his machine in danger.

You see, General Electric wasn't actually interested in anything Alavetti was working on. They wanted a foothold in Italy, just as Olivetti wanted a foothold in the United States. GE didn't make small computers. They made mainframes. In this period, GE was competing directly with IBM, the traditional juggernaut of the computing world. IBM was a hulking beast that didn't make small computers, so GE couldn't either. In that struggle, there would be very little room for dreamers. The traditional story is that Peroto pretty quickly understood the danger he was in.

If the programma landed in GE's offices, it would be ripped to shreds. The project would be canceled. The dream would be over, and Peroto wouldn't likely be out of a job. So he lied. Peroto stretched the truth. At least, that's the traditional tale. He would claim the Programma 101 wasn't a small computer at all. It was just a very big desktop calculator.

The case was rigged up to look like a calculator, some details were changed, and the illusion was complete. Since it was a calculator, it didn't actually belong in the electronics division. That was part of Olivetti's main division. So therefore, GE didn't technically own the project. Thus, Peroto could continue to live the dream in Italy. It turns out, though, that that story is wrong. Peroto describes a very different situation in his book. He didn't lie.

Instead, he was just mean to GE engineers until they decided they never wanted to work with him again. And that's not a joke. That is straight from Peroto's own telling. Engineers from Olivetti's electronics division were flown out to tour GE's facilities. This happened just as the sale was finalized. For Peroto, this left a very disappointing first impression. It's on this trip that he realized GE didn't have space for the kind of work he wanted to do. He was also upset with how GE's engineers treated their new Italian counterparts. So, we have a mix of political and personal reasons that made Peroto want to

stay out of GE's grasp. To quote, It pushed me, given my loss, to adopt a bellicose opposition to the agreement at every meeting I had the good fortune of being called to. Ultimately, I was trying to save some residual space for my work and that of my collaborators. The conclusion was that the Americans let Roberto Olivetti know, not so discreetly, that they would not be unhappy if Engineer Peroto, although part of the Pragana electronic laboratory that was being sold to them remained with Olivetti. And so it duly happened, end quote. Imagine this. You get a new co-worker because your company acquires a firm. They are so unpleasant to be around that you kick them back to their old company.

Perotto was able to stay with Olivetti by being rude, bellicose, and belligerent. That's how the programma 101 avoided the chopping block. He never lied and said it was a calculator. He was just nasty to be around. I think this myth of the big lie persists because the programmer 101 is such a strange device. It doesn't look like a computer. The machine does look like a very big desktop calculator.

So, well, there must be a story behind that, right? I wasn't able to track down the origin point of the myth, but I think it's pretty clear to see how it could have been created. You see a computer that doesn't look like a computer, you read about the traumatic GE sale, and, you know, computer folk have always been at least a little mischievous. It sounds like a classic story, but it's simply not true. Actually, the story is a little more classic. The truth just rings a little more funny. There's no lie. There's just being mean to new coworkers.

One thing I don't like about the mythical telling is it takes away a lot of the intentionality behind the programmer 101's design. This computer didn't transform from a small computer to a desktop calculator. Its final form wasn't a trick designed to keep it away from GE. Rather, it was planned to be different from the start. In trying to imagine a small machine and trying to break from established norms, Peroto took a radical leap. Furthermore, he knew it was radical.

There's no accident or deception here. If the program A 101 doesn't look like a computer, then good. That was the point, to quote. In essence, the world of computing and office work was still one of subservience and slavery to the unnatural laws dictated by machines. Humans freed from physical labor had not yet found a way to free themselves from the routine of immaterial, oppressive, gray, and very unpleasant tasks, end quote. Again, I really want an actual translated edition of this book. Peroto is forceful and idealistic about the programmer. It's not a machine so much as a rethinking of

what a computer is and what a computer should be. The machine was designed to be more like an appliance than a mainframe. The programma would be a tool used by office workers, not a system that office workers were slotted into. That central goal shaped the machine into its radical form, and it was there from the start. Again, there was never a deception. There was never any force applied to this machine that changed what it was. The vision was very clear to begin with. I'm going to work my way backwards with this machine. I want to talk about the outside before we get to the innards. After all, that's how I was introduced to the programma, and I think there's some neat shock value there. Externally, the Programma 101 is a little

imposing. It's about 70 pounds of cast metal painted up in an instantly recognizable beige. It looks like a desktop calculator that's just been stretched in all dimensions. Its front has what looks like a normal numeric keypad expanded with about 20 other keys. This doesn't, however, reach the size of a keyboard. The back half is a housing for the guts of the computer. The housing is, well, big. I feel like the photos don't really do it justice. It would take up at least half of the computer.

of a normal desk. Perch to top the machine is a paper spool. And you did hear that right. Paper. The program doesn't have any kind of display or even blinking lights. It doesn't have a serial port for connecting to a terminal. All output comes from a small printer. This uses the same type of receipt paper that you'd see in a contemporary desk calculator.

In fact, it would have used the same paper as other printing calculators. all of any manufactured. That's all that's readily visible, but there are some hidden tricks and doodads. The most important is the magnetic card reader. Any good computer needs some mechanism to read and store long-term data. The programma is no exception. However, it uses a very different medium for storage.

It uses these magnetic cards. Each card is a slip of paper about the size of an envelope. On one side is, well, simple paper. Bonded to the other is a magnetizable plastic sheet. It's the same kind of material used in a cassette tape or a floppy disk. These cards were then readable and writable by a magnetic pickup, basically a tapehead. The reader-writer was hidden in a slot on top of the programmer.

From the outside, it almost looks like a styling on the case. The closest equivalent to a magnetic card is probably a punch card. Peroto intended that mag cards would be used to both store programs and data. That's basically what punch cards were used for on other platforms. I stress that this comparison is a rough one. Magnetic cards had a higher capacity than punch cards. A mag card held 120 characters of data while a punch card could only handle 80. That, however, is a smaller point.

The bigger point is this. Magnetic cards were re-writable. Punch cards are a very permanent format. Data is encoded as holes physically punched in paper. Once you punch a hole, you can't fill it back in, so you can only write to a punch card one time. Magnetic cards can be rewritten as many times as you want, within some reason.

You can wear them out eventually. This allowed them to be used for storing temporary data. You could actually edit a program stored on a mag card, or you could just use it to store some information at the end of the day. In terms of use patterns, this is a very different technology. When a card is read, its contents are loaded into memory, but what exactly does that mean for the programmer? The computer's memory was just 240 characters of delay line.

That's right. We have a computer in the 60s using delay line memory. Delay lines hold a very special place in my heart. They're a very, very cursed technology. Electrons don't like to stay put, which means that electronic memory is about the hardest digital component to construct. That led to a wild diversity in early memory design. Some early machines use these things called mercury delay lines, tubes filled with heated mercury.

Piazoelectric crystals were used to send sound waves down the tube, where it would eventually strike another crystal and be turned into an electrical signal. By adding some clever circuits, you can circulate a pattern of pulses in a tube of mercury. that Pulse Train is decoded as binary data. These old machines just kept bits cycling through the delay line, grabbing them when they're called for. Mercury was used because a wave will travel through it at a very predictable and pretty slow speed. It's all about timing, and the timing with Mercury ended up working really well with the timing

of vacuum tube circuits. The Programme 101, however, doesn't use Mercury. It uses something equally strange. The technical term is a magneto-restrictive delay line. I've also seen them called torsion delay lines or... Magneto-restrictive devices. The last one sounds a little ominous, I must say. It's a spring steel cable that stores data.

Instead of waves in a tank of fluid, this delay line uses a small twist in the steel cable. If you twist one of these cables, that twist will propagate from one end to the other. Each end of the steel cable is bonded to a magneto-restrictive element. These are just special metals or alloys of metal that change shape when you apply current to them. Nickel is the most commonly used one. So this isn't a very exotic technology.

It's using pretty common materials in, interesting ways. Now, these magneto-restrictive elements, little slabs of nickel, work in both ways. If you apply a current, they'll warp a little bit. If you warp them a little bit, they create a small current. That takes a place of the piezo crystal used in a mercury delay line. The steel memories could also be coiled, and that's crucial. The program's memory circuit is just over 21 feet of spring steel. If that had to be laid straight out, that would be a little bit unreasonable. Here's my 21-foot-long desktop calculator. Because it can be coiled, that memory fits in a circle that's about seven inches across. As wacky as that sounds, it actually makes for pretty good

memory. In that space is stored 2,000 bits of data. Why would Perotto go with such a radical form of memory. Well, it wasn't all that radical, it turns out. In the mid-60s, memory was not a solved problem. There was still a lot of space to get, well, to get weird with it. The main contender at the time was magnetic core memory, which is very difficult and expensive to be manufactured. It essentially had to be woven by hand. The steel delay lines could be made much more easily and much more cheaply, and the only material it needed was steel and nickel. There were, oddly enough, a few other desktop calculators of the era that used steel memory as well. It was just more cost-effective the magnetic core, especially when you only needed a little bit of memory.

Remember, the programmer is not a big computer. It just needs a little bit of power and a little storage. This is helped by how the program has structured its memory. A downside with delay lines is their sequential devices. If you ask for a specific bit, then you have to wait for that bit to come up in the cycle. There's no such thing as random access here. That becomes an issue if you allow a programmer to ask for specific bits. You get into all kinds of weird timing.

The programmer just doesn't let you get close to that problem. It doesn't let a programmer ever even think of a programmer. a specific address. Memory instead is exposed as a set of registers, as separate little storage compartments. These aren't numbered but named. There's no direct connection between the running program and some concrete location on the spring steel wire. There are 10 registers which each hold 24 characters.

These are actually just data on the wire memory, which, well, puts us in a weird spot. The programma 101 kind of makes comparisons impossible. Let me explain. There are some machines that use memory to implement their registers. The TMS 9900 is a pretty classic example. That computer uses a chunk of memory as its register storage. It's more common, however, for registers to use their own storage circuits that's most often on the microprocessor itself or in a pre-microcessor design very close to your mathematical circuits. In that design, registers are their own thing, totally isolated from memory, and maybe even made using different technologies than your memory storage.

The programmer 101 is odd because it takes a third approach. There's no such thing as random access memory. So it's not accurate to say that the programma is taking the same approach as the TMS 9,900. The program's registers are its memory in totality. That's a very different way of looking at a computer and leads to some unexpected implications. The programma is a stored program computer. Its programs are stored in registers. Specifically, there's a set of registers that hold instructions.

Those registers are called P1 and P2. There are also some extra registers, D, E and F, that can hold either data or code. So, what architecture is this computer? When classifying stored program computers, there are two main options, Harvard Architecture or Von Neumann Architecture. In a Harvard architecture machine, code and data are stored in separate locations in memory. They often just live in completely separate, isolated forms of memory. In a Von Neumann architecture machine, code and data are stored together and can be treated interchangeably.

The programma, again, defies classification and comparison. It lies somewhere in between. There are spots where data and code can mingle and spots where data and code are separate. In the real world, we can't use these hard. hard definitions without some tempering. There are many other machines that blur the line between Harvard and von Neumann. The programma is just one example, but it's a very odd example. It's interesting because it blurs more than one line at the same time. It defies classification because it's just its own thing. The rest of the register set is slightly more conventional. You get three

registers that are used for arithmetic operations and two data-only registers. That sounds pretty normal. Until you remember, these registers are all just memory. They're literal twists on a steel wire. The instruction set is pretty similar to old-school machines, with, you know, caveats. Let's take ad as an example. The ad instruction is the plus character. It can be used in two forms. If you just type plus, the programmer will add the value in the register M to the value in the A register, storing the results in A. If you type out the name of a register and then a plus, the programmer will add the value of the named register to A. That's relatively close to how an older load store style machine would act. Many simple computers will have a special register

called an accumulator, which is often shortened to A, that's where all math operations occur. Math operations on these kinds of machines will take one argument that's usually an address in memory. That way you can tell a computer to add some value from memory to the accumulator. These are called load store machines because, to make them useful, you get a few instructions to load data from memory into the accumulator and then to store data from the accumulator into memory. This was a very common design, and many loadstorm machines feel pretty close to one another. It's simple, relatively easy to implement, and not all that bad to program. But the programmer doesn't have a concept of memory. Instead, you have to choose a register. On the surface,

that may seem like a simplification, but there's a trick here. Remember that the argument is optional. You can write a program that's just plus, and that will add the M register to the accumulator. Why would you do that? Well, it's a design side of hand. By default, when you punch a number into the keypad, it's stored in the M register. When you type an instruction, be it plus, minus, or something more sophisticated, the programer carries it out immediately. That lets the program reuse its circuits. The same circuits that handle a program also handle normal desktop calculator operations. This, to me, more than anything, is what makes the programma 101 a pure-bred computer. I admit, I had some misgivings, but the simple fact is that the programmer is a computer

that can, under certain circumstances, be used as a desktop calculator. Peroto is correct. when he says he's trying to take a radically different approach to computing. The result is this small machine that's not quite like anything else. That's true on a technical level and also true on a functional level. The programma is plain different, but for me, one big question remains. How did you actually program this thing? It's time for the classic yardstick, Turing completeness. I joke about needing a sound drop for IBM, but I think I actually need a sound drop for every time I mention the church-turing thesis.

So, anyway, it's Allen time yet again. Strictly speaking, to be a computer, a machine must be able to do conditional execution. In other words, it has to have a way to decide what to do next. This is usually shortened to conditional looping, as in a true computer, execute something over and over again until some condition is reached, at which point it stops. Simple enough. The programma meets that bar. The question is, how?

There are a lot of different ways to reach the threshold of Turing completeness. So, details become important. A Programma 101 program is composed of a string of characters. As we saw with addition, these characters can be instructions or they can be arguments. And as we saw with addition, these instructions are variable length. This is what's known as a variable length instruction set, since an ad instruction can be one or two characters, and there are even some instructions that can be up to three characters long.

Most instructions on the program of follow this kind of pattern. There is a one-character version that uses some default values, or you can specify the register you want to use. Not all instructions, however, look as nice or as clean as addition. The Programma 101 had its own special character set. For example, the instruction to print to the paper feed is a hollowed-out diamond shape. The instruction to transfer the value from one register to another is the up arrow. This is all technically machine code, as in you write a program in the language the computer natively reads. Machine code is normally inscrutable to humans.

The custom character set here and variable length makes the programmer's code look especially odd. It gets more strange. Here I'm going off the Programma 101's reference manual and some sleeves for storing magnetic cards. By convention, a program is written vertically. Each line is one operation. That's the same as most programming languages, except for the fact that each line of a programma machine program

is one, two, or sometimes three characters. The first time I saw one of these programs, I didn't really clock it as a program. It simply doesn't look like any kind of more traditional program I know. For instance, let's look at my beloved LGP30. That computer has a very terse machine code. You program directly in machine code and you write it line by line. However, it uses addresses. So each line of code is at least five characters long. And by convention, each line you write down in a programming sheet starts with its own address. So you end up with these very formatted lines that are relatively long. There's some structure and meaning in each line. For the programma, a line might just be a plus, and then the next line could be a double-headed arrow followed by another line that's just a

minus. It looks a lot different. It almost looks alien. Jumps complete. the odd picture. So, here's where we get to the weirdness. A jump normally tells a computer to start execution at some specific address in memory. The program A 101 does not have the concept of an address or really memory. So it uses labels. A label is just a way to tell a computer to remember this location for later. It doesn't actually do anything when it's encountered. They're super common in assembly language, that's the step up from machine code, and labels even show up in higher-level programming languages, like Basic, for instance. Labels aren't as common in machine code.

In fact, this might be the first computer I ran across that supports labels at this low-of-a-level. There are some limitations here. The programmer gives the programmer 32 labels to use, 16 for unconditional jumps, and 16 for conditional jumps. An unconditional label is two characters, but you have to choose them from a list. These read something like AV. That label is paired with a jump instruction. In this case, the AV label is paired with the V jump instruction. When the programmer encounters a V instruction, it transfers execution to wherever AV is located

in your program. Is that a little confusing? Well, good. This is one of those things about the programma that really struck me as, well, confusing. The reference manual has tables that show the jump and label pairs, like CZ and BZ. I can almost see a logic in how the pairing lines up, but not quite. It's not exactly a pattern. Conditional jumps follow the same pattern except with a slash.

You can use a slash v as a conditional label and then slash v as the conditional jump to the label. That jump will only execute if the A register is greater than zero. As far as conditions go, that's enough to meet the requirements of turning completeness. Speaking more broadly, this is a pretty common condition for simple computers to use. What's weird, though, is it the... The conditional and unconditional labels are separate. You have to know what kind of jump will make its way to your label before you write a label. It's just very different.

These jumps are, by convention, represented on paper using an arrow. So add that to your picture of how a program a program looks when it's written down. Each magnetic card has a paper sleeve, which has space for you to write out the program store on the card. The sleeve ends up having this long, vertical line scroll down it with these short instructions, really these short glyphs, with arrows off to the left-hand side showing how it flows and jumps around. To me, it looks more like a spell than a program. But I guess if we're being honest, all programs are technically an incantation of a sort. This one just really looks it.

A critique would usually be in order here, and it would be warranted, right? The programmer is a very limited computer and has very limited programming capabilities. I mean, only 16 conditional labels. Talk about a limitation. For the programma, however, I think this is just the right amount of space. The maximum size of a program is 120 characters. Let's assume an instruction is, on average, 2.5 characters long. That gives us a whopping 48 instructions per program.

There are ways to up that limit using multiple magnetic cards, but still, that's a huge limitation for the size of a program. in memory. On paper, this makes the programma look laughable. Who in their right mind would buy a computer that could only output to a tiny spool of paper, had less than two kilo bits of memory, and could only run tiny programs? That's madness. But, and I keep saying this, and I'm going to keep saying this until the episode's over, the programma is not a normal computer.

In fact, it's very hard to compare it to... anything. I'd normally do a price comparison here, but that's a little hollow in this case. The Programma 101 would sell for $3,500 in 1968 in the U.S. That's over 33K today. But what do you compare that to? I actually went out looking for options here. The two closest comparisons I could find are the PDP8 and the Datapoint 2200. The PDP8, the PDP8, VDP8 was developed around the same period and sold in the same period. It's a small machine meant for use in a lab by, most often a single person. It was one of the smallest computers money could buy.

It cost $18,000 in the 1960s and was much more capable than a programmer. The Datapoint 2200 is another interesting comparison here because it was literally a desktop computer. as in it sat at your desk and was used by a single person. It was meant to be a programmable terminal. So it's definitely cuspy like the programmer is. It sits between two different types of machines. That computer sold for 7,800 in 1970, and it was still a bigger machine than the programmer 101.

Hopefully, you see the issue here. The only machines that are of similar capability to the programma, at least on paper, are along lines of demonstration units or home-built kits, not serious computers. The programma, for the time, was the smallest machine you could buy. I want to be careful here because that can sound like I'm saying the programmer was a bad computer. It wasn't. It was a different type of computer. a specialized instrument, more specialized than, say, a PDP8.

With a PDP8, you can do anything, assuming you can learn its weirding ways, right? With a programmer, you have a desktop calculator that can stretch its circuits a little. On a technical level, both the PDP8 and the programmer are identical. That's the beauty of turning completeness. A PDP8 can do anything a programmer can do, and vice versa. Although, getting a programmer to work like a PDP8 may be a little impractical, but it is theoretically possible since it's programmable. The key difference is the programma is a specialized tool,

while the PDP8 is a generalized one. It takes a lot more generalized knowledge to use a PDP8. You have to become subservient to the computer. The programmer, by being small, cheap and limited, breaks that power dynamic. The best explanation of the programma comes to us from an oral history with David Whittle, who worked at NASA during the Apollo program. That program used a wide range of computers, from massive IBM mainframes on the ground to tiny custom-built machines in the Apollo capsules,

and even little guidance computers in the Saturn 5 rockets. And there was even space for the programal 101. Whittle didn't call the program a computer. He called it a supercalculator. There were some in-flight calculations that couldn't be carried out by the Apollo capsule's own computer. A few of those calculations would be carried out on the ground. Whittle describes the process with initial steering of one of the capsule's radio antennas. The crew would send down some parameters. Widdle would pull out a mag card on the programma,

load it up, punch in the parameters, and radio up the results. Here the programma isn't operating as an all-encompassing machine. It's a little calculator. Its programs are a way for someone like Widdle to make new operations. Sure, it had add and subtracting square root, but what about angle calculations for small radio dishes, or orbital equations. Using a little code, you could expand the programmer to have that capability.

And that's ultimately the promise of the programmable computer. A computer is the ultimate adaptable machine. A computer can calculate anything calculable. All you have to do is write the program to do so. And just about anything can be reduced to a series of simple math operations. So in theory, a computer can do anything. It can be expanded and adapted to solve any problem. Then a computer should be everywhere, right?

The only restriction should be cost. The programma takes a different angle. You could look at it and see a very small and limited computer, something that's built to a cost, but that misses the important differences. The programma is meant to solve a different problem than a PDP8 or an IBM System 360. It's a specialized tool that's made much more capable because it's a computer. It's not so much a desktop calculator with a computer slapped on.

It's more like a computer that can work as a better desktop calculator. If used correctly, it's a more powerful and more refined tool. It's a tool meant for any worker to use, not something that you have to specialize in using. All right, that does it for the software. story of the programma 101. This is honestly just a sketch of the full story. There's a lot more to be said about the machine, from its industrial design to the rest of the team and how it sold and was discontinued. But this is enough for today. If you want to learn more, there are a number of resources for you. The Mysterious Affair at Olivetti is one of them. That text is in English and

focused largely on the politics around the program. Of course, Perotto's book The Programma 101 is the best possible source. If you know Italian, seriously, if someone makes a good translation of that book, I will cry. I will also buy you an indeterminately large quantity of beer. The Programma 101 is fascinating because it lies on a boundary. It's near the edge of what's traditionally considered a computer, and for the time, it was near the edge of what was possible. Its philosophy, design, and purpose are just so different compared to contemporary machines.

One point I've been avoiding this whole episode is this. Some call the Programma 101 the first personal computer. I didn't open with that because, well, you know how I feel about firsts? When you use that language, you open yourself up to a fight. In preparing this episode, that idea that the programma is a personal computer has always been in the back of my head. And, well, there's something about it that doesn't feel entirely correct to me. I don't know how to put together a good argument here. The programma has a lot of the features that are needed for a personal computer.

Heck, it even fits on a desktop. But to me, the vibe is different. This may be a victor bias here. The programma looks and feels nothing like the personal computers we see in the 70s. But ultimately, it works the same way and hits many of the same beats. It's just a little computer that's used for little tasks. All this is to say, I'm conflicted, and I'm going to keep my mind and my eyes peeled moving forward. I really want to see if the program's DNA shows up anywhere else.

Who knows? Maybe if I'm looking for the bits and pieces, they'll appear everywhere. Anyway, thanks so much for listening to Advent of Computing. And as a reminder, adjunct of computing is now lie. The after show for today's main feed episode should be up in a week. That means if you want to hear more about the program, if you want to hear idle chit-chat and discussion about producing this episode, episode, well, go subscribe to Adjunct of Computing. It's available everywhere you get podcasts. I'll be back in two weeks with another mainline episode, and until then, have a great rest of your day.