5 comments about The Semantic Web: A Guide to the Future of XML, Web Services, and Knowledge Management.

1. This book is well written and comprehensive. It clearly explains highly complex subject matter. I refer to it constantly.



2. Different people will not agree on exactly how to define all concepts.
   As a result there will be ontological mismatchs across parts of the
   web designed by different people. In conventional logic if even one
   inconsistency exists it will be possible to draw all conclusions and
   their contradictions! It is not explained how they will prevent this
   from happening.



3. Painstakingly, in a literal sense, read from cover to cover without learning much about semantic description and search (more pedestrian XML technologies, eg, XPath were covered well). Some of it, eg, on Topic Maps, is impenetrable. Very light on interesting and compelling usage and how-to of the more ambitious, semantic technologies that are the reason most would buy a book of this title.
   
   And so, unfortunately, I agree with the negative assessments already given here: little practical information for implementers and on the contrary, the considerable time spent in attempts to decipher will not be justified, in my experience, with their pay off in knowledge that is useful or memorable.
   
   To be fair, part of the problem, from what I gather by its absense in the book, is that the W3C semantic web technologies are not even attempting to solve any part of the ultimate problem of semantic analysis: natural language understanding. Instead the highest goal in this presentation is the /manual/ cataloging of /whole/ documents (and emails, customer questions, etc).



4. This book can be a good general introduction to semantic web technologies, to get an idea about how they can be useful inside your organization. The starting and ending chapters are rather good in this respect.
   But unfortunately the middle chapters, which try to explain the technical side in more detail, are somehow confused and hard to understand, maybe incomplete. The part about RDF is not bad and can give you some useful info, but things get worse when you get to topic maps and ontologies. Maybe this wasn't the main purpose of the book, but it's a waste of pages and reading time anyway.
   
   So, when you finish reading it, you can be excited about the topic and have nice ideas for implementing those technologies in your work/life, but you still are left clueless regarding HOW you should actually do it.
   
   It should also be noted that the book is becoming a little dated now: new technologies like OWL are more mature now, than what it describes. Not the authors' fault, of course.



5. The book throws around all of the right buzzwords: ontologies, XML, KIF, taxonomies, metadata, etc. However, it never even properly defines these terms or organizes the information. If you already understand what the semantic web is, the book makes perfect sense but you don't learn anything new. If you don't already understand what the semantic web is, you won't be able to make sense of the author's high level descriptions and diagrams and you won't learn anything either. You can go to Wikipedia and probably get better explanations of most of the terminology. For example the Wikipedia definition of ontology from a computer science perspective is : "In computer science, an ontology is a data model that represents a domain and is used to reason about the objects in that domain and the relations between them." Why can't the author just SAY that??? Instead he wanders all over the map with a kind of philosophical musing about ontologies, and then proceeds to dissect a human resources ontology without ever properly defining why this model is useful in terms of the semantic web and what makes this model an ontology in the first place. The whole book is like this.
   The only reason I give it three stars is that there is useful albeit poorly organized information in here, and if you do know what the semantic web is and you have to present the information to management you can use the individual pieces of the book to probably stitch together a pretty good introductory presentation ... providing you already know what you are doing.
   However, I really recommend the book "The Semantic Web Primer" instead. It is more technical and better organized with much clearer explanations.

5 comments about Foundations of Ajax (Foundation).

1. It is not a thick book. Easy to read, to finish. It does a good job to introduce Ajax to beginner. It introduces several situations you can start to use Ajax, like data checking, auto page refresh... Almost every web project can apply Ajax on these areas.
   
   I do not give it 5 stars because it talks too much javascript. This is not a javascript book, why does auther need to tell reader how to debug javascript?
   
   But it is still a very good book for beginner to quickly learn ajax with its great sample code.



