Monthly Archives: March 2011

On the Trail of the Oregon Trail, Part 2

I mentioned last time around that the original Oregon Trail was written on an HP-2100 series minicomputer. That’s a pretty interesting topic in itself.

HP’s first computer line, the 2100 series could be equipped with a number of possible operating system. One of the most common, and the one under which The Oregon Trail was written, was called HP Time-Shared BASIC. This system was very unique in its time, and perhaps even visionary. Rather than placing the user in the command-line driven environment typical of virtually all other OSs of the period, Time-Shared BASIC, true to its name, dropped the user after login into an interactive BASIC environment. Not only could she write programs here using BASIC, but all of her other immediate interactions with the system — loading and saving files, etc. — were also done using BASIC statements.

This was the design concept later used by many of the 8-bit generation of personal computers, as anyone who ever typed “LOAD ‘*’,8,1” to start a game on a Commodore 64 can attest. Following the norms of the time, even the original IBM PC dumped the user into a little used and seldom remembered BASIC environment if it didn’t find a DOS disk to boot at power-on. I’d been curious for years how we got from the command-line driven environments typical of most institutional computing to the interactive BASICs of these machines; now I think I have an idea.

Time-Shared BASIC represented a more welcoming environment for working and programming than was typical of the time, and this fact combined with the relatively low cost and easy maintainability of the HP-2100 line made these machines favorites of universities and even high schools. HP seems to have put considerable effort into designing and marketing the HP-2100 as a more user-friendly, accessible sort of machine. This manual is particularly interesting, being an introduction to BASIC programming pitched to the complete novice. It’s actually really well done, managing to walk the fine line of being friendly and accessible without falling into condescension. In light of all this, then, it’s not at all surprising that an HP-2100 would have found its way to Carleton College.

There were quite a lot of games and educational programs written in Time-Shared BASIC, and some of these have ended up on the Internet in the form of an unorganized dump to a huge tape image. So, I decided to try to bring up an emulated version of Time-Shared BASIC on my computer and to look through this mass to see if there might be an copy of the original The Oregon Trail in there somewhere. Well, it sounded like a good idea at the time, anyway…

You see, while there is an HP-2100 emulator available thanks to the amazing efforts of The Computer History Simulation Project, Time-Shared BASIC was a pretty complicated configuration. It was in fact TWO HP-2100s, one serving as a sort of gateway to users who connected via remote terminals and the other hosting the core of the OS itself. So, emulating the thing means running two separate HP-2100 emulators, loading the appropriate software onto each, and linking them together via sockets. Finally, one opens a THIRD window on one’s PC to telnet into system via the loopback address. I never would have gotten anywhere close to a working setup if hadn’t been for a Yahoo group dedicated to the platform, who host in their files section an emulator setup that almost worked right out of the box. I won’t bore you with the details of my struggles to get from almost to completely working; suffice to say that I finally got my own little Time-Shared BASIC system up and running.

And so I started going through the tape dump. This was almost 6MB of data, a large quantity indeed for a collection of BASIC programs often only a few kilobytes in length. Alas, though, no joy on The Oregon Trail.

But what I did find was pretty darn interesting, and more than justified the time it took to get to this point. Here were literally hundreds of BASIC programs: games, educational programs dealing with every subject, practical scientific and mathematical tools, etc. I even found what appears to be the original version of the old Star Trek game. There was obviously quite a thriving culture of program development and trading on this system from the late 1960s to the late 1970s. That’s perhaps not so remarkable in itself. What is, though, is that these programs were being written and used not by a priesthood of professionals as in the world of the IBM mainframe or a collection of focused hackers and researchers as in the world of the DEC PDP line, but rather by everyday students and educators. This gives their work a very different character. And if this sampling of their work is anything to go by, these people were very, very interested in games.

This mother lode deserves more attention, and I’m going to try to give it some and perhaps post a bit more about it in the future. (In particular, I want to see if I can find a version of the Hamurabi game Jason Dyer mentioned in a comment to the first post in this series.) But before I do that I’ll get back to The Oregon Trail proper next time around.


Tags: ,

On the Trail of the Oregon Trail, Part 1

I recently got a copy of 1001 Video Games You Must Play Before You Die. It’s not really a very good book, for reasons that are interesting on their own and that I hope to talk about in another post very soon. Right now, though, I want to talk about the very first entry in the book, on The Oregon Trail, because that entry sent me down a rabbit hole from which I have only just emerged, blinking and reconsidering the history of interactive narrative.

