A personal history of Write Once Run Anywhere (WORA) — Part I, the ‘80s

I’m writing a practical series about my first impressions of several modern attempts at conquering the problem of learning a new set of systems for every platform an application targets — iOS, Android, Web, Mac, Windows, Web, Linux, etc. The introduction to that series is here. I am tuning the central articles in the series for publication over the next few weeks, so please keep an eye out for those. But in the meantime, I wanted to lighten things up with a quick tour through some of my personal history with portable code.

The Sun marketing team coined the term WORA in the mid-nineties to push the Java platform. And a related word LOWA (Learn Once Write Anywhere), is currently the subtitle for the React Native website. But both of those concepts have been around nearly as long as programming.

I considered doing some deep research to write an ambitious article about the history of the WORA/LOWA phenomena. There were many intriguing things that folks near me at Microsoft were working on to help leverage code across platforms. But I wasn’t close enough to many of them to reliably recount the details years later. The first C#¹ is an example. So I even considered seeing if I could access the Microsoft archives to research some of the more intriguing things I heard about. In the nick of time, I realized I was not the right person to do any of that. I cannot, however, resist the urge to write out my personal experience, as I recall it, of WORA, LOWA, and related phenomena. I’ll do a bit of fact-checking where I can, and I hope to include some fun links. But please take this all with a grain of salt, especially in places where I’m pulling from memories that are decades old. I’ll get back to the more practical posts next week.

BASIC

I bought my first computer (an Apple ][ +) in1980, and my closest friends at the time owned a TRS-80 model I and a Commodore PET. Each of these computers came with a version of BASIC on ROM. This gave me my first taste of LOWA. The three of us learned BASIC together and were able to share tips, techniques, and other discoveries. It was a little more difficult to share code, but both 6502-based machines (the Apple and the Commodore) used variants of Microsoft BASIC. And while the built-in version of BASIC on the TRS-80 was homegrown, we could load a Z80-based Microsoft BASIC dialect onto that machine from tape.

As an aside, I spent some time in the late nineties grousing over the fact that computers no longer came with built-in programming languages because that was such an essential entry point for folks of my generation to the wonders of programming. So how were the teenagers of the 90s supposed to dig in and start coding? Turns out that was a big non-problem.

We could share code for programs like a DND character generator, which was entirely text-based. Mind you, sharing code meant typing it into all three machines since there was no hope of compatibility between secondary storage devices (floppy disks and tape drives) and translating between dialects of BASIC manually. Projects that were more graphics based required nearly complete rewrites. Some of the more significant projects we attempted with graphics were rudimentary arcade games and The Game of Life. We weren’t the only folks doing this. Computer magazines at the time would frequently publish complete listings of BASIC programs. They were often written for a specific dialect for one particular piece of hardware, but it was common practice to translate these programs to whatever hardware one had access to.

UCSD Pascal and P-code

My next, slightly less direct, experience with WORA came from reading about how my favorite game at the time, Wizardry, was developed. This was the game that convinced me I could and should become a programmer² (I don’t know that I had even heard the term Software Engineer at the time). It was written in UCSD Pascal by two people. And it was a truly fantastic game. So the concept that I (possibly with the help of a friend or two) could write a state-of-the-art game on my Apple II in my parent’s basement didn’t seem out of reach. I was still in high school at the time, so don’t beat me up about living in my parent’s basement, please :-)

The intriguing thing about UCSD Pascal that completely blew my mind in the early 80s and has stuck with me all these years is that it was my first introduction to the concept of a P-code machine. Portable code machines encapsulated the idea that you could compile your high-level language code to a compact byte code. That stream of P-code could then be read and executed by a small interpreter on any number of machines with different processors running different operating systems. This transferability was not at all practical at the time since there was no standard media to load programs from, and even early online solutions like CompuServe weren’t really up to the task of sharing large chunks of code. But it was a really cool idea. At about this time, Microsoft was developing its own p-code machine to build a line of productivity software, the first (and only shipped instance) of which was Multiplan. If you’re interested in this era, there is a recent interview with Jeff Raikes about Microsoft’s early vision of Office that touches on Multiplan and Microsoft p-code.

MacFORTH

Fast forward to 1984 and the release of the Apple Macintosh. By that time, I was working part-time at an independent Apple retailer (Bethesda Computers) and was able to get my hands on one of the very first Macintoshes. It was love at first sight. But wait — there was no built-in way for a hobbyist to program the darn thing. Apple’s development environment ran on Apple LISAs, and they may have also been cross-compiling from minicomputers. The LISA was also a 68K-based machine that retailed for $10,000 a pop — well outside of the budget of a high school student. I suspect Microsoft was cross-compiling from PC or Xenix build environments at the time, but that was before my direct experience at the company.