2. This book from Ryan Asleson and Nathaniel Schutta is a basic introduction to Ajax focused on the user interaction aspects. Therefore, most of the book focuses on how to use JavaScript to enhance user experience on web sites. After introducing the XMLHttpRequest object and server communication, the authors show how the Ajax approach can be used in various interaction contexts. The final chapters of the book are dedicated to tools than can ease JavaScript development, particularly for the testing and debugging activities.
   
   Although it is targeted to developers that already master JavaScript and HTML, the clarity of examples makes this book accessible to a larger audience, even if you do not have a PhD in JavaScript. Some may think that the focus of the book (client side scripting) is limited, but I see this book is a good starting point for practical Ajax implementation, especially to enhance an existing web site. The fact that the few server code examples are in Java may however be seen as a disadvantage for readers using another server-side language and that are looking for a broader coverage on their specific configuration.



3. This book is terrible. The exposition is rather poor and shallow. Too focused on Java and not JavaScript/Ajax. The authors knowledge of JavaScript come across as being peripheral and unfocused. This book is simply riding the Ajax craze wave and if you're a self-respecting programmer, you'll be returning this book in no time. Terribly disappointed. There are two other books on Ajax/JavaScript that do a much, much better job at explaining the technology and its uses than this primer; I'd give the names, but don't want to cross-advertise.



4. I am a professional Java guy but i can't get what I want (knowledge about Javascript/AJAX programming objects) from this book because the book highlights on advanced concepts from related technologies to explain things. So unless you are a pretty competent Javascript programmer you will struggle to understand this book and struggle to understand the significance of what you are being told and why.



5. This is a good book if you are looking for an introduction to Ajax programming with straight to the point examples and common tools.

5 comments about Ant: The Definitive Guide, 2nd Edition.

1. This book can take you from zero Ant knowledge to being productive in a matter of days. After starting with some simple examples, it builds up the following concepts very well: properties and types, compilation, deployment, testing with JUnit, working with CVS, and Eclipse integration. I skipped chapters 8, 9, 10, and 12 because I did not anticipate a need for them right now. However, if I need to know about web deployments, working with XML docs, optional tasks, and extending Ant I know that this book covers these things too. To get the most out of the book, you need to download ant to your computer along with the example code from the book's web site. It is very easy to modify the code and see how different options for the various tasks work.



2. This book provides a good enough introduction to Ant, but it only takes you to the point of knowing how to use Ant and not the point of knowing how to use ant on a project of any size. As an introduction it works well. You learn how to get up and running with Ant very early on in the book, and you learn all of the key tasks rather quickly as well. Everything is explained clearly, and it seems reasonably organized. What it lacks is really any explanation of various best practices for using ant, whether on a small program or a large one. For a book of this size, I was surprised at the absence of this info and ultimately I felt that it was only a bit more useful than the free online docs for ant.



3. Apache Ant is the primary build tool for Java projects and this book is excellent introduction to it. Although the title is misleading - this is not really a definitive guide (its not really reference book for starters), it is well written and easily understood. If you work through this book from start to finish then I'm confident that you'll come out the other end as an Ant expert.



4. Web research on Ant revealed a lot of explanations, but they were very hard to understand. And I didn't want to waste time scratching my head. This book explained what Ant is and how it works in an approachable way without insulting my intelligence. The author obviously has a lot of experience in Ant and many of the other technologies it interacts with. While other comments have pointed out that it's not a reference, I can easily get those other details on the internet. This book got me up and running with Ant quickly and painlessly. It contained useful examples that actually worked when I tried to follow them.



5. This book is a regurgitation of O'Reilly web material. This book had a real opportunity to discuss Ant internals or at least something that can't be found on tech sites or the software documentation. Project wikis will undoubtedly replace the need for tech books of this sort.

5 comments about Java Developer's Guide to Eclipse, The (2nd Edition).

1. The book is very good. The problem is the examples. The examples are all heavily loaded and compounded. Like when you want to learn a certain type of a tree, instead you will be put into a dense forest and lost totally. I do not recomend the beginner to start with this book. I want the author to redesign the examples so that the topic be focused.



