5 comments about Programming with Qt (2nd Edition).

1. I am new to Linux programming (I'm a .Net developer) and was a bit frustrated with the online tutorials for Qt and decided to give this book a try. I am very happy with the decision, this book is very well written. I like the style of the author, giving us some practical exercises after each topic, so we can improve the application he develops throughout the book (a "paintbrush"). Now that I understood the basics I can use the Qt documentation to do my own apps.

   People who like those huge, "step-by-step" ("click File->Quit to exit the application...") books might be a bit disappointed with this one though, the author assumes that the reader knows some C++ and can figure out some stuff by himself/herself, so be warned. Not that he skips any information needed, but he doesn't repeat the same thing 10x either, so you gotta be a bit "smart" to read this book.




2. Not enough examples und for beginners as I am, too many questions. Betterone is "Das Qt Buch" in german. This ise tehe bestone what I have ever seen.



3. Book starts out strong, and was helpful as an introduction for Qt. However, it seems to cut out about 350 pages in, putting subjects such as "Focus Handling" in its own 3 page chapter, rather than integrating it into an existing chapter. That said, the Portability chapter, which includes a list of Qt functions that are not portable, was a valuable addition.
   
   Keep in mind, the 2nd edition of Programming for Qt was written for Qt 3. At the time of this review, the latest version of Qt is version 4. This is a problem because Trolltech appears to reinvent the wheel for each major version. While the author had me salivating at the thought of a QStyleSheet, checking the API docs for Qt 4 QStyleSheet is now a deprecated class, and as far as I can tell there is no current equivalent.
   
   One aspect I wish the author had covered in more detail is the actual compiling and linking of applications that use Qt. I'm starting to get the impression that Trolltech's dirty little secret is that while their API is both clean and thorough, the signal/slot method is overly reliant on #defines, and the developer has to compile and link as many as twice the number of files to make it function. Trolltech includes a program 'qmake' almost as a bandaid which will generate Makefiles that will then automatically generate and compile the extra 'moc' files. The problem is that if you're porting an application to Qt, you're likely to have existing makefiles. Adding the additional layer of qmake and it's .pro files is both cumbersome and not actually necessary. While you can certainly figure out on your own how to avoid using qmake, it would have been helpful if the book described the functionality of the qmake-generated makefiles. This would help developers porting to Qt to include that functionality in their existing makefiles.



4. If you want to learn Qt, you'd better start with Qt4. This book is really for Qt3, but it's still full of useful examples and information. In order to get the code in this book to work, you should #include at the top of your code, and then add "CONFIG = release", "CONFIG += qt", and "QT += qt3support" to your *.pro project file. After that was done, I had no problems with the code from this book.



5. This book gives you a relatively quick and easy introduction to using Qt. You should know the fundamentals of C++ programming to benefit from the book. However, if you seriously want to get into using Qt are several much more up to date titles that also comes with a more modern and appetizing style. I bought this item because I have been using Qt for some time (Qt really rocks!) and went in to get all the books without critically reviewing before buying.

3 comments about Starting Out With C++: Standard Version.

1. This book really helped me learn C++. I was taking an Advanced C++ class, but I never had the introduction to C++. (I had already learned C and C#). I used the first have of the book to familiarize myself with the basic syntax and the second half to learn more advanced topics, like classes, virtual functions, and the STL.



2. I truly read and learned from this book. Gaddis has written a book that can be comprehended without having any prior knowledge of the C++ language. This is a refreshing change from the dreary references and intangible text found in other titles, once opened, this book will leave the others on the shelf collecting dust.



3. I used this book to teach myself advanced data structures & abstraction, when in a class where the professor was a joke. His clean, logical & elegant style is the best writing of programming "how to" I've ever seen. He puts the O'Reilly version to shame. It's also excellent at teaching the basics using his signiture style, while being comprehensive at the same time.

5 comments about Effective C++ CD: 85 Specific Ways to Improve Your Programs and Designs (Addison-Wesley Professional Computing Series).

1. This is the most disapointing book on C++ that I have ever read. Not only are the author's "simple" examples unrelated to anything that programmers do in the real world, they are written from the viewpoint of the programming gods on Mount Olympus. Does anybody really care whether your "pointer to a derived function of a virtual base class that inherits nothing, can end up being a consternation for those expecting a pure, inherited pointer to a class that is virtually derived?"

   Huh? Enough said.

   C++ is an obscure language enough. And not one that will be around for very long in view of the developments of web programming in general. It will always be a basis to start from -- then once learned, quickly forgotten, like Latin.

   If you want more from this book then study FORTRAN, the precursor of the Latin we all know (and are struggling to work with to this day).




2. This CD does not work on modern computers. You need Internet Explorer 4.0 to view it. With other browsers no diagrams are shown.
   I could not find a bug fix on the authors web page.
   
   It is interesting to see that one of the big software gurus doesn't seem to know about graceful degradation. He could have easily added a statically linked HTML-only version to the CD.



3. I am a huge fan of Scott's philosophy. I re-read his books every couple of years. Having his books on CD is most convenient. You can copy the CD to your hard drive and browse it whenever. Don't forget to look at his STD Lib book.



4. Very well written book. It not only give what to do and what not to do. It also has very detail explanations.
   
   This book is not for C++ beginner nor a reference. But there are a lot of interesting and useful ways of programming C++.



5. I have following comments on both Effective C++ and More Effective C++ CDs:
   positive:
   - good practical tips and advice on avoiding pitfalls
   - heavily cross referenced
   constructive:
   - too informal at times and sometimes patronizing
   - lack of structuring in explanation at some places

5 comments about Writing Solid Code: Microsoft's Techniques for Developing Bug-Free C Programs (Microsoft Programming Series).

1. This is hands down, my favorite book on software engineering. If you care at all about writing quality code, you should read this book. The examples are in C, but the concepts (defensive programming, code that detects bugs, etc.) apply to any language. I read this book early in my career, and have re-read it nearly every year since. The used copies are 8 bucks, and the book is worth 10 times that in practical knowledge.



2. You may not be impressed when you see that this is a Microsoft book. You may get bored at the beginning when all the examples are C and most about memory management. But it's worth persisting and reading onward, because sooner or later, some of the examples will look familiar. Simple concepts about what kind of coding leads to more defects, and what kinds are "solid" or robust.



3. I would not read this book now but I'm so sorry the author does not write an updated one! This book really changed the way I wrote code.



4. This book has been recently recommended to me by Amazon based on my previous purchase habits and I decided to go take a look at its description. At first, I was little bit skeptic about the value of a book published in 1993 and prepared with Word for Windows 2.0 because software programming has changed a lot since then! However, it was a very low risk purchase because of its very low price tag so I decided to give it a try and I have been pleasantly surprised!
   
   This book is the proof that that there are few things in programming that are timeless. Errors of the past still occur today. The programming language used for the examples is C but what is taught is also applicable to C++ programming as well. Topics discussed in the book are: assertions, integrity checks, stepping through code with a debugger, how to not design interfaces that are error prone, avoid language features that are error prone and finally the author conclude his book by describing the attitude that a programmer should have. Among other things, a programmer should prioritize safe code before micro-optimizations. All these concepts are written in a style easy to understand filled with anecdotes that make this book a pleasant read.
   
   To conclude, I have not been blown away by the content of this book but I have learn one thing or two and I am glad that I have read it especially with its very low price tag.



5. This book quickly reminded me that the "old school" rules to software development will always apply, no matter how many new labels you put on it (e.g. Agile). It was recommended to me by a college professor aside from the regular classroom reading we had to complete. And I was more than happy I purchased it and added it to my bookshelf.

5 comments about C# Primer Plus.

1. If you are looking for practice problems to learn C#, this book is a must buy. The practice problems are well thought out and are useful to understand C#. Also, most of the elementary topics are covered. So this is a great first book to learn C#. On the downside, the author's writing style is wordy. Finally, the author does a poor job of explaining WHEN to use certain features of C#. The benefits of using one approach over another is not apparent to the beginners. For example, I wish the author had spent some time explaining when to use inheritenance and polymorphism, especially when one can write perfectly decent C# code without them.



2. I thought it's a basement of C# programming , It also tells you lots of Class detail...I use it as reference and futher more programming...



3. I specially entered amazon to write this review to gratitude the author of this book.
   I think guys, this is the best book over there, since I bought many other intro books on C# and had chance to compare.
   This book gives almost everything you need about core syntax of C#, explaining why particular technique became part of C# syntax (I think it is very important to really understand the language), and showing wise ways of using it. Examples are very excellent.
   The book is very comfortable to read, despite of its size, sentences are simple and craftly bring you to point, and you do not get tired until you understand (I think it is very important about programming books, since it takes much brain energy to read and understand them). I myself finished this book in about a month, having some experience in C++, and at the same time being busy with other things.
   I think (really, in my opinion) you will not regret if this will become your first C# book.



4. If you are a novice like and never programmed before this book is NOT for you. All the reviews claims it is a beginner book for novice programmer. This is totally untrue. The athor starts with an advanced example of elevator and expect you to understand all the nuances of it with a few explanations. Trust me if you are a novice try either absolute beginner C# or C# 2005 for dummies , those are real books for beginners in programming & C#.
   
   This book is for programmer trust me. The author write a simple program "hello" explain with 2 pages. Then he goes and pass with an advanced example of Object oriented with his elevator program.
   The program is FAR to be as simple as you think. And it is poorly explaned.
   
   From the reviews I am reading either those guys are liars when they claim to be novices or they are genius to be able to understand this book as first book.



5. I used this book to learn C# a few years ago and I still pick it up from time to time. C# Primer Plus is an easy read that I reccomend to anyone else learning C#.

4 comments about Using C++: An Introduction to Programming.

1. This is the best book I ever read in my entire life which gave me all the details about the c++ programming language. The author of this book professor Hennefeld are the best teacher and the writer in the entire world that is why I am taking him for the third semester in a row for my computer and info science major. The book is so clear that anyone who has no background in C++ can master this language and yet the best c++ reference book for any professional.



2. If you are looking for a well written easily understood C++ book, this is it. I've been in the MIS business for 15 years and am currently attending Penn State. This book as enabled me to recieve A's in all my C++ courses. The book starts off slow for the novice user, showing basic concepts. Within weeks the reader can master the most challenging C++ algorithms. I refer to this book as the C++ bible. Definately worth the investment!



3. If you find c++ scarey, this is the book for you. My professor wasn't the best, but this book guided me to score an 'A'. It explains everything real well and provides mini examples along the way to ensure you understand what is going on. You wont be bombarded with details, since it isn't necessary at the introduction level anyway.



4. I have been reading many c++ programming books now to learn programming. So far I have just started to read this book, and I have to say that this is the best book, i've read so far. The author does an excellent job in explaining everything step by step for the reader and he gives simple little examples in order to better understand the programming language of c++. I have no experience in programming at all, and this book is making it very easy for you to get to learn this language. Awesome book!!!

5 comments about Essential .NET, Volume I: The Common Language Runtime (Microsoft .NET Development Series).

1. In my POV this is a masterpiece!

   I read both (Don Box's book and Stutz's Book)!

   Stutz's book has an "inside-out POV" to expose the CLR features,
   Don Box's book has an "outside-in POV" to expose the CLR features.

   These two books are really cool... Any review less than 3 stars must be ignored!




2. There are like a zillion CLR books out there and overall, it's not the type of subject that normally keeps you glued to it. When I got Jeffrey Richther's Microsoft .NET Framework book, I was convinced no one was going to outdo him. Well, it's a close call, but I think they are both Superb books by excellent authors. I've purchased Don's stuff before and really liked it. This book lived up to its expectations.

   I think his ability to communicate some of the more obscure areas of the CLR in a very clear matter is what makes this book shine. This book can be understood by anyone because of the writer's gift for writing...but that's not to say it's a novice's book. Wherever you are in the .NET learning curve, there's something for you in this book.

   If you really want to learn the CLR, this is a great place to start.




3. This is not the book to dive into first if you want to really get .NET. It's actually a fairly interesting mixture of what I now consider obvious and what I never stopped to consider. If you are just starting out, I would begin with Richter's book, and then digest this one quickly afterwards. There is a significant amount of overlap, but your final understanding will be very balanced.



4. only for advanced readers. If you are a beginner, you may get lost. I had to read a couple of times to get 100%. Excellent. Some concepts are pretty difficult to understand.



5. If you havn't read this book, Buy it! I really enjoyed the style, flow, and great insight into the CLR.

3 comments about Beginning C: From Novice to Professional, Fourth Edition (Beginning: from Novice to Professional).

1. I decided to do some WIN32 API programming and all of the old documentation and Petzold's book uses c source code so I thought a formal presentation would be the thing to do. This book gives a very good explanation of pointers using lots of small but complete programs. This book is much like a college text in that there are problems to solve at the end of each chapter. Horton makes you work but the writing is clear with appropriate detail. C is a small language but the syntax can be obscure so I appreciated the thorough and detailed treatment. Page layout and fonts are attractive and the source code is easy to follow. I plan to follow up with Horton's C++ book.



2. It is really a very good book and Mr. Horton explains things very clear.If you want to learn C from the beginning this is maybe the best book.



3. I bought this book to get an introduction to C, however I found it lacking since I already had some programming experience (Perl, Python, Scheme, Emacs Lisp). As far as C goes, this book is complete and covers things in great detail, for example workings with memory. Since C is "close to the hardware," I think this material is the book's strongest attribute. The explanations of pointers are also really good. Again, pointers are one of the most important aspects of C, so if that's what you need, this book could help you. I surely learned a lot about C from this book, unfortunately I was turned off by the silly examples (e.g., organizing basketball scores).
   
   I don't recommend this book for someone with a mathematical background like myself (I would have rather had more abstract problems in combinatorics or numerical analysis). I learned as much about pointers from C Programming Language (2nd Edition) (Prentice Hall Software), and learned even more from that book about good programming practice, and the idiosyncrasies of C programming (while (c = getchar()) ;). If you already have some background in programming, or you need more realistic examples, get C Programming Language (2nd Edition) (Prentice Hall Software) instead. If you have no experience, then this book would be a good place to start.

5 comments about Computer Science: A Structured Approach Using C++, Second Edition: A Structured Approach Using C++, 2nd.

1. From the back cover: "[...] no matter how powerful the language, it is still far too easy to write poor programs. [...]". The code examples in this book prove exactly this point.

   The authors mention the ISO/ANSI C++ standard and claim to follow it "wherever possible" (sic). However, they make so many false statements that I seriously doubt that they have ever consulted the ISO/ANSI Standard documents, or any of the excellent text books on modern C++ design and coding practice (Cline, Meyers, Sutters.)

   I believe (and I'm not alone) that in a modern C++ course std::vector should be introduced before arrays, and std::string before const char*. Not only are they safer, they are also *a lot* easier to use, and make it possible to come up with more interesting programming exercises than the endless array of meaningless numerical computations. Unfortunately, many instructors and authors consider std::vector and std::string to be "advanced topics", and torture their students and readers with the old stuff they had to learn themselves ten or more years ago. The authors belong to this category, I'm afraid: they learned C, and think that they know C++.

   Let's have the book speak for itself.

   Page 28:

   "While C++ allows declarations and statements to be intermixed, we believe that functions should be organized for readability. Therefore, we continue to follow the C organizational concept that places declarations first in a function, followed by its statements."

   On a related note, on page 40 the authors write:

   "One final point about initializing variables when they are defined: Although the practice is convenient and saves you a line of code, it also can lead to errors. It is better, therefore, to initialize the variable with an assignment statement at the proper place in the body of the code. This may take another statement, but the efficiency of the program is exactly the same, and you will make fewer errors in your code."

   (My comments:) It is commonly accepted by knowledgeable C++ programmers that the practice of declaring variables near the point of their first use in one of the things that makes C++ a better C. It is the old style that leads to errors (forgetting to initialize variables) and maintenance problems (variables that are no longer used, but are still in the declaration section). Furthermore, it is considered good style to prefer initialization ( int sum = 0; ) over subsequent declaration and assignment ( int sum; sum = 0; ). The former is always more efficient, and the difference can be substantial when dealing with large objects for which construction is expensive. You may argue that this is of no concern for beginning C++ programmers, but I disagree; habits, both good and bad, form early.

   --

   From the code example on page 363: bool binarySearch (int list[ ], int end, int target, int &locn){ ... }

   (My comments:) The first argument should be const-qualified: const int list[ ]

   Not only does this protect the programmer from inadvertently changing any of the values stored in the array; it also makes it possible to use the function with const int[] arguments (which would fail to compile with the original code). The const keyword is an important asset of the C++ language, and students should be trained to use it properly from the beginning. Using the Standard Template Library will drive programmers who are not aware of const-correctness issues insane. The book is extremely sloppy in the const-correctness area.

   --

   Page 119:

   "If a function has not been declared or defined before it is used, C++ will assume that you will provide that information when you link the program. Since there are no specifications, C++ will also assume that the return type is integer and that the parameter types correctly match the formal definitions."

   (My comments:) This is not true: in C++, functions have to be declared before they are used, and there is no such thing as 'implicit return type int'. C++ really is different from K&R-style C.

   --

   On page 195, the following insight is highlighted:

   "The else-if is an artificial C++ construct that is only used when

   1. The selection variable is not an integral, and

   2. The same variable is being tested in the expressions."

   (My comments:) No further questions here, your honor.

   --

   It gets really interesting when the authors express their ideas on Object-Oriented programming. They claim that Object-Oriented programming is just a different view, but that the implementation is exactly the same as in structured programming. They are probably misguided by their own example of an elevator simulation program (in the chapter on classes), which is simply a structured program wrapped in a class, and has nothing to do with OO.




2. Great choice for new students to programming.



3. easy to read, helpful excercises, a good book for those who want to learn C++ programing



4. This is the text for my C++ class, so I did not buy it by choice. It's terrible! The people in class who are new to programming are having a hard time. Often the authors use imprecise language. There are many errors of omission: sometimes there is backpedaling or an explanation later. It says a lot that the non-programmers in the class can almost always tell when a statement in the book isn't quite right, even if they don't know why it isn't right. You have to wonder if there was a technical review of this text. And I can't figure out how it got chosen as a text for any class anywhere.

   One, the authors did not mention which compiler they used to compile their program examples. Many of the programs do not compile in MS Visual C++ 6.0 as written in the text. The authors fail to mention you might have to modify the code to get it run on your compiler. For instance,
   cout << fixed;
   may have to be replaced with
   cout.setf(ios::fixed);
   or
   cout.setf(ios::fixed, ios::adjustfield);
   to run right in your compiler.
   They do finally talk about cout.setf in chapter 7 (out of 15). The program example downloads from the website compile; they contain preprocessor directives to make the programs more portable. I guess it never occurred to the authors, while adding those preprocessor directives (which DO NOT appear in the text), that some words about compiler compatibility might be helpful. Fortunately, I have C++ Primer Plus by Mitchell Waite; he addresses the compatibility issues as he teaches the syntax.

   Two, I often disagree with the authors' definitions. My favorite example: the statement
   x = 5;
   changes the value of the variable x to 5. The authors call this a "side effect." Huh? Seems like that's exactly what the programmer intends to do. Usually, I think of side effects as being more subtle than that. More like a function changing the value of a variable parameter to the function because the variable was passed by reference instead of by value (this could catch an unsuspecting programmer by surprise if he/she didn't check the prototype carefully).

   Three, some of the "good programming" tips would cause me to fail code inspections at work. This is a good thing, because they would make verification and maintenance a nightmare. Like not initializing variables when they are declared. I guess the authors have never seen weird things happen as an executing program tries to deal with the garbage in an uninitialized variable. Or maybe they just figure this is a good way for you to discover you forgot to initialize a variable before first use. It just might take a while to figure out that's what's going on since the results can be unpredictable and/or bizarre.

   I could continue, but I think I've more than made my point. I won't be standing in line to get the second edition when it comes out next year.




5. Spend your money wisely and get another book. This book is poorly written in what seems to be a foreign language. The phrase "it's Greek to me" certainly applies here. This book contains grammatical and spelling errors alike. The coding is incomplete and as a student of C++ I find it outrageous that computer science professors require this book as a textbook. All in all do not buy, try C++ Primer Plus.

5 comments about The C++ Standard Template Library.

1. If you are new to STL or if you just want to sharpen your STL skills, this book is *not* for you. It's of very little use to STL client programmers, i.e. users of STL. It's even a little bit advanced for a programmer who is interested only in developing new STL algorithms but not containers/iterators.

   But, if you're serious about extending STL, especially if you want to write new container and iterator classes, this is *the* book you need.

   Personally, I make use of the information provided in this book to write a 3D container class and a couple of highly complex 3D iterators for an academic study demanding high speed and reliability. I have other STL books like Austern's Genetic Programming and the STL or, Musser's STL Tutorial and Reference Guide which are both extremely good references for *using* STL. But, those books did not help me even a little bit when I was trying to write a 3D iterator. I believe, The C++ Standard Template Library is the only book around that's really meant for serious STL developers.

   So, if you ever want to develop a new container with a fair amount of new features or a new iterator with fancy tricks, buy this book. But, If you're only after using STL and/or developing new algorithms, stick with Austern's Genetic Programming or some other similar book...




2. Just a few months ago, I bemoaned the fact that Plauger's _The Draft Standard C++ Library_ had never been updated to the actual standard. I'm happy to report that this book contains an answer to a considerable part of my prayers: It contains an in-depth discussion of the STL, along with a complete, high quality implementation in source code form (Contrary to what the "Topics Covered" section on this page implies, however, the source code is NOT the Hewlett-Packard implementation, but a proprietary derivative which is commercially licensed).

   It's hard to pin down exactly why, but this book was not quite as pleasurable a read as its predecessors. One of the reasons might be the typography: The use of underlining for emphasis of the actual makes the standards sections of the book unpleasant to read. There might be an issue of the subject: For all its power, there is not all that much interesting algorithmic stuff going on in the STL. Lastly, it seems that C++ template code as such, no matter how brilliantly written and how useful to the library client, is rather unpleasant to read-a somewhat sobering insight to a C++ aficionado as myself. As a result, the code that *was* algorithmically interesting was quite hard to understand-I would not recommend this book to somebody trying to learn about red-black trees, for instance.

   If you buy just one book about the STL, buy Josuttis' _The Standard C++ Library_. If you want additional in-depth insight into the workings of the STL, and are willing to invest the time it takes to study the code, buy this book. I certainly never regretted reading it, and I hope that Plauger will update his implementation of the rest of the C++ library to publish a standard compliant version of the iostream and string libraries sometime in the future.




3. I had basically no knowledge of STL when I purchased this book and was quite afraid of templates. My job duties involve only sporadic forays into C++ so I had not had a lot of chance to get practical exposure to STL. In addition, the books I studied to learn C++ (and most C++ books I have seen since) tend to stumble a bit when it comes to covering templates. It was with these pre-existing handicaps that I began tackling this book. I will discuss the bad parts of the book first, but please keep reading down to the good parts because I think this book is an excellent resource to have available and I wouldn't want to do the authors a disservice.

   I found STL, and this book, to be pretty complicated when I started. Basically the book is divided up with a chapter for each header file in the library, which I am now convinced is NOT the best way to teach someone the STL. Keeping in mind that I had absolutely zero knowledge of the STL prior to reading this book, it was understandably confusing at first. Iterators and allocators are explained long before containers, which sort of leaves them with no apparent applications. Mention is made that they will be used later, but it was really hard (at least for me) to understand and remember the how's without knowing the why's. When I finally got to the container section I found myself flipping back pretty regularly to the iterator and allocator sections to review because much of that earlier material I didn't absorb in the first read. A student must be diligent and read most of the book before it will start to make sense. This means if a reader is looking for a book that will just get them up and running with the STL, this probably isn't the one.

   Despite the above paragraph, I was on the verge of giving this book five stars. The book is thorough and methodical, and if you have the time to read it (and do some of the questions, I found them helpful) you will probably be quite good with the STL by the end. The authors definitely know the subject material. I did not find much humor or funny anecdotes to make the reading pass quicker, but most of the book was really concise. Probably 150 pages or so spread throughout the book is the source code, so they had to keep editorializing to a minimum. I found the writing to be pretty clear and as easy to understand as possible, given the complexity of the subject matter. It took me awhile to read through the whole book, and even afterwards I was still a bit cloudy, but after a couple hours of banging around with some test programs it all clicked into place and I feel really confident that I learned the material well.

   Now that I have a good understanding of the STL, this book is second to none as a reference. While laying out the book header by header is a detriment to the learning process, it is invaluable later on as a reference. In addition, a complete and functional version of the STL code is printed in each appropriate chapter of the book. After each section of code is found a few line summary of each class and method, again invaluable as a reference.

   In conclusion, I would rate this book as a must-have if you are serious about learning (and *understanding*) the STL. For the pretty reasonable price you get a thorough book by authors who know what they are doing, and an excellent post-read reference that you will want to have on your shelf. The only bad part about the book was it could have been organized to make the first read a bit better (to the detriment of later reads), and it won't get you up and running with the STL as quick as some other books might. It is definitely one of my top three favorite books on the shelf at home.




4. Hi,
   
   I had read the reviews and ordered this book. It IS what the reviews say. I purchased the book as I wanted to learn more about C++ and collecting all the recommended books (accu.org). So I was not looking at developing new container or any generic algorithm.
   
   Personally, I found this book containing too much of code and manual style writing - which does not make it a normal reading.
   It will become too heavy going, if you don't understand a lot about STL. Use it as an indepth implementation reference guide only.
   
   So if you looking for learning only STL and NOT interested HOW TO DESIGN or understand design of STL then this book is not for you.
   bye
   ketan



5. This is an excellent book for those of us who want to know why things where done the way they where; after all, the odds are that the author probably created, or was instrumental in creating, the version of the STL that you are using right now. The only thing that bothered me was what was not covered, such as strings. I have a habit of asking questions in areas that are not well known or are very complicated to explain. Therefore the book loses one point, because it was written by someone who knows the answers I have been seeking and did not include them.