HPL

HP9825.COM

The Story of the Little Computer That Could!

 

Revised 7/8/07

HPL – Basic with the vowels sucked out

After Don Morris became the project manager for the HP 9825 project, after Morris and Dick Barney conducted their market research in the summer of 1973, and after Wayne Covington came to Morris with the idea of using DeRemer’s table-driven language parser (now known as the LALR parser), after all that Morris needed someone to manage the 9825 software development. It would be the most ambitious software project yet undertaken at the HP Loveland facility and Morris knew he needed someone with at least some computer and software-development experience. He also wanted someone who could effectively manage a team.

Morris’ first choice was Loveland software veteran Jack Walden, who had been on Morris’ doctoral committee at Oklahoma State University. Walden had been a classmate of Fred Wenninger, Morris’ boss, at the same university. Walden left Oklahoma State University in 1969 to join Wenninger at HP in Loveland. His first job at HP was developing software for the HP 9810A.

Unfortunately, Walden was otherwise occupied and therefore unavailable for the HP 9825 project. Morris didn’t want to give the management job to Covington so he went looking for the right person. He found that person in production engineering. The person Morris chose to head the HP 9825 software team was Chris Christopher, who had joined HP Loveland in the spring of 1968 after earning a BSEE from Colorado State University in nearby Ft. Collins.

Chris Christopher 197404


Chris Christopher

Photo Courtesy of
Hewlett-Packard Company
 



Christopher’s first job at HP Loveland was working with Chuck Near to develop automated test facilities for the HP 9100 desktop calculator’s complex motherboard. When Christopher arrived at HP in 1968, the first production motherboards were just coming off the production line. Near and Christopher chose the relatively new HP 2116 instrumentation minicomputer to run the automated test line and Christopher spent some time in California taking HP 2116 programming classes. (The next two generations of HP’s desktop calculators would be based on the HP 2116 instruction set.)

From production to the lab

After getting the HP 9100 manufacturing tests up and running, Christopher moved to the R&D lab in Loveland to work on operating system and driver code for the HP 9830 desktop calculator’s digital cassette tape drive. He again found himself using the HP 2116 minicomputer, this time for HP 9830 software development. When the HP 9830 desktop calculator was released to production, Christopher left the R&D lab and went with it. That’s where Don Morris found him.

Morris brought Christopher back into the R&D lab just as work was starting on the HP 9825. The machine was still in the early prototype stage and Christopher worked with Wayne Covington under Morris developing first-pass code for the machine. The HP 9825 team felt that they wanted to take the next step with this machine by vastly expanding its capabilities through extensions to the programming language originally developed for the HP 9820 and 9821 desktop calculators, which was viewed as somewhat limited. They also wanted to make the language easier to use and wanted to greatly enhance the new machine’s mass-storage abilities. (Recall that Christopher had worked on the HP 9830’s mass-storage code.) One of the main drivers behind the quest to improve upon the existing proto-HPL language was Wang Labs, a tough competitor that sold a competing line of desktop machines including some that could be programmed in Basic.

Consequently, the HP9825’s programming language grew from its roots in the HP 9820 until it outgrew the machine’s original keyboard layout. Initially, the HP 9825 desktop calculator was envisioned as a key-per-function machine (one of two reasons why the project’s code name was “Keeper”) but the numerous language extensions required that each key represent two and then three functions. The net result was a confusing collection of shift keys to access all of the function overlays. At some point, Morris pulled down the whole house of cards and convinced everyone to replace the key-per-function keyboard layout with a conventional QWERTY one.

The language that wouldn’t die

Barney Oliver 197104


Barney Oliver

Photo Courtesy of
Hewlett-Packard Company
 



