3 comments about Obfuscated C and Other Mysteries.

1. This book is not only about obfuscated C, as seen in the Obfuscted C Code Contest, although that is certainly a big part of the book. Libes also covers a lot of other ground, that will be a big help in your day-to-day programming.

   But that isn't all: Libes actually makes all this hardcore C stuff fun! I burst out laughing many times while reading the book, which (you may have discovered) doesn't happen often, when reading books on programming.

   This book is for anyone who thinks that C-programming will one day be recognized as the artform it truly is!




2. If you liked the ``butt ugly fish book'' from Peter van der Linden, you'll love Libes! Like _Expert C Programming_, this is an immensely readable book complete with humor and occasional drama. Don't let the ``Obfuscated'' part of the title fool you. The book doesn't dwell excessively on the IOCC nor is it oblique. Libes does an excellent job of turning obfuscation (and mystery) into clarity. It's great _recreational_ reading for C linguists...with recreational meant in the ``re-create'' sense of the word. Hey Don -- how 'bout an update so you can merit a 10 rating?!?



3. The OCC code snippets and Don Libes commentary should be
   a required reading in any programming class. Unfortunately
   It is hard to find.
   
   This book was an relevation, the gems in it
   proved that language (C/C++/Java) has nothing to do
   with beatiful ideas and the genius of programmers like
   Larry Wall (past winners of OCC) and the algorithms
   that make a program.
   
   Read this book, and you will never have to join a
   'C vs C++ vs Java' discussions, you will be too busy writing
   beautiful program, in the tradition of Stallman, Knuth and Wall.
   Programs should be beautiful like Poetry.

3 comments about Schaum's Outline of Data Structures with C++.

1. That is very good book for new programmer learning. It is very helpfull.



2. Like it says, it's a study guide. Its got great problems if you want to go above and beyond what's challenged of you in class. Author presents each part in a very straight forward manner, but doesnt dive very deep in abstraction.



3. Though a very good book, most programming assignments require
   that the data be entered interactive and not implimented for
   list and trees.

5 comments about Application Development Using C# and .NET (Integrated .NET Series from Object Innovations).

1. It's hard to categorize this book. You not only you get an overview of C#, detailed emphasis on some aspects of application development, but it also provides an overview of .NET technologies, like various other .NET "Programming" books. So it's like one and a half books in one. You should certainly study a beginner's book on C# before reading this (mine was C# Primer Plus, which I recommend), though read this you should, because it's extremely well written and covers many aspects of .NET with crystal clarity, surprisingly so for a book of this scope. About 3/4 of the book covers core C# and overview of technologies, and then two or three chapters are dedicated to core .NET issues. So it's more of a "Programming/Overview" type of book than anything else; the best one I've read though. I would've preferred more emphasis on .NET fundamentals, and application design development. Nevertheless, I'm impressed.

   I'll keep an eye out for future books from this author!




2. The authors never seem to stay focused on the topic at hand for more than three or four sentences. Constantly branching back and forth in a GOTO type logic that makes you loose enthusiasm for the topic. Mentally unpleasing. Especially on the ADO.NET interface. Cannot seem to give a healthy grip.

   Other may argue that you need to be an expert to appreciate this book. If your are that expert, then you do not need the book to begin with. If you cannot enjoy the sequence of presentation without feeling mentally taxed, then it is not a book that you want to read. At certain points, you feel that your are reading a dictionary of term and concepts.

   I found other books far more superior in presenting an expert opinion in a very straightforward manner, staying focused, complimenting the theory with a good advice.

   This book is not worth the ink that it is written in.

   Thanks




3. This book picks up and overlaps a little with Robert Oberg's "Introduction to C# using .NET" which I believe is mandatory reading for C# programmers.

   There is more detail and lots more information on the .NET framework itself. It's a thorough grounding in the general framework stuff.

   It is not, however, an exhaustive look at everything that you can do with .NET. A lot of subjects are given very cursory looks and you will need to add extra books to your collection for in-depth coverage of more of the details.

   Reading this book and its predecessor will definitely get you a solid grounding with .NET, but you must do it with a computer in front of you working through the examples and case studies.




