A good book, but just it.
It's like a normal book. It's not bad but not excellent...

Excellent book. Nothing to say for this one.

Uhm... I had to buy this book because it was a required text for a required course. Who would buy a book like this otherwise? Duh!

I have used this book as a self-study guide. What I love the most about this title is the Gradiance online service. I could explore Automata theory a lot more by various feedback from working out Gradiance execises. I highly recommend this title.

I had to use this for a Formal Models of Computation class last semester. It's okay but can be hard to follow. It is often hard to learn from the examples. The formalism and proof gets in the way of intuition. It would make a better 2nd book or reference than a first book on the subject. I supplemented the book with Sipser and found that a much better book for learning from. Hopcroft (this book) is more mathematical in nature but the explanation is harder to follow. If you have a choice, go with Sipser.

As near as I can tell, the big improvement in the 3rd edition over the 2nd is the inclusion of some online practice problems. If your class isn't going to be using these, can you save money by going with the older copy.

I started to learn this course at the beginning of this semester and I just brought this book from Amazon in August.
I had no introductory course before but I was so curious about this subject so I am taking this graduate level course.
Now, I am in chapter 10, and I would like to give a review of this book.
This book is well organized, from the beginning to the end.
I have read almost each word in this book(including the extra ones in the box), and I would like to say: It is worth to do that.
Although sometimes the sentences are not very clear(maybe because I am an international student), but almost all the ideas are precious. So, please be patient when you are reading.
Trust me, if you do not have any related course before, you need time for it. but if you can understand all the contents in this book, and if you are more energetic, finishing most of the exercise with excalmatory marks, you will find your mind becomes so clear that is beyond your imagination.
For the tests, if there are some in your class, is only a half piece of cake. you will feel 100 points is just for the left hand(given the condition that you are a right-hander). :)
If you buy an international version, prepare to visit the book's website. and I will say this second edition seems to me the -1th edition because it contains all the errors listed on the website. Prepare you pen and become a co-auther of the book.
If you feel you need to improve your mathematics, take it, because reading this book can improve your mathematical thinking and proof ability tremendously.
If you feel all the course in your university is too easy and can not match your intelligence, take it, then you will find something interesting.

The first edition is one of the best book in its field. A classic. A reference for many advanced courses in computer theory.

Sadly, the second edition misses a great deal of the first edition. Many chapters were removed. Important lemmas and theorems are missing.

I would gladly exchange my second edition for the first one, if it wasn't out of print.

J.

This was my textbook for an introductory course on Finite Automata and Languages - I enjoyed it a lot and I think that the chapters until the Turing Machines are covered very well, along with good examples. As one previous reviewer has already mentioned, the exercises can get very hard as compared to what's actually presented - this I found not too good.

The topics of complexity classes and NP-Completeness, as well as the chapter on Turing Machines are rather succint and do not cover the full depth. Papadimitriou's "Computational Complexity" does a better job in this respect, even though it is not at all flawless. Some might say that there is a reason why this book is introductory, but I argue that instead of doing a poor job, the authors should have maybe just made another book dealing with the above-mentioned topics.

PS: My professor told me that the first edition was much better - maybe you could find it somewhere in the library, if interested.

As a student using this book, I simply found it a little too difficult at times to grasp what the concepts were. The examples, at times were just too complicated, and could have been done better with easy to understand examples. Not so sure about this one. However, if you are already tamed in automata theory concepts, I'm sure you'll love it.

Hopcroft's book is a very good introduction to the theory of computing, from finite automata to undecidability. He introduces the text with a crash course in proofs, which is useful for a text of this nature. They have several examples with illustrations to facilitate quicker learning of deterministic finite automata, pushdown automata, and Turing machines. These illustrations proved very helpful for me, a visual learner. The book itself is chock full of examples and theorems with proofs. Problems with the book: more explanation on Homomorphisms would be nice. The exercises can get very much harder than the simple material the book teaches, so running through them takes considerable amount of time often. Overall it's a good book, and a lot easier to understand than their first edition in 1979. The material can at times seem a bit outdated since the computing world has changed by several orders of magnitude since their original work, but it still provides a solid foundation in the philosophy and mathematics of computing. Perhaps if you're a Cornell student you'll get the privilege of taking this theory class with Hopcroft as your instructor; he's very nice and willing to help students understand the material.