This move jeopardized HPL. The legendary Barney Oliver, then an HP corporate executive vice president and head of HP Labs, absolutely loved the HP 9820 and its proto-HPL language. Oliver had made substantial contributions to the HP 9820’s programming language during the machine’s development. In some sense, he considered HPL to be “his” language and he was very protective of it. One of the things Oliver especially liked was the language’s ability to infer multiplication operations. So, for example, you could multiply the three variables A, B, and C simply by typing “ABC” (although “A*B*C” also worked). Parsing this expression is easy to manage in software if each variable (A, B, and C in this case) has its own key (HPL had 26 simple variables, one for each letter of the alphabet), but it became unworkable with a QWERTY keyboard because there is no way of telling if “PRINT” is a command to print something or if it’s the implied product of five simple variables: P, R, I, N, and T.

By now, Christopher had also become a project manager. Section manager Fred Wenninger had split the HP 9825 project into a hardware project under Morris and a software project under Christopher. The increasing complexity of HPL and the switch to a QWERTY keyboard convinced Christopher that the software team’s current direction was squarely aimed at essentially reproducing the Basic language’s abilities. So why not just switch to Basic and be done with it? Christopher felt that HPL was a language that only engineers could love and he wanted a broader market for the HP 9825. He proposed the switch to Basic. As Christopher says, his proposal “raised some dust.”

Barney Oliver had a talk with Calculator Products Division manager Bob Watson. Afterwards, Watson came over to Christopher’s cube, sat on the desk, and delivered the news. “Chris,” said Watson, “I understand your motivation but I have talked with Barney Oliver and considered the options. We’re sticking with HPL.” Christopher acquiesced and found ways to enhance HPL through innovations such as extensions to the limited number of variables. (Originally, HPL only had 26 variables labeled “A” through “Z.”) Oliver solved the problem of the implied multiply by requiring variables to use capital letters while functions used lower-case letters. HPL eventually absorbed many of the most desirable attributes of Basic, but with HPL’s peculiar 3-letter function mnemonics, it looked like Basic with the vowels sucked out.

The HP 9825 software-development project took about two years. Joining Christopher and Covington on the project team were Jeff Osborne, John Nairn, Joe Beyers, Mike Tremblay, and Bill Hanna. Originally, the plan was to reuse a lot of the existing HP 9820 code because the processor instruction sets were largely compatible between the second-and third-generation desktop calculators. However, the HPL language extensions, the expanded alphanumeric display, the enhanced mass storage in the form of the DC100 tape cartridge, and the new Diana thermal-printer mechanism meant that very little of the HP 9820 code could actually be reused. Even the math routines had to be rewritten.

John Nairn Small03

 

Joe Beyers 198103


John Nairn

Photo Courtesy of
Hewlett-Packard Company
 

 

Joe Beyers

Photo Courtesy of
Hewlett-Packard Company
 



The software-development tools available to the HP 9825 team were quite primitive by 21st-century standards. Initially, software was developed by typing source code into a clattering Teletype connected to an HP 2100-series minicomputer. This was a typical development environment for the early 1970s. All project code was stored on a 5-megabyte (not gigabye) removable hard disk called an HP 7905. Eventually, the software-development team graduated to a timeshared HP 3000 minicomputer with HP terminals.

When it was ready to be tested, the assembled code was punched on paper tape and manually transferred to a hardware simulator. The simulator was a separate HP 2100-series computer interfaced to a breadbox of circuit boards that emulated the custom I/O chips and peripherals being developed for the HP 9825. The simulator allowed the developers to run and single-step their code in a hardware environment that supported simple debugging. There was only one hardware simulator, so developers had to sign up for time slots, which often meant working strange hours.

Kill all bugs now

The project’s biggest challenge, the one that kept Christopher awake in a cold sweat at night, was that this code was going into ROM. All of the profits from HP 9825 sales would vaporize if the language ROMs had to be replaced in the field due to a bug in the code. Every day, the HP 9825 code base grew bigger and bigger, making the probability of shipping a bug bigger and bigger as well.

