Anyone who has done any serious programming knows that programming is fun but not easy. The fun part comes from understanding a problem, developing a conceptual solution, writing a program, and seeing the program work. The hard part is making sure that the program not only works, but that it always works correctly. One of the best ways for a novice to learn the art and craft of programming is to study problems that are well understood and to emulate high-quality examples of actual coding solutions. As in any craft, nothing beats practice, and well-guided practice works best. This book will be an excellent source of material for college students who know a little programming and for their teachers.
The book consists of 16 chapters, two of which--on games analysis and optimal coding--are new to this second edition. Most of the material found here is covered in greater depth in courses that deal with algorithms and compiler construction, so this book could be used as an adjunct for such courses. The material in the book is presented as problems, some simple and some complex. If the problems are not solved in the form of Pascal programs, most provide enough hints so that a correct solution can be coded. Other problems, however, simply ask the reader to extend the material and provide a solution; there are enough of these problems that this cannot be considered a programming cookbook. Bulaceanu’s review of the first edition [1] gives a summary of each chapter; a detailed table of contents can be found on Amazon.
This is a short book--272 pages total--but it contains a lot of great information for the computer science student. Ideally, students would acquire this book in their freshman year and begin using it as soon as they learn the basics of procedural programming. They will then find this book an excellent companion, as they develop their analytical and programming skills throughout the curriculum.
The reader will soon discover that the coding examples in this book have two characteristics. First, as I have already mentioned, they are coded in Pascal, a language no longer widely used or taught. Shen includes a short appendix that describes Pascal and C features side by side, to help with the translation. Since the code is lucid and well documented, the translation to C or any other procedural or object-oriented language is straightforward. In fact, I have found that translating programs from one language to another always results in a deeper understanding than simply reading the source code. So I consider the Pascal code to be an unintended benefit of the book. The second, more important characteristic is that the book shows code fragments rather than complete programs. Granted, the code actually implements the algorithms in question, but the readers will need to do some additional work to develop working programs. They will need to turn the code into methods or subroutines, ensure that programming interfaces are correct, and work out the details concerning user input and verification, output formatting, and testing.
Another outstanding feature of the code, one that will be greatly appreciated by teachers and one that students will appreciate more and more as their programming skills mature, is the extensive use of invariants. Shen uses invariants to justify the logic of the code and to demonstrate its correctness. The comments are an integral part of the code. Readers would be well advised to include the comments in their translations, and to develop an eye for essential commenting of programs as demonstrated in this book.
In addition to the Pascal and C appendix already mentioned, the book concludes with a list of 14 book references for further reading and a six-page index.
This book is a delight to read and work with. I highly recommend it.