I think this is a great book. I'm starting to use it now and by now it suits all my needs perfectly. I'm studying in Oviedo, Spain and I think this book will help everyone on this subject, with its examples and theoretical part. I know it's a bit dense, but when you know what you're looking for, it's not a problem at all.

I think this is a great book. I'm starting to use it now and by now it suits all my needs perfectly. I'm studying in Oviedo, Spain and I think this book will help everyone on this subject, with its examples and theoretical part. I know it's a bit dense, but when you know what you're looking for, it's not a problem at all.

I've just passed my exam on Theory of Computation, and I've used both editions of this text. Frankly speaking, I couldn't choose one of the two should I keep only one of them.
Whereas the first was full of strict formalism, the second has traded this for a more discursive approach. Whereas the first reported theorems name (of their authors), the second has traded this for a richer bibliography at the end of the chapters. And more objectively, the first edition covered more "classical" topics with shorter treatments than the second, but this last treats survived topics with richer details (starting from the first chapter on mathematical basis for the course) and with updated examples of applications (XML and Markup Languages, e-commerce for DFA, etc).
This said, you know why I can't decide. A discursive approach is of course always desiderable, especially if you're completely new to a subject, but a strong notation is helpful in my mind because it improves communication and removes ambiguities. Hence, the best approach would probably have been a mix of the two, or halfway the two.
As a second matter, having a rich bibliography is surely helpful both for further studies and as a reference, but it's quite tedious to look at the index and be unable to find something like "Kleene theorem": you've to dive into bibligraphy to discover that "L is an L(DFA) if and only if it also is L(REG)" is something that has been studied by Kleene.
Finally, I surely can't question the removal of the complexity theory part since it is in the right of the authors to remove "optional topics" (if you use the book for a course on Theory of Computation only) and give a more focused target to the book, but removing stuff like the Myhill-Nerode theorem make things annoying since virtually every course on Automata theory and Computation includes it (like my one did, as well as the course on Languages and Compilers), so you have to look for it elsewhere if your only one book is this second edition.

