This file has been edited to correct some annoying spelling mistakes.
-----------------------content started in about 2007-----------------

Although these archive files are dated 1993, this version of Awit is  
the one that played in the 1986 WCCC in Koln (Cologne).  It was the  
program's last public appearance.  The 1993 dating of the files stems  
from the time they were removed from the back-up 9-track magnetic  
tape that was becoming obsolete.

Awit competed in 1986 only to serve as a benchmark for other  
programs.  It was virtually unchanged [largely cosmetic changes to  
"pretty-print" the code, if my memory serves me correctly] from the  
1983 version that tied for second place in New York Tournament of  
that year.  Few changes were made in the 1983-86 era, because I was  
working on Parabelle [a C-based system that was used for experiments  
in multi-processor computing.  It was built from Ken Thompson's  
original (circa 1975) T.Belle chess program].  See for example:   
"Parallel Game Tree Search" T.A. Marsland and F. Popowich, IEEE Trans  
of Pattern Analysis and Machine Intelligence 7(4), July 1985, pp442-452.

Awit-Wita was written in AlgolW and ran on IBM System-370 hardware  
under the Michigan Terminal System (MTS).  By the 1980's it was  
impossible to compile the whole program at one time, so I developed a  
special working environment to compile a few procedures at a time.   
The process is described in an article: "Management of block- 
structured programs," T.A. Marsland, Software Practice and  
Experience, July 1985, 715-723.

The original program, which played in the first ACM CCC in New York  
August/September 1970 was called WITA.  The name was derived from  
WITAN, which I thought was a gathering at Stonehenge of wise (old)  
men.  In about 1977, the name was changed to Awit for two reasons.   
First, to put the program nearer the top of an alphabetical list and  
second (more importantly) to reflect the program's propensity to play  
subtle moves that were rife with fatal flaws.  These moves sometimes  
worked well against humans, but never against the deeper insights of  
computers.  At the moment I can't remember exactly when the name  
change occurred -- sometime after 1972, when WITA was converted from  
Burroughs B-5500 Algol to the teaching language AlgolW for the IBM  
mainframe.

The inspiration for Wita came from a Fortran program written by Bob  
Stubblefield, a fellow graduate student at the University of  
Washington.  We had both attended the 1966 FJCC Conference in San  
Francisco and had been impressed by Richard Greenblatt's talk about  
MAC HACK.  At that time I was a good chess player and Bob was a good  
programmer!

When Bob left for Bell Labs, Holmdel, in 1967 I probably inherited  
his program and used it as the basis for learning Burroughs Algol for  
the campus B-5500 computer [as an interesting aside, my mentor--who  
gave me instruction in the mysteries of recursion in Algol--was a  
junior graduate student friend, Gary Kildahl, who went on to found  
Digital Research and build CP/M, before his untimely death in 1994].   
By 1968 I had completed a year as Assistant Prof. in EE at UW and  
moved to Bell Labs in NJ.  I did not work in Bob's group, but instead  
joined Bill Ninke's Department doing Digital Systems and Software  
Research in Holmdel.  Although my primary role seemed to be building  
a virtual memory graphics system for a PDP-9 computer, I managed to  
fill my discretionary (free) time developing Wita, using a B-5500  
timesharing system (provided by COMNET) in Newark.  My (portable)  
terminal was a Model 33 Teletype! By the Spring of 1970 I had a  
pretty good program--good enough to beat my neighbour, Ray(Butch)  
Kirkwood, who now lives in Texas.

At about the same time I wrote to Monty Newborn, who was working at  
Columbia University in Manhattan and was an organizer for the  
upcoming ACM Fall Joint Computer Conference, suggesting that we  
provide some kind of a Computer Chess Exhibit.  I had in mind a  
demonstration of computer vs. human play.  Instead, Monty came up  
with a better idea of a computer chess tournament and we met with  
Keith Gorlen and David Slate (North Western University) in a Howard  
Johnson's cafe on the Garden State Parkway and hammered out a  
proposal that Monty took to the ACM for their blessing--and history  
was made, since no less than 25 North American Computer Chess  
Championships followed.

By way of preparation I travelled to MIT and met with Richard  
Greenblatt, where Wita played a one-game match against Mac Hack [Wita  
was soundly defeated].  Richard humoured me in this Saturday  
afternoon request, since he felt that only human-computer games were  
of any real interest.  About that time, Wita also played a night-time  
telephone match against COKO, a program written by Ed Kozdrowicki  
(another fellow graduate student from UW) and Dennis Cooper who were  
then at UC Davis in California.  Both of these games are to be found  
in my research notebooks, which are now available to the public  
through the University of Alberta Archives.  A listing of the  
materials on file can be found at: http://web.cs.ualberta.ca/~tony/ 
T.A.Marsland.2004-58.pdf

