Dense but surprisingly accessible for the computer science student
582902
This is a review of the physical copy. The book is well-bound and I appreciated the green MIPS cheat-sheet. As for the content, the book is quite dense and lacking in example quantity and variety, but I'm surprised how much I'm able to retain, as the language used is pretty straightforward. My teacher ended up using the appendices (which are included on the CD-ROM) quite a bit; I would have liked to have them in a physical form, which is why I ordered the textbook in the first place -- so I guess that's a bit of a disappointment. Overall, I ended up liking the book's conciseness in conjunction with my teacher's lectures since I felt like the book quickly got "to the point," but someone who is reading this material independently might benefit from supplementary material.
3542474
If you are a computer science student or professional wanting to delve into the semantic web, this book is a recent [2015] summary of the key ideas. The potential is vast - to make a more intelligent set of web pages, that can be parsed and analysed by machines in ways more useful to end users. There is an obvious overlap with the so-called Big Data, where now the latter refers to the universe of web pages.

A key idea is that you get far beyond the look and feel of the HTML presentational style. You can appreciate how the original HTML 3 of the 90s gave us a mash up of presentation and data, much to the frustration of programmers wanting to get at the data.

The text explains OWL and the overall idea of different ontologies pervading the web. Much work has already been done in various domains like medicine on defining several ontologies. Maybe the book can inspire you to look deeper.
1103160
This was an excellent book to accompany the Systems Programming class at SUNY Oswego. I would highly recommend it to anyone looking to gain deeper insight into low level algorithms and systems programming. This book might be a bit challenging for undergraduates but it provides you with a solid understanding of how computer systems work, which in my opinion in necessary for any computer scientist.
3467945
As an aspiring student, this text could not be more useful.  Each chapter consists of a brief introduction to the topic at hand (i.e. binary search trees) that is no more than a few pages in length and is followed by 15-20 example interview problems with full solutions.  The shear volume of examples presented here is the real goldmine.  For any student that learns best by doing, these examples provide a massive resource.  Although you may find yourself overwhelmed at first, working through the full problem set allows you to build up your intuition and understanding of the nature and type of problems involved.  It might take you several hours to get through one chapter, but by the end you will feel a real mastery of the content.  I consider that an incredible feat, and I certainly do not think the same can be said of most software engineering textbooks.

Furthermore, this book does not read like a textbook.  Dr. Aziz uses a writing style that is succinct and to the point.  In an area where the content itself can be very difficult to wrap your head around, short and clear explanations are very much appreciated.  At the same time, the writing is not too dry.  You will not find yourself falling asleep while you read it because the writing shows a real passion for the material and an incredible depth of understanding.

If you are a student and find yourself day-dreaming about having your own start-up or working at a big name like Google, this book is a must have.  I could not be more happy with it.
3148533
I took Ted Sider's class at NYU, for which we used this book as the text. It is really an excellent intro to logic -- accessible without scrimping on technical details. It is also very comprehensive for a single-volume logic intro, covering many of the varieties of logic that are found in contemporary analytic philosophy.

Some caveats: firstly, this book is indeed an "intro" to some less-than-standard logics, but it is not an "intro" generally, and it really falls more squarely in the category of "intermediate" difficulty (filling a rather gaping hole in the available literature, between bare introduction and technical jungle). Readers looking for a purely beginning introduction to formal logic should look elsewhere (there is an abundance of good material at that level). Secondly, the purpose of the book is quite clearly to provide the technical equipment required for a working knowledge of certain logic-heavy areas of philosophy, and this book is not aimed particularly toward, say, mathematicians. That said, as an overview aimed at providing a solid groundwork for understanding the many flavors of logic one encounters in philosophical writing, it is probably the best book you can get, in my humble opinion. A solid second-place goes to that two-volume series by LTF Gamut, which is also quite widely available, and shares many of the same merits as this.
4353427
My first exposure to Automata Theory backs to 1992, as a senior undergrad textbook for that course, which was mandatory and a prerequisite to the Compilers Course. (No student could take them together). Although I got the highest grade among over 80 students, but I was not getting enough comprehension from the class, as it should be. I admit it was due to the complexity and sophistication of that text, since this was the first course that 100% dedicated to computational theory; taking into account it is BS in Computer/COMPUTATIONAL Science.

In my MS work, the required text was By Sipser, but the instructor was giving material that was from Hopcroft/Ullman 1979 text. It was the definitive resource, period.

I purchased the 2nd Ed, 2000, Hopcroft/Ullman/Mitwani; it was simpler than the 1st Ed. and easy going. My focus, and all Professors and researchers whom I know who work in a related-area, have this exact edition as a reference when needed!

