These are turbulent times in which to teach and to learn how computers are to be introduced. There are the curriculum recommendations published in Computing curricula 1991: report of the ACM/IEEE-CS Joint Curriculum Task Force [1]. There is the push to make software engineering, an evolving discipline, central, with its object orientation and its surrender to C and C++ and accompanying complications that only Ph.D.s may be able to understand. There is a continuing sense of the irrelevance of computer science and information systems and technology as computers and their workings become central and integrated into other older, as well as newly established, disciplines. Bureaucracies are created, and introductory textbooks get thicker and thicker.

Yet there is still Pascal, and the wonderful ideas of teaching and learning and safety that its early pioneers responded to. This comparative review covers textbooks dealing with Pascal as it has evolved to, or near, its current condition over the last quarter century. One has to wonder about the relevance of a comparative review of Pascal books in the light of the demands of industry and the hacking out of code that have led to C and C++, with their accompanying stacks of books to explain what it takes a Ph.D. to understand. If, however, keeping focused on some issues, which prompted the creation of Pascal to provide correctness, simplicity, and safety, is still appropriate, then a comparative review of Pascal books is very relevant. Of course, these are concerns of pedagogy and, yes, requirements. Few people in computer science, information systems, or information technology can analyze and reflect on requirements, and indeed, it is beyond my capabilities.

These seven books are concerned with topics and concepts covered in three of the early courses in many computer science curricula. These are the introductory course, the intermediate data structures and programming course, and the advanced data structures and analysis of algorithms course. The Duntemann; Palmer; Leestma and Nyhoff; Pollack; and Savitch books contain introductory material. Pollack; Leestma and Nyhoff; Savitch; Kruse; and Carrano, Helman, and Veroff could be used in the second course. The Kruse and the Carrano, Helman, and Veroff books are appropriate for the advanced course. It is difficult, however, to categorize such books because they all make some attempt to do it all, and there is some overlap.

Palmer

This 1993 manual, written as a training book or a textbook, covers Borland Pascal 7.0, including DOS and Windows. It has a crisp, technical, manual style. It is divided into four parts: “Starting Out,” “In-depth Tutorial with DOS,” “Windows and ObjectWindows,” and “Portability.” They comprise 36 chapters covering basics, accessing DOS services, sound and music programming, object-oriented programming, TURBO vision, ObjectWindows, various Windows topics, cross-platform programming issues, and link libraries. Some object-oriented material deals with elementary data structures.

Palmer provides lots of good information. Not much in the way of exercises is offered, other than what readers do on their own in working things through. The author rambles on and on about operational Pascal. This would be a good book to use in a first course, with exercises provided by the instructor. One appendix is on “Borland Pascal vs. Borland C++,” and the other is on the “Ten Most Common Mistakes.” This nuts-and-bolts training manual really needs to be supplemented with additional pedagogical material, such as exercises at various levels.

Duntemann

Duntemann also covers Borland Pascal 7.0. This book might be appropriate for a first course, with some possibility of use in an intermediate course. The style is friendly, technical, and verbose. No exercises are given. The book consists of 25 chapters, plus an appendix on character codes. The chapters include basics, tools and resources, the TURBO Pascal interactive development environment, locality and scope, controlling a CRT, separate compilation, type conversion and type casting, dynamic structures, and the graphics interface. The last chapter is entitled “Onward to Objects.” This nuts-and-bolts training-oriented book may need to be supplemented with additional pedagogical material, such as various levels of exercises.

Pollack

While this textbook is designed for students with no prior experience, others could use it as well. It addresses Turbo Pascal versions 5.5 and 6.0. Text and pixel graphics are integral parts of the text, and the later chapters address them in detail. Pollack recommends and teaches table-driven design, in which instructions are separated from the data that motivate them. This approach can be contrasted to hard-coded processes, in which the data are integral to the instructions.

The book consists of 18 chapters and 10 appendices. The first four chapters are a foundation. The rest can be covered in any order. Topics include basic Pascal, arrays, records, files, graphics, dynamic structures through stacks and queues, and program development. No chapter is devoted specifically to recursion, though the topic is discussed. Objects and object orientation are covered in later chapters. The appendices cover syntax diagrams; installing and configuring Turbo Pascal; preparing, compiling, and running Turbo Pascal; the Turbo Pascal editor; useful DOS commands; Turbo Pascal’s built-in subprograms; compiler directives; the Turbo Pascal debugger; and a glimpse of the future.

This is a good, basic text for a first course. People who have used other design strategies may have difficulties if this book is used in intermediate courses. It may be a little dated, given the trend to always teach the current marketed compiler. Extensive case studies are not emphasized. This book is designed as a college textbook, with exercises. Answers to many of the exercises are provided in an instructor’s manual.

Leestma and Nyhoff

This is a textbook with a response to the Curriculum 1991 report and its recommendations, particularly with regard to moving some of the current perceptions of high-level, waterfall life cycle, software engineering concepts into early courses in informatics. It contains at least 60 sample programs and program runs. A laboratory manual by Linda Elliott and Jane Turk is recommended to accompany the text. Coverage is through trees, but the book omits graphs. This book could be used for an introductory or intermediate course.

