The Handbook of Programming Languages (HPL): Imperative Programming Languages [Textbook Binding]

Peter H. Salus (Editor), Peter Salus (Author)

Book Description

Publication Date: June 1998 | Series: Handbook of Programming Languages (Book 2)

This handbook covers imperative programming languages. There are chapters on FORTRAN, C, Turbo Pascal and Icon. For each language, information on history, syntax, variables, tips and traps is provided.

Editorial Reviews

Amazon.com Review

The second volume in the Handbook of Programming Languages series, Imperative Programming Languages presents some of the most widely used languages of all time. These languages primarily process instructions methodically.

The first part of this book discusses Fortran, and two chapters on C follow. The part on C relates the language's history and its evolution from its predecessor, B. This section then presents an in-depth, analytical look at the structure of the language.

The book briefly touches on intermediate languages such as Cfront, LaTeX, and IL. Finally, Imperative Programming Languages includes a part on Pascal--emphasizing Turbo Pascal--and the high-level language Icon.

Like all of the volumes in this series, volume 2 includes an excellent foreword that traces the entire history of programming and features diagrams inside each cover that illustrate where each discussed language came from. This installment is handy as both a historical account of these languages and as a language reference. --Stephen Plain

Product Details

• Textbook Binding: 444 pages
• Publisher: Macmillan Technical Pub; 1st edition (June 1998)
• Language: English
• ISBN-10: 1578700094
• ISBN-13: 978-1578700097
• Product Dimensions: 8.7 x 6.1 x 1.4 inches
• Shipping Weight: 1.8 pounds
• Average Customer Review: 3.0 out of 5 stars  See all reviews (1 customer review)
• Amazon Best Sellers Rank: #3,785,862 in Books (See Top 100 in Books)

Customer Reviews

Most Helpful Customer Reviews

2 of 2 people found the following review helpful:

3.0 out of 5 stars Fair, July 17, 2001

By 

Dr. Lee D. Carlson (Baltimore, Maryland USA) - See all my reviews
(VINE VOICE)    (HALL OF FAME REVIEWER)    (REAL NAME)   

This review is from: The Handbook of Programming Languages (HPL): Imperative Programming Languages (Textbook Binding)

This book is the second of the series on programming languages and gives an overview of some representative languages that follow the imperative programming paradigm. Specifically, the languages Fortran, C, Pascal, and Icon are discussed in the book, with the largest coverage given to C. There is also a very short part of the book devoted to "intermediate languages", which are essentially used as intermediaries between high- and low-level languages.

The book starts with a discussion of Fortran, and gives a short history of it development. The chapter emphasizes Fortran 95, and the comparisons between it and Fortran 90. Fortran 95 is presented as having an object-oriented flavor, due to its ability to provide derived data types, procedure overloading, and operator definition. It however cannot support operator inheritance. The author of the article lists the Fortran 90 features that were omitted in Fortran 95, and discusses portability issues. The features to be incorporated in Fortran 2000 and the high performance extension, called High Performance Fortran, are discussed, the later emphasizing ease in parallelization of code. A fairly comprehensive summary of the features and syntax of Fortran 95 is given. The author goes over in detail an interesting example of constructing a new data type in Fortran, namely a type definition for big integers.

In part 2 of the book the history of the C language is discussed, and is written by D. M. Ritchie, one of the developers of the language. It is interesting reading for those curious about how C originated and the developed. This is followed by a rather lengthy overview of the language itself, almost 150 pages long. The author gives good advice on how to deal with the potential complexity of C expressions, namely to think of them recursively. His discussion of how to do this, by first using what he calls primary expressions, is the first I have seen in an introductory exposition on C. Since C does support them, "goto" statements are discussed, but thankfully the author admonishes against their use. A good discussion of function calling in C is given, via its "pass by value" function semantics. The author emphasizes that there is only one exception in C to the requirement that a function not alter the values of variables passed to it as arguments, namely the case of arrays, which are called by reference. For those doing programming for embedded systems, there is a fairly decent discussion of low-level addressing.

After a brief discussion of intermediate languages, the rest of the book covers Pascal and Icon. Except for some experience programming in SNOBOL, I do not know these languages and so I cannot comment on the quality of the presentation.