2. The book composes of 6 parts.
   
   Part 1 fouces on how to use the Eclipse IDE. The authors do a good job in explaining how to use the Eclipse IDE. Once a while, you will pick up some tricks that you will find extremely useful. Unfortunately, it also explains things that seems obvious from the UI perspective. In short, you read through 10 lines to get one line of useful information.
   
   Part 6 are the exercises that illustrates some simple concepts discussed in the previous section. That part does a pretty good job also.
   
   The other 4 parts discuss how to extend Eclips IDE and to write Rich Client application. Unfortunately, the authors fail miserable in organizing the information. I am expecting the authors will first explain the basic concepts and then start with some simple application and then build on that.
   
   Unfortunately, the first few chapters in those parts does a very poor job to give you a comprehensive overview. Then the authors will get into details that will make you completely lost. The worst part is that when they are getting into details, the section will fill with a lot of "forward looking" statements like do not worry about some details which will explain in later chapter. Sometimes, you will find that if they reverse the order of the chapters, it may be easier for you to understand.
   
   This book definitely needs a better Editor to make the information more coherent, and to condense the information better. The authors should re-organize the chapters/information to start from building a simple application with a window compose of a few views and some manual items.



3. Like many others I wanted to extend Eclipse so I can be more productive. Unfortunately I found this book to be poorly written and the technical details vague. I know what I want to do, but the book (over 1000 pages) does not show me how?!
   
   It explains the Eclipse architecture and idea goals which is fine but is repeated over and over again in various chapters of the book. I also could not get a handle on how it can be applied. This is not a practical guide to Eclipse. It is more about Eclipse's internal design which for most people is a waste of time. The online documents are more useful.
   
   Note the book is also out of date. I tried to follow some of their sparse examples, but I quickly realized it's a waste of time because I have the latest Eclipse 3.11 installed and the examples were for Eclipse 3.0 and the menu options and API have changed. All in all, this book was a real let down.



4. The first edition was simply great. Not only that it was the first book to describe how to write an Eclipse plugin, it still would be the best -- if Eclipse had stand still. The second edition is not too bad. But the chapter on writing a text editor plugin is so superficial that it could have been left out. Where the first edition described in (necessary detail) how to write a text editor plugin, the second edition just roughly describes the concepts, but no API usage, no example in the book's text. The code on the accompanying CD is somewhat better, but now (2006) partially out of date as well. So if you want to write a text editor, there currently is no book or article I am aware of, that really helps you. You have to dig through existing code and try to find out for youself, why things are as they are.
   
   Finally, the first part of the book on how to use Eclipse could have been removed (~20% of the book) and the chapters on how to write plugins should have been enhanced.



5. The reason this book gets both great and lousy reviews is that Eclipse is such a huge subject. The writing of Eclipse plug-ins is simply a larger subject than any reasonable book can cover. If the topics that the authors chose to cover happen to align with the ones you personally need, then the book is excellent, but if they don't align, the book isn't going to help you much. Part I (six chapters) covers using Eclipse to write programs. Part II (seven chapters) covers the fundamentals of Extending Eclipse with plug-ins. Part III (9 chapters) covers plug-ins in more depth. Part IV (5 chapters) covers extending Eclipse with new tools for the IDE. Part V (6 chapters) covers assorted extra topics, such as OLE and Active X integration and performance tuning. Part VI is a set of nine farily detailed exercises (with source code on the provided CD).
   
   This book is not an overview, the authors opted instead to cover certain topics in pretty good depth. This aproach is good for those already aware of the basic concepts, but will be confusing for noobies (which I was when I first got it). I suggest that those new to Eclipse plug-in development start with a good overview (such as _Eclipse 3 for Java Developers_ by Daum) before switching over to this book for more detailed descriptions.
   
   This book doesn't cover the Eclipse Modeling Framework or the Eclipse Graphical Editing Framework, probably because each of these is a book in itself. This book is also light on its coverage of SWT and JFace, which you will need to be familiar with to develop your own plug-ins (again, a book-length subject in its own right). You will also want to be thoroughly familiar with Java Design Patterns and best practices, since Eclipse uses practically every design pattern you've ever heard of.
   
   While there have been changes to Eclipse since the Second Edtion came out, I was able to figure it out and map between the examples in the book and Eclipse 3.2.1 without too much trouble.

