Sumerian timesharing?

So there was an obituary in the New York Times the other day:
“Overlooked No More: Mabel Addis, Who Pioneered Storytelling in Video Gaming”
“She was a teacher when she participated in an educational experiment
with IBM. As a result, she became the first female video game designer.”
There’s a photo of Ms. Addis, surrounded by three young girls, captioned:
“Mabel Addis, at the keyboard, in 1964 with students. Her Sumerian Game
taught the basics of economic theory.
Credit…R.W. Burghardt/IBM, via Devin Monnens”

The article goes on to say “A slide projector and a cassette player set
the scene as students entered commands on a typewriter-like IBM 1050 linked
to an IBM 7090 mainframe computer.” And another photo is captioned:
“An example of the typewriter-like IBM 1050 that students would have used
to play the game Addis wrote.
Credit…N.E.A. Photo, via Kate Willaert”

So my first thought was – OK, so clearly this interactive program
wasn’t likely being run on a typical IBM 7090 batch operating system
(like IBSYS or UMES), so. . . timesharing?

The only timesharing system I’m aware of for the IBM 7090 in 1964 would
have been MIT’s CTSS. Also, the tank-like 1050 terminal is pretty heavy
guns to be installed in a school – you’d think an ASR 33 teletype
(as commonly used with CTSS) would have been a more likely choice,
right?

So, a bit of googling turned up (via a podcast and YouTube channel I hadn’t
known about, so that at least was useful):

Sean Haas’ “Advent of Computing” podcast (also available on YouTube).
Episode 57, “Simulated Sumeria” contains (at 26:07 [/1:00:45])

“You may have noticed that I’ve been a little bit unclear about some
aspects of the Sumerian Game. That’s for good reason. The program itself
hasn’t survived into the modern day. In fact, it didn’t survive very
long at all. After revisions, the updated version was used in a
classroom in 1966. Then, its hundreds or maybe even thousands of lines
of Fortran seemed to disappear into the sands of time. So, why did such
a complicated program, one that was even developed with government funds,
just disappear? Why did no one keep a copy of the code around? I think
a big reason is that the Sumerian Game wasn’t really the project’s final
result. This gets back to the root of the IBM-BOCES [Boards of Cooperative
Educational Services in New York State] collaboration. The initial
proposal was to study if a computer game could help teach students
economics. The Sumerian Game was just part of the experiment design.
Once the study ran its course, the game didn’t really matter as much as
the data. I think a contributing factor was probably computer access.
During the study, students were bussed out to an IBM office to actually
play the Sumerian Game. Once the study was completed, the rural school
just didn’t really have access to IBM’s computers. It’s not like many
school districts at this point in history could afford their own computer. . .”

