5 comments about C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond (C++ In-Depth Series).

1. This book is called "C++ Template Metaprogramming" but it should be called "Boost MPL API Reference." The first portion of this book covers the basics of template metaprogramming fairly well, but what I wanted the rest of the book to cover were both advanced techniques and real-world applications. What I got was material on how to use the Boost metaprogramming library. This book mostly covers just that library, and the various templates that it offers, but what I felt the book should have provided was not only how the more interesting parts of the MPL were implemented, but also interesting applications of the MPL where some interesting algorithm was made possible by template metaprogramming. I can look up the MPL reference docs online, thank you very much.
   
   To summarize - this is a pretty good introduction to template metaprogramming, but seems to be suited for the unlikely position of someone who wants or needs to use this technique, but isn't academically interested in it, and so mainly needs a walkthrough of the set of standard functions available as part of the MPL.
   
   This book is a bad choice for those interested in template metapgramming and wondering if it might help them, but want to learn more about it and its applications first.



2. I would really like to learn about the boost mpl and I thought this book might help. Well, I'm learning, but only because I'm working very hard to untangle the mess presented. Here are some of the fundamental flaws in this book.
   
   1. There is no target audience. This book might have been about how to design an mpl like library, but it makes no attempt to address this issue. This book might have been about how to use the mpl, but it doesn't do that either. It seems to be about justification for why certain choices are made, but it gives false examples when doing so. For example 3.3's example of the add_pointer template is simply not what is in the library. You can see this yourself by visiting the boost site and compare what's in the text of this chapter to what's in the boost library's code. In the end I can't even tell what this book is trying to accomplish. The author should have stated the target audience somewhere, but doesn't. It is written as if the designer wrote note justifying design decisions to a co-worker already knowledgeable about both how to use mpl and it's design. Maybe this book was translated from notes between the two while they designed it?
   
   2. Example code on CD wrong. They include sample code on the CD from the book's text. The code says it was automatically extracted. Unfortunately it doesn't match even remotely. I think something was wrong with the tool they used. Even if it was right, it's a repetitive dump without any reference to page or section so you have to open many files and dig to find what you want. There is absolutely no way to look at the code in a particular section and find it on the CD in any reasonable way.
   
   3. No examples are complete. The authors like taking an attempt to solve a problem, then show a weakness to the suggested solution, tweak some code, show another weakness, ... This might be an okay approach, but I strongly suggest a final product at the end of the tweaks be somewhere. If that's somehow prohibitive in printing costs, at least put the final code on the CD.
   
   I could go on all day about just how bad this book is, but I really need to spend my time learning the concepts if I'm ever going to use it. If I get a chance I'll get back here and write more about the mistakes. To those thinking of purchasing, go to the boost site, read the free chapters, then assume you've read the "best of" materials. If these free chapters make sense and you learn a lot reading it, you are smarter than me. If not, then don't assume you will do better if you had the full text, because it won't help you.



3. 
   metaprogramming is understandably a difficult topic. but it could have been made easier to understand with a talented writer. obviously these two authors have no such talent. organization of book is bad, there is no clear flow. concepts are often introduced without explanation, and only defined a few chapters later.
   
   in the bigger picture, this is the problem with the c++ community. the language has evolved so fast, so much into a complicated mess that only the very seasoned programmers (often young ones) can keep up the pace. in consequence, these untalented young writers bubble up as some sort of experts, and write messy books.