5 comments about Perl in A Nutshell: A Desktop Quick Reference (2nd Edition).

1. This book is full of alphabetical high level descriptions (which are always ambiguous) of Perl language statements with few or no illustrative examples (which always help clear up ambiguity).
   It is a waste of money.



2. I am not a beginning programmer nor am I what you would call an expert. Having a background in PHP made Perl easy to learn, so I didn't need a book that would "teach" Perl. All I needed was a good reference to figure out the differences between PHP and Perl. This book did exactly that! I was able to start programming within a day and I have referenced this book more times than I can count during my most recent development efforts. The binding is nearly worn out! I recommend this book to intermediate programmers that only need a small boost to get to work. If you're a beginner, buy this book to use after you learn the basics and you'll find it to be one of the most valuable tools on your desk!



3. This is a handy reference, but if you have a limited budget you should probably go with Programming Perl and the Perl Cookbook before this one. This is a fine reference but it doesn't have the depth that the other books have and the information on the modules is available online through CPAN. I have the entire Perl library on my bookshelf and I hardly ever pick this one up.



4. Exactly as advertised, "Perl in a Nutshell: A Desktop Quick Reference" is a great reference book if you already have a basic understanding of Perl. Although it does have a section that it refers to as an "Introduction to Perl" it is actually a pretty cursory introduction and there are better books for learning the basics of Perl.

   The book does have an excellent section on installing Perl including installation on both the Unix and Windows platforms. I've worked with both platforms and the installation process is well documented including how to install modules. This brings us to the large chapter on getting and installing Perl modules. I have spent hours sometimes trying to find an appropriate module for a special situation. This chapter lists all the most common modules and includes descriptions of what they do. This alone makes it a valuable resource for anyone involved in Perl.

   The authors also include a lot of technical information including command line options and environment variables as well as a section on program structure, data types, special variables, operators, expressions, subroutines, filehandles, and just about anything else that you might need a quick refresher on.

   Functions are listed both by category and by alphabetical order with descriptions and syntax information. I had a couple of problems on a large project recently and it took three days to get an answer through the forums on the Internet. The answers to all of them are right here and I could have saved myself a lot of trouble if I had had this book then.

   A lot of other information is available in the book including CGI programming, Webserver programming, database programming, SOAP, Network modules including Net, Mail, NNTP, FTP, and LDAP, Perl/Tk, Win32 Modules and Extensions, OLE Automation, and ODBC Extensions. This book will be the one I keep close at hand when working with Perl and deserves its location on my desktop instead of in the library. "Perl in a Nutshell" is highly recommended for Perl programmers from basic to advanced level.




5. I have a shelf of Perl books from O'Reilly, from the Quick Reference to Advanced Perl Programming. This tends to be my first grab when I am looking for something. A bit thick when I am on the road, so I fall back to the Quick Reference, and whenever I do, I find I miss having the Nutshell book (with all my notes in the margins :) If I can't find it in this book, I jump to the Perl Reference most often.

1 comments about Beginning Web Development, Silverlight, and ASP.NET AJAX: From Novice to Professional (Beginning from Novice to Professional).