Christopher and his team developed some “new” software-development methods (new for HP anyway) to try to combat this problem. One of these innovations was statistical analysis of the bug rates on the HP 9825 code to try to determine roughly how many bugs might be left lurking in the code. Henry Kohoutek, the Calculator Products Division quality manager, assisted in this effort. Kohoutek had a background in statistics and had written the Loveland Division’s reliability engineering handbook. Christopher introduced the concept of “ego-less” programming. The idea was to get the coders to accept bugs as a fact of life and to drain the emotion out of generating bugs. The idea was to take the emotional energy normally associated with the negative feelings caused by having bugs found in your code and channeling that energy into finding and eradicating the bugs.

Another innovative addition to the quality assurance effort was the innovative “Steaks for Bugs” program that rewarded anyone who discovered a “class 1” bug with a gift certificate redeemable for dinner for two at a fine local restaurant. Christopher had determined that the cost of a steak dinner was trivial compared to finding a class 1 bug in the field after release. With this additional incentive, many HP employees, not just the development team, quickly volunteered for testing.

In addition, Christopher also hired three part-time helpers to help find the bugs. One of these helpers, a Colorado State University student named Jan Kok, developed an exquisite knack for breaking HP 9825 code. He created ever-more-devious ways to abuse HPL and his efforts exposed more code bugs than anyone else on the team. John Nairn remembers waiting for Kok to arrive each morning. “You would look to see if he had that faint smirk on his lips and gleam in his eye that told you he had found another bug and couldn't wait to show you.” says Nairn.

Christopher also adopted a “quality first, schedule second” mentality. He was not about to allow the HP 9825 ROMs to ship with bugs. Christopher made sure that his engineers understood the dire financial consequences of shipping buggy ROMs. The first production HP 9825 shipped in 1976. In 1977, it produced the highest revenue of any HP product from any division.

The language ROMs were never replaced in the field due to a bug.

In all, the entire operating system, language compiler and reverse compiler, the I/O code, and all of the option ROMs were crammed into half of the HP 9825A processor’s 64-kbyte address space. The other half of the address space was reserved for 32 kbytes of RAM that held the user programs and data. Eventually, some judicious code examination would allow the creation of a block-switching module that permitted more than 60 kbytes of RAM to be crammed into the calculator, but this feature only appeared later with the introduction of the HP 9825B.

Aftermath

About 10 years after the HP 9825 was introduced in 1976, Chris Christopher’s phone rang at HP in Fort Collins. It was Barney Oliver. “Hi Chris. How are you?” said Oliver. Then he said “I found a bug.” Oliver had received one of the first HP 9825s as a gift from lab manager Bob Watson, which he used extensively—particularly in his work with SETI (the search for extra-terrestrial intelligence). Oliver had even gone as far as to have HP Loveland’s Mike Kolesar develop special high-precision binary math routines for the HP 9825 that performed calculations with 28-30 digits of precision. After 10 years, something had finally gone wrong with the calculations on the HP 9825 and Oliver wanted it fixed.

Christopher took down some notes and hung up. He considered his options. Who could he get to work on this problem? The last HP 9825 had been sold and the machine discontinued in 1983. The development team had been disbanded. The original source-code files might be impossible to recover. What a mess.

Then, Christopher’s phone rang again. It was Oliver. “Never mind,” he said, “I found the problem. There’s no bug.”


References

This page was developed using emails and interviews with Chris Christopher, John Nairn, Jeff Osborne, and Joe Beyers.

HP9825.COM is in no way associated with the Hewlett-Packard Company.

Hewlett-Packard, HP, the HP logos, the HP 9825, and all other product model numbers starting
with HP are all trademarks of the Hewlett-Packard Company and don’t let nobody tell you different!

This site exists strictly for educational purposes. Nothing is for sale here. Substantial material from various issues
of the incomparable Hewlett-Packard Journal appears on this site, by permission of the Hewlett-Packard Company.

All text Copyright 2004 to 2010 - Steve Leibson

[Home] [Prehistoric Times] [The 9100 Project] [Prologues] [The 9825 Projects] [Epilogues]