||This entire article possibly contains original research. (September 2007) (Learn how and when to remove this template message)|
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.
In the early 1960s, newly formed computer science departments started university programs to teach computer programming languages. The Fortran language had been developed at IBM, but suffered from slow and error-prone three-stage batch processing workflow. In the first stage, the compiler started with source code and produced object code. In the second stage, a 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 cards or tape. Students, on the other hand, had very different requirements. Their programs were generally short, but usually contained errors, resulting in time-consuming repetition of the steps and confusing "core dumps". Once their programs worked correctly, they were turned in and not run again.
Here is an alternative interpretation of the way things were. As a student, you first spent time on paper writing your program, knowing that each line was restricted to the number of columns on a punch card. You then had to go to a keypunch machine to turn these commands into a series of punch cards which you could then submit to the appropriate office as a "job". So you had at least 2 sources of error, one your logic and syntax, the other typographical errors as you used the keypunch machine. You would submit your job one day and pick up the output the next. Output then, of course, consisted of some sort of printout from a dotmatrix printer. You might get what you intended, or you might get some truncated output indicating your program contained too many errors to run, or you might get pages and pages of output because you created some never-ending loop, which the operator at some point would cut off. So it at the least would take a day for you to find out you had absolutely failed, after which it was your job alone to go through your commands line by line to find the error(s).
In 1961, the University of Wisconsin developed a technology called FORGO for the IBM 1620 which combined some of the steps. Similar experiments were carried out at Purdue University on the IBM 7090 in a system called PUFFT.
In summer 1965, four undergraduate students of the University of Waterloo, Gus German, James G. Mitchell 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. 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 (1932–1999) provided leadership throughout the project.
This simple, one-step process allowed non-experienced programmers to learn programming with lower cost in time and computing resources. To aid in debugging, the compiler uses an innovative approach to checking for undefined variables (an extremely common mistake by beginning 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).
The advantage from the student user's perspective was that punch cards were gone. You used a terminal to write your program, which was saved on the system (tape at that time), and you could go back to it later to edit and refine your program. Instead of waiting a day, you instantly received confirmation it was correct and ran as intended, or there were errors you needed to work on. This was the death knell of punch cards, since it really showed the way of the future.
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. The project members, Betty Schmidt, Paul Dirksen, Paul H. Cress, Lothar K. "Ned" Kesselhut, Bill Kindree and Dereck Meek, who 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.
As a result of proposals from the 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. 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", 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. Daniel D. McCracken said "it is no exaggeration to suggest that WATFOR revolutionized the use of computers in education." 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 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.
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-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 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/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 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. 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.
- Donald D. Cowan; J. Wesley Graham (July 1970). "Design characteristics of the WATFOR compiler". ACM SIGPLAN Notices: Proceedings of a symposium on Compiler optimization. Association for Computing Machinery. 5 (7): 41–44. doi:10.1145/390013.808481.
- Clarence B. Germain (1965). Programming the IBM 1620 (2nd ed.). Prentice-Hall. p. 62.
- Saul Rosen; Robert A. Spurgeon; Joel K. Donnelly (November 1965). "PUFFT—The Purdue University fast FORTRAN translator". Communications of the ACM. Association for Computing Machinery. 8 (11): 661–666. doi:10.1145/365660.365671.
- "Java: Where You Want to *Be* Tomorrow: Dr. Jim Mitchell, 1997 Recipient of the J.W. Graham Medal in Computing and Innovation". University of Waterloo, Canada. May 30, 1997. Retrieved April 1, 2011.
- "James Mitchell". The People at Oracle Labs. Oracle Corporation. Retrieved April 1, 2011.
- Chris Redmond (September 8, 1999). "UW computing pioneer mourned". UW Gazette. University of Waterloo. Retrieved April 3, 2011.
- P. C. Brillinger; D. D. Cowan (November 1970). "A complete package for introducing computer science". Association for Computing Machinery SIGCSE Bulletin. pp. 118–126. Retrieved 2012-12-18.
- Harold Alkema & Kenneth McLaughlin (2007). "Unbundling Computing at The University of Waterloo". University of Waterloo. Retrieved April 5, 2011.
- "1972 – Paul H. Cress". Grace Murray Hopper Award. Association for Computing Machinery. Retrieved April 5, 2011.
- R. J. Hurdal; W.R. Milne; C.R. Zarnke (1972). "WATBOL". University of Waterloo. Retrieved April 5, 2011.
- "Chronology - 1970s: The Evolution of The University of Waterloo Continues -- 1972". University of Waterloo. Retrieved 2012-12-17.
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.
- Christopher Brown-Syed (2011). 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. ABC-CLIO. p. 10. ISBN 9781591587910. Retrieved 2012-12-17.
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.
- Daniel D. McCracken (1972). A guide to Fortran IV programming. Wiley. p. 253. ISBN 978-0-471-58281-6.
- "WATFOR's Silver Anniversary". WATCOM News volume 8 number 1. 1991. Retrieved April 1, 2011.
- Peter W. Shantz; R. A. German; James G. Mitchell; Richard SK Shirley; C. Robert Zarnke (January 1967). "WATFOR—The University of Waterloo FORTRAN IV Compiler". Communications of the ACM. Association for Computing Machinery. 10 (1): 41–44. doi:10.1145/363018.363059.
- Peter James Ponzo (1992). Computer science at Waterloo: a history to celebrate 25 years, 1967-1992. University of Waterloo.
- Paul H. Cress; Paul Dirksen; James Wesley Graham (1968). FORTRAN IV with WATFOR. Prentice-Hall.
- Paul Cress (1968). Description of /360 WATFOR: a fortran-IV compiler (PDF). Dept. of Applied Analysis and Computer Science, Computing Centre, University of Waterloo.
- Paul Cress; Paul Dirksen; James Wesley Graham (1970). FORTRAN IV with WATFOR and WATFIV. Prentice-Hall.
- Paul Cress; Paul Dirksen; James Wesley Graham (January 1, 1980). Structured FORTRAN with WATFIV-S. Prentice-Hall. ISBN 978-0-13-854752-3.