Chapter Contents and Material Exhibits
The chapters are relatively not big in text but are very-rich in contents, that sometimes, if this is your first read/exposure to Automata theory, then perhaps you may need to read each section more than one time. If you're reading the text in deep, and in chapter 4+, you would really have a full enjoyment of how the authors are going with their exploring the ideas, with motivation. This is not my first text that I read by Ullman, Hopecroft, and Aho, especially, their older texts; their writings are just "amazing."

Exercises
Try to solve the exercises but not at once. Perhaps the exercises can be divided into 4 categories
1. Simple ones
2. moderate (average), that mayhap need to scratch your brain
3. difficult (beyond average), but not challenging, they are just doable.
4. challenging --> I didn't solve all of this category. They are few.

An Advice: some of the exercises in early chapters might be easier to do once you read the later chapters. This is due in part that the way you are making progress in the material, and another, some depend on and only "ideas" that are explored in later chapters.

Errata
I've searched the Internet looking for a (maintainable) Errata list, but there's no one. The text has some typos, and otherwise very minor that you could easily spot. I'll mention some:
One of the, perhaps, typos, is in on of the examples related to the conversion between NFAs to DFAs. Another one also in an example to the PDAs, but don't remember exactly.

The Bottom Line
If you are going to have some future work in Automata and Computational theory, you may grab the 3rd Ed. and/or 2nd Ed. to star with, but for sure you should have the 1st Ed. at your disk; it's a "PRIMER."
3829526
I actually feel that this book is a mixed bag.  On one hand, the concepts are intuitively presented and are easy to understand.  On the other hand, the book doesn't delve too much into technical details, which may or may not be a godsend to various students.  Personally, I'd rather use the Drozdek Data Structures text, since it goes into much more detail into analysis and logic behind choosing various data structures and algorithms in order to implement an ADT.

Anyway, it's still a great textbook for an introductory course in data structures.  Just be sure to get another textbook on the same material down the road if you want to get a more detailed understanding of the concepts presented.
3841257
Elements of the Theory of Computation, by Lewis and Papadimitriou, is something of a classic in the theory of computation. Of the many books I have used to teach the theory of computation, this is the one I have been most satisfied with.  It covers all of the fundamental concepts one would expect in such a book (more on this below) but offers a bit more mathematical rigor than most other books I've seen on this topic.  It also covers one topic that is rarely even mentioned in other textbooks: the composition of Turing machines.
The book begins with a brief introduction to the relevant discrete mathematics (such as set theory and cardinality) and proof techniques, then introduces the concepts of finite automata, regular expressions, and regular languages, describing their interrelationships. It proceeds to context-free languages, pushdown automata, parse trees, pumping lemmas, Turing machines, undecidability, computational complexity, and the theory of NP-completeness.  (These are all standard topics.) Along the way, Lewis and Papadimitriou also introduce random access Turing machines and recursive functions,  and do a nice job of explaining the halting problem and how this translates into undecidable problems involving grammars, various questions about Turing machines, and even two-dimensional tiling problems. All of these topics are covered with an appropriate mix of formalism and intuition.
Perhaps the feature I like best is the discussion of composing simple Turing machines to obtain more complex and interesting machines.  The authors even introduce a convenient graphical notation for combining Turing machines and spell out specific rules for composition. While most authors are forced to immediately employ heuristics in reasoning about complex Turing machines (lest the notation become overwhelming), Lewis and Papadimitriou are able to keep the discussion more formal and structured by virtue of their Turing machine "schema".  I believe this makes their arguments more rigorous and even easier to follow.
This is clearly one of the best books on the theory of computation. However, be aware that there have been very significant changes from the first edition, which was lengthier and more thorough.  I confess that I actually prefer the first edition, as it contains nice sections on logic and predicate calculus (which have been removed from the 2nd edition), and is a bit more formal (albeit with some fairly awful notation). The 2nd edition is definitely crisper, with much cleaner notation; it is clearly more student-friendly, which was presumably the aim of the new edition.
If you wish to teach an introduction to theoretical computer science, or wish to learn it on your own, this would be a fine book to use. It's hard to go wrong with this classic.
866360
I stumbled over this (lovely) book a little by accident. As I kept reading, my enthusiasm for the book gradually increased. While the book is addressed perhaps more to students in computation and in CS, it is very attractive also as a text to be used in mainstream mathematics, and in probability theory.

 It begins with a new look at the classical Kolmogorov construction of measures on infinite product spaces, and asks for explicit ways of labeling them with a class of certain concrete numerical functions. Then it moves onto noiseless coding theory (from communications science), but it stays rooted firmly in classical ideas from Shannon-Kolmogorov communication and information theory.

It is indeed pleasing to see that God still plays dice, not only in quantum theory, but also in such classical areas of math as in number theory.

