Algorithms + Data Structures = Programs
Peer Review by Arnout Symoens, Pascal Developer

Algorithms + Data Structures = Programs

Author: Nicklaus Wirth
Publisher: Prentice-Hall, 1986
ISBN: 0-13-022418-9

About the Author

Nicklaus Wirth is the original founder/creator of Pascal and Oberon (and probably some other languages as well). In this book, he covers some general aspects of computer programming, including:

• data structures (basic, arrays, records, sets and sequential files)
• sorting (arrays, sequential files)
• recursive algorithms
• recursive data types (linear lists, tree structures, multiway trees, hashing)
• language structures +compilers (sentence analysis ,parsers, code generation)

Who should read this book?

In my opinion, it's a book that should be read right after you read your manual and know how to program in Pascal. Because Wirth is at the roots of Pascal, he knows better then anyone how to write logical and optimal code in Pascal. To be honest, I started reading this book for the compiler section. But after I read the other chapters on hashing and recursive data types, I forced myself to change some programming habits. Old habits needed some face-lifting.

So, if you are new to Pascal programming, check out this book. If you are a pro and need some information about compilers, you might check out the language structures and compilers section. It covers syntax recognition and at the end even gives the source code for a full compiler and its virtual machine to run it on. I tried it, and it worked.

What is it not?

It's not a primer to Mac programming. In fact, all examples are plain old ANSI, SIOX Pascal examples. And yes, they work. I even encountered some strange type definitions that worked perfectly with Metrowerks' compiler. If you're a pro and not interested in compilers, skip this book. You'll fall asleep or will remember your old programming classes. In fact, the book is based on several courses that were given at the Federal Institute of Technology at Zurich.

Any annoyances while reading?

Not really. The only weird thing I encountered was the use of '¬' to denote the 'NOT' logic. After I knew what it meant, things worked smoothly. Sometimes the explanations can get a bit complicated. That's fine if you're a schooled mathematician, but I need to read things twice. Or even more when I read the compiler section.

In Summary

Personally, I enjoyed this book a lot while doing some research for a compiler. The other chapters can teach new programmers a good base for future development and optimal code programming.


- Arnout Symoens