Renga in Blue
ZENO (1983)
Welcome to ZENO – a test of your initiative
The objective is to survive as long as possible against an increasingly hostile environment
IBM as a company has only come up here so far in passing, as a competitor to other companies like ICL or General Electric. Today’s game deals with IBM quite directly in a way that requires going back to the 60s, hence–

1963 photo of an IBM 1401, from George Dunbar in Toronto with more pictures here.
1954, MIT: in a discussion about a future where more people could use computers (that were at the time room-sized and used for one thing at a time) the legends Grace Hopper and John Backus (later famous for COBOL and FORTRAN respectively, amongst other things) brought up two opposing views. Hopper endorsed the idea of computers in parallel, many small computers linked together, while Backus instead promoted the concept of “a big computer” used as “several smaller ones”. John McCarthy, one of the time-sharing pioneers, already was thinking of the idea in 1955 and he made his first proposal in 1957, eventually using the current hardware available at MIT to implement what he called a lesser version of the idea:
This demonstration was called time-stealing, and was regarded as a mere prelude to proper time-sharing. It involved a fixed program in the bottom of memory that collected characters from the Flexowriter in a buffer while an ordinary batch job was running. It was only after each job was run that a job that would deal with the characters typed in would be read in from the drum. This job would do what it could until more input was wanted and would then let the operating system go back to the batch stream. This worked for the demonstration, because at certain hours, the M.I.T. Computation Center operated at certain hours a batch stream with a time limit of one minute on any job.

This was in 1959; the same year, Christopher Strachey (who created one of the candidates for “world’s first videogame”, see picture above) published a patent for his own time-sharing concept.
When I wrote the paper in 1959 I, in common with everyone else, had no idea of the difficulties which would arise in writing the software to control either the time-sharing or multi-programming. If I had I should not have have been so enthusiastic about them.
Hence, the idea was in the air: the technology just needed to catch up. The first actual working system was started in 1961 (based on McCarthy’s work) using an IBM mainframe. So while Dartmouth (with GE) was at the vanguard of computer time-sharing (1964), it is hardly surprising that IBM reached commercial time-sharing at essentially the same time, with the IBM System/360.

University of California, 1966. Source.
The original System/360 had a “Virtual Machine Monitor”; this was the overarching master system that made contact with the “metal” of the mainframe. Within this was built a CMS (Conversational Monitor System) which essentially appeared to the user like a “personal computer”; this was a way to do timesharing in a way that was essentially seamless. The user could treat the device in front of them as their own.

