“You’ve probably heard the definition of a camel as a horse that was designed by a committee. This quip maligns the camel, a noble animal, the ship of the desert, but it gets the point across about what you can expect from a committee. Fortran 90 is a computer language that was designed by a committee.” With this remark, the author opens this book’s first chapter, “Introduction to Fortran 90,” a necessary and interesting mini-review of the historical development of Fortran. The author uses this review as a motivation for the beginner. He quickly introduces constants, variables, arithmetic operators, arithmetic expressions, simple input/output, relational operators, relational expressions, logical operators, logical expressions, and attribute specifications (a more detailed treatment of type declarations in Fortran 90 with attribute specifications is postponed to chapters 3, 4, and 8).
In the first chapter, the author also introduces the three goto statements of Fortran 90 with the recommendation that “because all the GO-TO statements require the use of statement label, they should be avoided if at all possible.” He also points out that the assigned goto constructs have been classified in the ANSI X3.198-1992 standard as “obsolescent.”
I obtained a copy of ANSI X3.198-1992, the Fortran 90 standard, in order to check up on the author’s claim that the book conforms to the standard. Among additions to FORTRAN 77 in ANSI X3.198-1992, seven are apparent:
Operations for processing whole arrays and subarrays, making it more useful for engineering and scientific computing;
Portable control over numeric precision specification, adding improved control of the performance of numerical programs;
An optional facility for multiple-character data for languages with large character sets (such as Chinese and Japanese). This also allows additional symbols for mathematics, chemistry, or music);
User-defined data types like the records in Pascal, known as “derived types,” and procedure definitions to define operations on intrinsic or derived types;
Encapsulated data abstraction through facilities for modular data and procedure definitions, allowing modules to be accessed by any program unit;
Pointers allowing arrays to be sized dynamically and ranged, and allowing structures to be linked to create lists, trees, and graphs. Also, an object of any intrinsic or derived type may be declared to have the pointer attribute; and
Addition of new facilities, allowing phase-out of old, redundant features.
Beginners, or those familiar with other versions of Fortran but unfamiliar with Fortran 90, will have no difficulty with Huddleston’s explanations of the above concepts. There are many experienced FORTRAN 77 programmers for whom encapsulated data abstraction, derived types, pointers, and so on may be new, and this book will be an excellent starting point for their retraining. The author devotes the first five chapters to issues and ideas mostly familiar to those experienced with earlier versions of Fortran, helping to ease their way to Fortran 90. These topics include looping, flow charts, pseudocode, arrays, subprograms, and I/O. He then introduces pointers and arrays in chapter 3, and stacks, queues, and deques in chapter 4 to capitalize on subprograms for the building of operations for these structures.
Earlier versions of Fortran have been weak at string processing. Fortran 90 is reasonably capable of fixed-length string processing, and with its derived type capability, users can build their own variable-length string data structures. The author has devoted all of chapter 6 to string processing. In chapter 7, the author provides programmers of earlier versions of Fortran with some number crunching with Fortran 90. In chapter 7, he builds the concept of encapsulation, and in chapter 8, he explains data abstraction and the important “derived type” feature of Fortran 90. Appendix B provides valuable information for new users of Fortran 90--intrinsic procedures of the language.
My favorite programming languages for software engineering are Ada, C++, Modula-2, and Pascal. However, after reviewing this book, I would seriously consider having my software engineering students build at least one of their projects using Fortran 90. With good books such as this one, Fortran 90 may actually remain a productive programming language.