So what was a poor kid to do? Amazingly, another variation of WORA solved the problem. A company called Creative Solutions, Inc. in Rockville, MD (right up the road from where I was in Bethesda) had a line of FORTH systems that they had been building for personal computers for some time. The generic name for their flavor of FORTH was Multi-Forth, and they quickly ported it to the Macintosh and called it MacFORTH (which was somewhat confusing because there was another dialect of FORTH at the time called MacFORTH, totally unrelated to Apple’s hardware). FORTH systems were well set up so that one could write a small amount of native code to implement a FORTH Kernel and then port the rest of your FORTH code intact. These systems used Threaded code, which differs from P-code but solves similar problems. I used this system to write my first music editor but never got that to the point where I could ship it.

Cross-Compilation

Speaking of music editors, I worked for “The Center for Art and Technology” (now the IDeATe) while studying at Carnegie Mellon University. The project I worked on was to take a program written by another student called MacVoice that helped music students drill on Voicing and expand the program to handle more sophisticated musical concepts. Dr. Marilyn Taft Thomas directed this project, and I had some technical help from Dr. Roger Dannenberg and his staff. MacVoice was written on a minicomputer (maybe a PDP-11) and cross-compiled to the Macintosh. For the expanded program called MacHarmony, I programmed in Object Pascal on a Macintosh XL (LISA hardware running a MAC OS) and cross-compiled it to Macintosh. While these applications of cross-compilation weren’t direct examples of WORA, they were my introduction to this vital tool currently used in many multi-platform frameworks.

CISC Architectures and High-Level Language Concepts

Two other applications of LOWA clicked for me in college. They are more human brain-based than directly technology-based, but that’s where I’m drawing the distinction between LOWA and WORA. The first is that spending time with one CISC architecture and really getting to know it would transfer to other architectures. This saved me in one of the most challenging courses I took at CMU called “Introduction to Digital Electronics.” While I struggled with some of the math introduced in this course, I completely breezed through the practical lab. The lab was to write a small game on a 6800-based breadboard computer (basically a breadboard with a 6800 processor, a little memory, I/O for a game controller, and a connection for a black and white monitor). I spent way too much time in high school writing 6502 code for my Apple II, to the point where I had the instruction set memorized. I also read processor manuals for fun, including the 68K (which was the processor in my Mac). So it was easy to pick up 6800 assembly language and hack out the project in record time.

My final example is a real stretch conceptually but is important enough to be included here. In my sophomore year, I took a course called “Comparative Computer Languages.” This was a survey course designed by the estimable Dr. Jeannette Wing. In this course, we touched on easily a dozen computer languages and wrote significant projects in CLU, LISP, and Prolog. CLU was an imperative Object Orient language, LISP a functional language, and Prolog a logic language. This showed me that I only needed to deeply learn a language concept in the first language where I encountered it. I could then apply that concept relatively quickly when I saw it in another language. This application of LOWA is something that I used when researching this series of blog posts. Adapting to DART, a completely new language to me, was one of the most manageable parts of this adventure.

Conclusion

That covers my high school and college adventures in LORA, WORA, and, coincidently, most of the 80s. Next time I write about this history, I’ll launch into my early career at Microsoft and some of the more direct impact I had on WORA.

My next post will switch back to the practical aspects of Multi-Platform development systems with a review of my stab at writing my simple beat counter application using Microsoft’s .NET MAUI.

The Series

1. Which Multi-platform framework should I use to write my app?
2. Which Multi-platform framework should I use to write my app? Let’s try Flutter.
3. A personal history of Write Once Run Anywhere (WORA) — Part I, the ’80s (this post)
4. Which Multi-platform framework should I use to write my app? Let’s try .NET MAUI.
5. A personal history of Write Once Run Anywhere (WORA) — Part II, the ’90s.
6. Which Multi-platform framework should I use to write my app? Let’s try React Native.
7. Which Multi-platform framework should I use to write my app: Conclusions from the first round. (Coming soon)

¹As an intern at Microsoft in 1988, I worked on a team building an object-oriented C-variant that they were calling C-Sharp. I wasn’t on the compiler team, so I don’t recall any details of the language beyond that it felt kind of like Objective-C to me. In any case, I did end up spending way too much time trying to get the internet to cough up details about the first C#. The only semi-official source I could find was Rico Mariani’s “My History of Visual Studio” where he briefly mentions it in part 1:

…1988. The project I’d been hired to work on was cancelled after a few months (I expect I’m in good company on that score), that project by the way was a cute variant on the C language designed for incremental compilation — it was called, cough, C#. Strangely, through the lens of 2009, it looks remarkably like what you would get if you tried to make C.Net.

That may implicitly support my recollection that the early C# could build to P-code. I also think there might be a small error in the quote; I have some vague recollection that the official name might have been C-Sharp — in the ’80s, we weren’t quite ready to use a non-alphanumeric symbol in the name of a language?

² There is a Planet Money episode called When Women Stopped Coding that touches on the unfortunate flip side of teen-age boys discovering personal computer gaming and getting an early start on programming.