4. You can't expect a book on such a broad topic as this to be completely successful. This book is an excellent resource for explaining the new C# language. However, when it delves into the meat of the .NET software it lacks in some areas. I found myself laboring to find out things that I feel the book should have explained. Other books explained those concepts very well. The sample code was very well done although frustrating to implement because of the placement of the documentation in the book. The Web Services portion of the book is probably the poorest. I found Web Services easily explained in other books.

   I am new to .NET but I've read 4 other books including one that tries to cover all aspects. In some ways I believe the authors tried to cram too much into one book and parts didn't work out so well.




5. I would use two analogies to describe this book.

   1 - Have you ever talked to someone who is really bright - a doctor, a scientist, a computer geek - who you could tell was really smart but who could not communicate clearly and coherently in plain English?

   2 - Have you ever heard the expression "it makes sense if you already know the answer" as applied to an explanation which is convoluted and confusing but ultimately right?

   Well that's what this book is like to me. From the sections I've read these guys are not authors but they are experienced developers. They are not good at explaining things. They cannot lay out something simply in a one, two, three order. They jump from here to there and their writing looks like somebody cut and pasted some different sections of text together.

   They do present a sophisticated code example which exceeds what you get in most technical books, however.

   So I would say this book is not a good book if you are reading it for an explanation of C# and .NET. It could be useful if you are an experienced developer (and are used to dealing with people with poor communication skills) and are looking for some good code examples.

5 comments about Visual C++ Windows Shell Programming.

1. I wish Wrox Press would learn to edit books. They choose appealing subjects, but the books themselves just don't cut it. This is nothing against the authors, it is the editor(s), if any, that are causing the problems.

   The book content is fairly good. Much of the info is taken from articles that appeared in MSJ, or from Nancy Klut's book on shell programming, but it does add some useful new information.

   Unfortunately, the source code (which is not included with the book, but is a free download) does not compile. I tried two of the projects (Shell hooks and Context menu) and neither would compile under a vanilla VC 6 installation. I know it is not my compiler, because the errors are in syntax. I suspect, despite the forward's statements otherwise, that the code was built with VC 5 and never recompiled under 6.

   In any event, you may want to buy this book if you don't have access to Nancy Klut's (or MSDN, where it is included) and don't want to dig through the back issues of MSJ.




2. I have found this book to be very usefull as a guide to shell programming. The information in msdn is a good reference, but there are often many ways to accomplish the same thing. This book presents the various ways to approach a task and also warns you of pitfalls including misleading documentation and implemenation bugs.

   Also, the source does compile in vc6 if you select the appropriate build setting (non unicode). The problem is related to unicode versions of macros being used in standard c functions such as fopen. Selecting the non-unicode build setting fixes this.




3. Recently I was tasked to develop a name space extension. Not knowing that much about the topic, I scoured the web for relevant information. Unfortunately this is an area that, in my opinion, is rather poorly documented. All I could find was a couple of articles written several years ago. Fortunately for me, I found Mr. Esposito's book, and found it very enlightening, and easy to read. It's the only book that I found that has a complete chapter dedicated to this rather niche topic. Obviously the book also spends a great deal of time covering the larger scope of shell programming. All in all, I would highly recommend this book for anyone interested in learning more about shell programming, and personally, I consider it mandatory reading for anyone who is planning on developing a name space extension. Selfishly, I only wish the entire book was dedicated to name space extension, oh well, I'll have to wait for that book...



