How Ted Hoff’s Simple Idea Led to the Microprocessor Revolution

A Simple Question Leads to a Revolutionary Idea

Our story paused at an important moment in Part 1. Ted Hoff had spent hours studying Busicom’s calculator architecture. The design was technically sound, yet something about it didn’t feel right. Before moving forward, one deceptively simple question lingered in his mind: Did the calculator really need twelve different chips?

At first glance, the answer appeared to be yes.

Each chip in Busicom’s design performed a specific function. One handled arithmetic calculations. Another controlled the keyboard. Others managed memory, coordinated the display, or communicated with the printer. Remove any one of them, and the calculator would no longer function as intended.

Yet Hoff wasn’t questioning the purpose of those functions. He was questioning the way they had been implemented.

If Busicom wanted to introduce a new calculator with additional features, the process would begin almost from scratch. New functions meant new logic. New logic meant new chips. Every new product carried the cost of designing another custom chipset.

Hoff began to wonder whether the industry was solving the same problem over and over again.

Instead of asking how to design better custom chips, perhaps the real question was whether future products needed so many custom chips at all.

Looking Beyond the Calculator

The idea that began to take shape wasn’t about calculators. It was about flexibility.

Computers had been executing stored programs for many years. Large mainframes and minicomputers already relied on processors that fetched instructions from memory and executed them one after another.

What if the same fundamental principle could be applied on a much smaller scale?

But those processors occupied multiple circuit boards and were assembled from numerous integrated circuits. They were far too large and expensive to be used inside a desktop calculator.

Instead of building dedicated hardware for every operation, perhaps a single logic device could execute different tasks simply by following instructions stored in memory.

The hardware would remain the same. Only the program would change.

It was a remarkably elegant idea.

Not because it introduced programmable computing—that concept already existed—but because it suggested programmable computing could become practical for compact electronic products.

An Architecture Begins to Take Shape

As discussions continued inside Intel, the concept gradually evolved into a much simpler system architecture. Rather than relying on a large collection of custom logic chips, the calculator could be organized around a small set of integrated circuits working together.

At the center would be a programmable processing unit capable of executing instructions. Supporting it would be memory devices to store both the program and working data, along with dedicated input/output circuitry to communicate with external devices such as the keyboard, printer, and display.

Today, this architecture feels completely familiar. Nearly every computer, smartphone, embedded controller, and microcontroller follows the same basic principle. In 1969, however, applying that concept to a calculator represented a significant departure from conventional electronic design.

The proposal offered something that dedicated hardware could never provide. The same hardware platform could potentially support different products simply by changing the program stored in memory.

That possibility was difficult to ignore.

Refining the Concept

Although Ted Hoff played a central role in shaping the architectural direction, transforming the concept into a practical processor required contributions from several engineers.

Intel engineer Stanley Mazor worked alongside Hoff as the instruction set and overall architecture evolved.

Meanwhile, Busicom engineer Masatoshi Shima remained closely involved throughout the project. Having designed the original calculator system, Shima possessed a detailed understanding of its functional requirements. His input proved invaluable in ensuring that the new architecture could perform everything the original design was expected to accomplish.

Rather than replacing Busicom’s engineers, Intel’s team worked with them. The project gradually became a collaboration between people approaching the same problem from different perspectives. One group understood the product. The other was reimagining how that product could be built.

Winning Confidence

A new engineering idea is only valuable if people are willing to trust it.

For Busicom, adopting Intel’s proposed architecture involved more than accepting a different technical solution. It meant changing the direction of a project that was already well underway.

There were obvious questions.

Would a programmable processor provide sufficient performance?

Would reducing the number of custom chips actually simplify manufacturing?

Could a completely different architecture be delivered within the project’s schedule?

These weren’t theoretical concerns. They were practical engineering and business decisions.

As technical discussions continued, confidence in the new approach gradually grew. The simplified architecture promised lower complexity while preserving the functionality Busicom required.

Eventually, the project moved forward based on the new concept. What had started as a calculator chipset was steadily evolving into something much more significant.

The Hardest Part Was Still Ahead

By this stage, the architecture largely existed as diagrams, specifications, and engineering discussions.

The difficult work had yet to begin. Ideas are relatively easy to sketch on paper. Turning them into a reliable integrated circuit is an entirely different challenge. Thousands of transistors would have to work together flawlessly. Instruction timing had to be carefully coordinated. Memory interfaces had to operate correctly. Every signal path had to function reliably within the manufacturing limitations of the technology available at the time.

The project no longer needed someone to imagine the processor. It needed someone who could build it. That engineer would arrive at Intel in 1970. His name was Federico Faggin.

His contribution would prove just as important as the idea itself.

A bold idea is only the beginning. In Part 3, we’ll discover how Intel overcame the engineering challenges of turning that idea into a working processor—and why achieving it was far more difficult than imagining it.