This is the first book on compiler design that covers object-oriented, functional, and logic programming languages--as well as imperative languages. The theory of computer design is covered in depth, but the focus throughout is on tools and implementation techniques which will be of practical use to software developers.
Quite possibly the best mix of theory and practice I've ever encountered in a book on the guts of programming languages. It provides a mathematical foundation without getting bogged down in self-congratulation or formality and focuses on practical compilers and features of languages we use, including foundations of object oriented inheritance and how it's implemented. Also provding a look at the historical P-machine, virtual machine design and chapters on functional programming that are widely applicable, this book is particularly relevant now that most languages synthesize imperative, functional and deductive aspects.
Probably the biggest mark "Compiler Design" made on me was that, in its practicality it allowed me to write some toy compilers easily and think and build on what I'd seen, due to the practical approach and smooth conceptual layering of the chapters about actual compilation. In turn, I applied its ideas in places I didn't expect, such as thinking of interfaces between language environments and program modules as programs in a small language, and being able to think of production of metadata and execution of the program itself as different kinds of program interpretation. In some cases, programs one might not expect, such as real time information processing systems, lend themselves well to treatment using language like tools, despite expectations.
This is a highly informative book. It concentrates on the concepts and theories rather than any particular programming language, hence the code examples are sparse and are in pseudocode. Of course, that also means that there are mathematical formulas that I simply dread as I can't seem to understand them easily.
The book covers topics such as the techniques and structures for the efficient compilation of object-oriented languages, functional languages, and logic languages. The discussion and explanation on the different approaches and their complexities are highly detailed.
The book is written in a very serious and professional tone, much like an authoritative work on a subject, rather than a book that invites the reader to explore and experiment. This is somewhat an issue because I had to read this during university and it wasn't easy to read it.