1. This book is a good start for anyone who wants a quick overview of web technologies as offered by Microsoft. Roughly one-third of the book is dedicated to what would nowadays be called "traditional" web technologies based on ASP.NET. It covers a lot of areas (Web forms, ADO.NET, Web Services, deployment), but never dives very deep. The second part focuses on the Next Generation technologies for Web Development and provides an introduction to WCF, WPF, WWF, Cardspace, Ajax, APS.NET AJAX and Silverlight. Unfortunately, it only addresses Silverlight 1.0 and some interesting new developments such as LINQ and project Astoria are left out completely.
   
   I noticed quite some errors in the code examples in the book (especially in the first part), which I think should have been picked up by the reviewer.
   
   All in all, an interesting read that will certainly make the user want to visit Amazon for some more in-depth books on one or more of the many topics they've just become acquainted with.

5 comments about Physics for Game Developers.

1. If it wasn't for the poor code examples, I would have rated this book four stars.
   
   The problem is, instead of building new examples on previous ones, author has decided to repeat same code over and over again with only minor tweaks. This lack of generalization unfortunately obfuscates the point of the examples and (besides other instances of bad programming practice like abundant use of global variables or excessive copy/paste programming) makes me grind my teeth.
   
   However, the text portion of the book is written well. It's great introductory material to the subject.



2. If you wish to add more realistic environment interaction or object behavior to your games, you will benefit from this book. This book is much better for beginners than more recent books on the subject that maybe talk in more detail about game physics, but do so from the standpoint of some specific physics engine that the author has put together. I have personally lifted several pieces of code from this book, adapted them to Java, and placed them in a multimedia application I have been writing with no trouble. The book goes over the basics of adapting Newtonian physics to games, and then uses these ideas to set up the motion of simple projectiles, cars, hovercraft, and ships. 3D issues are also discussed at length.
   To be sure, you do not need to be a physics expert to learn something from this book, but it is assumed that you have a basic level of understanding of classical physics. Anyone who has taken high school or college level physics should have no trouble understanding the material. You should also be proficient in trigonometry and vector and matrix mathematics. Certain topics in calculus are also discussed, so some degree of familiarity would be useful, but is not required. However, a strong C++ programming background is required if you are to tackle integration of a physics system into your existing game engine. This book is a great starting point for readers who aspire to understand "Game Physics" by Eberly, which is far more advanced and academic in tone.
   I shall talk about the details of the book in the context of its table of contents:
   PART 1 - MECHANICS PRIMER
   This consists of chapters 1 through 5 and starts out with simple concepts such as Newton's laws and builds up until you get to rigid body dynamics. If you are already are up to speed on mechanics, you can skip these chapters.
   PART 2 - REAL-WORLD EXAMPLES
   Chapters 6 through 10 focus on modeling so that you have a solid understanding of the nature of certain physical systems. The craft selected were chosen because they best illustrate the specific physical phenomenon and concepts that are relevant to a wide variety of problems. The systems modeled are projectiles, aircraft, ships, hovercraft, and automobiles.
   PART 3 - REAL-TIME SIMULATION
   This field is discussed as it applies to games in chapters 11 through 17. These chapters focus on the fundamentals by walking through the development of the 2D simulation of hovercraft, a 3D flight simulation, a generic multibody simulation in 3D with collision response, and a simulation of cloth using particles and springs.
   The appendices show implementations in C++ of classes for vector operations, matrix operations, and quaternion operations. The book's bibliography provides information sources for mechanics, mathematics, and specific technical subjects such as aerodynamics. All of the code for the book can be downloaded from the book's website at O'Reilly and Associates. I highly recommend this fun and comprehensive book for anyone getting started in adding physics to game programs.



3. I would have rated this book as great, but:
   
   1 - Why in the name of everything that is good and wholesome would anyone use imperial units when writing about physics?
   
   2 - The code in the examples is appallingly bad. There are abundant global variables, poor comments etc...



4. It gives a decent coverage on 2D and math vectors before it jumps right into kinetics, rigid bodies, momentum, torque, etc. Other people complain about the junk C code used to explain things here, but I just care about the concepts and understanding them and the book meets that goal. So buy it if you are like me?



