5 comments about File Structures: An Object-Oriented Approach with C++.

1. As a student, I have found this book to inhibit my studies more than help them. Instead of presenting the concepts clearly, concisely and with as little overhead as possible, this author seems to go out of his way to make it harder than it should be. The reader ends up wading through the examples, trying to find the core concept that should have been given up front. This student has discussed this book at length with fellow students, and has yet to find one who enjoys the book. We learn, but only after spending too much time filtering out junk.



2. This text was used for a junior-level File Manipulation Techniques course. We skipped around quite a bit in this book and did not use any of the C++/Unix material. I think (and I'm sure my professor does) that this book could be stripped down a quite a bit to present more topics when used for the classroom. What is presented is done well. This is a well-rounded text that should appeal to students and professionals alike. However, from the student's perspective, there is a lot of superfluous material. It is still one of the best, if not then it is the best, book on file structures and algorithms.

   The programs for class were in Visual Basic .NET . It was not hard to adapt sections from the text when writing programs for a different language.

   Our class moved through the book as follows: chapters 1-4 (introduction to external storage, files of records); start of chapter 8 (cosequential processes); chapters 5 and 6 (record access, insertion and deletion); end of chapter 8 (sorting large files); chapter 11 (hashing); chapter 7 and 9 (indexing and B-trees).

   Once I was able to figure out what I could skip and what was important, I was able to read the chapters quickly and understand the material without a lot of re-reading. This book shed new light on an area of computer science that I didn't know much about. After taking the class/reading the book, I feel that I understand well what was being taught. I would still recommend this book to students because there is nothing else quite as up-to-date and it is quite easy to read and learn from.




3. i love this book...used it in my file structures course obviously, and i found it very useful



4. I only bought this book because I needed to get an image of how fixed length records are implemented using C++. The book answered my question and provided me with examples. The examples compiled without a problem.

   4 stars instead of 5, because I had to write my own Makefile in order to compile. Aparently, presented makefiles were designed to compile all examples at once, and I only needed a little piece of that.

   Also, the information is a bit scattered around the book and it is not always easy to find what you need. But it is there, so you just need to work on it. After all, this subject is not covered at all in other books, so I would say it is a must have book for any programmer who works with files.




5. This book is very clear. You can skip the C++ stuff if you want, and it will still be excellent.
   It's the kind of book that you read without having to go back and re-read paragraphs (well, I did that sometimes -- but most of the times the text is very clear).
   
   If you're "somewhat" interested in filesystems, implementation of databases, information retrieval, it's a nice book. If you're serious about it, then you'll need newer and more in-depth material.

1 comments about Addison-Wesley's C++ Backpack Reference Guide.

1. DePasquale has written a nifty little guide to C++. It does not attempt to teach you the language. You need a comprehensive textbook for that. Instead, it assumes you have that background in the language. So it offers listing and brief explanations of what operators are available and their precedence. The latter may well be more pertinent to some readers. Typically you might quickly learn the sundry operators. But which overrides another in order can sometimes be unclear.
   
   There is also a comprehensive listing of the reserved words, and the contexts in which these can be used.
   
   The guide is suitable for new and intermediate programmers in C++.

3 comments about Essential C++ for Engineers and Scientists (2nd Edition).

1. I used this book as a text for an engineering C++ course in college. I found that it did a fair job of explaining the in's and out's of the language, but I can't help but think there are better C++ books out there.



2. For engineers, this is definitely the best C++ test out ther



3. The book gives a very simplified view of the C++ language. Almost everything in it does not exploit features specific to C++. Where the book might excel is giving some basic routines that scientist and engineers use, but alas it give simple algorithms that would are not very efficent. I would recommend getting a book to really learn the C++ language or a book to learn numerical algorithms. By trying to do both this book fails.

5 comments about Agile Java(TM): Crafting Code with Test-Driven Development (Robert C. Martin Series).

1. I'm not a beginning programmer, or even an absolute Java novice, so maybe this book isn't really aimed at me. My biggest gripe is that the code snippets continue on and on making the book very poor for anything other than cover-to-cover reading.



2. I've gotten about 6 chapters into this book and I love it. I've been developing Java for almost 7 years and am currently teaching myself Agile principles and this book comes as a great help.



3. This book is primarily for new programmers who want to learn Java as their first programming language. The book can also be helpful for programmers familiar with test driven development (TDD) but new to Java, or vice versa. I am an experienced Java developer, and I found that going through Agile Java presented me with a new and better way of approaching Java code development. This book covers Java 2 Standard Edition (J2SE) version 5.0, but covers only a few of the additional APIs at an introductory level. Technologies that are used pervasively in the majority of enterprise applications, such as logging, JDBC, and Swing, are presented in Agile Java. Some of the information, such as that on logging, will teach you all you need to know for most purposes. Other lessons, such as those on Swing and JDBC, will give you a basic understanding of the technology and will tell you where to go when seeking further information.
   
   The core of Agile Java is fifteen lessons of about 30 pages each. It starts with baby steps in Java, TDD, and OO. The book finishes with a strong foundation for professional Java development. The core lessons should be read sequentially since each lesson builds upon the previous ones. Once you have completed the core lessons, you should have a solid understanding of how to build robust Java code. If you haven't completed the fifteen core lessons, you should not assume you know how to write good Java code. Each of the fifteen core lessons in Agile Java has you build bits and pieces of a student information system for a university. This single common theme helps demonstrate how you can incrementally build upon and extend existing code. Each lesson also finishes with a series of exercises. Instead of the student information system, the bulk of the exercises have you build bits and pieces of a chess application. Some of the exercises are involved and quite challenging, but they are where learning the methodology really begins.
   
   There are three additional lessons to cover a few more Java topics. Two of the lessons present an introduction to Swing. These two lessons will provide you with enough information to begin building robust user interface applications in Java. But the bigger intent is to give you some ideas for how to build them using TDD. The third additional lesson presents an overview for a number of Java topics that most Java developers will want to know such as JARs, regular expressions, cloning, JDBC, and internationalization.
   
   I really liked how the author integrated the three concepts of Java programming, TDD, and object-oriented design without confusing matters. The book is very clear with good illustrations. I highly recommend it. The following is the table of contents:
   
   Lesson 1. Getting Started
   Lesson 2. Java Basics
   Lesson 3. Strings and Packages
   Lesson 4. Class Methods and Fields
   Lesson 5. Interfaces and Polymorphism
   Lesson 6. Inheritance
   Lesson 7. Legacy Elements
   Lesson 8. Exceptions and Logging
   Lesson 9. Maps and Equality
   Lesson 10. Mathematics
   Lesson 11. IO
   Lesson 12. Reflection and Other Advanced Topics
   Lesson 13. Multithreading
   Lesson 14. Generics
   Lesson 15. Assertions and Annotations
   Additional Lesson - Swing, Part 1
   Additional Lesson II. Swing, Part 2
   Additional Lesson III. Java Miscellany
   Appendix A: An Agile Java Glossary
   Appendix B: Java Operator Precedence Rules
   Appendix C: Getting Started with IDEA
   Agile Java References



4. This is my new favorite-book-to-give-to-anyone-who-is-learning-or-using-Java.
   
   The title is misleading in that this book is about much more than just the Agile Programming stuff. While it does a great job talking about Agile techniques and always starts by creating a unit test, the book really is about all aspects of Java (specifically Java 5) programming. Anyone who takes the time to work through the examples will become a much better Java programmer.
   
   OO patterns, collections, type safety and more are covered and explained in the context of a rich, in-depth example. And because the author has you construct a high-quality test suite around the example, you are free to experiment with different ways to implement each new feature - thus proving to yourself the benefits of Agile design.
   
   Just like it says in one of the quotes on the cover, this book is now required reading for the Java programmers at our company.



5. I had originally bought this book for son who was going to spend the summer working for my development team writing unit test for our database POJOs. I was so impressed way in which concepts were incrementally introduced I read the book cover to cover. It is now the only book I recommend to beginners and I introduce it as a 'must' read for all my new hires.

3 comments about C++ For Game Programmers (Game Development Series).

1. You can treat the book as a general explanation of C++. It explains the syntax, and the Standard Template Library. Along with how to optimise performance and memory allocation. Plus, the idea of patterns is introduced, with several common patterns given as examples.
   
   For the STL, there is an expanded discussion of algorithms. As a game programmer, you may find this useful, as it explains the ideas behind some algorithms. Since you might have to devise custom adaptations to improve your game performances.
   
   One final chapter talks about crash proofing a game. Memory leaks are the greatest bugbear, since there is no inherent programmatic way to check for these, unlike Java for example. Of course, this chapter is generally applicable to any type of C++ program.



2. This book is positioned at an interesting location. First let's talk about what it is not:
   
   It is not a tutorial on how to program in C++. While it has a little bit of introductory material, it presumes you already have some knowledge about working in C++. There are other books at an introductory level.
   
   It is not a general purpose reference manual on C++. To be sure it could be used as such, but there is extra material you would have to deliberately skip.
   
   On the other hand, if your time is to be spent developing high end games there are several time tested techniques that game developers have developed over time that may not be suitable for general programming but which work for game development. Example: games require much more attention to audio and visual activity to keep the screen and speakers going than does a payroll package that only has to print checks.
   
   This is an intermediate level book. The intended reader would already have written several C++ programs, be familiar with the syntax, the basic object-oriented concepts, and some knowledge of the basic computer architecture will be helpful. If you are at that level, this is a truly excellent book



3. This is a great addition to the bookshelf of anyone who has been programming for a little while and who finally gets the syntax and basics of C++. Do not expect to learn everything you need to here, this is strictly for people who are done learning the basic concepts of programming and who are ready for a better explanation of how things work under the hood and how you can optimize your code's performance.
   
   I do not regret buying this book and recommend that anyone who is getting ready to design efficient code should get it as well.

5 comments about Data Abstraction and Problem Solving with C++: Walls and Mirrors (4th Edition).

1. Before you read this book, I suggest that you have at least 2 years experiences on C++. Otherwise you will suffer from this book.



2. "Algorithms and Data Structures" is a huge field.
   Lot of algorithms and data structures are used in todays computer software of variuos types. Not all data structures or algorithms on them are adequate for solving a particular problem, so you must have some skills to say which one is "better" than another in your particular situation. Despite it's name, this book is an almost complete reference to achieve this skills.
   
   "This is great book!!!!" I like it. ( ^.')



3. This book is one of the best of its kind that I have read.
   It is very descriptive and contains a lot of good examples on the subjects.
   It describes the construction of a lot of the collection classes like lists, trees, queues etc. and how this is most efficiently sorted and structured.
   Other subjects are graphs, the Big "O" Notation for evaluation of algorithm performance and a very good description on how and when to use recursion (The mirrors).
   All subjects are described in detail with great examples.
   To further test if the subjects have been understood a self-test section is at the end of each chapter (and the answers are in the back of book).
   The reader of the book should have some knowledge of object-oriented design, but besides that the code is fairly easy to read.
   In short it's a buy.



4. This book is a great book to learn data structures. The book should not be read by the absolute beginner and you should have a solid C++ foundation. I used this book for a distance learning data structures class and found every chapter to be well written. The book explains everything in great detail even without an instructor to guide you through you will achieve a solid foundation in data structures. The book has excellent examples of recursion, sorting, hashing, and binary trees. They explain the efficiency(in big O) of the sorts\searches and when to use them. This book is an easy read with great examples but in some cases it helps to do computations on paper or compile small examples so you can truly understand how the various data structures are working. The section on hashing greatly demystifies hashing algorithms and how they work. You can download the sample code from the web. These authors did an excellent job of delivering a clear and concise text on data structures. I would recommend this book to anyone serious about learning data structures and recursion.



5. So clear and so thorough. From LLs to stacks to queues to trees anything and everything you need is in this book. My teacher used one more type of tree traversal, which isn't in the book. the three methods described in it should be enough. Loved it so much that I wanted to buy its Java counterpart, but the ideas and the concepts are the same. C++, Java or C# the difference is decreasing by the second.

No comments about C Programming for the Absolute Beginner, Second Edition (For the Absolute Beginner).

5 comments about Practical Perforce.

1. Well, I'm disappointed. I'm new to Perforce and found Perforce's documentation a bit unwieldy so I thought this book would help. I was wrong. What I was *hoping* this book would do was to provide a tutorial on getting set up and started, then serve as a reference on how to do at least some of the common things that you'd frequently need to do. Unfortunately, the book doesn't help with any of that.
   
   The book isn't organized so as to be useful as a reference, and it doesn't really offer much (if any) help on how to get started. Instead the book spends most of its space on discussions on advanced topics (branching, merging, automated builds, and so forth). It also focuses mainly on the command-line interface rather than the GUI.
   
   I'm sure this book is useful for some, but it sure wasn't what I was looking for.



2. As the title suggests, this is a how-to guide for doing Software Configuration Management with Perforce, but there's more. In addition to describing how the various commands work, this book helps you understand how to structure your version control system to help your team be more effective. For example, this book describes not only how to create branches, but why, and what policy to have on the branch. The Channeling the Flow of Change chapter is a great introduction to change management concepts in general, and the "Tofu Scale" is a great metaphor for structuring codelines. In addition, the clear writing style makes somewhat tricky concepts very accessible.
   
   Buy this book if you are using Perforce as your SCM solution, or even if you are evaluating multiple solutions, and Perforce is a candidate, as this book will help you understand how to structure your environment for effective development, regardless of your tool. This is an excellent companion to Software Configuration Management Patterns: Effective Teamwork, Practical Integration for Perforce users.



3. This book was better than I expected, because it not only explains how to use Perforce, but it covers handling branches in general using the "Tofu model" of softer to firmer codelines. This makes the book worthwhile even if you're not using a different CMS system, just as a way to think about using code branches to manage product releases, new feature development, and bug fixes all at the same time.
   
   One area that was a bit weak is that the majority of the book is geared towards development of shrinkwrap-style software with discrete release points, and only a final short chapter is dedicated to the continuous release style used by web-based products, seeming like an afterthought.
   
   But overall I would highly recommend this book to anyone using Perforce in software development of any kind.



4. I found this book a better resource for learning Perforce over the online documentation. It offers a good variety of source management situations and how to use Perforce in them.



5. Or anyone else who has any input into their company's software control decisions. (Or pretty much anyone using Perforce, or thinking about using Perforce, etc.)
   
   Unlike some I've found the standard documentation (and online knowledge base) easy to work with and understand, but like most I've longed for more examples and theory. This book provides those and more. If you're an admin, buy an extra copy because your serious users will want to borrow it (my copy is "out there" somewhere even as I type).

5 comments about Beyond the C++ Standard Library: An Introduction to Boost.

1. The book is well-written, clear, and honest to the title -- it truly is an intro. In fact, it's honest to the title a bit too much: I found it shallow. It is very much like most of the other recent C++ books (although it's one of the better-written ones), that is it has a distinct publish-or-perish taste to it, like a paper produced by another graduate student who doesn't really want to write it but has to. Not enough depth. It is, however, free from many sins of this PhD-indited flood: it's NOT pompous, it IS simple and clear, it has no pseudo-scientific pretense in it. I mean it's almost good; just not enough indepth.
   
   Someone asked me recently, a bit confrontationally, well, you don't like anything, what's a good book then? No problem: books you tended to get a decade and more back; mostly written by practising professionals rather than CS PhD students; written by people motivated by either love of their work, or vanity, or greed -- all valid motivators, frequently resulting in good products. Unlike, I mean to say, the publish-or-perish imperative of the typical graduate student/newly minted PhD, who produce inflated and unnecessary, poorly written drivel about undeserving minutia. Abrash, Meyers, Stevens wrote good books. If you want STL, fine: Mark Nelson wrote a wonderful book on STL. It is unfortunately out of print (and behind the times a bit), but it's done right -- it really works on things, tweaks them, pokes them with a finger, looks inside, considers alternatives -- you end up really understanding the subject matter. Karlsson's book is well written, but along other books of the same kind (Josuttis, etc.) is limited to a verbal exposition of header files' contents with a teensy-weensy bit of sample code -- waaaaaay too little to be of much practical use. Whoever wants to write an STLish sorta book should check out Mark Nelson's book on STL and use it as a guide.
   
   To summarise: The book is not bad by any means, but is superficial. Bjorn Karlsson writes very clearly, which is good and is not to be taken for granted -- and I hope Bjorn Karlsson will rewrite this book to make it more indepth, augment it with things like, you know: not only WHAT can be done, but HOW it is done (dig into the library itself: for example, how can you not want to stick your nose into the lambda library? It looks magical, I want to know how it's done... It is completely inadequate simply to mention what it can do, add a two-liner example, and be off to something else). OK, so do I recommend this book? Er... uhm... it's OK. A Quick Intro Guide, if you know what I mean. From a fifty-dollar book you'll want more.
   
   So, I say, first go to boost and read what they've got there; I don't feel this book gets you more than the site itself -- jeez, what am I saying, of course it is less, it covers only a small part of the overall deal, but it's better written and more consistent. So, if you got fifty bucks to spare then get the book as well. I mean, it's an OK book. Were it sold for fifteen bucks, I'd give it five stars.
   
   ----------------------
   
   PS. Bibliography is deficient: there's a couple of standard formats any style guide will describe; neither is used in here: what we have here is a kind of home-brewn summaries w/o year, publisher, etc., just the title and authors. Also, it seems that only books from Addison-Wesley made it into the bibliography (hmmm....)



2. Boost is a series of libraries for C++ that provides extra functionality missing in the C++ standard library. Unless you're forced to only use what's part of the current standard, you'll want to lean heavily on Boost. And even if you can't use it for some reason, a lot of it is passing into the next version of C++, so you may as well get familiar with it now.
   
   This book covers the most immediately useful Boost libraries for the general audience. Topics include various smart pointers, including the vital shared_ptr, that makes STL container of polymorphic types much easier to deal with, extra casting operators, regular expressions, and the signal library, that provides a framework for implementing the observer design pattern.
   
   A large chunk of the book is devoted to functional issues, covering the bind, lambda and functional libraries, which work together to substantially extend the functor capabilities of the STL. Code making use of these libraries are a good deal more powerful than what's currently in the standard library, more readable (although that's not necessarily saying much), and might even make the dream of writing loop-free code with functors a reality.
   
   As an introduction to Boost, this is pretty good, which is just as well, given how little competition there is out there. Bjorn Karlsson writes well, and provides plenty of examples of the code in action. None of the examples are very long, however. In many places you'll find just enough to work out the syntax of the libraries, which you can then use with the API details that are also provided to get your own code working. It's not intended to be a very deep treatment of any of the libraries, however.
   
   If you're looking for an introduction to Boost's most immediately usable code, this is a good purchase.



3. This book doesn't add any value over reading the documentation that comes with Boost (and some of the Boost documentation is really terse). It fails to explain concepts clearly and there are almost no diagrams.



4. Lets distinguish: Boost is great, but this book is just not well written.
   It is technically shallow, it is exhausting and boring to read and the authors attitude seems arrogant and is nerving.
   
   I wouldn't buy this book again but recommend working through the docs on the boost website which are way better.



5. I feel that the book does an OK job of introducing the reader to several boos libraries. It seems to be a good resource for somebody who never used boost libraries before and wants to learn about them. However, the book seems to lack certain depth. A lot of space is wasted on listings of the header files or listing of all methods and fields in classes. This kind of information is readily available online and does not contribute much to the book. On the other hand, not enough info is given about the concepts that the libraries are based upon.

3 comments about Big C++.

1. Lots of examples, very easy to follow along. A big downside that I noticed is that there is no website for the book to find the necessary libraries for the examples. I now found that I can find them on the site of the previous book the author wrote. After wich I had to find more libraries wich were either missing or incomplete. This come down to skipping chapter 3 and subsequent programming exercises that require the knowledge gained from chapte 3. Very frustrading, but I hope that that the author will create the site soon, making this a 5/5 book. Great otherwise.



2. This is an excellent textbook written by knowledgeable authors. Horstmann teaches at San Jose State University in California. He has in-depth knowledge of C++, having written the Safe STL library. He also writes for the Sun Core Java series of books.
   Although the book is large, it can be used for a 2 or 3 semester sequence of courses in software development using C++. After covering fundamentals, the authors cover advanced topics with modern relevance. Chapter 13 on Object-Oriented Design discusses the software development life cycle, Class-Responsibility-Collaboration using CRC cards, and gives practical tips for implementing class associations. Other advanced topics include templates (similar to generics), the C++ Standard Template Library, design patterns, GUI's, Relational Databases (using MySQL), and XML. Appendices cover C++ Language Coding Guidelines, and legacy C/C++ topics.
   
   The authors' writing style is very clear and easy for college freshmen to understand. The Random Facts sections help make the textbook interesting, and cover topics such as: Computing History, the First Bug, the Therac-25 bug (an ethical issue), the Ariane Rocket incident, etc.
   
   Sample code can be found at the author's website at:
   http://www.horstmann.com/bigcpp.html
   and also at the Wiley publisher higher education website:
   http://he-cda.wiley.com/WileyCDA/ (search by author for Horstmann). The book is well organized with a good set of end-of-chapter exercises, programming problems, and references for further reading.
   
   We have adopted this textbook for a 2-sequence course in object-oriented software development. I highly recommend it.



3. UPDATED AT THE END - ORIGINAL REVIEW LEFT UNTOUCHED
   
   I used this book as the required text for my introduction to C++ class. I'm currently enrolled in the advanced C++ course which uses this book also. As a beginning programmer I have a different perspective than most - I have never used or learned C++ prior to my introductory course. Just so you know I'm not a lazy student, I have over 40 hours of A and made an A in my intro course. I expect to get an A in the advanced course.
   
   I feel potential buyers need to know what it is like to use this book as a complete novice to C++. My professor was excellent and only used the book as a guideline to teaching us the subjects. This book has merit but there are better options available...hence the 3 stars. I was tempted to give it 2 but the ability to use it as a reference manual (after learning the language upped my rating).
   
   I do NOT like the writing style of the author, nor the progression of thoughts throughout the chapters. The author will introduce a topic, then immediately jump into an advanced example, then a couple of pages later explain what that advanced example does. However, sometimes this explanation never comes and he just moves on to another topic.
   
   This style of writing overwhelmed me at first and I found myself unable to understand the topics being discussed. I found that I had to reread the chapters 2 or 3 times to get a full grasp of the concepts.
   
   After passing my introductory course, I reread some of the chapters to see if my perceptions were correct and they were. What I think would help tremendously is if the author gave a complete program at either the start or the end of the chapter, then simply made references to that code.
   
   The author also relies too heavily on examples in previous chapters, without giving page numbers of the code he's referring to. Instead the student has to almost become a detective to find some of the referrences. This is amazingly frustrating as I have to search back through the chapters to find the examples currently under discussion.
   
   One example is using the :: operator to define class member functions, the author shows (via example code) that this definition (which is outside of the class definition) can access private member variables of the class. However, it gives absolutely NO explanation as to why this is allowed. It's not even discussed later in the chapter. Two pages before this example, the author introduces encapsulation. This left many students confused about the rules regarding encapsulation/function definition.
   
   This book is not without merit. There are many examples and at times very helpful discussions regarding certain topics. Perhaps as my knowledge of C++ grows I will be returning to this book as a reference...however, I doubt it. I found other books were more helpful to the beginning programmer. One such book is C++ A Beginners Guide by Herbert Schildt ISBN 0-07-223215-3. At 1/3 the price of this book, it's a much better deal and in my opinion a better book for the complete newcommer.
   
   As far as reference material, I found many other books on the market that were better explaning these complex issues. In my opinion, this book is overpriced and should only be considered by buyers if money is not an object.
   
   ***** UPDATE ***** (February 10, 2006)
   It has been quite awhile since I first wrote this review (orig was written Feb 12, 2005) and my skills with and knowledge of C++ have both increased. Not only that, I have a new found respect for this text. I stand by my original review and have left it untouched because I still believe this book is a bit difficult for the C++ novice.
   
   However, I have now progressed through Adv. C++ and Data Structures (made As in both classes) and I'm now into Junior and Senior level programming courses. I find myself returning time and time again to this book. As a reference manual, I'm finding a lot of very helpful discussions. Given my familarity with the language, I find the text thought provoking, insightful and very helpful. I suspect I will return to this book many times over the years.
   
   For the newcomer, I still think that Schildt has a better book for teaching this language. If you plan to continue using C++ then you should definatly pick up this book as a reference.