The book consists of 16 chapters and eight appendices. The chapters cover basic Pascal, arrays, strings, records, abstract data types and object-oriented design, sets, pointers and linked structures, and files. Exercises are provided. The appendices cover character codes, Pascal reserved words, syntax diagrams, predefined functions and procedures, sample data files and programs, using Turbo Pascal, and selected exercise answers. According to the authors, answers to most of the other exercises are in the supplementary materials for the instructor.

Savitch

Using Turbo Pascal version 6.0 and 7.0, this book provides an introduction to programming. No knowledge of computers is assumed, but high school algebra is assumed to be within the reader’s capabilities. The text tries to be student-oriented and to give the instructor flexibility. It includes nice instruction on pitfalls and useful techniques. Turbo Pascal usage is covered. The author attempts to broaden the coverage beyond programming to consider some software engineering topics, such as design and verification. Objects are mostly left to the final chapter, although units and abstract data types are introduced earlier.

Chapters cover fundamental concepts of Pascal within the software engineering concepts, arrays, records, files, recursion, numerical computing and random number generators, analysis of algorithms, and pointers. Appendices address go to and exits, syntax diagrams, Turbo Pascal 7.0, DOS commands, the Turbo editor, version 7.0 hot keys, error messages, the Turbo CRT unit, the Turbo printing unit, logging input and output, redirecting input and output, open string and array parameters, the version 6.0 environment, breaks, and constant parameters. The text does not emphasize extensive case studies. Some short-answer exercises have answers for the student, and Savitch says that many programming exercises are solved in supplementary materials.

Carrano, Helman, and Veroff

This text is intended as a follow-up to previous work in Pascal, probably after an introductory or intermediate course. The presentation is flexible, allowing the instructor to cover as much or as little technique as desired. Part 1 is a review, Part 2 is on data abstraction and recursion, and Part3 and Part 4, which deal with problem solving using abstract data types and data management, can be covered in a flexible order. Part 2 begins with chapter 4, which introduces object orientation. Problem solving is emphasized, using computer science processes and methods. The authors give an application on recognizing and evaluating algebraic expressions. The early chapters also present principles of programming and software engineering. A total of 14 chapters cover topics up to trees and graphs. Eight appendices are included, on the following topics: mathematical induction, conditional OR and conditional AND, reserved words in Turbo Pascal, Turbo Pascal operators, character codes, standard functions, standard procedures, and directives. This is a big book, with lots of ideas. Answers to short-answer questions are included, and selected problems are solved in the supplementary materials provided to instructors.

Kruse

This book was written for a two-course sequence after an elementary programming course. It includes the current view of software engineering, considering specifications, analysis, prototyping, abstract data types, algorithm design, refinement, and verification. Chapters include recursion, queues, lists, searching, sorting, multiway trees, tables and information retrieval, and graphs. Four appendices present  Fibonacci  and Catalan numbers; pseudorandom number generators; Turbo Pascal units with files to implement abstract data types; and additional features such as records, procedure parameters, syntax diagrams, and pointers. Each of the 13 chapters ends with a section on suggestions and pitfalls. The book includes some analysis of algorithms, using big-O notation. The text does not provide answers to exercises, but the author asserts that the instructor’s material includes solutions to all the exercises.

Comparison

The books are all excellent efforts at some different views. The books by Palmer, Duntemann, and perhaps Kruse may be better suited to general training environments and self-study. On the other hand, perhaps Pollack; Savitch; Leestma and Nyhoff; and Carrano, Helman, and Veroff are more appropriate for academic environments. Perhaps all the books could be more student-oriented and give students perspective, advice, and encouragement.

This does open up the issue of how a Pascal textbook ought to be written, and the effects the politics of curriculum decisions are having on the texts that are being written. Like most projects, this one needs a plan. I think the optimal approach combines the top-down strategy and bottom-up strategies. The top-down strategy involves industry advisory groups, curriculum groups, accreditation and certification boards, and the like. The bottom-up strategy involves teachers and students in the trenches.

This amalgamated strategy assumes intellectual ability, intellectual honesty, huge amounts of knowledge and deep thinking, and the highest order of integrity from the people involved. We have the opportunity to apply these to teaching. This approach also assumes little attempt is made to gain the spotlight; it assumes working and doing, with no political axes to grind. People like Bill Joy, Steven Jobs, Edsger Dijkstra, Tony Hoare, David Gries, Niklaus Wirth, and some ordinary students and teachers who are not in the spotlight need to amalgamate their ideas.

This is all politics. I do not know what to do. Perhaps it should be as it has always been and as all the excellent authors of the reviewed texts are doing. That is, present the technology, let it be absorbed and applied in whatever way, and see what happens. Let everyone deal with it. This is free enterprise and democracy and finding what the market will bear. It is a tough knot, and if we stop to unravel it, we fall further behind all the innovation and opportunity. Still, there are plenty of us, and at least, we might have strategic plans to consider. There are many ways to do things, and we lose track of that when we surrender to high-level curriculum groups, industry boards, or accreditation or licensing groups.