5. This book covers most of the physics problems that a game developer may face. From the basic laws of motion to car and aircraft simulation. It includes clear examples and formulas that can be implemented right away. On the more complex subjects, it also includes source code listings.
   
   I read this book expecting to get an insight into game and simulation physics and was disappointed. On most cases, the book gives quick introduction to the problem and then jumps straight to the equations. Therefore, if you just want to implement physics for your game without learning all the principles involved, this is the book for you. On the other hand, if you want to get a feeling of physics and go a little deeper, it is not.
   
   Furthermore there are some details that you may want to consider. First, the book works mainly with the imperial system of units which I find confusing. Second, all the source code is for Windows. Third, there are lot of places where statements are made without a hint of an explanation or a reference, which is annoying if you want to understand what is happening.
   
   Overall, the book is clear and concise. It gives a good set of equations that you may need for your game programming, and is good to have around for quick reference. But if you are serious about physics I recommend getting a more advanced book.

5 comments about The Game Producer's Handbook.

1. This is the book that de-mystifies video game production. What a fantastic handbook!



2. The book is very insightful of the anonymous role that bares the title "Producer." Producers ARE the backbone of development. They have to set the ground rules on game design and what actually gets developed for the consumer release. Without a good producer the development process will either never end or the game would fall apart to garbage, literally in one day. Producers seem to be the understated person in the development team. Many coworkers have snickered and have said things like "Of course he has a stupid big smile on his face. He's getting paid well to do nothing but order pizza." The obscure, daunting task of keeping together a big developing team, the assets, the budget, marketing, etc. all in line is an under appreciated feat. But somebody has to do it!
   
   I recommend this book to all people working on a team, and all the hopeful talents who want to partake in the videogame industry. Videogame development is a physical and mentally tasking process. Producers do carry the burden of easing the shell-shock of how a "cool" job is actually hard work by planning and organizing the development schedule. I feel the book gives a good recap of what is expected from producers. If it feels like something is missing (was that piece copyrighted) this is a good book to check, hence the name The Game Producers Handbook. Good producers could very well become great producer after reading this book. Leadership skills are essential. The book covers quality traits of a good producer briefly, which I appreciate, very to the point. If a person needs more self-help material on leadership I recommend a purchase of a Forbes magazine. But my favorite tip from Handbook, and it just common sense: when having a meeting have a written agenda and mind the allotted time because dev-time is a lot of money. Finally it has been written, thanks Dan.
   
   Another section of the book worth reading and following is the process of how to deliver, or pitch a game idea to get the production green light. It would have been nice to see the initial documents. I think everyone that has purchased this book was hoping to find the answer to how to get "my" game into development. For example, what exactly does the proposal document look like? Is it typed in formal-unbound report format? How much written is enough for a game proposal? What is too much and too confusing to read?
   
   Lastly, developers who are uncertain of the role of a producer may benefit by understanding the producer is your work-friend, not the pizza boy. Or the guy that cuts out your work because he (hates) you:-P Understanding the various roles in a game team makes better teams. Your producer already knows this. This book is sure-fire recommend to all my coworkers. I believe the more your aware of the process of making a video game, makes you a more valuable employee. Many work blindly to the task at hand, and do a great job. But I like to see the big picture. But hey that me.



3. After shipping over 50 different titles in 15 years (working in various capacities), I thought I knew it all. However, after seeing Dan's common-sense approach and mastery of the production cycle beautifully laid out, I suddenly found myself an aspiring student in several areas. In the others, it was an affirmation of what I know, believe, and have personally experienced.
   
   If you are an Assistant / Associate / Full-Fledged Producer--this book is for you. If you are someone who is striving to break into the games industry, again, this book is for you.
   
   Dan is currently the CEO of Threewave Software in Vancouver B.C. (if anyone is keeping tabs), and his knowledge and personality resonates throughout the book.
   
   Major kudos, a great read, and like the subject line says it's an invaluable resource for now and years to come.