I would give four stars, should I keep in heavy account the radical changes they made over the first edition and that includes the removal of some stuff, important on my opinion. But ... this is just my opinion, and since it is a very well written and informative book (rich of many details that other texts lack of) and surely one of the bests in the area (I've had 4-5 books in my hands for this course), that's why I gave it 5 stars.

(I'm talking about the FIRST EDITION of this book)
This book is a must for any student or professor in the field. I've heard the new edition is more readable but hides some minor details from you.
I can say some paragraphs could have been written in a friendlier way, but in a general sense the book is a bible in its topic.

This second edition of the classic text tries desperately to be more accessible to beginners than the first edition was, but the results are disappointing. In terms of clarity, the Sipser book still beats this one hands-down.

The authors seem to have assumed that the more words they use to explain a concept, the easier it is to understand. Unfortunately the reverse is often true.

For instance, in the beginning of the chapter on Turing machines is an extremely long, drawn-out example of an undecidable problem. The example is based on a C program that tries to solve Fermat's last theorem and prints "hello, world" when it finds an answer. If this sounds weird to you, you are not alone. I dare anyone who doesn't already comprehend undecidability to be enlightened by this example as it drags on for nearly 10 pages.

That said, overall the book does a respectable job of presenting the material, and if you are patient enough to muddle through the murkier sections you will gain a solid understanding. I especially like the fact that solutions to selected exercises are available on the authors' web site.

But if you have a choice, start with the Sipser book as an introduction, and pick up a used copy of the first edition of Hopcroft and Ullman to use as a reference. Use this second edition as a backup, for alternative explanations of key concepts, or for a broader set of exercises and problems.

This book comes before the dragon book and delivers important
theories like Finite Automata, BNF, Context Free Grammar, Turing
machine and etc. My philosophy for better understanding of
computer is to get a complete concept of the computer theory first, then try to simulate and code it. This book gives you
a clear concept of computer theory that can drive your brain
to think what a computer is and you can dry-run your program
without a desktop computer next to you.

I owned the 1st edition while I was
studying the first year of computer science at the University of London in 1983. I always come back to this book looking for theories like LALR(1), RE, 2-way PDA and etc... when needed for writing my parser programs in VC++ or java without any debugging tools.
This book really gives programmer a deep thought to understand the theories completely before coding.
Besides, dragon book is also helpful for writing parser programs.

This is a good book - but as a revision of a much-revered classic of
the field, it's a bit of a disappointment.

Hopcroft & Ullman wrote the classic text way back in 1969, and then
revised it in 1979. It was pretty much the standard text the world
over for an introduction to the theory of computation.

But over the last two decades, more and more people have been studying
Computer science, and many of them have no time for theory and
formalism and all the 'dry stuff' ..........

The authors point out that because of such reasons and also because
nowadays there's little research in the theory of computation per se,
and more in its applications, they've written a book to cater to today's
students.

Which, in other words, means they've simplified the presentation, tried
to provide intuition whenever possible, given lots more examples and
done away with some of the more difficult material.

This approach puts the book into direct competition with Michael Sipser's
excellent 'Introduction to the theory of computation', a contest it
cannot win, though it might be a respectable second.

Almost all topics are motivated by giving examples of how they're
related to applications in the 'real world', and similar to
Sipser's 'proof idea' approach, the authors first present a topic
informally and then formally, thus gently leading the reader to
the formal proofs.

This book sets out to do pretty much the same as what Sipser's book
does, ie to provide a readable, user-friendly introduction to the
theory of computation with lots of examples and intuitive approach
to problems wherever possible, but Sipser's already done an
'optimal' job.

Moreover, this book tries to be 'chatty', which i'm afraid is just
not the authors' style - the 'economy of expression', which has long
which has long been the hallmark of the legendary textbooks by
Aho,Hopcroft and Ullman, is sadly missing here.

Which means that this may not be the book for you if you're pressed
for time - but on the other hand, if you want to led gently to the
proofs and results with lots of examples and motivation, then this
might be just the book for you.

So all in all, it definitely worth a read - in fact, i'd say
it's still among the top textbooks around.

In fact, i would suggest that you read both this and Sipser, if you
have the time. Otherwise Sipser's the better choice for most of the
part, though it may not cover all the topics you need.

And if you're comfortable with a terse, concise & rigorous
presentation, then the earlier edition of this book is still
unbeatable - and you'll surely need it if you want to pursue research
in this area.

Having studied the Formal Language and Automata Theory (FLAT) using the first edition of the text, I think this 2nd edition is much easier to read and to understand. This is a very good thing because the 1st edition was a bit difficult to follow, especially for those who aren't familiar with the subject already. (As stated in the preface of the 2nd ed. that the 1st was written for graduate students who already have the idea of what the subject is all about).

Also, I found the approach "Example->Informal Def->Formal Def->Proof" very good, and should be used in more textbook. This way, the readers will have the idea of what they're going to study, what for, and why, instead of pointlessly studying something, forget it, and realize how important it is later (this happened to a lot of people, though). A lot of useful and interesting Theorems were also introduced.

However, there're things missing in this edition. For example, the Greibach Normal Form (GNF) for the Context-Free Grammars, which was covered in the 1st edition. I'd talked to the professor who taught the FLAT class I took, and he doesn't seem to like this edition either. He said something like, it is of course easier to understand, but something had been left out. So, he still prefered the 1st edition. (Well, he is a very good researcher in Computation Theory and is now writing a book on Term Rewriting System, another model of computation, which will be published by Springer-Verlag. Don't know when, though. So, this edition is probably too easy for him :-)

I, on the other hand, think that this 2nd edition is good on its own ground. It made the subject of Computation Theory easier and more accessible to wider range of people. (You still have to "think" and have Math knowledge anyway).

Also check out Michael Sipser's book on Computation Theory. I think that one is somewhat better than this one. It uses lesser Math (don't get me wrong, I like Math), and clearer explanations.
Also look for the first edition in Library, used book stores, or wherever you can. That one is definitely a classic, and cannot be replaced by the 2nd edition. I agree with one reviewer here, so bad that this was a new edition, rather than a new book....

This is the one book that I refer to time and time again for all of my automata-theory needs. It covers all the fundamental theorems of finite-state automata such as determinization and the pumping lemma in a clear, concise manner. Excellent coverage of context-free grammars, with excursions into generative power, normalization and parsing. The book is rigorously mathematical, yet easy to understand.

