They start out with the general exponential time depth first and breadth first back-tracking parsers, followed by CYK and Earley parsers that can parse any context free grammar in polynomial time, and then go on to linear time LL, LR, and LALR methods that are used in compilers.
Customers who bought this item also bought
Along the way they cover regular languages and their parsers which are used to implement regular expressions, as well as generalized LL and LR techniques, that can parse any context free grammar but still retain the speed of LL and LR parsers for most practical grammars. There are also chapters on more esoteric topics that might be of interest only to select few.
They include non-canonical parsers, parsers as intersection of context free and regular languages, and context sensitive grammars. On the other hand, there are also chapters on the applied aspects of parsers: The language of the book is mostly non-technical. It seems like there has been great effort made to keep CS jargon to the minimum and to explain everything in simple terms. Most of the concepts are presented as examples first, followed by general description. There is almost no pseudo code, most of the algorithms are described in plain English.
The authors do a surprisingly good job at that, leaving few ambiguities and at the same time not bogging down the readers with unnecessary details. This makes the book suitable for gentle night time reading, without a need for paper and pencil at hand.
The material is presented in sufficient detail for basic implementation of most of the presented algorithms, and there are plenty of references to consult for extensions. I really liked the first half of the book. It was clear and easy to understand. However things do speed up considerably in the second half. Explanations become terser, there are fewer details, and sometimes it requires several re-reading of each section to fully absorb the material.
I think the authors wanted to cram in more material towards the end and had to make some sacrifices in presentation. There are some additional things that I think could have been done better. Sometimes the authors use terms that haven't been fully defined yet and only define them a few sections further. This makes it a little hard to read, since you're constantly wondering if you have somehow missed the definition earlier.
I also wish that more connections to graph theory were presented. For example, there are lots of algorithms that could be viewed as a graph search. The authors do allude to that but never mention it explicitly. I wish that they would have stated clearly what the nodes and edges of those graphs are. Some of their examples are too simplistic and may lead the reader to believe that the algorithms are simpler than they really are. For example, the authors spend only two paragraphs on parse tree construction from the Earley parser and their example makes it look like the algorithm is deterministic.
In reality tree construction for the Earley parser requires back tracking and I had to consult outside sources to understand that. This is a very widely used method it's used in Unix's yacc , but it's limitation are not well understood by beginners. It's difficult for someone new to it to understand why their grammars produce conflicts and are not parsable using LALR, and I wish the authors spent more time on explaining how to detect those conflicts in various grammars.
a Practical Theory of Programming
Overall, I think this is a great overview of the parsing landscape, with enough detail to understand, use, and even implement some of the methods. Every serious programmer should be aware that these techniques and algorithms are available to them, and be ready to at least consider them as a possibility the next time they're thinking of writing a parser by hand. Should the reader be interested in implementing their own parsing algorithm, there is a whole chapter devoted to bibliography, with a short description for each reference.
Equipped with the background provided by this book the reader can go on to explore the various books or papers on parsing and should have no trouble understanding their content. I'm the creator of Irony parser kit, and this book was my guidance in implementation of efficient LALR automaton construction.
The Dragon book is quite dated today, there had been much new research and advancement in parsing algorithm since dragon times. Then I discovered this book - it was my savior!
The algorithm is carefully explained on several pages, step by step, using clear and helpful diagrams. I carefully reproduced the algorithm in code, and got almost fold perf increase compared to old dragon method. Note that the book covers many other algorithms and parser types, and I'm sure readers interested in them would find excellent coverage. This is one of the nice things about this book - you can pick up a chapter covering your particular area, and read it, without need to read the entire book from start to end.
It works as an excellent detailed reference on wide variety of parsing techniques. I have spent the last six months of my life learning as much as I can about parsing. I own half a shelf of compiler books, and I have flipped through the pages of half a shelf more. No other book approaches the clarity and comprehensiveness of this book.
- Monographs in Computer Science.
- brian the crap vampire.
- The Countrymans Field Sports Bible.
- Ageing Matters: European Policy Lessons from the East (Social Policy in Modern Asia);
When you try to read most literature about parsing, authors tend to throw around a lot of terms without explaining them. What exactly is a "deterministic" parser, a "canonical" parser, a "directional" parser? Grune and Jacobs explain every one of these distinctions lucidly, and put all known algorithms in context of how they compare to the rest of the field. How do the algorithms compare in what languages they can parse, how fast they are, and how much of the work can be done ahead of time? The book addresses all of these trade-offs, but doesn't stop at asymptotic complexity: This high-level overview and comparative survey are something I was desperately seeking, and I've found nothing comparable to them anywhere.
There is also a lot of important background information that other authors tend to assume you know: If you're not sure, Grune and Jacobs will give you all the explanation you need to fully understand. Share your thoughts with other customers. Write a product review. Your recently viewed items and featured recommendations. View or edit your browsing history. Get to Know Us. Delivery and Returns see our delivery rates and policies thinking of returning an item? See our Returns Policy.
Visit our Help Pages. Audible Download Audio Books. Shopbop Designer Fashion Brands. Amazon Prime Music Stream millions of songs, ad-free. Ming Li , Paul M. An introduction to Kolmogorov complexity and its applications. Guttag , James J. Horning , Stephen J. Garland , Kevin D. Modet , Jeannette M. Languages and Tools for Formal Specification.
A Practical Theory of Programming
What Computing Is All About. Book , Friedrich Otto: David Gries , Fred B. A Logical Approach to Discrete Math. Anil Nerode , Richard A. Design and Analysis of Algorithms. Bischofberger , Gustav Pomberger: Fejer , Dan A. Verification of Sequential and Concurrent Programs. Programming in the s - An Introduction to the Calculation of Programs.
Dijkstra , Carel S. Predicate Calculus and Program Semantics. Reps , Tim Teitelbaum: Programming in Modula-2, 4th Edition. Moll , Michael A.
- America Transformed: Sixty Years of Revolutionary Change, 1941–2001;
- Mortified: Love Is a Battlefield.
- A Home for the M.D. (Mills & Boon Cherish).
- Product details?
- Twisted Strands.
- Healthy Holiday Guide: 7 Tips to Stay Healthy and Skip the Weight Gain!
An Introduction to Formal Language Theory. A Guide to Modula