4. I knew in purchasing this book that most of the time it would just be talking about the Boost MPL. That shouldn't be too bad - the Boost MPL is pretty much the fore-running meta-programming library, and there has to be lots of concepts in there to be learnt too, other than library specifics, right?
   Right.
   This book completely lives up to this explanation. Very quickly we are into the guts of the library, even within the beginner's tutorial section. There certainly is a LOT of concepts to be learnt and used, even if externally to the MPL.
   However, I found that very quickly I was having to reread and triple-read passages to try and distil a principle from the library construct being explained. They principles are there, and are good, but I find that they are not presented distinctly enough from the library itself. This results in what feels like a lot of work to really understand the book (other than just know how to use the library).
   I don't consider myself slow - I got through almost all of "Modern C++ Design" (by Alexandrescu) without having to go to a computer, but here I really felt like I NEEDED to try this stuff out on a computer and attempt the problems at the end of the chapter. This book is a lot of work - beware! - and particularly it is more than I feel should be necessary, if perhaps the authors allowed themselves more time to explain principles and concepts away from the interface of their library.
   However, there is a lot of knowledge here that I don't think that you can find elsewhere, and it is a topic that is, by nature, a bit mind-bending, so I am still definitely happy with the purchase.



5. I am not a meta programming expert, however I learned a lot from this great book. I suggest first to read Alexandrescu's Modern C++ first and a learn basic techniques then get this book to be able understand the mpl better.

5 comments about C++ Programming for the Absolute Beginner (For the Absolute Beginner).

1. This book is a decent beginners book, but I feel that it isn't exactly for the absolute beginner. The challenges at the end of each chapter could be a lot better, they don't completely test comprehension of all concepts in the chapter. If you are already familiar with another programming language, this is a good book to get you started with C++.



2. This book was the most useful, informative, easiest, greatest reference for learning C++ in the world until it got into the chapters on directX programming. The book used directX7 while the world has moved on to DirectX 9 (and in the very near future DirectX 10).
   
   I wholeheartedly reccommend the book to the beginning c++ programmer as a tool to teach you all the basics up to basic WINAPI programming. After that though, you will need a different book.



3. 
   I have just started working with the book and while it seems fine and straightforward thus far, the package is flawed at a very basic level. The accompanying CD contains quite a bit but what it does not contain is CodeWarrior (the program referenced in the text) or a similiar program for actually working with C++. To be perfectly clear, you must first acquire software elsewhere before you be able to begin using the information and exercises in the text AT ALL. It strikes me as a very serious oversight / error on the part of the authors to have not included at least a trial version of the required software in order to let people use the book upon receipt.



4. I would agree with what most people have said. I would like to caution people however that there are many errors. If you are a complete noob to programming you may not catch these. This will slow down your learning and may frustrate you enough to quite. I would recommend 'Beginning C++ Game Programming' over this book. However, I do think that this book is great because the explanations are quick and concise. Used with another resource this book is great.



5. This book started out good, but then got me dissappointed because since i'm a beginner in this programming stuff, i found myself having to fix the errors of the programming samples that they had in the book. Ofcourse that was extremely hard for me, since the job of this book was to teach me c++ programming, especially for a beginner in this area. Not for me to fix their porblems with no programming experience. Horrible book!!

5 comments about STL Pocket Reference.

1. Cute, if I may use that term for a computer book! Hopefully, you already are familiar with the constructs described in this nifty little guide. Priority queues, queues, sets, iterators ... The book is strictly an aid to memory. You might consider it the hardcopy kin to online manual pages on each term.

   Which raises the question. If you have the equivalent information already on your computer, why should you get this book? For some, there is in fact no need. But a surprising (and ironic) number of programmers still prefer hardcopy by their desktops. There is still something appealing about the combined visual, tactile and random access of a good concise reference book which trumps a screen, though we all write to the latter nowadays.




2. The O'Reilly Pocket Reference series serves the need of software developers to quickly lookup how to code something that they don't do every day. The formula is quite strict. Like all of these books, this book is a hybrid of introduction, cookbook, and reference in a package that is small enough to easily fit several dozen on your bookshelf. What's good about the STL Pocket Reference is that it provides succinct descriptions of some very abstract concepts that are the lingua franca when dealing with the Structured Template Library. What's missing here is more sample code.



3. This small but succinct reference book is all that I wanted in an STL pocket guide and more! I am using it today while teaching a beginning STL class. It is more useful to me than the many textbooks I have been reading on the subject. GO GO O'Reilly! Your materials are excellent for programmers.