From the foreword: "...putting Shannon's information theory and Turing's computability theory into a cocktail shaker, and shaking vigorously..."

The book is a second edition 2002, with a number of attractive additions to the first edition from 1994. It will likely work equally well in a course, as for self-study.

The main portion in the book focuses on classical and modern topics in computability, and its connections to randomness; covering concrete halting problems, chaos, cellular automata, algorithms, and their complexity.

Palle Jorgensen, October 2004.
3128975
This book is suitable for my graduate studies on computer performance.  The author directs us from combinatorics, distribution theory, queue theory to queueing networks in a systematic way.  I have read the book at ease for its stepwise elaboration of concepts.  However, I have also read with hardship as it requires the readers to possess a good command of mathematics, both pure and applied, in order to go through the book.
For a mathematics graduate studying computer networks, I recommend this book.  A novice or a mediocrity should pay more patience to read if not yet at a loss.
This book has aroused my interest and eagerness to know more about computer performance from the viewpoint of queueing and networking.  In a word, I enjoy reading this book.
1278159
A joy for the lovers of clear thought, mathematics and yes assembler. A must read? No, those times are gone by.

But what can you expect from the first Volume of the "Art of Computer Programming"?

You will get a very thorough introduction to the required basic mathematics including a lot of number theory. Even for a math major this is not exactly light reading. Luckily Knuths explanations are clear, precise, short and sometimes with a sense of humor. There are also a lot of exercises and Knuth is generous with the answers. In fact he spends nearly a quarter of the entire volume with the answers to the exercises.

All algorithm examples are in a simple fictitious assembly language (MIX), which is also explained in this volume. MIX allows a rigorous proof of algorithms without any assumption of correctness of a compiler or an operation system. The implied view of a computer is really close to "a computer is a machine" view. This is in contrast to an object oriented view, to a functional view and to a structured view on programming.

Also in this volume you find a discussion of the basic information structures lists and trees. Knuth is not hesitating to use memory management as an example for them. Be prepared to a lot of forward referencing in the "Information Structures" chapter and a lot of joyful guided thinking.
787069
I absolutely enjoyed this book. I would highly recommend it for people new to programming and computer science. I think Wladston has done an outstanding job making the concepts in this book easily digestible. As a newcomer to computer science, not once did I scratch my head or felt overwhelmed by the information in this book. Wladston in my opinion did an outstanding job explaining the concepts through pseudocode and visuals. The satire images also helped with the explanation and keeping it fun. Though I wish there were a view more. This is a great book for getting your feet wet with computer science. I can't wait for a follow up on this book or one that tackles a more specialized area. Great Job!
2567631
When I first received the pdf version of this book, I did a quick skim of it. My first impressions were mediocre at best. There is something about the layout of the book that just doesnt click with me.  I also noticed that some of the screen shots had very tiny type. (After working through the book, I can understand why they were small and found it not to be the problem I had originally thought.) I had promised to review the book, so I put aside my preconceived notions and got started reading and working through the book.

Having taught computer programming to high school students, I have seen a lot of textbooks. Getting the correct balance of explanation and examples is something many textbooks strive for but often miss the mark by either being too technical for the beginner or so wordy that the student gets lost in the explanation. I was pleasantly surprised with this books content.

As I worked my way through the book, I found a very thorough discussion of all the items beginning programmers need to know. Items are explained in a clear, concise manner, giving you just enough information to understand, without talking over your head or filling the page with excess explanations. The code examples are also clear and concise. They demonstrate the concept without a lot of clutter or extraneous code. Because of that, the examples are not impressive (no explosions or flashing lights). To get the most out of this book, one needs to be at a computer, working through the examples and trying out the exercises. To me it seemed like the last three chapters were a little light on the explanations. I was also hoping for a more complex example for the iOS App in Chapter 8.