From IBM’s 45 (Official) Years of Virtualization.
A young Stuart Madnick started work on the CMS at the IBM Cambridge Scientific Center in June of 1966 while still a student at MIT. He started with developing the file system, basing it on MIT and Dartmouth’s time-sharing work, then (part-time during the school year) developed the EXEC system (originally called COMMAND). EXEC was a scripting system meant to manage computer commands in sequence; a program to run other programs.
You can create simple EXEC procedures that execute several frequently used commands~ or you can devise complex EXEC procedures that test several logical conditions before deciding whether or not to execute a command. The logical capabilities in the EXEC processor are controlled with statements similar to the IF/THEN, GOTO, DO, and LOOP statements familiar to high-level language users.
— From a 1975 EXEC user manual
For example, this sample from IBM compiles and runs COBOL code:
* RUNCOB2 EXEC *
&CONTROL OFF NOMSG
&IF &INDEX LT 1 &GOTO -ERR1
COBOL2 &1
&IF &RETCODE NE 0 &EXIT
GLOBAL TXTLIB VSC2LTXT CMSLIB
&IF &RETCODE NE 0 &EXIT
LOAD &1 (START
&IF &RETCODE NE 0 &EXIT
&TYPE RUNCOB2 EXEC FINISHED
&EXIT
-ERR1
&TYPE PROGRAM NAME NOT GIVEN
&EXIT
This was followed in the 70s by EXEC 2, which had more flexibility and user-defined functions; essentially, it took EXEC’s more practical approach and tried to make an all-purpose scripting language. However, it was still designed with the assumption that most lines were intended to run other programs (like COBOL compilers) and while it was possible to apply if-then logic and the like the notation in such cases was relatively cryptic.
Hence, another follow-up: the language Rex (later renamed Rexx), work started in 1979. To compare the change, here’s some EXEC 2 code…
COPYFILE &FNAME &FTYPE &FMODE = BACKUP =
&IF &RC GT 0 &TYPE Copy failed with return code &RC
…and here’s some Rexx code that’s equivalent.
‘COPYFILE’ fname ftype fmode ‘= BACKUP =’
if rc>0 then say ‘Copy failed with return code’ rc
The second “if” statement is more natural. Rex(x) prioritizes readability and is considered one of the predecessors to the ultra-popular Python language.
My first implementation of Rexx was made freely available over IBM’s world-wide internal network in late 1979 and rapidly became popular. The network made it easy for people to exchange ideas and make suggestions for improvements. Also, because the language was limited to one (large) organization, it was possible to make some rather large changes in response to these suggestions. For example, one change, in which the ARG instruction replaced an earlier ARGS instruction, required updating hundreds of thousands of Rexx programs.
As a result of this direct feedback, the language quickly evolved to meet the needs of its users through a number of releases over the next few years. By 1982 it had become essentially the language known in OS/2 2.1 today; its name gained an “X” to avoid any confusion with other products. Rexx was included in the third release of IBM’s VM/System Product, shipped in 1983.
— Mike Cowlishaw, original designer of REXX

Cover of a 1990 edition of the Rexx user guide written by Cowlishaw.
(The three languages — EXEC, EXEC 2, Rexx — are still maintained to work with modern IBM systems. Corporate mainframe code can have legacy code dating back to the 70s in active use; this is why COBOL programmers are still in demand.)
All this is relevant today because not only is today’s game ZENO written in Rexx (back when the language was still internal to IBM), ZENO is a “programming game”; you are at a central computer controlling robots with programming. Regarding programming games in general, I briefly touched upon the game OMEGA in my writeup of Pillage Village; I also recommend Data-Driven Gamer’s series on the classic (and extremely difficult) Robot Odyssey. We’ve never had any that are also adventure games. (There’s some linkage to Suspended, but ZENO ends up being very different.) I’ll give the details on how ZENO works in a moment, but let me jump back to the 60s again and follow our author, hopping geographically over the Atlantic.

Dave Mitchell first went academically down a very different path than he ended up in; he got a BA in Theoretical Physics at Oxford in 1963 before doing postgraduate work in Psychology. He joined IBM in 1968, only two years after EXEC started development, although his original work was in the language PL/I. (See my writeup on Ferret for more on the PL/I language.) He spent the 1970s mostly working on “programmer training”.
Like many mainframe programmers in the 1970s, he came across Zork, becoming very interested in how “tools” were used in the game; also note that original mainframe Zork includes a section where you give commands to a robot.
As a programming teacher, he decided to riff off Zork but use it to create a programming language for robots. You are in a central base and your job is to protect it; while you can’t leave the base, you can interact with the outside world with a variety of robots.
This game generally speaking hasn’t been available for ages; it was designed to work on an IBM mainframe which was only running a short time, and it only re-appeared on the internet 5 years ago when the author (Mitchell) got the game up and running with Hercules (an emulator for running old IBM virtual machines). The part of his website that held the download is now defunct but it was rescued by Robert Robichaud (Rob in our comments); getting it running was also a Herculean feat but Gunther Schmidl managed to create a package you can download here. (As a word of warning, your virus detector may not like the setup as it runs an open port; I had to turn it off to play the game.)
Before moving on, I should emphasize that ZENO and Suspended landed on roughly the same concept from roughly the same source. Infocom’s ideas around commendable NPCs first appeared in the Zork robot, and they advanced their system with Deadline that was then re-used for Suspended. Mitchell was working independently, landing on a more esoteric outcome in being a full programming game.
ZENO is an experimental REX exec (currently in version 1, the initial prototype). It was written (in the author’s own time) in 1983:
(i) to provide an interactive environment to stimulate the learning of problem-solving skills (debugging etc)
(ii) to demonstrate the expressive power of REX (though the prototype should NOT be taken as illustrating good programming style)
(iii) to show that an interpreted language CAN provide adequate performance, even for a large complex application
(iv) to prototype a number of “Personal Computer” characteristics (e.g. a VDU scroller, command language, full-screen editor etc)
(v) to experiment with the computer control of a variety of complex devices (lifts, robots etc)
(vi) for entertainment (outside business hours)
The language being used in the game is not a “real” language but one made for the game he calls SIMPL/E (as a parody of PL/I).

While the game technically accepts parser commands, it does so with a major simplification: it really cares about single objects, like a textual version of a point-and-click game. That is, while you can start the game with “go lift”, you really just need to type “lift” to enter it. (Or “computer” to use the computer, or “book” to use the book.)

The button in the lift is broken (pressing it causes nothing to happen). Typing “notebook” will automatically pick it up and use it (your avatar will subsequently keep it on hand for taking notes). Because of the parser simplification, typing “drop notebook” will just open it again; there’s no way to drop the notebook once you have it.

Early on messages start like “the air here is a bit stuffy”. Like Suspended (and Starcross) there are environmental problems going on, and the first thing to do is to start the air pump (this is mentioned explicitly in the directions).

My first time through I struggled for a while to figure out the air pump as the “book” that’s in-world is rather long and esoteric, but I’m pretty sure you’re intended to use the guide the game comes with for starter commands; it’s hard to figure out how to even get going with the robots otherwise. The relevant page from the book, for reference:

The lift needs to be turned on with the computer just like the air pump; once on, the button inside works to take you to an observatory.

If you try to go to the computer and type a command, you get pulled out as
You are distracted from the keyboard because:
The robot enters the lift
The book on this floor, ominously, has many pages ripped out, but keeps information on how to handle errors from source code:

This gets extremely complicated fast, so I’ll explain the various computer features and what can be done with robots next time. In the meantime, here’s the result of typing “window”:
After you touched the window it shattered, and you are sucked into the vacuum of empty space.







































