4. I love these little pocket references, since my new job I use custom container classes, but when I was using the STL this was a wonderful reference.
   I actually like these booklets better than Microsoft's electronic documentation, but Apple's XCode documentation system is still faster than paper.



5. I have used stl and think stl is great. I was hoping for a quick programming guide so that I did not have to carry and reference stl books I all ready have. Very few programming examples were given. Found very little use for a book that gives short snippets about stl but avoids showing the use of stl in programming.

5 comments about The Standard C Library.

1. First of all (also metioned by other reviewers), the layout of this book is horror. Everything is printed behind each other (not very much whitespace).
   
   This book is a nice reference, but maybe you can better use Internet nowadays.
   
   What make this book really nice, is that it offers implementations for the standard C library. So if you're looking for a implementation for sqrt/sin/tan/printf/etc. you will find it in this book. This is a really nice way to get some insight how an implementation of a Standard C Library could work.



2. This is a bad book. The print is in small font. The book is cryptic to follow. I only read the first few chapters than I had to stop. I did not like this book.



3. People sometimes make jokes about people who call them self's real programmers (and vise versa). But this is a book that a real programmer will have on their bookshelf as reference material, along with their copy of "The C++ Programming Language" and others. I have not referred to this book in years, but I have never regretted the purchase. It is rare that someone who probably wrote the library that you are using writes a book on it. So even though it is very technical, it is a must have for anyone who wishes to meet the same standards as "The Standard".



4. Essential for C programmers who want to use as many library functions as possible to avoid reinventing the wheel. A must have.



5. When I bought this book, in college, I really didn't understand it. It didn't really give me much information, just had a bunch of code from the C standard libraries in it.
   
   I picked it back up a few years after I started working in the real world and now had enough experience to realize what a gem this thing was. It basically implements (full source code) all the standard libraries. It let's you see how things work on the inside. It shows structs and accessible items that you may otherwise not even know it exists.
   
   The best part is the source for standard library functions. This is a super handy gem if you are doing embedded code that doesn't have OS support. It was a wonderful help to me that let me write a few of the standard C functions that were handy to use when in an embedded environment where those functions weren't available. Many of these I could have done myself, but only with much though, time and testing. From here its virtually free.
   
   This is a MUST HAVE book to any hard core C/C++ developer.

5 comments about Schaum's Outline of Programming with C.

1. I am a student writing a paper which I plan to hand in, the end of this month i.e. October 2002. I noticed that Dr. P. Sellapan's book, P. Sellapan, 1999, "Object-Oriented Programming Using Visual C++ Through Examples", First Edition, Federal Publications Sdn. Bhd., Selangor, page 6-9 - ISBN 983-58-0451-6 and his other book, P. Sellapan, 2001, "C++ Through Examples Include Object-Oriented Programming", Eight Edition, Federal Publications Sdn. Bhd., Selangor, page 177-178 - ISBN 967-914-746-0 have the same diagrams as Dr. Byron's book entitiled, "Schaum's Outlines - Programming With C", 1996, Second Edition on page 371-372. So can somebody tell me, which of the authors should I reference to? I am a bit confused as to whom I should reference to!



2. Do not buy this book if you are just learning C. The way in which the information is organised in this book assumes that you have a knowledge of the topic and that you only need a refresher. There is information in this book but if you want to learn C without swallowing boulders, you should look elsewhere.



3. This is one of the excellent books in programming. I have come to master C programming in less than two months by following this book page by page. Chapters are organized in an excellent way that goes systematically with programming skills development. I highly recommend it.



4. C is not a large language, there's not a lot to remember a far as conditionals, types, etc... but there is much to learn. This book gives only the facts and not dogma or methodologies, and the examples are to the point as they should be. This book really should be hardbound and sitting next to your copy of The C Programming language by DR and BK. This manila tome is truly one of the hidden gems you can get for 15 bucks. Use it until the pages fall apart, by then you will have assimulated it's worthwhile knowledge.
   
   You really have to enjoy this book for it's straightforwardness. If you like the "Dummies" series, this book will progress a bit too fast for you, for it is rather complete in it's description of the language features. But if you read and digest technical matters in one or two (or three) gulps, you'll benefit from this book.