If you’re of a certain age and nationality (i.e., mine), you almost certainly know The Oregon Trail. From the early 1980s until well into the 1990s virtually every public school in America seemed to have at least a few Apple IIs off in a corner somewhere, and one of the titles available on them was guaranteed to be this little educational game which placed the player in the role of a would-be settler setting off from Missouri on the long journey to the Oregon Territory. Those versions communicated mostly in text, but they spiced up their presentation with lots of colorful graphics, and were appealing enough to become favorites among students then and to still be nostalgically remembered by millions today. In fact, I just learned that there is now a Facebook app of the game.

What’s not often realized is that even when it first arrived on the Apple II The Oregon Trail was already a very old game. That’s why it’s the first entry in the chronologically arranged 1001 Video Games. (Actually, the fact that they got this date right is kind of surprising, because there are a heck of a lot of others that they got wrong. But I promised not to kvetch about the book right now…) It was in fact first written in 1971 by three educators at Carleton College, a small liberal arts college in Northfield, Minnesota. Don Rawitsch, Bill Heinemann — no relation to the “Burger Bill” Heineman who worked on The Bard’s Tale series among other games — and Paul Dillenberger wrote the game in BASIC on an HP-2100 series minicomputer.

When I was writing my history of IF, I named two programs as the most important predecessors to the landmark Adventure (1976-77): Joseph Weizenbaum’s Eliza (1966), which first deployed the basic system of IF interaction (albeit in the context of an elaborate parlor trick rather than a game) and Gregory Yob’s Hunt the Wumpus, a simple game in which the player moves from room to room in a maze while attempting to avoid and eventually kill the eponymous Wumpus. The Oregon Trail makes me think that there should be a third entry on that list.

Let’s consider the state, such as it was, of interactive narrative in 1971. While there had been experiments with interactive storytelling before in the mystery genre, examples of the form were pretty thin on the ground. Edward Packard had already tried to get the first of what would become the Choose Your Own Adventure line of books published, but had been rejected by every publisher he had turned to, and would have to wait years more to see his idea in print. A group of scruffy wargamers in Wisconsin were toying around with the systems that would become Dungeons and Dragons, but, again, their work was years from publication. Wargames and other simulation games certainly had an experiential component, implicitly inviting their players to imagine the events they simulated unfolding in their imagination, but said events unfolded from the perspective of a god on high rather than that of an individual player in storyworld. In the world of computers, there was some ongoing work into computer-generated narrative among artificial intelligence researchers, but these were not really interactive narrative, but rather self-contained stories that the computer generated beforehand based on a set of input data and played out for an audience.

Yet The Oregon Trail opens by telling us, “Your family of five will cover the 2040 mile Oregon Trail in 5-6 months – if you make it alive. You had saved $900 to spend for the trip, and you’ve just paid $200 for a wagon.” It’s dropping us into a storyworld, and inviting us to take a role there and decide what happens next. Was there a computer program before this that so obviously wanted to make a story with (as opposed to for) us? I don’t know of it if there was.

So, I set off on a quixotic quest to experience The Oregon Trail in as close to its original form as I could manage. More on that next time.


Tags: ,

The Madness Spreads…

The Madness Spreads...


Posted by on March 11, 2011 in Interactive Fiction


Filfre version 1.00

(For the impatient: A new version — version 1.00 at last, in fact — of Filfre, an interpreter for IF games running under the Z-Machine or Glulx, is now available. You can get it from this very site.)

Seven years ago, I decided to write my own Z-Machine interpreter for Windows for two main reasons: 1) I wanted an interpreter with an integrated scroll-back buffer, and no one seemed inclined to provide one; and 2) I thought it would be a crazy fun project. Nerd that I am, the latter expectation proved to be correct. The first game I got working, opcode by opcode, was Infocom’s Infidel. I’ll never forget the feeling of satisfaction I had when that first paragraph of text finally appeared on my screen. There’s nothing quite like creating something for yourself, then stepping back and watching it work.

Still, that first version was very much a learning experience. I had only dabbled in Windows development before I started on it, and had no idea how to put together a modern object-oriented C++ application. When I decided to add Glulx support along with all the multimedia goodies that entails, I quickly realized that the only viable approach was to rip it all up and start again. I now understand that I still didn’t really know how to build a modern etc., etc., application, but I was at least a little better at it than I’d been the first time around. Since the burst of activity that resulted in Filfre 0.97, the first to support Glulx, in July of 2007, I’ve only come back to it in fits and starts, generally to fix bugs when my list of them got sufficiently long and to implement additions to the Glulx and GLK standards as Andrew Plotkin has made them.

