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 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.

No comments about Engineering Problem Solving with C++ (2nd Edition).

5 comments about Problem Solving, Abstraction & Design Using C++ (5th Edition).

1. In my opinion, this book is below average. According to the chapters it covers, this should be a book for beginners at programming. But by reading the book, only non-beginners would be able to follow all the examples. Rather than rely on the feedback of one person, I will give you the feedback of the students that I taught with this book. Most students beginning a programming class will have a hard time understanding this book that assumes that you already know a lot about math and logic. When I tried assigning homework from this book, most of my students had problems just understanding what the math and logic of the problem would require, and couldn't concentrate on the programming concepts. There are quite a number of inaccuracies in it as well, such as it's miscalling preprocessor directives a compiler directive. It also calls an array a data type which it is not, it is a data structure. It also calls the exponent of a scientific notation a characteristic. That term is only used in the natural science community. Even the IEEE standard for floating-point numbers calls it exponent and not characteristic. One of its first examples starts with a standard input statement without prompting the user with what input the program expects. These little annoying problems with this book have caused me to abandon it all together. I would much rather recommend Diane Zak's Fundamentals of Programming in C++ if you are a beginner to programming.



2. This isn't a great book as I thought it was. The begining chapters were pretty much detailed and explained program examples step by step. Starting on chapter 6 till the end of the book, there were few step by step explanations and the author for some reason assumed that brief explanations were sufficient.



3. This book was required for the first semester programming class. Now I was able to understand 'cause I was in CS and had been programming for 10 years. But the history majors in my class were crying cause this book couldn't really explain the basic concepts. many of the intro to programming classes are core classes in Univs in US. So, a guy who's in CS, I assume wouldn't have any problem cause it's way too low level for him. Whereas those who really need this book..Art majors, or those who want to learn what programming in C++ is..will have a tough time..

   I wouldn't recommend this book..cause it's too poor for a guy who knows C++ and too tough for those who don't.. They haven't been able to get that balance.

   Another interesting point I was able to observe was that this text gives all source code example with Visual C++ in mind. Most of the Univs in US prefer to teach this course on Unix platforms, and so a book more relevent to Unix would be appropriate.

   I give it 2 stars, cause it isn't all that bad a book that doesn't make sense. I still go back to it sometimes to look up the syntax and some basic stuff..But nothing more than that.




4. This book was required for a C++ course I attended at the local community college. I had been doing some minor programming in other languages but felt I needed at solid foundation in C++. This book would have been a difficult place to start. However, thanks to a talented and very patient instructor, the entire class did well. I would have given at least a four star rating but this Addison/Wesley paperback was very poorly published. Pages fell out daily throughout the semester. Have some tape and glue handy.



5. As an instructor of this course, I enjoyed stressing to my students that they must develop their problem-solving skills and programming style.
   
   That's the strength of this book -- a huge emphasis on the importance of breaking down a big problem into easier parts (it's clear that the authors paid attention to G. Polya's How to Solve it), and tips on programming style, from the naming of identifiers (variables) to the use of reference vs. value parameters.
   
   This was a great support as I taught this course to a class with a very mixed programming background.

5 comments about C++ Plus Data Structures.

1. Typically most students that take Data Structures are neither lazy nor stupid. This may be considered to be a good book if the person using it already knows the language and has good understanding of the principles used within the book. As a course book for people that are attempting to learn, this book has very little to offer. Sadly, I am in a class that requires this book. Everyone in the class is complaining about this book and even the teacher is having second thoughts about using it again. Probably the main problem is the cryptic code snippets included.



2. This is the worst textbook I have ever had. I have no idea how anyone could learn to program from this mess. No complete examples, not very coherent chapter lay-out, extremely unclear. The best use of this book is for firewood.



3. I had used this book only for a course. I was compelled to sell it once my course was done. I am glad I did.



4. Product came within the expected time and was in stated condition. I would definitely order from this vendor again. Pricing and delivery time were on point.



5. This book is absolutely the worse book that I have ever seen for any course I have ever taken in college. From the start, this text is confusing. The author constantly makes useless points and wastes time on examples that are meaningless and spends little time, if any, on pivotal parts. Even my professor is finding errors in how the author structured her work and examples and is actually lecturing the author via email! For someone who already has a background in this field, this book is tolerable. But if a person is trying to learn this material for the first time, this book will leave a person confused and with even more questions than when they started. I'm considering using my old textbook for this course, because that one actually made sense in every aspect and was clear cut.