4. This book is basically just a long list of platitudes, like "strive for excellence", "plan ahead" and "be nice to people". It contains very little of substance and is incredibly superficial.
   
   Apart from that, it is poorly organised (apparently every single paragraf deserves to get its own header!), extremely repetitive, and also contains annoying small mistakes (like referring to a reading list which doesn't exist).



5. I've been a game Producer for 8 years. Over that time I've had some successes and some failures. There is no doubt in my mind having this book would have prevented some of the failure. It goes very in depth into all aspects of a producer's job. I learned several new things from the book and can't wait to try them out on my team. I heartily recommend this book to anyone who is thinking about becoming a producer or anyone who currently is a producer.

5 comments about LabVIEW Graphical Programming.

1. For those of you who do not have this book, this book is one of the top Labview books available. It goes very quickly through the basics, and focuses more on building actual applications in Labview. Many pointers on how to maximize resources are through out this book. It saved me many hours of trial and error. The book reads as if an articulate person is speaking to you. Very no nonsense.

   For example, there's a comprehensive chapter on actually developing a Labview VI for use. It goes through the requirements, the development (internally and also the user interface) and the release of the VI. Further, it has a nice section on DAQ.

   This book is more or less a rehash of the old book, with some upgrades, but for those who don't have the old one, read it's reviews. I wasn't terribly disappointed with the omission of Labview 6i stuff, since the content extended beyond it. You'll be making a good investment in this book.




2. I've purchased all three editons of Gary Johnson's LabVIEW book and haven't been disappointed yet. This is one of those rare books that lives up to its hype. The writing is clear and engaging, without condescending to the more advanced user. If you're using or learning LabVIEW, check this book out.



3. I didn't find this book helpful at all. It is neither for beginners nor for advanced Labview programmers. If you are somewhere in middle and want to enjoy reading a book about labview like reading a fiction, this may be the right book for you.

   If you are really looking for a book which you really need to learn something about Labview, this book is not that one. Continue your search!




4. This book has little to offer for those that need to do programs in Labview. The first four chapters are useless. If you want a good book get "Labview for Everyone" it will help you to understand Labview.



5. This book is good for Labview intermediate programmers. It sort of seems hard for a beginner. It does not go into great depths and tricks of programming in labview. if you are in the learning curve this books adds more to that. It is very limited in certain aspects, like real time programming, and does not explain much about DAQ mx. This book is great for people as reference but I guess there lots more to be added.
   It did help me intially as I got into more programming, it would not help me.

5 comments about Data Structures and Their Algorithms.

1. In this book, Lewis and Denenberg attempt to explain data structures and associated algorithms. They rely too heavily on obscure proofs, have few, if any worked-out examples and many ambiguously worded questions. Their assesrrtion that a "high school" math background is needed is clearly false. The book also suffers from poor typesetting.



2. One of the best ways to discover the strengths and weaknesses of a textbook is to teach a course using it. A few years ago I taught a senior-level course on Data Structures using this book. The book was a joy to teach from, and I would happily use it again -- I thought it was one of the nicest textbooks I've ever used.

   (In case you haven't figured it out from the above paragraph, I believe that Paul Schreiber's review of this book is far too negative.)




3. I seriously like this book. It's explaining is close to crystal clear to me when I read it, and the algorithms listed (in pseudo-code) take it to a practical level.



4. This is one of the 2 texts we've had for our data structures course. I'm not sure what the other book is, because this one was so good. It covered the material in a clear and precise way. I even have a copy of this book today, for further reference!



5. I never really appreciated this book until many years after graduating from college. I had this in my library just sitting around. The data structures course I took in school was completely uninspiring. However, when it came to researching and implementing appropriate data structures for my own software, I didn't realize how comprehensive this book is. It covers more algorithms and in greater detail than the ever popular Cormen book. The pascal-like examples are very thorough. There are times when code is not provided, but it gives you enough detail to extrapolate from what is already there to get started.