Perhaps most exciting, during July 1970 I was working with Ken  
Thompson (who was in the same department as me, but based in Murray  
Hill).  Ken had his own PDP-7 computer (an 18-bit machine and  
forerunner of the PDP-9) and was developing on it his own time- 
sharing system (I guess he had discretionary time too, or at least  
Multics systems R&D did not consume all his interest).  Anyway, Ken  
was encouraging me to transport his timesharing system to my PDP-9  
for virtual memory experiments.  By way of demonstration of a 2-user  
time-sharing (half-second time slice!) system we used to do the  
following experiment.  Ken would edit his programs on the keyboard (a  
Model 33 TTY) and I would play "Star Wars" using the graphics display  
and mouse.  The combination worked quite well, since only my side of  
the activity was CPU intensive.  In the end I did not transfer his  
system to my machine for several reasons.  First the idea of using  
paper tape as the transfer mechanism did not appeal, second the idea  
of linking our two computers, one in Holmdel and one in Murray Hill,  
by telephone and then using X-ON and X-OFF to buffer data between the  
two machines seemed beyond my technical skills at the time.  Finally  
I was leaving BTL to join the staff at the University of Alberta in  
Edmonton in just a few weeks, and I seemed to have all too many last  
minute jobs to do.  Meanwhile, by late September Ken had taken  
delivery of a PDP 11/20 and had started building what was to become  
Unix, surely based on his PDP-7 experiments and Multics experience.

The first ACM FJCC Computer Chess Championship took place in New  
York.  Meanwhile I was busy driving across the continent (probably I  
was in North Dakota when the first round started).  However, I had  
arranged with my local sponsors, Young and Rubicam Inc, to use their  
B-5500 system in downtown New York.  I believe Joe Frisch from Y&R  
served as my delegated operator.  I am sure he would have had a  
happier time had Wita performed better, but at least we recognized  
the value to the advertising world of a New York Times headline like  
"Computer Loses in King-sized Blunder"!  Any mention of computer  
chess in the NYT was better than none, I guess.

Tony Marsland, August 2007, Qualicum Beach

Addendum.

The directory Wita-Awit and its generating tar file Wita-Awit.tgz contains
all the files pertaining the computer chess program Awit (aka Wita) that had
been moved from an Amdahl 5860 (System 370 under the Michigan Terminal System)
to a Unix box between 1983 and 1993.  It was the starting point of the project
to re-create Awit so that could execute on a Unix box.  The impetus for this
work was the development of an AlgolW to C translator (AW2C) by Glyn Webster,
or Waikato, New Zealand, and the strong support and encouragement by Carey
Bloodworth, of Arkansas.

The Directory Awit-Wita, and its generating tar file Awit-Wita.tgz, is the
actual starting point of the project.  It contains awit.alg the 1986 version
of Awit, but with corrected character mappings from awit.1986.alg

By this time, all necessary supporting documentation, such as the MTS AlgolW 
Manual, the MTS Systems and Subroutines, the AlgolW Reference manual and the 
like had been gathered and are held in the generating file 
AwitSupportFolder.tgz and are described in AwitSupportFolder.txt  many thanks
are due to Mike Alexander (one of the authors of the Chaos chess program) for
locating the MTS documentation.

The directory Awit-Wita contains an early working version of Awit and was
possible thanks largely to the efforts of Carey Bloodworth who worked with me
re-generate the Data Tables that initialized some of Awit's arrays.  Carey
also produced support.c, the i/o interface program that mapped MTS-style index
sequential files to unix sequential files, thus allowing Awit to generate
History and Debugging files, and the input of the original 768 random numbers 
for Hash-Transposition Table generation.

Finally the directory Awit-2009 and its generating file Awit-2009.tgz is the
April 2009 (version MH1.5) instantiation of Awit.  It contains the source file 
awit.alw and a makefile that creates a Unix-executable of the computer chess
program Awit.

The file Awit_Table.txt is our re-creation of the lost array initialization 
file.  It appears in folder Awit-2009

Also included in folder Awit-Wita/AwitNotesFolder is the file Awit-rex.pdf
That file is an image of the score sheet of Awit's last game, a match against 
Don Dailey's Rex program in the fourth round of the 1986 World Computer Chess 
Championship in Cologne, Germany.

Tony Marsland, April 2009, Qualicum Beach