5 comments about C++ Pointers and Dynamic Memory Management.

1. I learned to program in C++/MFC pretty much by the seat of my pants. This book is invaluable for learning pointers. It starts simple, and then dives down deep. I think it is an excellent book. Most developers seem to hate C++ because of pointers. Learn pointers from this book and you will not only learn to love them, you will become a expert programmer as well!



2. While I understood pointers I always felt a little uncomfortable with them - this book has made things crystal clear. It has helped me to understand pointer and memory management concepts and pitfalls and has made me a much better programmer. This is NOT the book for you if you are trying to learn C++ or are at a beginner level - this is for the intermediate to heavy C++ programmer who wants to improve his/her coding skills and depth of knowledge.



3. If you want a simple resource that encapsulates what pointers are and how they are used, this is an excellent resource. If you are looking for something deep and intricate, this is not your resource. This book is extremely easy to read and understand, and you can be introduced to every kind of pointer you want to know about by reading this book. I gave it 4 stars because I thought Daconta's attempt to talk in average programmer speak went a little too far. He could have been a little more formal. Regardless, I think it's a worthy buy.



4. Since I am a programmer and mainly built applications using visual basic, I always had an urge to master c++ due to the power of this language, but pointers were the only hurdle for me to overcome this goal. I always had bad times understanding MFC offered classes and the way whole infrastructure work, coz they play with pointers alot..and after all learning C++ and coding in c++ is not difficult without pointers but the fact is, if someone really wanna code in C++ they better do it efficiently other wise no need to switch, you should remain on ur currently practice language..This book not only taught me what pointers are but really made my mind think and work like a compiler..I really appreciate the author Micheal C Daconta and his team of putting such a masterpiece into existance, with out this book I simply believe one cannot solve the mystery of pointers coz no other stuff is available that is comparable to this book..
   once again I deeply thank the author and his team for their hard work, for simplifing the true power of c++

   Zeeshan




5. This is a really awesome book. In my opinion, nobody to date has explained pointers better than Mr. Daconta. By the time I finished reading the book and doing the exercises, I was really thinking out "pointers" and how they were being represented inside the machine, which is what makes this book great.
   
   Pointers being a difficult topic, I have referenced scores of sources, but have come away disappointed. The author with his unique explaining style (using diagrams and "paper computer" paradigm) brings out the essence, power and the pitfalls of pointers, references and memory management.

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 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 Introduction to C++ Programming, Brief Version.

5 comments about Programming a Multiplayer FPS in DirectX (Game Development Series).

1. This book is terrible! You read through the whole thing, and you don't even learn anything!
   
   I would strongly recommend people not to buy this book.
   
   Otherwise, you just wasted 30 dollars on worthless bs.



2. I've enjoyed reading this book. It effectively shows you how to write a very basic first person shooter in directx. Well done. It briefly introduces rendering, a simple scripting system, peer-to-peer networking, handling user input, scene management, collision detection, sound effects, and more. Not bad. The code is fine, I had no problems compiling it in VS2005 (check the authors website for the latest code though) and I learned a lot from reading the book and going through the code. In short, I am glad to have bought and read this book and I do recommend it to others.
   
   The book does have some drawbacks though. I feel that the actual game that is built in this book is embarrasingly bad. The networking system, rendering system, user interface, and everything else about it are bare-bones functional, but certainly not good enough that you'd want to encorporate them into your own game. I suppose that the thought is that you should first learn to build a Yugo before you learn to build a Ferrari, but personally I'd rather just learn to build the ferrari right off the bat :) Oh, and why must the graphics suck so badly? I realize that it doesn't necessarily impact the goal of learning the various topics, but seriously, how hard would it have been to at least provide a decent character model, or some decent textures and lighting and so forth?
   
   One last thing. The book assumes a familiarity with C++ and to a lesser extent with Directx, so if you are brand new to either of those, the book will be pretty challenging to follow.



