View source for WATFIV

{{Short description|Implementation of the Fortran computer programming language}}
{{Original research|entire article|date=September 2007}}

'''WATFIV''' ('''Waterloo FORTRAN IV'''), developed at the [[University of Waterloo]], Canada is an implementation of the [[Fortran]] computer [[programming language]]. It is the successor of '''WATFOR'''.<!--incoming redirect-->

WATFIV was used from the late 1960s into the mid-1980s. WATFIV was in turn succeeded by later versions of WATFOR.
Because it could complete the three usual steps ("compile-link-go") in just one pass, the system became popular for teaching students computer programming.

==History==
In the early 1960s, newly formed [[computer science]] departments started university programs to teach computer [[programming language]]s. The [[Fortran]] language had been developed at [[IBM]], but suffered from slow and error-prone three-stage [[batch processing]] workflow.<ref name="design">{{cite journal |title= Design characteristics of the WATFOR compiler |journal=  ACM SIGPLAN Notices|publisher= [[Association for Computing Machinery]] |author1= Donald D. Cowan |author2-link= J. Wesley Graham |author2= J. Wesley Graham |volume= 5 |number= 7 |pages= 41–44 |date= July 1970  |doi= 10.1145/390013.808481 |doi-access= free }}</ref> In the first stage, the [[compiler]] started with [[source code]]  and produced [[object file|object code]]. In the second stage, a [[Linker (computing)|linker]] constructed a complete program using growing libraries of common functions. Finally, the program was repeatedly executed with data for the typical scientific and business problems of customers.  Each step often included a new set of [[punched card]]s or tape.  Students, on the other hand, had very different requirements.  Their programs were generally short, but usually contained logic and syntax errors, resulting in time-consuming repetition of the steps and confusing "[[core dump]]s" (It often took a full day to submit and receive the successful or failed output from the computer operator). Once their programs worked correctly, they were turned in and not run again.