If you have never programmed before, or have dabbled in other languages, you should definitely give this book a try. If you are a professional programmer, you would most likely find this book to be too elementary for you, although a quick skim through it would give you a taste of some of Swifts ways of doing things. This book provides you with a good foundation in programming with Swift. It will definitely leave you wanting more. Foundations aren't pretty, but they are a vital first structure on which to build your programming skills.
2688450
I'm using this book to relearn core CS material in preparation for the CS GRE after several years in the industry. I can't recommend it highly enough.
This is not a book from which to learn concepts for the first time. If you've never heard of (e.g.) "undecidability", don't get this book intending to learn about it. However, if you know enough to know what you don't know, this book will efficiently fill in the gaps.
The book consists of over 100 chapters covering material across nearly major area of computer science. Each chapter is 20-30 pages long and is geared to someone who has seen the material before but is in need of a review and summary of core terminology and historical context. Someone experienced in one field who wants to be able to read current technical material in another field will also find it useful.
Most of the authors are academics; the remainder are members of major research labs. Some of their chapters, like James Feldman's piece on Digital Logic, are truly extraordinary. Most others range from solid to exceptional. The material isn't just that of concern to traditional academic CS; I was pleasantly surprised to see an entire section (8 chapters worth) on practical software engineering topics (development process and lifecycle models, requirements and specification, design, validation, tools, testing, project management, etc). The material was authored around 1995 or 1996, and nearly all of it is still relevant and as up-to-date as is appropriate for this sort of collection.
One minor weakness is there's no cross-chapter index or glossary. The book is organized as a collection of papers, and each paper includes its own index, bibliography, and glossary. To find material about the web, for instance, you have to hunt through the (excellent) 20-page table of contents for the relevant subsections scattered throughout. This weakness is far from fatal, however. Should the next edition add an index, it will only add value to an already exceptional collection, by making it easier to locate references to material that spans subfields.
Again, highly recommended for targeted learning.
153969
I've been teaching data structures and algorithms for over 25 years,
and the fundamentals--which every computer science student should
know--haven't changed very much. However, it doesn't follow that
everyone needs to write their own linked lists or hash tables from
scratch, when Java already supplies so much of that. I have looked for
a textbook that balances explanation of the basics with exploration of
the Java Collections Interface, and this is by far the best book to date.
(The similarly-named book by Zukowski has too many errors of fact
in it for my taste.)
Another reviewer said that this book does not cover the Java Collections
API. This is incorrect. The authors develop the ideas behind each data
structure as a suitably abstract data type, and then go on with "...and
here's how the Java Collections API does it." I think the previous
reviewer simply didn't read far enough to get to those parts.
For a tutorial on just the Java Collections API, Sun's online "Trail" is
the best single source, and has the advantage that it is not intermixed
with implementation details. If that were enough, no data structures
textbook would be necessary. However, in real problems, any
predefined generic data structure is likely to be inadequate and will
need to be extended; this is why a good programmer needs to know
the Collections API (so as to avoid reinventing the wheel), but in
addition a good computer scientist needs to know how these data
structures are implemented, so that he/she can go beyond them when
necessary.
The book is somewhat weak on algorithms and would not serve as a
reference on this topic; however, there is plenty of meat here for a first
course on data structures and algorithms.
4571510
It's unusual for a book on scientific computing to gain currency in mainstream software development, but a small number of C++ authors in the know have been recommending this since its publication, and rightly so.

Skim read the first 300 pages, which introduces C++ to Fortran and C programmers, without being too interesting, with the exception of the illustration of a Fallible class, which is like Haskell's Maybe. It's a neat use of templates, which has nothing to do with typesafe containers of T.

Fortunately, the rest of the book is in this vein, providing a very thorough introduction to object oriented design, using scientific examples. Don't think you need to read another introduction to OOP? No problem: the applications include modelling algebraic structures to provide mixins that provide + and * operators, function objects, wrapping C and Fortran libraries (e.g. LAPACK), implementing arrays and matrices, and an SVD solver. All good solid scientific programming, and all of which makes use of templates (including an appearance of the Curiously Recurring Template), in as elegant a way as the earlier implementation of Fallible<T>.

In particular, the authors make excellent use of the ability to use non-type template parameters. These were introduced into C++ as an optimisation so that library designers could know at compile time how large a container was - here, they're used to implement dimensional analysis, to provide compile time safety when multiplying and dividing quantities (e.g. speed and time) with units. This exemplifies the authors' use of templates - creative and eye opening, but not too baroque. In these pages you will see the beginning of the major direction taken by C++ in recent years - template metaprogramming.

How interesting you find it may be proportional to how numerically nerdy you are, but whatever your interests in matrices, technically, this provides an essential introduction to advanced template usage. You'll find the transition to the material in Generative Programming or Modern C++ Design much easier if you digest the template usage here. And arguably, the  resulting code in this book is at a sweet spot of functionality, readability and maintainability, compared to the more arcane representations in those later books mentioned above.

Being a scientific computing book, it's a tad pricey compared to some others that might be on your reading list, but it's still well worth your (or your company's?) cash.
819037
this book is a fine introduction to computing.  imagine a book with cogent, well-illustrated explanations of topics like (1) what a variable is  (2) linked lists (3) pointers....
...that also discussed the plusses and  minusses of various computer languages....
...and that was useful to a  professional programmer, and entertaining for his 13-year-old kid.
that's  this book.  i occasionally teach introductory programming classes, and i've  used this book as a source of handouts and overheads (within the bounds of  "fair use" and the copyright laws, of course.  :-) )  in my early  days as a developer, i also pulled it off of the shelf more than once when  i needed a quick graphical metaphor for something that i was trying to  understand.