5. I have been teaching introduction to programming with C for almost two decades and over that time many students have asked me for a source for additional programming problems. My answer has always been the latest edition of Schaum's outline in Programming in C. The problems are sound and challenging and working through the solutions is great practice in the art of paper debugging. While interactive buggers are a godsend, performing critical visual reviews of code is a skill that is still essential for the good programmer.
   While this outline is somewhat dated, having been published in 1990, the base language of C is still the same. I still recommend it to students who need more practice in visual debugging skills.

5 comments about Computational Geometry in C (Cambridge Tracts in Theoretical Computer Science).

1. This book provides a reasonable introduction to the field of computational geometry, although the notation is sometimes sloppy and the author frequently makes inconsistent assumptions about the reader. For example, on the first page he refers to a circle as a "one-dimensonial set of points," which although valid from a toplogical perspective is a little confusing in an introductory text. As another example, the first exercise refers to "every point in dP," presumably meaning just the corner points (otherwise the problem would be unsolvable). The book also sets up a lot of irrelevant mathematical definitions that generally obfuscate the presentation rather than clarifying it. Although not prohibitive for the ambitious reader, these needless hindrances are at best a little annoying.

   Secondly, I must criticize the text's scope, in light of the important role computational geometry has played in modern computer graphics. There is no discussion of clipping, culling, occlusion (e.g. BSP, octree, OBB), or even non-polygon primitives -- important topics arguably more useful to the target audience than e.g. convex hulls (to which over 1/4 of the book's pages are devoted).

   Regardless, this book (combined with a professor and a course) probably would serve quite well as an undergraduate text. Readers interested in a cookbook of applied graphics algorithms, however, should look elsewhere.




2. i think that these website is very.it has everything that i need. all of my books are from amazan.



3. Anyone who is involved in areas such as computer graphics, computational radiology, robot vision, or visualization software should have a copy of this book. The author has done a fine job of introducing the most important algorithms in computational geometry, choosing the C language for their implementation. The choice of C might be somewhat dated now, since C++ is now beginning to dominate computational geometry, but readers who are actually programming these algorithms using C++ can easily extend the ones in the book to C++. Not all of the algorithms in the book are implemented into C, unfortunately, but the clarity of presentation is done well enough to make this implementation a fairly straightforward task. My interest in the book came from a need to design and implement algorithms for polyhedra in VRML and toric varieties in algebraic geometry. This book, along with others, was a great help in that regard. The running time of these algorithms was not really an issue with me, so the detail the author spends on discussing the complexity of the algorithms was not a concern. Readers who need to pay attention to running-time issues will appreciate his discussion of them for the algorithms that are presented.

   The ability to visualize objects in an abstract subject like algebraic geometry boils down to, in the case of toric varieties, to a consideration of how to manipulate polytopes geometrically. A major portion of the book, if not all of it, is devoted to the computational geometry of polyhedra. Because it is an introductory book, some more advanced topics, such as Bayesian methods to find similarities between polyhedra, and neural network approaches to classifying polyhedral objects are not treated. Readers who need to do such things will be well-prepared for them after a study of this book. In addition, there are good exercises assigned at the end of each chapter, so the book could be used in the classroom. Some readers will however choose to use it as a reference source, and it would be a good one, for the author gives references to topics that he only touched upon in the book.

   Some particular areas that were treated especially well were: 1. The discussion on data structures for surfaces of polyhedra. Although not very general, since he choose to deal with only triangulated polytopes, readers who need to be more general will have a good start in this discussion. 2. The discussion on volume overflow and how to deal with it using robust computation. 3. The discussion, albeit short, of the randomized incremental algorithm. 4. The treatment on the minimum spanning tree and Kruskal's algorithm. Communication network performance optimization is now a major application of this algorithm and others in graph theory, including the author's later discussion of Dijkstra's algorithm.