In 1961, the [[University of Wisconsin]] developed a technology called FORGO for the [[IBM 1620]] which combined some of the steps.<ref>{{cite book |title= Programming the IBM 1620 |edition= 2nd |year= 1965 |author= Clarence B. Germain |page= 62 |publisher= Prentice-Hall |url= https://books.google.com/books?id=BtpWAAAAMAAJ }}</ref>
Similar experiments were carried out at [[Purdue University]]  on the [[IBM 7090]] in a system called PUFFT.<ref>{{cite journal |title= PUFFT—The Purdue University fast FORTRAN translator |journal= Communications of the ACM |publisher= [[Association for Computing Machinery]] |author1=  Saul Rosen |author1-link=Saul Rosen|author2= Robert A. Spurgeon |author3=Joel K. Donnelly |volume= 8 |number= 11 |pages= 661–666 |date= November 1965 |doi= 10.1145/365660.365671 |s2cid= 1822147 |doi-access= free }}</ref>

===WATFOR 7040===
In summer 1965, four undergraduate students of the [[University of Waterloo]], Gus German, [[James G. Mitchell]]<ref>{{cite web |title= Java: Where You Want to *Be* Tomorrow: Dr. Jim Mitchell, 1997 Recipient of the J.W. Graham Medal in Computing and Innovation |date= May 30, 1997 |url= http://infranet.uwaterloo.ca/infranet/s199705.htm |publisher= [[University of Waterloo]], Canada |access-date= April 1, 2011 }}</ref><ref>{{cite web |title= James Mitchell |url= http://labs.oracle.com/people/mybio.php?c=601 |work= The People at Oracle Labs |publisher= Oracle Corporation |access-date= April 1, 2011 |archive-date= June 16, 2012 |archive-url= https://web.archive.org/web/20120616174019/http://labs.oracle.com/people/mybio.php?c=601 |url-status= dead }}</ref>
Richard Shirley and Robert Zarnke, led by Peter Shantz, developed a Fortran compiler for the [[IBM 7040]] computer called WATFOR.  Its objectives were fast compilation speed and effective error diagnostics at both compile and execution time.<ref name="design"/> It eliminates the need for a separate linking step and, as a result, FORTRAN programs which contain no syntax errors are placed into immediate execution. Professor [[J. Wesley Graham]] provided leadership throughout the project.<ref>{{cite news |title= UW computing pioneer mourned |date= September 8, 1999 |newspaper= UW Gazette |author= Chris Redmond |url= http://communications.uwaterloo.ca/Gazette/1999/sep08/graham.html |publisher= [[University of Waterloo]] |access-date= April 3, 2011 |archive-date= October 1, 2011 |archive-url= https://web.archive.org/web/20111001221302/http://communications.uwaterloo.ca/Gazette/1999/sep08/graham.html |url-status= dead }}</ref>

This simple, one-step process allowed non-experienced programmers to learn programming with lower cost in time and computing resources.<ref name=Sigcse1970-11>
{{cite news 
| url         = http://dl.acm.org/citation.cfm?id=873659
| title       = A complete package for introducing computer science
| publisher   = Association for Computing Machinery SIGCSE Bulletin
|author1=P. C. Brillinger |author2=D. D. Cowan | date        = November 1970
| pages       = 118–126 
| access-date  = 2012-12-18
}}
</ref>
To aid in debugging, the compiler uses an innovative approach to checking for undefined variables (an extremely common mistake by novice programmers). It uses a diagnostic feature of the 7040 that can deliberately set areas of memory to bad parity. When a program tries to reference variables that hadn't been set, the machine takes an interrupt (handled by the Watfor runtime routines) and the error is reported to the user as an undefined variable. This has the pleasant side effect of checking for undefined variables with essentially no CPU overhead.

WATFOR quickly gained popularity and over 75 institutions installed it on their IBM 7040 systems.  The distribution of the compiler was handled by Sandra Bruce (née Hope).

===WATFOR 360===
In 1966, the University planned to replace the 7040 with an [[IBM System/360]] computer, which was much faster but not software compatible.  A team of full-time employees and undergraduate students was formed to write an IBM 360 version.<ref name="wat">{{cite web |title= Unbundling Computing at The University of Waterloo |author1=Harold Alkema  |author2=Kenneth McLaughlin   |name-list-style=amp |publisher= University of Waterloo |year= 2007 |url= http://www.cs.uwaterloo.ca/40th/Chronology/printable.shtml |access-date= April 5, 2011 }}</ref> The project members, Betty Schmidt, Paul Dirksen, [[Paul H. Cress]], Lothar K.  "Ned" Kesselhut, Bill Kindree and Dereck Meek, were later joined by Mike Doyle, Rod Milne, Ron Hurdal and Lynn Williams, completed 360 WATFOR in the early part of 1967.  Many other institutions (universities, colleges, businesses and governmental agencies) started using the WATFOR compiler to meet needs similar to those experienced at the University of Waterloo.  The distribution of the software and customer support was carried on by Sandra Ward.

===WATFIV===
As a result of proposals from the [[SHARE (computing)|SHARE]] user group Fortran committee and others, a new version called WATFIV was produced in 1968.  WATFIV introduced new features such as CHARACTER variables and direct-access input-output.  The [[Association for Computing Machinery]]  presented Paul Cress and Paul Dirksen the [[Grace Murray Hopper Award]] for contributions to the WATFOR and WATFIV projects in 1972.<ref>{{cite web |title= 1972 – Paul H. Cress |work= Grace Murray Hopper Award |publisher= [[Association for Computing Machinery]] |url= http://awards.acm.org/citation.cfm?id=4117320&srt=all&aw=145&ao=GMHOPPER |access-date= April 5, 2011 |archive-url= https://web.archive.org/web/20120504100839/http://awards.acm.org/citation.cfm?id=4117320&srt=all&aw=145&ao=GMHOPPER |archive-date= May 4, 2012 |url-status= dead |df= mdy-all }}</ref>   The WATFIV compiler was included in the DATAPRO Honour Roll for 1975 and 1976.
People involved with maintenance and enhancement included Bernie Murphy, Martin Wiseman and Yvonne Johnson.

WATFIV was pronounced as "WHAT FIVE" (and sometimes "WATT FIVE"), but, as was realized at the time, could also (almost) still be pronounced as "WHAT FOR", as in WAT-F-IV (Waterloo Fortran IV).

Universities and corporations used these compilers and a number of other software products have been developed in the WATFOR tradition.
For example, a version for the [[COBOL]] programming language is called [[WATBOL]].<ref>{{cite web |title= WATBOL  |author1=R. J. Hurdal |author2=W.R. Milne |author3=C.R. Zarnke |publisher= University of Waterloo |year= 1972 |url= http://csg.uwaterloo.ca/sdtp/watbol.html |access-date= April 5, 2011 }}</ref><ref name=UWaterloo40Years1972>
{{cite news 
| url         = https://cs.uwaterloo.ca/40th/Chronology/1972.shtml
| title       = Chronology - 1970s: The Evolution of The University of Waterloo Continues -- 1972
| publisher   = [[University of Waterloo]] 
| access-date  = 2012-12-17
| quote       = In 1969 and 1970, the WATBOL compiler was completed. The WATBOL compiler for the COBOL programming language had speed and error diagnostics similar to the WATFOR compilers for FORTRAN. 
}}
</ref><ref name=ParentsOfInvention>
{{cite book
| url         = https://books.google.com/books?id=28qmcQCVFcYC&q=WATBOL+waterloo&pg=PA10
| title       = Parents of Invention: The Development of Library Automation Systems in the Late 20th Century: The Development of Library Automation Systems in the Late 20th Century
| publisher   = [[ABC-CLIO]]
| author      = Christopher Brown-Syed
| year        = 2011
| page        = 10
| isbn        = 9781591587910
| access-date  = 2012-12-17
| quote       = During the 1970s, the University of Waterloo, located in southern Ontario, Canada, was almost as synonymous with computing as MIT or Berkeley.  It had developed extensions to the popular general-purpose Fortran programming language called WATFOR and WATFIV and its own version of the equally popular business computing language COBOL, called WATBOL.
}}
</ref>
[[Daniel D. McCracken]] said "it is no exaggeration to suggest that WATFOR revolutionized the use of computers in education."<ref>{{cite book |author= Daniel D. McCracken |title=A guide to Fortran IV programming |url=https://books.google.com/books?id=aNhWAAAAMAAJ |year=1972 |page=253 |publisher=Wiley |isbn=978-0-471-58281-6 |author-link=Daniel D. McCracken }}</ref>  At one point, more than 3,000 mini and [[mainframe computer]] licenses and over 100,000 [[microcomputer]] licenses were held worldwide for this family of software products.

===WATFOR-11, -S and -11S===
In 1974, a compiler with characteristics similar to the IBM implementation was created for the [[Digital Equipment Corporation]] [[PDP-11]] computer and called WATFOR-11. The team members, Jack Schueler, Jim Welch and Terry Wilkinson, were later joined by [[Ian McPhee (computer scientist)|Ian McPhee]] who had added new control statements to the WATFIV compiler for [[structured programming]] (SP). These new statements included the block IF (later included in the ANSI X3.9-1978 language standard), WHILE, UNTIL, and others.  WATFIV-S was announced in 1974 and a few months later, WATFOR-11S (the "S" indicating the new SP features) was also announced.  The original SP features were later enhanced with additional statements by Bruce Hay in WATFIV-S in 1980 and by Jack Schueler in WATFOR-11S in 1981.

===WATFOR-77===
During the 1970s, the ANSI X3J3 subcommittee (the FORTRAN language standard group) developed a new language standard which was officially approved in April, 1978.  This standard, designated [[FORTRAN 77]], introduced many new statements into the language.  In fact, the previous language standard FORTRAN 66 is a very small document and describes, what is in effect, a subset of most implementations of FORTRAN.  For example, the WATFIV and WATFOR-11 implementations are based upon the IBM definition of [[Fortran#FORTRAN IV|FORTRAN-IV]].

As programmers used the FORTRAN 77 features, a new compiler was required to combine the advantages of the WATFIV compiler with the new language standard.  In January 1983, a project to develop a FORTRAN 77 compiler was started at [[Watcom|Watcom Systems Inc]]. Under the leadership of Jack Schueler, Watcom employees and undergraduate students from the University of Waterloo's Co-operative Computer Science program became involved in the creation of the WATFOR-77 compiler.  The major work was done by Geno Coschi, Fred Crigger, John Dahms, Jim Graham, Jack Schueler, Anthony Scian and Paul Van Oorschot.  They were assisted by Rod Cremasco, John McCormick, David McKee and Brian Stecher. Many of the team members from former compiler projects provided input.  These included Bruce Hay, Ian McPhee, Sandra Ward, Jim Welch and Terry Wilkinson.

Unlike previous compilers, a significant portion of WATFOR-77 was written in a portable systems language to ease the implementation of the compiler on other computer systems. Earlier WATFOR compilers were written entirely in machine-dependent [[assembly language]].

Two components of the compiler are not portable.  The code generator translates FORTRAN statements into native computer instructions and stores them in memory.  The first version of WATFOR-77 generates instructions for the IBM 370 computer architecture. Most of the execution-time support (undefined variable checking, subscript evaluation, intrinsic functions) was written in assembly language for good performance.
In September 1984, the first version was installed at the University of Waterloo for the Department of Computing Services.  It was an implementation for IBM 370 computers running the [[VM (operating system)|VM/SP CMS]] operating system.

A few months earlier, in May 1984, a project started to implement the WATFOR-77 compiler on the [[IBM Personal Computer]]. This project included Geno Coschi, Fred Crigger, Tim Galvin, Athos Kasapi, Jack Schueler, Terry Skomorowski and Brian Stecher.
In April 1985, this second version of WATFOR-77 was installed at the University of Waterloo for use by students of the Faculty of Engineering.  The compiler can run on a 256K IBM Personal Computer using [[IBM PC DOS]] 2.0 and does not require special floating-point hardware.

In the fall of 1985, a Japanese version of WATFOR-77 was delivered to IBM Japan for the [[IBM JX]] Personal Computer. This version produces [[Japanese language]] error messages and supported the Kanji, Hiragana and Katakana character sets for variable names and character strings. To support the JX, the Language Reference manual and User's Guide were translated into Japanese. Another version of WATFOR-77 with the same features mentioned above was also developed for Japanese IBM PS/55 family of personal computers in Spring 1988.

During the summer of 1986, the IBM PC version of WATFOR-77 was adapted to run on the [[Unisys ICON]] which runs the [[QNX]] operating system. Since QNX is quite different from IBM PC DOS, parts of the run-time system were rewritten. This implementation of WATFOR-77 was made available in September 1986.

During the summer of 1985, a project was started to adapt WATFOR-77 to the Digital Equipment Corporation [[VAX]] computer series running the [[OpenVMS|VMS]] operating system. The members of this project included Geno Coschi, Marc Ouellette, Jack Schueler and Terry Skomorowski. This implementation was made available in March 1987.

Also, in the spring of 1988, a new project was begun to develop an optimizing FORTRAN 77 compiler. This compiler uses the code generator from the [[Watcom C compiler]], which produces superior machine code to other C compilers. The FORTRAN 77 optimizing compiler was first shipped in mid-1990.

In October 1990, the 25th anniversary of WATFOR was celebrated.<ref>{{cite web |title= WATFOR's Silver Anniversary |work= WATCOM News volume 8 number 1 |year= 1991 |url= http://csg.uwaterloo.ca/sdtp/watfor.html |access-date= April 1, 2011 |archive-url= https://archive.today/20120721141408/http://csg.uwaterloo.ca/sdtp/watfor.html |archive-date= July 21, 2012 |url-status= dead |df= mdy-all }}</ref> Many involved in the development of the WATFOR compilers were invited to the University of Waterloo for a reunion.

In spring 1992, a version of WATFOR-77 was adapted to the [[NEC PC-9801]] family of personal computers. This version was similar to the IBM PS/55 version but modified to accommodate architectural differences.
In January 1992, development of a 32-bit version of WATFOR-77 for [[Intel 80386]] and [[Intel 80486]] personal computers began. The first version was shipped in the fall of 1992.

As late as 1995, classes for programming in WATFIV were still being held at the [[University of Mississippi]], led by Professor Charles H. (Chuckie) Franke.

==See also==
* [[Watcom]]
* [[Donald B. Gillies]] (early adopter at University of Illinois)

==References==
{{Reflist}}

==Further reading==
* {{cite journal |title= WATFOR—The University of Waterloo FORTRAN IV Compiler |journal= Communications of the ACM |publisher= [[Association for Computing Machinery]] |author1= Peter W. Shantz  |author2= R. A. German |author3-link= James G. Mitchell |author3= James G. Mitchell |author4= Richard SK Shirley |author5=  C. Robert Zarnke |volume= 10 |number= 1 |pages= 41–44 |date= January 1967 |doi= 10.1145/363018.363059 |s2cid= 14472718 }}
* {{cite book |title= Computer science at Waterloo: a history to celebrate 25 years, 1967-1992 |author= Peter James Ponzo |publisher= University of Waterloo |year= 1992 }}
* {{cite book |author1= Paul H. Cress |author2= Paul Dirksen |author3-link= J. Wesley Graham |author3= James Wesley Graham |title=FORTRAN IV with WATFOR |url=https://books.google.com/books?id=reEmAAAAMAAJ |year=1968 |publisher=Prentice-Hall|author1-link= Paul H. Cress }}
* {{cite book |author=Paul Cress |title=Description of /360 WATFOR: a fortran-IV compiler |url=https://cs.uwaterloo.ca/research/tr/1968/CSTR-1000.pdf|year=1968 |publisher=Dept. of Applied Analysis and Computer Science, Computing Centre, University of Waterloo}}
* {{cite book |author1= Paul Cress |author2= Paul Dirksen |author3=James Wesley Graham |title=FORTRAN IV with WATFOR and WATFIV |url=https://archive.org/details/fortranivwithwat00cres |url-access= registration |year=1970 |publisher=Prentice-Hall|isbn= 9780133294330 }}
* {{cite book |author1=Paul Cress |author2= Paul Dirksen |author3=James Wesley Graham |title=Structured FORTRAN with WATFIV-S |url=https://books.google.com/books?id=LtKTQAAACAAJ |date=January 1, 1980 |publisher=Prentice-Hall |isbn=978-0-13-854752-3}}

==External links==
* [http://www.openwatcom.org/ Open Watcom]
* [https://web.archive.org/web/20110927015438/https://hopl.murdoch.edu.au/showlanguage.prx?exp=307&language=WATFOR History of Programming Languages: WATFOR]

[[Category:Fortran programming language family]]
[[Category:Procedural programming languages]]
[[Category:Programming languages created in the 1960s]]
[[Category:Assembly language software]]