So Haas’ commentary (together with any lack of any Google conjunction among
“CTSS”, “Sumerian” and “Mabel Addis” suggests that this was a standalone
program that actually monopolized an entire IBM 7090 while it was being run.
Which would explain both the necessity of bussing the kids to an IBM office
and the heavy-duty 1050 terminal (which was presumably simply what IBM had
on hand to interface with the mainframe). Clearly never intended to be actually
distributed to schools, at the time (which would, presumably, have required
collaboration with MIT to obtain the use of CTSS, which apparently was
never in the cards).

¯_(ツ)_/¯

Interesting history… I see there’s a Wikipedia entry which might be worth a look:

There was an article on the Sumerian Game (and Hammurabi) on “a critical hit!”:

This also includes a newspaper photo of Mabel Addis:

1 Like

Hi! I’m a researcher who worked on The Sumerian Game for years. I wrote about it in one of my books and now I’m nearing the release of an entire book on this subject: The Sumerian Game: A Digital Resurrection. BTW I’m the guy who rebuilt it and released it on Steam for free, just in case you’d like to try it out by yourself.
You are doing some interesting questions. Maybe I have a few answers, maybe you can help me with some details I’m missing. First of all, as far as we know, the IBM 1050 terminal wasn’t installed in the school but was in the faculty office of the School District. The source code (that was lost) was described as 15.000 lines of Fortran code. According to a few sources, it was stored on punched cards but I supsect it was recorded on magnetic tape.
Was it executed as a time sharing software or it occupied the entire mainframe? That’s a very very good question. I might have the info you can use to answer it.
According to the few printout that survived (and that I used to rebuild the game), the program was uploaded into memory with these few commands and output:

"PRO SUM9RX B
SEMBLANCE FORMATION STARTING.
STORAGE REQUIREMENTS FOR ABSOLUTE PROGRAM
PROGRAM NAMED SUM9RX USES HIGHEST LOCATION 04237
EXECUTION BEGINS AT LOCATION 00000
PATCH AREA LOCATIONS ARE FROM 04240 THRU 04377
SEMBLANCE FORMATION COMPLETE.
?

ILLEGAL COMMAND
?
SEL SUM9RX
WAIT
SUM9RX IS SELECTED.
?
RUN
SUM9RX IS RUNNING"

“Pro Sum9rx” should load the program into memory, Sel sum9rx should select the program and run… well it should just launch it :slight_smile:

There’s a bit more in another printout where the program is launched with:

“run 100
Suilxr is running.”

(suilxr is another version…, I rebuilt both in the Steam game)

That said, I suspect the game was stored on magnetic tape and was executed exclusively (ie: not time sharing). If you can validate my hypotesis, it would be
great!

When funds started to run out, the game was ported by Jimmer Leonard (a researcher quite good at programming!) to the cheaper IBM 1401 with autocoder. He also programmed the The Free Enterprise Game, another educational game designed during the same project.

1 Like

According to the few printout that survived (and that I used to rebuild
the game), the program was uploaded into memory with these few commands
and output:

PRO SUM9RX B
SEMBLANCE FORMATION STARTING.
STORAGE REQUIREMENTS FOR ABSOLUTE PROGRAM
PROGRAM NAMED SUM9RX USES HIGHEST LOCATION 04237
EXECUTION BEGINS AT LOCATION 00000
PATCH AREA LOCATIONS ARE FROM 04240 THRU 04377
SEMBLANCE FORMATION COMPLETE.
?
SEL SUM9RX
WAIT
SUM9RX IS SELECTED.
?
RUN
SUM9RX IS RUNNING

Clearly that’s an interactive monitor of some sort (whether it’s
timeshared or not is a separate question).

It doesn’t look like any kind of output I’ve seen from IBSYS or FMS (the
Fortran/FAP Monitor System) – both of those were batch systems;
or CTSS (MIT’s 7090/7094 interactive timesharing system). FMS hasn’t
survived as far as we know, but there’s a description of it at
people.csail.mit.edu/saltzer/Multics/MHP-Saltzer-060508/bookcases/CC%20Memos/CC-170.pdf

The 7090 is primarily associated with batch processing; but on the other hand,
in addition to CTSS, the SABRE airline reservation system was an interactive
system initially implemented on IBM 7090s.

I suppose the surviving session example might have been from a custom,
internal-use monitor developed by IBM (possibly as part of the game project
itself; though that “PRO” command – initiating a loader – suggests it
could have been used with other programs).

But that in itself would be worth knowing more about, and documenting,
if there’s any ancient IBMer still around who might recognize it.

The source code (that was lost) was described as 15.000 lines of Fortran code.

If I had to guess (and it would be just a guess), the source code was
written in Fortran II (rather than the later Fortran IV), with perhaps
a bit of FAP (Fortran Assembly Program), and was compiled/assembled down
to relocatable object code under FMS (the Fortran Monitor System).

MIT was still using FMS in 1963 (at a time when CTSS was being developed)
to create, for example, the STRESS (Structural Engineering System Solver)
program. (Fortran II and FAP were still available as a “subsystem” under IBSYS,
whose IBJOB subsystem also provided Fortran IV, Cobol, and a newer
assembler.)

I wonder if that interactive monitor completely overwrote itself when
it loaded the program, rather than leaving a nucleus in memory (as IBSYS did –
in low memory; I see that SUM9RX starts at location 0). That would presumably
have required operator intervention to re-load the monitor when the SUM9RX
session ended.

According to a few sources, it was stored on punched cards but I suspect
it was recorded on magnetic tape.

Either one would have been an option with FMS.

That loader command, though – “PRO SUM9RX B” – I’ll bet that was
fetching the program from a magnetic drum (or even a disk).

Here’s a bit of Fortran history:

++++
Reminiscences of Fortran
Conrad Weisert
March 25, 2007

. . .

Operating system hostility

The 704 Fortran compiler was a stand-alone program. The coming of the successor machine,
the IBM 709 with overlapped I-O channels; and its much faster second-generation solid-state
counterpart, the 7090, brought the expectation of and necessity for a batch operating system.

Unfortunately, the huge multipass Fortran compiler had been developed with the assumption
that it owned the whole machine configuration and with little attention to localized
input-output. To make it work under the proposed SHARE Operating System (SOS) was going
to be a massive undertaking. To make matters worse, SOS’s linking loader couldn’t handle
the relocatable binary modules produced by the Fortran compiler. Fortran was hostile to
SOS and SOS was hostile to Fortran.

In desperation, IBM threw together a crude operating system, which it called
“The Fortran Monitor System” (FMS), containing the Fortran compiler and a
“Fortran Assembly Program” (FAP). George H. Mealy described FMS as
“an operating system in which every instruction knows about every other instruction”;
an exaggeration, but indeed FMS was a monolithic mess that you couldn’t adapt to
either new hardware devices or additional software components.

So, for several years the large community of Fortran programmers on large IBM computers
had to do their work within a clumsy and inflexible operating environment.
++++

2 Likes

By the way, the name “SUM9RX” is suggestive.

The component records of the FORTRAN II compiler (under IBSYS)
all have record labels beginning with “9”: “9F0100”…“9F3400”,
the Fortran II run-time library records have labels like 9FL001
through 9FL079, 9FLEND; and the Fortran II run-time subroutines
have labels like:

LBL TTL ENTRY
9ATN FLOATING POINT ARCTANGENT ROUTINE ATAN
9BST BACKSPACE TAPE (BST)
9CAB COMPLEX ABSOLUTE VALUE FUNCTION IABS
9CAS COMPLEX ARITHMETIC BASIC SUBROUTINES (IFMP) (IFDP)
9CHN MONITOR CHAIN ROUTINE CHAIN
. . .
9XP3 EXPONENTIAL ROUTINE-FLOATING PT. BASE AND EXPONENT EXP(3
9XPF FLOATING POINT EXPONENTIAL FUNCTION EXP

So the “…9RX” part of the program name may tie it to
Fortran II. Or not! ;->

I wonder if that interactive monitor completely overwrote itself when
it loaded the program, rather than leaving a nucleus in memory (as IBSYS did –
in low memory; I see that SUM9RX starts at location 0). That would presumably
have required operator intervention to re-load the monitor when the SUM9RX
session ended.

Or I suppose the program could itself have re-loaded the monitor upon
exit.

I think I may have found it.

https://dl.acm.org/doi/10.1145/1464052.1464092
++++
The time-sharing monitor system
Author: H. A. Kinslow

AFIPS '64 (Fall, part I): Proceedings of the October 27-29, 1964, fall joint computer conference, part I
Pages 443 - 454
https://doi.org/10.1145/1464052.1464092
Published: 27 October 1964

The IBM Advanced Systems Development Division is currently operating
the Time-Shared Monitor System (TSM), an experimental, general-purpose,
time-sharing system based on the IBM 7090 Data Processing System.
This system is capable of serving 24 remote users simultaneously. It
requires a minimum of computing equipment, and gives the remotely located
user a maximum amount of control over the 7090 itself; and over the
content of his program files within it.
++++

https://dl.acm.org/doi/pdf/10.1145/1464052.1464092
++++
THE TIME-SHARING MONITOR SYSTEM
H.A. Kinslow
International Business Machines Corporation
Advanced Systems Development Division
2651 Strang Blvd., Yorktown Heights, New York
PEekskill 7-6600

INTRODUCTION

The IBM Advanced Systems Development Division is currently operating the
Time-Shared Monitor System (TSM), an experimental, general-purpose, time-sharing
system based on the IBM 7090 Data Processing System. This system is capable of
serving 24 remote users simultaneously. It requires a minimum of computing equipment,
and gives the remotely located user a maximum amount of control over the
7090 itself; and over the content of his program files within it.

The basic programming language of the system is Fortran Assembly Program (FAP) symbolic.
There are no restrictions on the type of language capability which can be added to
the system, or on the type of programs which the system will accept, compile and execute.
At the present time the system contains a FORTRAN compiler, a time-sharing version of the
General Purpose Systems Simulator (GPSS), and an interpretive sub-system called PAT
(Personalized Array Translator).

Users’ programs, and the data files which they operate upon, are permanently stored in
an IBM 1301 Disk File. A user of the TSM system submits his program once, either from
a remote terminal or by a batch run in the machine room. Thereafter the program is part of
the system’s memory and can be manipulated at will from the terminal. . .

The 7090 CPU is equipped with three extra features for time-sharing purposes; repeatability,
memory protection and an interval timer. The repeatability feature allows all programs
to be compiled at origin 0000 and executed in any available memory space. The memory protection
feature sets upper and lower bounds for a program and prevents it from referencing
any space outside those bounds. The interval timer, which can be set only by the supervisory
program, will generate an interrupt at the end of any predetermined time interval. . .

At the present time the terminals on the system are from the IBM 1050 Data Communications System.
Subchannels have been designed for an experimental facsimile printer and a cathode-ray tube device.
The TSM supervisor has been written to be independent of the nature of the terminal. . .

A typical execution sequence in this mode of operation is:

  1. ID; Operator Number, Project Number.
    This signs the user on the system.

  2. SEL; Program Name.
    This identifies the program to be executed.
    The Select service routine retrieves the program from the 1301 file and writes it
    into the core image area. This is the equivalent of loading the program into
    memory.

  3. RUN
    Since the program has been identified and isolated for action, there is no need to
    keep repeating its name as an operand. The RUN service routine performs a nontrivial
    function of determining the requirements of the program in terms of core space,
    data files to be operated upon, tape reels to be mounted, special instructions to be
    sent to the machine room, etc. It then informs the TSM Supervisor that the program is ready,
    and the user’s program enters the time-sharing cycle.

  4. User Program Execution
    The user is on his own. His program is executing and in control of the terminal. . .

This is the basic set of commands for remote IBM 7090 operation. There are others.

“PROCESS” [or “PRO”?] is the command which triggers the compiler-assembler-loader functions
of the system . . .
++++

Timesharing after all. Amazing.

1 Like

That’s amazing. Thank you.
BTW here is an information I’m sure you like to know.
One of the surviving printed output was signed by the IBM supervisor. I studied it extesively because it was the base for my reconstruction of the Sum9rx game (BTW did you try my game? The Sumerian Game on Steam ). I decided to call the printout “McDonnell’s game” because of the sign (and the importance of the printout).
Well probably the supervisor was this McDonnell Eugene McDonnell - Wikipedia
And now everything checks out!

ps: btw would you like to contact me directly? I’d like to discuss my research with you. The tech part I mean. As I said, I’m in the middle of releasing a book about the sumerian game and my study

1 Like

I’m in the middle of releasing a book about the sumerian game and my study

Best of luck to you with your book; I’m happy to have helped
shake loose an additional morsel of background information for you.

But having satisfied the curiosity aroused by that New York Times
“better late than never” obituary of Ms. Addis the other day, I think
I’ll just slink back into the shadows. ;->

I’d like to discuss my research with you. The tech part I mean.

I’m afraid I’d have little more to contribute on that front. Among
the great lights of computer history/software preservation/emulation,
I’m a bear of little brain, a teeny-tiny potato indeed!

My only connection with the IBM 7090/7094 comes from the fact that
I helped polish off some of the rough edges of Rob Storey’s
B7094 emulator:

Storey’s was the first emulator for this machine back in 2004,
but since then there’ve been Dave Pitts’ s709, Bob Supnik’s i7094,
and Richard Cornwell’s i7090. The latter two are SimH-based;
both s709 and i7090 (but not i7094) will run CTSS as well as
IBSYS. There’s also Roberto Sancho Villa’s spectacular visualization
software, which will put photo-realistic (almost!) animations
on top of Cornwell’s i7090:

But Storey’s B7094 is still a good introduction to the
IBM 7090/7094 – it’s easier to set up than the others,
a bit more interesting visually (though not photo-accurate like
the Sancho Villa “skins”), and it can do a couple of things
the others don’t (at least not out of the box) – like running
demos from relocatable binaries as well as compiling programs from
source. It can also run MIT’s “STRESS III” (“Structural
Engineering System Solver”) from 1963, either built from source or
via relocatable binary. This was originally transcribed by
Richard Cornwell more than a decade ago, but only became
functional last year. B7094 doesn’t do CTSS, and it’s missing
peripherals the others support (like disk and drum), but
it now also runs the University of Maryland “MAMOS” subsystem of
IBSYS, so you can try out things like MAD, Algol 60, and Snobol.

If you want to see what a large-scale FORTRAN II/FAP program would
have looked like back in 1964 (which is presumably what the
Sumerian Game’s source code would have been), then STRESS III
will give you a good idea of that.

BTW did you try my game?

You know, this may come as a surprise, but despite my interest
in old computers, the whole computer game thing has passed me
by. And no, I didn’t grow up in a high-control religious cult ;-> ;
I just seem to be missing the game “gene” – knocked out by a
cosmic ray or something. Not just electronic games, but games
in general. Never learned to play “grown-up” card games like
poker or bridge; learned the basic rules of chess, but the last
time I played, more than half a century ago, my opponent gave
up in disgust because it was clear to him that I wasn’t
taking the game seriously.

So from Pong machines on campus in 1973 through the Pac-Man craze
a decade later; from Atari through Sega and Nintendo and XBox
and Playstation – it’s all passed me by. I’m happy that I can
see high-resolution pictures and video on my computer screen
thanks to Nvidia, but I’ve never used a graphics card to play
a game (in fact, watching YouTube videos of modern games being
demonstrated gives me motion sickness after a very short while).
I am aware of the irony that Nvidia GPUs + CUDA have propelled
the tech world through a “hard fork”, by fueling the current
“AI” revolution – whatever that may turn out to be. (Hopefully,
it’ll be more useful than Winograd’s SHRDLU was in 1969; it
seems that poor Frank Rosenblatt was on the right track a decade
earlier, but there just wasn’t enough cheap arithmetic around to
do the job: cue Moore’s Law. ;-> )

I did have a work colleague in the 80s whose brother worked for
Infocom. But I was never tempted by “Leather Goddesses of Phobos”.

;->

1 Like