4. I am a semi-advanced self taught C++ programmer. I use Borland's C++ Builder programming IDE. I found this book to be extremely valuable. It has provided me with more information on the pride and pitfalls of Windows 98/NT's shell implementation and API than I would've imagined. This is not a beginner's book. It won't hold your hand to get you through it's content. You will need a firm grasp of the Windows messaging system. Knowledge of and experience with the Win32 API is also important. While I am weak on COM technology (does it really provide things that can't be done in simpler ways, or are we just stuck with it?) I found that I could understand what was going on by (loosely) relating the COM objects and namespace extensions to C++ classes. This book does contain some typos and mistakes. You will have to know enough to spot them or else spend time on the author's erratta web page (haven't been there yet myself). This leads me to believe that the source code download isn't comprised of exactly the same code that's in the book. All in all, I truly wish I'd have found this book sooner. It could've saved me a great deal of time searching through many different resources for the answers to some of my recently overcome programming frustrations. I'm only halfway through the book and am already writing more robust applications. Who knew that my system tray based application would've been left (past tense) memory resident but unreachable whenever the Windows Shell was restarted! If you're serious about living with Windows...if you need to register an application or file type...if you want to use SHBrowseForFolder() better...if you can't figure out why the damned thing won't work and it's 3:00 am...BUY THIS BOOK.



5. The author, Dino Esposito, does excellent work in an instructional manner dealing with the customization of the Windows shell. There is an abundance of information located between the covers that will augment the comprehension the reader has about the Windows operating system as a whole. Many of the things that are in this book are available in other locations, such as MSDN and other articles available for free; however having a concentrated reference is very convenient.

   Chapter 1-2: These chapters include a basic introduction to the way the Windows shell functions, and the various portions of the shell. It also introduces the Windows Application Programming Interface (API).

   Chapter 3-6: Esposito explains how to work with files, including special folders, using the shell API functions SHFileOperation() and SHFileGetInfo(). Manipulating files, gathering information, and browsing for folders, it is all included. Certain Windows tasks such as working with shortcuts are explained programmatically.

   Chapter 7-8: Chapter 7 introduces the concept of `invading' the shell using hooks and COM objects: using shell events or events within other processes to trigger your own events. Chapter 8 explains how to spawn processes programmatically.

   Chapter 9-10: The first topic discussed deals with Windows icons, and then `invading' the Windows taskbar. This example can be used to take over any other process. Areas of the shell that are supposedly not very well known are covered; the recycling bin, formatting drives, etc.

   Chapter 11-13: The Windows shell, `explorer.exe' is investigated. The author describes to the reader how explorer works, both the default actions taken and how to invoke certain behavior using the command line. Benefits and differences between using rundll() and rundll32.exe are covered; complete with examples of how to use them. Esposito spends a lot of time on scripting, first offering examples of scriptable shell objects then covering how to use the Windows Scripting Host, (WSH).

   Chapter 14-16: Further levels of shell integration are presented as a conclusion to the book. Creating your own document types as well as many other features, like drag-and-drop support, give applications a native appearance in the shell. By creating new namespaces, the Windows operating system becomes even more customizable.

5 comments about C: A Software Engineering Approach.

1. 15 years ago I came across this book accidentally in a second hand shop primarily selling Springer books.
   I already had K&R because it was best known, but was not really satisfied with it as a transitioner from Fortran.
   This book had all I needed, especially on pointers (see all other reviews).
   I always enjoyed reading it. It's not about becoming a C obsfucation contest winner,
   but about C as a tool for software engineers.
   Combined with Harbison & Steele's "A C Reference Manual" and Hanson's "C Interfaces and Implementations",
   which are my other most referenced C books, you will have a solid basic library to rely on as a C programmer.



2. I have read the second edition and recently bought this third edition that has ANSI standard C in the main body of the work, rather than K&R C. I am using it to brush up on C that I have not used in a while. It is still a great book.
   
   I have read the other reviews from December 1997 through February 2004. I do not have much to add to what has already been said, other than what the others write is true. I wish all technical books were this well written.



3. The perfect balance of complete, useful information on ANSI C. All technical information (data types, operators, declarations, pointers, arrays) is there. It it all explained in sufficient, readable but not wordy detail. It is remarkable in its efficiency.
   
   It's all in there - the preprocessor, railroad diagrams showing the syntax of each statement, code snippets where they useful. Data structures, starting with the bit datatype, then defining and explaining more advanced concepts of unions, structures, and the user-defined types using _typedef_. Then full examples tieing it together with linked lists, then doubly linked lists.
   
   A brief section on software engineering concepts showing the importance of design and test, and finally a complete working C interpreter.
   
   What really sets it apart though is its complete reference of the most-used standard library functions - formatted and file I/O, string and memory manipulation functions. Effective use of the proven library functions is one of the marks of the software professional, and the outer framework of most useful real-life programs is getting data in and out.
   
   The book begins with a very high-level overview of programs to establish its context, but this is NOT a how-to-program book. If you already understand the fundamental concepts (arithmetic and logical operations, looping) and you need a comprehensive book on how to use C, this is the one. There are lots of books in the "this is a reference, not a tutorial" class (e.g. K&R) and lots of wordy tutorials that never get to the difficult parts (like 'how do I pass a pointer to a multidimensional array.'). This is one book that is sufficiently organized to be a reference, with enough clear explanation that you'll learn how and why things work.
   
   I've had my 2nd edition of this book since it was new in 1991 and recently purchased a copy of the reviewed edition for a friend. It's still excellent, with improved coverage of new features and extensions, and removal of the obsolete adjective "new" when referencing the ANSI standard that's been ratified for a good long while now.
   
   There is no mention of C++ - this is a C book. Good ol' ANSI C is still the language of choice for many if not most embedded projects, even new design. I believe a solid foundation in C will serve any C++ programmer well - under the 'object' layer of C++ lie member functions that actually do the work, and those functions look a lot like C...
   
   Like most good technical books, this one's not cheap, but it's a quality Springer-Verlag binding on acid-free paper that will last a career if not a lifetime. And considering the depth, breadth, and clarity of the content, it is a bargain.
   
   A must-have.



4. As some one who took an unguided path into C programming, I can really appreciate how much of a difference this book would have made if I came across it earlier.
   
   This book elegantly lays down the structure and parts of the C language. It presents the reasons behind various features of the language.
   
   This is the book that will teach you to think about programming in an intuitive way.



5. Where the K&R book is terrible for learning C, this book makes it a snap.
   It provides an organized and complete tutorial for the novice C programmer as well as a useful reference for the more experienced C user.

5 comments about STL Tutorial and Reference Guide: C++ Programming with the Standard Template Library (2nd Edition) (Addison-Wesley Professional Computing Series).

1. This was one of the earlier STL books, and even with its Second Edition, it hasn't caught up much. On its own, it would deserve 3 or 4 stars, but it's expensive and there are better ones out there for your money. I think even the publisher must agree, as this book's #1 competator is also an Addison Wesley book, _The C++ Standard Library : A Tutorial and Reference_.

   The real problem is that this book only does the STL, not the other parts of the standard library like strings and iostreams. The typical C++ programmer looking to become more modern is going to want to know all the new stuff, not just this little slice of it. If you're already familiar with the standard library and want a book on only STL, you can consider this a 4-star rating. The book is okay for what it does, but I don't see why anyone would want it, as you're going to have to buy a second book if you get this one.




2. John's reviews are interesting. While I agree with many of the points he makes, I disagree with some. And I found a few to be self-contradictory.

   He says, for instance, that "This is a good solid book that will get you up to speed quickly on all the important ideas in STL, and many of its basic usage idioms", but then naievely claims that "there aren't any higher level ideas than those presented here". Does the book cover only basic concepts, or is it that if the book doesn't cover it, it is not knowledge?

   The book is full of concrete examples. But my problem was that they were trivial. Reversing or sorting or finding characters within a string is great fun. But it doesn't help me understand who owns the memory within a container. Or how to directly and safely reference an element at an arbitrary position within a container outside of an iteration loop. A majority of the examples use trivial intrinsic datatypes for contained elements; how is using a struct or class different?

   All of those issues are important aspects of using the library, and not something I think a busy reader should leave to "a little imagination". While most of the disputed facts are eventually available in the text, they're not easy to find. The organization of the book isn't quite intuitive enough to make it a thoughtful reference or a breezy tutorial.

   And, in many cases, once found, they're not clear. John cited page 151 for an explanation of the differences between some of the collections. There, it says "With maps an multimaps, the data items are pairs of keys and data of some other type..." What's that mean? Two keys and data of some other type? Or a key and data of some other type? Does "pairs" mean "two", or an instance of the "pairs" utility class?

   The book really is missing information. None of the examples do any error checking whatsoever, and the exceptions that the templates throw aren't described. (Maybe, like priority queues, error handling was formalized after the book went to press. It is showing its age, and there's now a 2nd edition. I haven't purchased it.)

   It's ambitious to write a book that tries to serve as both a tutorial and the reference. (Me, I think it's just impossible.) This book does very well, but falls short of adequately completing either goal.

   I think that there's a bias against this book because it doesn't fit well with the way these reviewers would have liked to learn the subject at hand. I know that's where I landed. While true masters do indeed make it look simple, making it look simple doesn't help learning. Otherwise, we could all watch Tiger Woods for a few Sundays before taking home a Buick and a six-figure check.




3. This volume is a much improved version of the original of the same title. An additional author has come aboard. The major improvements I noticed were in the examples. There are many more examples and many more STL features now have examples showing how you can use them.

   The tutorial aspect of this book, which comprises the first part of the book, makes a strong case for not re-inventing the wheel, but rather using the containers, iterators and algorithms in the standard library. Practical examples come right from the start. This may take some getting used to by those who have never seen STL used before, however, the excitement is tonic.

   Also, the approach, of showing STL use before getting into the theories of iterator-based access, has been adopted in several subsequent C++ texts by teachers of C++ and has been found pedagogically sound.

   Don't overlook the precision and clarity of the (English) language discussion of the STL in the tutorial. It's worth reading every so often as a refresher.

   And the value of the reference section, which is easy to navigate and has everything in it that most other books dealing with STL don't is great indeed.

   On the whole, if you work in C++, this is a carefully put-together book that will have lasting value and continual use in your library.




4. As an advanced programmer, I must say that I'm disappointed that the level of information provided is not as deep and meticulous as I had hoped.

   Additionally, both the index and the overall organization of the book leave much to be desired.

   The book, however, is a valuable reference for beginning and intermediate programmers. It explains the STL (Standard Template Library) from the ground up, explaining when, where, and why you would use any particular aspect of the STL, how to use the STL, and sufficient examples to understand correct syntax. This book also contains a detailed section of applying the STL to real-life programming examples. Furthermore, the book also contains a comprehensive reference guide for quick and easy access to pertinent information about STL aspects you frequently use and modestly comprehend.

   If you are a beginning or intermediate programmer, this book is worth adding to your collection.




5. Whenever I need help with STL, I open this book only to find that it has nothing useful on it. For those who have MSDN don't bother to buy this book.

2 comments about Computers & Typesetting, Volume C: The Metafont Book (Computers and Typesetting, Vol C).

1. Most of the people who order this book will already know quite a bit about it, so I won't say much about the book itself. I will point out, though, that it is softcover, not hardcover. (The book linked to by the "softcover" link is spiral bound.) On the other hand, I haven't succeeded in locating any copies of the "real" hardcover edition.



2. Once upon a time, MF represented the best hope for outline font technology. Then came PostScript, Type 1 fonts, ATM and it became moot. It's a nice graphic programming language and for some mathematically-derived designs it's easier to work with than is, say, Fontographer or Fontlab, but the output is mired in the bitmap world (valiant MF2PS efforts notwithstanding).

   Serious students of MF will also need the Computer Modern Typefaces book. And possibly a healthy dose of liquor. But as I said, the language is actually kind of nice (and MF can be used as a simple algebraic calculator if you're so inclined).

3 comments about Essential C++ for Engineers and Scientists.

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.

4 comments about Oracle Database 10g XML & SQL: Design, Build, & Manage XML Applications in Java, C, C++, & PL/SQL (Osborne ORACLE Press Series).

1. I wish more books were written like this. When you read it you understand that a team of high professional people have worked on it. The book is organized to be useful for developers, DBAs, managers. You'll find here everything you need: XML & SQL, XSQL , XSLT, XML in PL/SQL, Java, C, C++. I highly recommend this book.



2. This book covers everything on how to develop XML applications based on the Oracle XML infrastructure. It also provides the readers with a lot of samples on how to utilize the technology. No matter you are an advanced professional or a fresh graduate, if you are interested in XML-related Oracle application development, personally I think this is a must-have book.



3. This book does not do a good job of getting the small experiments running. And w/o that, it is difficult to get any handle over the big picture. If you haven't done XML and Oracle integration before, this book definitely is not what you are looking for.



4. I guess I am rushing to judgement - but in the first 10 pages I read, there were about 8 typos - so I am giving this a 2 stars for now. Will update my review/rating as I go along.

5 comments about Data Structures and Problem Solving Using C++ (2nd Edition).

1. I am writing this review of Data Structures and Problem Solving Using C++ by Mark Allen Weiss on the heels of completing an undergraduate course in data structures. On a scale of 5 ( being the best ) and 1 ( being the worst), I would rate this text at a 2. I am being generous because I don't want to underestimate the possibility of this book having some future usefullness.

   Mr. Weiss has an impressive academic record. With a PhD from Princeton in Computer Science and having studied under Dr. Sedgewick, a king of algorithms, he now teaches at Florida International University. Clearly, he is an authority on the subject. However, he should pursue something other than writing textbooks. Let's examine the flaws in his approach.

   The author works heartily to impress you with his ability to demonstrate proofs for algorithms. He illustrates various proofs throughout the text and gives a liberal discussion of each. He then provides implementations of each algorithm and spends considerable time discussing the C++ language statements that are used. What he never does adequately is to provide a discussion of data structures and algorithms absent the details which distract the reader of an introductory text. As a point of comparison and constrast, I ask you to consult Data Structures with C++ using STL by William Ford/William Topp.

   Consider the study of stacks and how compilers utilize them to evaluate expressions. This is a subject taught in every data structures class. Let's examine the approaches of Weiss and Ford/Topp.

   Pages devoted to the topic. Weiss ( 38 ) vs Ford/Topp ( 45 )
   Number of tables+figures(excluding code listings) Weiss( 5 ) vs Ford/Topp( 27 )
   Pages devoted to writing about data structures ( not C++ implementation ) Weiss ( 8 ) vs Ford/Topp ( 17 )
   Questions at the end of chapter with solutions provided . Weiss ( 0 ) vs Ford/Topp ( 11 )

   From the brief analysis above, you may recognize a pattern that Dr. Weiss himself admits to following in the writing of his book. In the preface, he says that "fundamental choices need to be made including ... level of mathematical rigor, balance between implementation of data structures and their use ... and programming details related to language chosen ". Regrettably Dr. Weiss has made poor choices on all three areas.

   First, the mathematical rigor which might be highly valued in a graduate level text is seen here as a mere annoyance. Second, the balance between implementation and their use is skewed toward the former when it is needed toward the latter. Finally, students who have had adequate instruction in C++ do not need to be led by the hand as the author guides the reader through an implementation. Too many other authors do a much better job with C++ than Dr. Weiss ( read Schildt, Meyers, many more ). Dr. Weiss would be well advised to keep the code examples in play but cut out the narratives on the code.

   I was able to do well in my class because I recognized the deficiencies in Dr. Weiss' book and quickly abandoned it in favor of the Topp/Ford text.

   On a final note of disappointment, the binding of this book, purchased brand new, failed after just two weeks. I treat my books with respect and in the last twenty years have had only one other occasion of a binding failure ( the pages separate from the web and glue that holds everything together ). My bookseller replaced the text without question.

   You will probably be required to buy this book for your data structures class ( as I was ). It is a sad waste of money but many faculty remain impressed with Dr. Weiss' output. I recommend buying a used version ( absent the broken bindings ) and gettinf another readable text from a different author. To be fair, I did give this book a 2 rather than a 1 ( worst ) on a scale of 1 to 5. Since I am planning graduate study in computer science, I believe that the book might hold some value as a reference for the very items that I criticize here. That is, the proofs might be of some interest in a advanced data structures or advanced algorithms course.




2. This book was required for a data structures and algorithms class. At first it seemed interesting. By looking at the table of contents, lots of topics were covered. But the problem is that each chapter lacks a good introduction context or example. That is, when you dont know anything about hash tables or binary trees, this book starts by telling you what are the rules and types of binary trees or hash tables, but does not tell you really why they exist or how can it be useful in the first place. But the most frustrating part is the examples after each chapter that does include any answers, it is nearly useless.

   Please excuse me for my poor english, it is not my primary languange.




3. Today is Nov 10, 2005. I e-mailed Professor Weiss concerning his book on Nov 7, he responded promptly on Nov 8. His advice was very valuable. In a nutshell he advised me that online students using his text (or any text for that matter) may find the subject difficult to negotiate (if they are new to the material) and that a traditional classroom is preferred for getting the most learning out of a Data Structures and Algorithm Analysis course. As a result of his advice I researched teaching methods in general and discovered several additional sources supporting his remarks. Don't rely soley on my interpretation of Prof Weiss'observation...you have to check this out for yourself.



4. Although I did not read much of the content about data structures, I can say that the other half of the book is great for those in the field that have studied these topics previously.
   
   The concise lists of C++ gotchas are worth the price alone. Many of the topics from the Meyers' 'Effective C++' series are touched on (much more briefly) here. There's also a short chapter that very briefly highlights some major design patterns. I was pleasantly surprised to even find descriptions of pointer arithmetic efficiency in an appendix! This book really had exactly the scope I was looking for while job hunting; it's broad and concise.
   
   I gave it 4 instead of 5 stars because it might be too difficult for someone just starting out to follow and because its STL coverage is a little out of date and thin.



5. This is one of the best Data Structure books I have ever read. A Data Stuctures course is usually a second or third course in learning any programming lanaguages and it is where you actually learn why we do some things in C++ the way we do them. This book has done a great job giving a through explanation of what one might need to know about a lot of fundamental and practical issues in programming with C++! If I could, I'd give it 10-stars instead of 5-stars!!