I came to this book fifteen years ago as a grad student after reading Lewis and Papadimitriou (which is good, but overly detailed on notation where context would suffice), used it as a professor teaching automata theory at Carnegie Mellon, and now use it as a software engineer for a speech recognition company that builds grammars.

I like the "informal, then formal" way. There a few books that keep an eye on explaining everything in such a great detail, keep an eye on introducing everything step - by - step.

I think, this is the way scientific books for non-experts, that like to become experts, should be written.

Although my mathematical background is very bad, I had no problems reading this book. I prefer more pages for one conclusion (with examples and good explanation) than the Theorem -> proof -> conclusion scheme found unfortunately in many books.

This book can be read like a novella!

Keep up the good work: HOPCROFT / ULLMAN / MOTWANI

THIS BOOK IS EXCELLENT !!!

I used the first edition, actually, but I expect the basic text is the same. I notice one reviewer laments a few of the changes. This text and the course that generally accompanies it are often derided as overly difficult. This text will certainly only appeal to those who love mathematical theory and challenges. I took the class (using this text) and struggled, but I received a high grade because I spent a lot of time on it and it was exciting to work throught the exercises. Work through. Those who want to be spoon fed need pablum and should move into other realms. For those who enjoy explorations in mathematics and computation, as well as challenging problems, this is the text for you.

I needed a book which would speed me up with my GRE computer science subject test (part III: Theory). Having non US and non english language based Bachelor Degrees in CS and Math, I needed something to both learn the more precise terminology and at the same time to gather my prevous knoweldge of the subject. After little bit of browsing and examining of reviews, book contents and browsing pages in bookstores, I decided to buy this one.

I admit that I had a solid knowledge of almost all chapters of the book and that the book might be hard to swallow for someone who is not a little bit familiar in mathematical logic and elementary math but otherwise, the book is excellent. Even authors admit that previous editions were more demanding and in this one they introduced many easier examples and appropriate pictures and diagrams so I really did not have any problems understanding every concept.

