Back to GanjaTron's Site
HP-28S
[Click to enlarge]
The HP-28C and HP-28S were HP's first graphing calculators. The 28C only had 2K of memory and was quickly superseded by the almost identical 28S with a copious 32K (and a few additional commands). Due to these similarities I'll only refer to the HP-28S here.
HP calls this an "advanced scientific calculator", which is really a gross understatement. A more apt moniker would be "high-end scientific pocket computer" -- it's packed with sophisticated features most mere mortals wouldn't need. Like most of HP's stuff, it clearly zooms in on scientists, engineers, and techies in general, but also geeks who need a gadget to figure out the radius of curvature of their buttcheeks with 12 digit precision. :^)
The capabilities of the HP-28S are impressive; symbolic derivatives and integrals (although the latter restricted to polynomials), symbolic algebra with expansion, collection, and isolation of terms, Taylor series, and an equation solver, a library of ca. 120 physical units for conversion (including consistency check for combined units).
There's also a directory tree for grouping variables and programs (kinda like a file system). For reasons only known to HP, the current directory is only shown when you explicitly query the PATH command, and you can't change to parent directories, only all the way back to the HOME (root) directory. Later models showed the current directory at the top of the display thereby facilitating navigation
Other advanced features such as numeric integration, matrices (including determinants and inversion), complex numbers, statistics, linear regression, and binary operations (with word lengths of up to 64 bits) are standard these days on high end scientific calculators, and had appeared on prior HP models. To top that off, the HP-28S has a dot-matrix graphic-capable LCD and offers a function plotter (again, symbolic) with the ability to zoom in and redefine the plotting range and scale. Oh, and most importantly, it can beep up to 4400 Hz. :^)
The programming model is based on RPN (reverse polish notation), popularised in many earlier and now classic HP calculators. While some swear by it, others curse it. There's no denying however that its stack-based paradigm is an interesting concept and has its merits (particularly efficiency-wise), although it does take a while to get the hang of it, and the code is generally unreadable.
With the introduction of the HP-28S, HP extended RPN to handle arbitrary stack-based operations in a unified manner, regardless of the underlying type. Thus you can toss matrices, strings, and complex numbers on the stack and apply common operators like + or - with meaningful results (kinda like OOP with overloaded operators). Among the other additions are:
- Stack depth limited only by available memory
- More elaborate stack manipulation commands
- Commands to restore previous commands, operands, and stack contents (COMMAND, LAST, UNDO)
- Named programs and variables
- Definite loops with named counters (FOR... NEXT / STEP), indefinite loops (WHILE... REPEAT... END, DO... UNTIL)
- Local variables in programs; mainly used to get local copies of arguments passed via the stack (essential for recursion), although their values cannot be modified!
- Graphics commands (could have been more tho, in particular no line plotting)
- Hidden features (e.g. real time clock) via SYSEVAL command
Programs are treated just like other objects and are also entered into the stack where they can be evaluated (executed) or assigned to a variable for named invocation. Consequently, there is no explicit program entry/editing mode. Instead, you have to punch in the entire program on the command line (and I mean on one line), which isn't exactly user friendly.
A remarkable feature is the ability to save/load the display contents (text or graphics) to/from a string object with the LCD→ and →LCD commands. This not only allows you to save and restore the display, but also opens up quite a few possibilities by manipulating the string, such as animations, scrolling or by shifting characters, bitmask operations by applying logical operators, etc.
Having expounded its amazing capabilities, I must say I have mixed feelings about this calculator. All this sophistication comes at the expense of ease of use. I find the HP-28S aggravatingly clumsy to use, and it's not because of RPN. For starters, the clamshell design, while ideal protection, is awkward -- you'll find yourself constantly flipping back and forth because keys on both sides are frequently used in typical operation.
Another major problem is that the HP-28 is, for the most part, not
keystroke programmable; most commands are indirectly accessible through
menus (over 20 of them). Once a menu is activated, the cursor keys become
softkeys which select commands appearing in the LCD above them. Only 6
commands are shown at a time, so you'll have to page through the menu
until you get there -- an extremely tiresome process requiring multiple
keystrokes for almost
Since the cursor keys are mapped to commands once you've selected a menu, attempting to navigate your program will result in the accidental insertion of commands (possibly even overwriting parts of your program). You have to explicitly disable the current menu and reactivate the cursor keys to get around. Once you've repositioned the cursor, you'll have to repeat the process and pop up another menu. An insane approach to program entry!
While you can also type in commands via the alphanumeric keys, that's still quite a few keystrokes (even BASIC pocket computers allow keyword entry with a single keystroke). It also requires you to learn all commands (over 280 of them) by heart. There is infact a built-in catalogue of commands listing the expected operands but no synopsis of what each command does. That's convenient, but it's no substitute for direct keystroke entry. It's admittedly difficult to come up with a decent concept to easily access such a multitude of commands on so few keys, but personally I feel HP didn't do a decent job here. A command completion feature (as found on UNIX shells) would've been really neat, though a stretch for a pocket compie.
The debugging features of the HP-28S are also disappointingly crude and don't match its overall sophistication. To step through a program you have to insert an explicit HALT command into your program where necessary. Once there, you can single step through your proggie with the currently executed command briefly flashing in the top line. In their infinite wisdom, HP decided to group the SST (single step) command in a menu along with other program control commands; there is no dedicated key for this! This can be a real pain when you're debugging complex programs.
Error messages on the HP-28S are pretty verbose for a pocket compie. Syntax errors are already caught during program entry, with the HP-28S marking the offending token for you to correct -- very convenient. If an error occurs during execution, however, there is no indication as to where the error occurred (unless you happen to be stepping over the offending command)! Good luck in finding that bug, because your HP-28S won't help you...
The HP-28S comes with a (then, for a pocket compie) whopping 32K of memory, enough to handle even highly complex programs. That's all very fine, except you have no way of saving your programs and data in case the batteries die; the HP-28S has no mass storage capabilities. That's acceptable if you have just 2K of memory, but with 32K it's inexcusable, and I don't think price was an issue as this certainly isn't an entry level model. The only I/O capability comes from an infrared LED to link up the HP-82240 printer. That's right, wireless printing. Certainly novel for 1987, but it doesn't save you from having to type your proggies in when the memory blanks.
A niggle which one normally has to live with is the poor performance of pocket computers, which at least tends to prolong battery life. The HP-28 is noticeably sluggish in operation and plots considerably slower than, for instance, Casio's graphing calculators that preceded it. There's apparently a lot of book-keeping going on in the background, such as saving stack states and command lines so they may be restored with UNDO and COMMAND, as well as frequent "garbage collection" cycles to reclaim and consolidate unused memory. Although you can disable UNDO and related features to save memory, it doesn't seem to affect performance.
[Update: According to Voyage au Centre de la HP-28 (see Links below), the HP-28 has a variable speed setting ranging from 0 to 15 at a certain memory address (depending on the version). The default setting is 7, which means the HP-28 normally runs at half speed, presumably to extend battery life. Increasing this value accelerates the HP-28, but there is one caveat: Pressing ON (which also performs the equivalent to AC on a basic calculator) resets it to the default, so this feature is of limited use in direct mode. On the other hand, programs should be able to tap its full potential, but I haven't experimented with it yet.]
And then there's the build quality. To be fair, the glare-free LCD with the matte finish is a nice touch and clearly readable even with strong reflections. The keys are firm and have the trademark HP clicky tactile feel which collectors have come to love (and which was replaced by squishy rubber keys in later models). Personally I feel the keys could be a bit softer, but maybe that's because I'm too accustomed to the more common rubber keys.
The case is a different story. Its build quality is not up to HP's earlier standards. The double hinge assembly joining the two halves seems sturdy enough (and actually folds 360 degrees), but the plastic is flimsy. The design is, as always, subject to personal taste and styling trends at the time of release, but I personally wouldn't call the chocolate brown / light gray combination attractive.
The battery compartment is an absolute disaster! Its cover is subject to enormous pressure from the springs in the compartment (powerful enough to repel a frigging locomotive!), causing the brittle plastic around it to eventually crack. Most HP-28's have a cracked battery compartment which doesn't hold its cover in place anymore. Even if the compartment is still intact, you'll have a jolly time pushing the batteries in with your fingers to overcome the force of those springs so you can shove the damn cover on! Sometimes I really wonder what those HP guys were smoking when they designed this thing...
| Well, this is what's left of the battery compartment on my HP-28S, and it barely closes. C'mon HP, for crying out loud: you've done a helluva lot better than this! [Click to enlarge] |
So what we have here is a powerful and versatile instrument with lots
of possibilities marred by clumsy handling and needlessly complicated
operation. The HP-28S is
I'd consider this an experiment or a case study of HP's (then) next generation of scientific programmables, and frankly, it wasn't entirely successful. Its successors fared better while still retaining many of its features.
Hardware Issues
- Selfdestructing battery compartment
- Inferior build quality
- Slow speed
Specs
| Year of introduction | 1987 |
|---|---|
| Retail price | $235 (1988) |
| Chipset | 2× Lewis 1LR2 at 1 MHz in master/slave config (slave CPU disabled) |
| Memory | 32K for programs and data, 128K ROM |
| Display | 137×32 dot matrix LCD |
| Audio | Piezo beeper |
| I/O | Infrared output to HP-82240 printer |
| Storage | None |
| Programming model | RPL |
| Power Source | 3× N / LR1 1.5V |
| Rarity | Common |
| Verdict | Overly complicated RPL toy for HP geeks |
Links
HPcalc.org Software Archive (includes docs and programs for HP-28 series)Marcus' HP-28S page (includes program listings in German)
Voyage au Centre de la HP-28 (ML programming, software/hardware hacks)
Back to Retrocomputing
Back to GanjaTron's Site