4. This book was pleasantly surprising: I had expected to see code presented with minimal motivation or discussion of the underlying ideas -- something of a "Computational Geometry for Dummies" sort of book. That's not the case at all. This is a bona fide textbook on the subject, suitable for an undergraduate course.
   It covers all of the the "classical" topics: convex hulls, line segment intersection, polygon triangulation, Voronoi diagrams, motion planning.

   The mode of presentation -- supporting a discussion of the theories with implementable code -- is actually a bit refreshing. For comparison: Other books, when discussing the line segment intersection problem (ie: Given a set of line segments, find all of their intersection points) simply assume that computing the intersection of a pair of segments can be done in constant time. This is not an especially difficult problem, but the discussion seems more complete with a brief description of how this might be done. The same can be said about other primitive tests and operations in other algorithms.

   Overall, this book can stand alone as an excellent introduction to computational geometry, but a serious student in the subject will want more: perhaps Preparata and Shamos or de Berg et. al.




5. If you are perhaps a graphics or robotics programmer, then you will often have need for computing various geometric forms. And the intersections of these forms. Rather than derive algorithms from scratch, you might want to first look here. O'Rourke has collated several useful sets of methods. Germane to two and three dimenions.
   
   Convex hulls are important enough that he devotes 2 chapters to these. While the somewhat related idea of Voronoi diagrams gets its own chapter.
   
   The C code is a nice bonus to some readers. Though if you are experienced enough in another language, you should be able to readily code an algorithm in the book from scratch.

5 comments about Mastering Algorithms with C (Mastering).

1. The book contents is good, the algorithms presented are more or less well explained and the implementeations themselves are not bad (but could be better).
   
   Unfortunately this book has 2 mayor problems:
   
   Sometimes you need an implementation of an algorithm for which you already know the inner-workings, just need quick code instead of reinvening the wheel yourself... the book will not allways give you that, it will sometimes build an algorithm based on previous ones! Darn!, I am supposed to go straight to the point I want and get the code without having to read a couple of previous sections.
   
   Second and worst of all is the coding style this guy has. I don't know what the other reviwer that said that the code is great programs in but certainly not in C. The author of the book simply has the worst style ever... look at the comments, a one line comment surrounded by a box!!! give-me-a-break!... where did he learn this? He should read a book about style, perhaps read Code Complete by Steve McConnel or something before attempting to write code. Anyway this is just one of the many style flaws this book has.
   
   If I could I would return it, after all, you can get mostly any implementation from the internet (I had to do that or would have wasted lots of time and... time is money).
   
   If well written, the book would have been 1/2 its size and then it would have been good.
   
   Why 3 stars? Well, in spite of the poor programming style and bad presentation of some algorithms, if you have time and patience, you get someting out of the book. Just don't use the coding style he uses... if you try that at work you would be fired or at least laughed at.



2. compare to most algorithm/data structure books out there, this book is not as complete as those, but it's much easier to read, and diagrams in this book is well drawn and much eaiser to follow. Why would I only give it 3 stars? One thing really ruined this book - obviously the publisher/editor/author try to increase the total page number by putting ridiculously big comment block in sample code(single line comments takes about 5 lines, all surrounded by '*' and spaces) This made the sample code difficult to read, imagine a 5 line function has to be printed in 2 or 3 pages.



3. The book is probably OK, but there are better, much better ones on the subject. I highly recommend looking at "The Algorithm Design Manual", just search Amazon and you'll find it.



4. Things I didn't know when I ordered this book was how structured the book was. It's easy to comprehend and doesn't contain too much unnecessary information. Furthermore, what I also managed to miss was the disc which was included, and this contains more in-depth code, which allows one to check a whole program instead of only a part.
   It is definitely a good decision to start with buying this book if you're studying Algorithms with C, since this will truly help and support you on your way.