After each chapter exercises are given and while they are useful, I would prefer solutions embedded into the book (as in Knuth's Art of Programming). Rather that doing that, authors put solutions (to selected exercises) on their web page which is not bad but the book would be more complete (and probably more expensive) with solutions inside. I would pay $20 more for that version though...

I also must say that I really appreciate hard cover and excellent quality paper (these unfortunately raised the price)

Overall, this is an excellent book and if you are in a similar situation as me, I would recommend this one.

This book is an exercise in frustration. The format, which is inexcusable in a text for nonexperts, is 'Provide example, then dissect example into pieces organized by theory.' I personally find this approach very hard to follow. I would much rather have the relevant theory discussed first, then, once I know the rules, have examples.

Additionally, there is a vast insufficiency of examples and exercises in this book. Repetition is learning, and to be able to leave with a functional understanding of the concepts, students need to have a variety of illustrative problems available. The exercises in this book are weak at best. Solutions to all exercises must be provided if there is to be any benefit to working through them in the first place.

The fact that this book is the best available introductory text for this subject only shows that there is plenty of room for some ascendant computer science faculty to write a well written, well organized, and amply illustrated, replacement.

Like other reviewers, I find that the first ("classic") edition of H&U is an excellent reference when one is already familiar with some Theory of Compuation material. It was indispensible in at least the first half of the graduate Theory of Computation course that I took. H&U1 featured more detailed descriptions of automata construction than any other text. It did, however show its age.

In the second edition, the authors have added a few chapters near then end of the book on topics that simply did not exist twenty years ago (eg, there is a treatment of randomization).

At the same time, I find that the new edition is more readable for an undergrad. The introductory chapters expect less from students coming into contact with CS Theory for the first time. There are far more diagrams and sidebars and the overall tone of the book is far less formal.

On the one hand, this book has the potential to become the canonical undergrad text on Theory of Computation, I find that it has the feeling of a book that would appeal to undergrads much more readily than Kozen (which tends to intimidate students by the density of the material it manages to pack per page).

On the other hand, somehow I still prefer H&U1. One gets the feeling from H&U2 that it tries to hide something from students, whereas H&U1 pulled no punches.

And the cover art on H&U1 made it really distinctive (ala the cover of the Dragon Book), whereas H&U2 looks pretty much like any other modern textbook.

It's sad that H&U2 is a second edition of the book, rather than an entirely new book. It would have been wonderful to have both books in print as they serve somewhat orthogonal roles.

This book is a pain to follow. The authors have assumed readers would have a certain level of background knowledge. With this book being the preferred material in most univs wouldn't they bother to make it more understandable, include a few basic chapters for the users' benefit? It doesn't take the reader from a low level and walk him up, instead it starts somwhere at the top and stays there making it very difficult for users to follow the material. The frustrating part is I have not been able to find alternatives to this book for understanding the basics.One review suggested that a person should never go near this book unless his/her IQ is 130 or above. I have an IQ of over 130 and I'm groping in the dark. Would not recommend it to anyone but would love to see posts suggesting alternatives.

This is *not* a good book to use as an introduction to computation theory (CT). If you *already* know CT and look at this book, everything will make perfect sense and seem 'obvious'. If this is your first exposure to CT, then this book will seem very confusing. There are far far better books to purchase if you wish to *learn* CT, namely "Introduction to the Theory of Computation" by Michael Sipser. Once you have the basics down, you will be able to appreciate the detail of the Hopcroft book.

As a reference book, however, it is very good. It is extremely concise which makes it easy to zoom in on definitions and theorems without having to wade through explanations.

If you are taking a course in CT and this is the text you are using, then I suggest either getting Sipser's book or hope you have a really good prof!

There is, strictly speaking, no in-between for this book: it's either 5 stars or zero stars depending on the intended use.

It's very simple: Don't use it if _____, and do use it if ____.

Do NOT even THINK of buying this book:

1. If this is going to be your first brush with formal languages and the theory of computation.

2. If you need to get motivated to learn the subject, and you need that "first grasp" on it.

3. If you're taking a first course in the subject, and if you have an IQ below 130!

On the other hand,

You MUST buy this book:

1. If you already have some background, and you want a larger picture.

2. If you will often need an authoritative source for proofs etc.

3. If you need a reference for formalizing concepts touched on elsewhere.

This book may be an excellent reference text, but as a learning tool it is abysmal. It is confusing and takes a lot of knowledge for granted. I second earlier reviews and recommend Michael Sipser's "Introduction to the Theory of Computation" instead, which has to be one of the best books I've ever read for class.

The book is a great book if you are a beginner in automata theory. The exercises are also very good and the book makes your fundamentals very strong. It is a must for any student of theoretical computer science.

A predecessor of the book was published in 1969 titled "Formal Languages and Their Relation to Automata." It was re-written in 1979. This is a classical textbook for last year undergraduate students or postgraduate students in computer science, especially those who are going to deal with computer languages, artificial intellegence, compiler design, computational complexity and so on. One of the author, J. E. Hopcroft, is the Turing Award winner of 1987.

I have both versions of the book and I'd like recommend every computer science student spend some time on reading it.

After Having finished reading this book I found myself asking more questions than I felt were answered for me. From a pedagogical point of view this book leaves much to be desire. At times it is out and out confusing and seemingly contradictory. I am told this is supposed to be a classic: such a shame!

A classic text on the subject and a must have for any student of computer science. If you have taken a course in discrete math as taught by most CS departments then this book should pose no overwhelming challenges. It also makes a great companion to Aho, Sethi and Ullman's "Dragon" book.

This slim volume is the standard reference for research in automata theory, languages, and computation (especially regular and context-free languages). For that, it gets five stars. As a textbook for students, however, it is dense, uneven, and confusing throughout. Generations of novice computer scientists have been soured forever on theory by being forced to endure this book in their undergraduate- and graduate-level theory courses.

Conclusion: buy this book and keep it on your shelf, with the other essential references, but if you want to *learn* the material, look elsewhere -- for example, Michael Sipser's excellent new textbook, _Introduction to the Theory of Computation_.

It is unfortunate that Hopcraft and Ullman have been referred to as authors. Not only is the text indecipherable to anyone without a Ph.D., but the examples do not apply to the exercises and the exercises are not conducive to learning the material.