I’ve been working with the specifications on Andrew’s site quite a lot recently for another project, one about which I’m quite excited and hopefully can tell you more very soon. A couple of weeks ago I downloaded the exhaustive suite of Glulx unit tests Andrew has recently uploaded there, one of the first fruits perhaps of his new status as a full-time IF “professional.” I decided, just for grins, to try them out quickly on Filfre. Lo and behold, what I found was pretty disheartening, in the form of great swathes of Glulx opcodes (dealing mostly with floating-point support) and GLK functions (dealing mostly with Unicode support) not yet implemented at all, and, even more embarrassingly, quite a few old opcodes that didn’t always work quite right under my implementation. So, the exciting project went on hold for a while, and two weeks later I finally have a Filfre that passes every one of the unit tests, and thus should fully conform with every aspect of the latest Glulx standard. And so I’ve decided to call it version 1.00 at last.

Mind you, I still die a little bit inside when I look at the code for Filfre. When I developed it I was still essentially treating C++ like C with a few useful new conveniences; all of the GLK I/O layer, for instance, is essentially implemented in a single class. And I have another burgeoning problem: the whole thing was developed with Borland C++ Builder 6, and relies on Borland’s VCL libraries from 2002. Builder 6 in fact has a number of compatibility issues with Windows 7, which made the last two weeks less fun than they otherwise would have been. My instinct is to rip it all up yet again, start over, and see if the third time really is the charm. But not right now. I still have the more exciting project, after all. And, while the old girl is a bit ugly on the inside, she works quite well from the user’s perspective. (The compatibility problems I spoke of affect only the Builder IDE, not applications created with it.)

Filfre hasn’t exactly taken the IF world by storm, but there has been one particularly gratifying thing about the experience: it turns out that Filfre works very well with screen readers, and thus it’s allowed quite a few blind people who had problems with other interpreters to play and enjoy IF. I wish I could say I anticipated and designed Filfre for this, but I can’t. It’s simply a happy accident, a result of my choosing to use the RichEdit libraries to implement I/O rather than drawing directly onto a canvas. But it still makes me pretty happy, and the emails I’ve received from the blind over the years have been some of the most gratifying of my life.

So, if you know and use Filfre, the latest and greatest is waiting for you. (And yes, the bugs that caused problems with The Blind House and Aotearea from last year’s Comp are both fixed.) And if you don’t, and you use Windows, and you’d like an interpreter with a somewhat more full-featured interface than the norm, an integrated scrollback, and a few useful convenience features, maybe you’ll want to check it out.

1 Comment

Posted by on March 7, 2011 in Interactive Fiction


Introducing a new blog…

While surveying the state of the Internet today, I decided that what the online world really needed was another blog. Luckily I have never been short of opinions to share. And so I proceeded to do some research into the best approach to my new endeavor. Several sites told me that if I hoped to acquire actual readers I should choose a narrow niche and hew to it rigidly. Others told me that with a bit of planning I could actually make a living off this blogging thing. One helpful fellow said I should review as much music as possible as quickly as possible, linking in each review to the product listing to make some money off every happy consumer I sent Amazon’s way. I needn´t waste a lot of time actually listening to the music I reviewed, he informed me; I need only use the snippets of songs on the Amazon site to get a “good impression” of an album, and so could I be on my way to riches with a minimum of critical effort. I thought about combining these two pieces of seemingly excellent advice, but quickly realized I would have a problem almost immediately: if I built a blog about, say, flugelhorn players who recorded during the 1970s, and reviewed as many flugelhorn albums from the era as possible as quickly as possible, I would soon be out of material. So I decided to throw out all this advice.

Instead, I’m going to use this blog to write about an eclectic mix of things that actually interest me. I may be commiting a sort of Internet-traffic suicide, but maybe one or two of us can have some fun while it lasts. So, you can expect updates on my various projects here along with lots of opinions on music, books, games, and who knows what else. And you can expect a bit of theory, and perhaps some cultural observations, and perhaps even a personal anecdote or two. Or maybe I won’t get to all of that. Who knows?

Defensive self-effacement aside, I have no idea where this blog will go. I tell myself that, as a writer by at least one of my trades, it’s good practice for me to write someplace like this frequently, to keep the old chops sharp, as it were. That’s true enough, and it’s also true that plenty of people before me have kept diaries and journals just for their own satisfaction. But I won’t lie; I’d like it if a few people actually started to read and comment as well. So, whether this is the start of a big thing or a failed experiment or a literary masterpiece whose importance will be understood (a la Samuel Pepys) only a century from now, it’s definitely the start of something. Wish me luck, and thanks for reading!