3. At my school we used this book for our networking class. (I had been begging our teacher to show us some directPlay stuff... yes, I'm aware that directPlay is ugh in terms of networking, but, it was a lot better than learning some java networking stuff. At least to me).
   
   This book was an invaluable tool for designing my networking system. I basically gutted this networking system and stacked on some variable size packets that I studied from one of the Lamothe (actual author:Todd Baron ) books. (weird book, guy talks about his exploits in ultimate online for like, almost a chapter before he goes on to explain about how you can hack the networking system for exploits.
   
   This book shows you how to implement a peer to peer network and then treat it like a server/client system. It's an interesting (I chose to just go strictly peer-to-peer in my system) approach. And I read in one of the Game Programming Gems a way to bypass some of the connectivity issues with peer to peer networks.
   
   Regardless, this book is an EXCELLENT study of networking for games. I read the networking chapter probably 20x during our project and it took me quite a while to figure out exactly what he was doing with it. In the end, it's a logical system that works fairly decently.
   
   We didn't use the rest of the code in the book too much. Some of the other people in my class modified the FPS game to do other things (made a shooting gallery, other's made some text based games on the networking code, etc).
   
   The source code is useful and there is an update available for it (his precious linked list had a memory leak in it... he really harps on about it).
   
   If you have never designed a game system before. This book is going to be a tremendous help. It teaches a bit about design patterns without all the unnecessary mumbo-jumbo, and how they directly relate to game programming and how they're useful (helloooo singleton).
   
   The code is in visual studio 6 I believe, and you have to set the default project to the actual project and not the engine to get it to run. Also, if your hardware doesn't support hardware vertex buffers (you have integrated graphics, we had a couple people on the team with this issue) you have to change one of the directX intializers to something else to account for this (can't remember the call now, look at some other directX init calls from somewhere else and you can find it).
   
   He goes into quite a bit of detail about each topic and the basics, and then delves down into the design of each system. It's very methodical and well thought out. AND YOU GET SOMETHING WORKING AT THE END!
   
   Do not get this book if:
   You are new to C++(you better have a CRYSTAL clear understanding of pointers and OOP, classes etc).
   
   You are not interested in engine design.
   
   You hate directX, or directPlay.
   
   You hate max; he uses 3dsMax to make the scene files etc.
   
   You are an industry professional that has a basic understanding of how a game engine works. This is definitely a n00b book.
   
   You expect to get your hand completely held at each step. He does skip over some details that are easily discovered if you delve a little into the MSDN or any other online resource.
   
   Get this book if:
   You are incredibly interesting in engine design and want to get your feet wet; as well as learn some engine design in the process.
   
   You're interested in any of the systems this book covers ( I can really only attest to the networking system, and that he uses directPlay, which is in sunset mode).
   
   Interested in basic modular programming and looking to expand the code in the book to meet your needs or to experiment with. It is an incredibly useful base to start with.
   
   Are extremely comfortable in c++/directX and are interested in expanding your knowledge and it's applications into games.
   
   Overall, the book was a good purchase and is an excellent stepping stone into engine design. It has been very useful in my future projects since I've used this book in my course work.



4. In general I'm very pleased with the book "Programming a multiplayer FPS in directX". It provides a very nice introduction on how to approach the task of building a complex 3d application for user with basic knowledge of C(++) and DirectX. Structured programming is important! It is nice that one has such a concrete result at the end of the book. The only drawback is that it could have a little more in depth treatment of certain areas, but hey, it is already almost 500 pages :)



5. To start with, I would say the reader needs to have some basic knowledge of DirectX before reading this book.
   
   This is not a book that "teaches DirectX with the goal of creating a First Person Shooter". It's a book where the author explains how his game engine/framework he built on DirectX works. It's not the type of book that explains to you step by step what is going on and tells you to add this piece of code here, which in my opinion, is the best way of teaching something. Rather, it's a book that lets the reader open up the source code in the CD/DVD and expect him to figure out where the code the author is talking about is located.
   
   Furthermore, the source code won't even compile cleanly in modern versions of visual studio.
   
   Now, if you want to learn how an FPS game engine/framework was created, perhaps you might consider reading this book. I would recommend you look forth to modern game engines and forget about the book, as the end game is not all that good anyways...
   
   So basically what I'm saying here is: 1. This is not a DirectX tutorial for newbies 2. The code/game is rather outdated.
   
   The author knows what he's talking about, though. The actual code is pretty good looking. He's got a great concern for proper memory allocations and memory cleanups. The game loop he designed is pretty consistent too, and very well thought of. My only regret is that, in my opinion, the whole "tutorial" part of the book was disastrously focused, which is a shame.