5. Hi:
   
   Well, this book has a lot of very interesting programming issues, like pointers, recursion, linked lists, stacks & queues, trees, etc, etc...
   All of these issues are very well explained and have many code examples, but here is the big problem of this book:
   The comment style of the code examples is ridiculous!!!
   The author used five lines of code when he could use only one!!!
   Like this:
   
   /*********************
   *
   * Absurd comment...
   *
   *********************/
   
   This makes slower and really uncomfortable the lecture of the code.
   
   Anyway, having this book you'll learn a lot of advanced C programming issues.

No comments about Programming Basics Using Microsoft Visual Basic, C++, Html and Java.

5 comments about C By Discovery (4th Edition).

1. We have to use this book for the college class that I'm taking and it is a horrible book. I often find myself looking for help on the internet rather than going to this book. It is poorly organized, I have to go to the index in order to find something I specifically need because the book isn't in any order. I wouldn't recommend this book to anyone. Find another there are many more.



2. I am using an older edition (I think the 1st) to teach myself C. So far, (along with the mingw32 compiler) I have been able to write several small matrix programs and a small statistical package, soley from using the resources in the text. I started on page 1 with no previous study of C or C-like languages.

   I have one complaint. The coverage of fread, fwrite, etc could be more thorough, with more examples. The example given actually doesn't work with my compiler. I had to come up with my own examples to discover how to use these functions.




3. This book is very well written for beginning C programmers. The topics are clear and easily read. I think it is more concerned with the understanding of topics for the beginner rather than the best coding techniques. An experienced C programmer would probably not use some of the programming techniques in this book, but it serves well for people who want to learn C.



4. I am a CS student and had to make my first contact with programming through this book. The title is right. You can learn C using this book by discovering other ways of looking for information (other books, internet). Examples are terrible, theory is messed up and put in large clusters. How can you teach a beginner if ALL the information about a particular feature is put together? The basic stuff and the advanced together? Hey, I am a teacher who actually has a few years of experience in school, this is not the way to teach.



5. I read and wrote a review on this book several years ago in undergrad. Since then I've become an Oracle DBA (IT) and have worked in the field for several years at major corporations. This book is extremely straight forward! But you need to spend the time with it. Computer science is not a subject where you can glance over a chapter and answer some questions at the end. If you are looking for that, then this is the wrong area for you. But if you put the time into it and really learn the material in the chapter BEFORE trying to do the problems; then you will really enjoy this book! And if you continue in the field, as I did, you will find there are very few programming books written this well.
   
   -gb

5 comments about Introduction to MFC Programming with Visual C++ (Microsoft Technologies Series).

1. MFC programming is a bear, especially in VC++ 6.0 (not .NET). This book does a decent job of introducing key concepts, and comes with a mountain of sample code on CD. If MFC/VC++ were my first programming language, I would look for a book geared more towards total complete novices; otherwise, it does the trick.



2. This is the best programming book that I read from page 1 to the last page. I hope Jones can write more books on MFC or Visual C#. Not only did I learn MFC concepts and programming skills, but also I found Chapter 1 and 2 are very useful because they are basic and fundamental to C++ that I sometimes forgot. I love the pace and layout of this book. User-defined messaging and modeless are explained in a very nice way. The Appendice are very useful too.
   
   I give this book a full 5 stars.



3. Shipping is prompt, and the item is in good condition as described.



4. I waisted my money buying this book. It should be sold less than 1 dollar. You don't get far using this book. I recommend the book by Ivor Horton.



5. I have found this introductory book very useful to start with Windows desktop applications development. Although it is quite outdated and uses Visual Studio 98 as build environment, it guides you through the basics of the MFC framework (main classes, dialogs, graphics, document/view architecture) and Win32 programming in general (messaging, maps, data types), leaving room for personal development in the exercises after each chapter, and providing in-depth coverage of advanced topics like bitmap manipulation and database access for the advanced reader. With an additional introductory chapter on COM it would have been perfect.