5 comments about C++ Builder 6 Developers Guide with CDR (Wordware Delphi Developer's Library).

1. This book serves well both novices and experts by providing answers to technical questions such as simple "how to" s, as well as presenting useful pointers on rather complex concepts that make further research easier. The author does an excellent job of helping readers comprehend and appreciate the overwhelming features of C++ builder, by offering a step by step approach in explaining fundamentals as well as advanced concepts. This book explains in clear and simple terms why C++ builder is not just a compiler but a feature packed, fully integrated development environment, which is essential for developing high performing, user friendly applications. The chapter on C++ advanced concepts does a commendable job in jogging your C++ memory. The first part of the book covers in great depth how to use the set of tools provided by C++ builder to develop database applications with ease and effectiveness. The author presents in great detail how to take advantage of the features of C++ builder to develop simple, as well as advanced database applications. Part two provides the web developers using Borland technology an excellent source of information along with examples to understand the difference among verity of proprietary architectures currently available. Finally, an entire chapter on advanced topics is well justified and serves as a prelude to upcoming technology innovations. Quite simply, this book is a must have for all serious developers using Borland Technology.



2. Unlike many other books written on C++ related technologies, this book discusses all the new technologies supported by C++Builder, and fundamentals of desktop and database development with the same level of emphasis. With regard to database development all the three technologies supported by Borland, BDE, ADO and the new dbExpress are discussed at length. This book is as useful to a new C++Builder developer interested in learning C++Builder, as it is to an experienced developer who is interested only in advanced development concepts of the product. This is a notable feature of the book. In nut shell, new developers will be benefited by the whole book, while the advanced developers will be benefited by about two thirds of the book. In my opinion, the author is very smart in choosing the book's contents to make it useful for every kind of reader.



3. This is not the book to buy on the subject of C++ Builder 6. Save your money on this one and go with Borland's development guide on C++ Builder 6.



4. I am the author of this book, and I feel I should write a response to this review made by "A Reader" from NY,NY on March 10, 2003, which, in my opinion, is made without going through the book in detail, or even attempting to use the examples.

   This book is certainly not on the C++ language; however, it is written for C++Builder developers very carefully to bring out many features not documented in the manuals. Extensive set of example projects are created throughout the book making sure that these programs compile and execute well. Extensive editing has been done by me and the publisher to minimise the possibility of errors. The book is written to be useful for both newcomers and experienced professionals. Obviously every book will not satisfy every need of every individual; however, it does not mean the book is useless. Book reviews are really appreciable when they bring out both the strengths and weakneses of the book in DETAIL rather than just a simple sentence; then only reviews are useful to the potential buyers.

   In addition, the book is really handy, without compromising on the quality of contents, and one can carry it easily and read while in travel also, not like the bulky books which are difficult to carry.




5. Not having used C++Builder for several years, I was looking forward to reading this one to learn the new bits of v6, and pick up some pointers on BDE while getting there. The book was very frustrating to me. There are some people who can explain topics in an easy-to-follow fashion. The author of this book excels at making topics as complex as possible, using multisyllabic words whenever possible, and just generally trying to appear erudite. Opening the book at random, I came across this sample: "A web application module is typically a TWebAppPageModule object or a TWebAppDataModule object. The TWebAppPageModule component should be used if our application is to generate at least one web page; in other words, our application is of page module type. (p307)" I'm not planning on throwing it away, but it's not a book to keep by the computer. For many topics, I can get more useful information from Borland's on-line help.

   This book feels like a surface skim of BCB6, with the occasional deep dive with extremely specific examples. I should have figured that at a bit over a third the size of C++Builder 5: A Developers Guide, quite a bit would be missing, particularly with all the cool new components in BCB6. For example, under "Developing custom components", the author states that this is a topic that could occupy an entire book. He then gives two pages of notes and code fragments that did not help me at all. CB5:ADG above, on the other hand, has an entire chapter, 74 pages, and actually provides the information needed for the task. Why bother including this topic if the information is useless?

   I also have to admit, I found the fact that the author had to come here and respond to critics with five stars not only amusing, but worth taking one star away from my own review (which otherwise would have been three stars). This is by no means a five star book.

2 comments about Practical FPGA Programming in C (Prentice Hall Modern Semiconductor Design Series' Sub Series: PH Signal Integrity Library).

1. Let's start on the positive side. This book is very current - it mentions the recent Cray and SGI FPGA accelerators as part of the reason for programmers to learn about FPGAs. It goes through some interesting and practical examples, showing how a C program can be used to specify the synthesizable logic for triple DES, including time/space tradeoffs. It gives some hardware awareness, without trying to turn a programmer into an EE. Best of all, it shows practical use of Impulse C, an ANSI C extension that supports pragma-driven pipelining and parallelism. Impulse C, by the way, seems to have an exceptional pedigree. It seems to descend from Maya Gokhale's work at Los Alamos, and there isn't much better parentage for such a product to claim.
   
   There are some problems with this book, however. It relies overwhelmingly on the Impulse C product, to the exclusion of Handel C and a flock of other products - it's really an Impulse C how-to. That's not necessarily a bad thing, but it's not what I assumed from the title. It emphasizes streaming data, like radar input, video, audio, or all the other traditional DSP applications of FPGAs. Streaming is good, but a poor match to the Cray and SGI coprocessors.
   
   The biggest problems in this book come from the basic approach of trying to turn an FPGA into a CPU. Back when iron was first introduced for bridge-building, iron beams were built to imitate wooden ones. The result was a wooden bridge made of iron. It worked, but used far more material than was needed for the job, and got relatively poor performance from the material. Ditto what happens when FPGA logic goes into a soft CPU. The result is a little like the classic "Fortran program written in C," only worse. Andre deHon, in his FCCM `04 talk on hardware design patterns, identified the FPGA CPU as one of the biggest anti-patterns in his lexicon (though he didn't use the word anti-pattern). Creating a CPU makes the FPGA look familiar to a C programmer, but is a great way to turn the FPGA's inherent parallelism into serial execution, and far slower than the host CPU's at that.
   
   The FPGA CPU re-introduces the "memory wall." A big Xilinx FPGA has 300-400 on-chip memories that can be accessed independently and concurrently. You can (I did) build a dual-ported RAM with 1000-bit words. You can (I did) create a 64-way interleave, so all data for a 3D tricubic interpolation can be accessed in one cycle. You can (I did) create scratch buffers for hundreds of concurrent computations. You can create all kinds of wild structures with massive performance - or you can reinvent the 16-bit von Neumann bottleneck. (Soft CPUs aren't inherently evil, there are good uses for them. Mostly, I'd rather use the same logic for 100 parallel, dedicated processing elements instead of one serial PE.)
   
   If you need to use Impulse C, there's probably no other book around. If you're a programmer trying to learn about hardware, I suggest Wirth's aging "Digital Circuit Design for Computer Science Students." I recommend this book only to people with product-specific needs.
   
   //wiredweird



2. As a reader of this book and a user of Impulse C I feel that I should clarify some of the previous reviewer's comments. While "weirdweird" is clearly knowledgeable about FPGAs, he (or she) is confused about the programming and execution model used by Impulse C.
   
   Impulse C is an extension to the traditional ANSI C programming language that permits development of FPGA hardware by writing C. Like any C-to-gates development tool, the resulting hardware design is inferior to what an experienced hardware designer could produce. However, many feel that the greatly reduced development time and effort of a C development environment is worth the performance trade-off. In many cases the resulting hardware runs significantly faster than software programs on a PC.
   
   The CoDeveloper tools that come with Impulse C (they are not included with the book) compile C to FPGA hardware and, in the process, extract multiple types of parallelism. Contrary to what "weirdweird" says, the resulting designs do not suffer from traditional processor bottlenecks as the resulting designs are nothing like a processor. Hardware synthesized from Impulse C programs consists of a datapath controlled by a Finite State Machine, the same structure used in most hardware designs and one that is not found in processors.
   
   In addition to any parallelism the user specifies through stream declarations, the Impulse C compiler can also perform loop unrolling and other optimizations to perform multiple operations in parallel. The tools also permit the simultaneous use of multiple memories internal to the FPGA, eliminating the "memory wall" to which the previous reviewer refers.
   
   "weirdweird" is correct that this book focuses solely on Impulse C, so readers without potential access to the Impulse C tools might want to consider other choices.

5 comments about Inside the Java Virtual Machine (Java Masters Series).

1. This book is somewhat less terse and succint than other books I've read. I don't have tons of time to read so appreciate short books that get to the point. This book was a little thicker than it needed to be. I like it but "Programming for the Java Virtual Machine" by Engel and O'Reilly's "Java Virtual Machine" are somewhat better books and thinner. PFTJVM has some nice diagrams while JVM has some better explainations on things like exceptions. It might be best to check out these three and pick according to taste.



2. This book is mostly a rehashing of the Java Virtual Machine Specification (which is available online from Sun, or in printed form). I found its reference section to be slightly less intuitively-organized than the JVM spec, and the rest of the book didn't really add a lot of new insight, beyond a semi-guided tour of the Java Class File format. I would've like a much more detailed tour of the really interesting JVM elements: locking/synchronization implementation, JITs, threads, and advanced garbage collection implementations. There's a lot of active research into JVM design, but not a drop of it can be found in here, sadly.



3. The book covers many abstract concepts, but it is hard to understand what something abstract means without a concrete example. Implementation of the heap, object layout, etc. is difficult to conceptualize without a real example. I would have been happy if this book discussed the VM as it does now with a running commentary on the Sun Win32 JVM implementation.



4. This book spends too much paper explaining the Java history and why it is a good programming language. It is very, very boring. The advanced stuff begins after chapter 3, but they are not well explained. Well, all I can say is I really regret having bought this book, and I do not recommend it to any expirienced and short-in-time Java programmer like me.



5. so many pages, and so little stuff. what a waste of time and money!

5 comments about MFC Programming (Addison-Wesley Advanced Windows Series).

1. Have been looking for a MFC book for sometime now, I came across this book, it wasn't as large as most other MFC books but I own many programming books and larger is not always better, most of the time the larger the book the more BS it includes. The book includes "real world" examples like the tree view example isn't just a tree view which includes 1-9 or some other BS it is you local drive structure! I have only been skimming through this book for about an hour and it has already answered about 50% of my questions! If you know C++ and want to learn MFC then this is a great book! It teaches MFC not the C++ language structure or how to use all of the wizards which most MFC books waste the first 3 - 4 chapters on!



2. I have not read this book, I have mostly browsed through it to find information that I need. This book has not let me down. I have a variety of programming books, many that were more than twice what this book costs, that don't cover important topics the way this book does.



3. As a 4th year CS BSc student I might claim to be the owner of the greatest number of MFC books. Most are like the curate's egg - good in parts. It is with regret that I came upon Feuer's book so late in the buying sequence. Had I discovered it earlier my bank account would now be better and that of Amazon somewhat less!

   My MFC library ranges from the 'Do it in 24 hours' variety (often laughable - but even they often have something to offer) through to MS professional tomes which seem like those job offers where you need not only the ability but a few years experience as well. Another excellent book is Kruglinski but this only proves it's worth once you have nearly got the whole idea well understood. Feuer - much better as a starter - assumes little except a good C++ base and then takes one forward step by step.

   I very strongly recommend Feuer for anybody with a good C++ basis wanting to move to VC++ and MFC. This is the one to start with if you want to protect your cash. Kruglinski should come after and then you're ready for the MS serious stuff! Happy coding!




4. After making relatively successful forays into MFC armed only with MS reference materials or books written by MS employees and I have finally found a book which explains MFC without marketing it. Very lucid and well-written. I think the Document/View model is a bit less generic and useful than is presented, but at least now I understand most of its underpinnings. One error - Delphi has never been interpreted (p.5);



5. I give this book 4 stars instead of 5 because it was published in 1997 and is somewhat outdated now. I purchased it in mid 99 because I liked the other book in the series, Win32 Programming by Brent Rector.

   Feuer's book is consise and I like his approach of explaining some of the internals of MFC, such as what BEGIN_MESSAGE_MAP expands out to. Feuer talks about the Win32 API too and I agree with his philosophy that MFC programmers can't hope to get by without knowing anything about the API.

   The sample code applications on the CD are great. They are simple to understand, but show you most of the options possible. For example, there is one app that displays all kinds of buttons, including owner drawn ones. Most MFC books don't even say anything about owner draw stuff. At the end of the book, Feuer shows you how to make a wizard-based install program.

   I recommend reading this book after you've read a beginner's book on MFC and/or Visual C++. Also, the author does not reproduce all of the sample code in the book itself. You should install the CD and read the actual code as you read the book.

5 comments about Practical Introduction to Data Structures and Algorithm Analysis (C++ Edition) (2nd Edition).

1. ...but this was a mandatory book for my university's two-course Data Structures & Algorithms sequence that all computer scientists and computer engineers must take.
   
   Coming in with a good deal of programming experience, I find that this book is not as clear or as complete as it could be. The sample code snippets throughout tend to be awkwardly implmented with obscure variable names and obtuse datatyping, and more often than not represent 'a' way of accomplishing a task rather than 'the best' way. Finding better ways of doing things is normally left for exercises at the end of the chapter; the answers are not included with the book.
   
   Also, many significant details or comments are skimmed over or are ommitted from the text. Many important (and complex) observations are left as exercises - but again, the answers are not included, so there is no way of validating your answers.
   
   Further, this book is targeted at the C++ language. It is obscene to discuss data structures and algorithms without mentioning the free, prepackaged, and optimized code of the C++ Standard Template Library. Indeed, this book and the code it includes would have benefitted from the ingenious architecture and software engineering behind the STL.
   
   I really hope the campus bookstore will buy this one back when I'm done with it.



2. Dr. Shaffer attempts to address the difficult topic of data structures and fails. Consistently he glosses over important points, or does not describe the implementation of data structures (the buffer pool, for example, is especially poor) adequately and leaves the hapless student confused and frustrated. For a computer scientist who already understands the subject this book may contain a few good points. Indeed, I was able to follow the sections where I had previous training, but when I studied material new to me, I was out of luck.
   
   If you are unlucky enough to have a university that uses this text, consider trying to find a better book to get yourself an adequate understanding of this important subject, because Dr. Shaffer's text won't do that for you.



3. I would not reccomend this book for learning about data structures. With incomplete code and scampy sections on core area material, it seems to serve more as a workbook than anything else. In addition to this I find it to be poorly worded which has often caused me to overlook important details or have to read a sentence multiple times to understand what the author is saying. What saves this from being a one star product is the fact that if you do know the material, it can help you review structures but even then, the ackward wording still can slow down a quick read.



4. I have Dr Shaffer as my professor and he is just as boring in real life as his book. He has told us that some of the code segements are broken to make his students figure them out. DONT buy this book... It's not worth the money.



5. 
   This book gave me no hope for Analysis of Algorithm and Data Structures class, i have yet to find another book to assist me in this area. the book was so-what easy to read, but the explanation of the concepts is really horrible, dont waste ur money

5 comments about C++ Algorithms for Digital Signal Processing (2nd Edition).

1. This book is rather well written. I have read both the C++ and C versions. The contents of both books are more or less the same, just the difference in the C language used. Source Codes provided compiled neatly without and need for modification, which is really cool. However, the image files provided are really puzzling. The book says the images are in a DSP data format. So far I can only get the programs to work on the 2 images (.dat) provided. I tried using other .dat images from the net, and many other formats, including monochromatic raw images, but it wouldn't work. Another reason I only gave 3 stars is because the book doesn't provide any online help or an email of the authors. Personally I feel that this book is more for professionals who is already trained in DSP.



2. Lots of practical code examples. Practical filtering routines and example code.Includes a general introduction to C /C++ concepts frequently used in DSP algorithm development. A good introduction to image processing is included. The DSP function library and sample code is perhaps the best part of the book.



3. The title promises a lot. But it doesn't deliver. This book is muddled and confused. It begins with a rather high browed treatment of the maths behind DSP then goes on to attempt to provide examples in C++. The examples are poor and unclear. The supplied code compiles under VC++ but not under any other platform without substantial reworking.
   Over 100 pages of this 500 page book are devoted to a general discussion of the C++ language. Why? If I wanted this type of material I would consult my C++ manual. Here are C++ programmers who want to tell us the do's and don't's of the language, that feel the need to test newed pointers for NULL after allocating and before deleting!
   As far as the rest of the book is concerned I found the examples and text unclear, pedantic and frankly quite useless. I will keep my copy only because I want to use the theoretical material. But this material was written for maths graduates - pages upon pages of proofs and derivations that provide little insight into the underlying principles and serve nothing. Hold off and buy something more usable.



4. The current edition of this book does NOT contain a physical CD-ROM. Instead, Prentice Hall has a link on their website that allows you to download the CD-ROM contents as a single ZIP file. That's a 207 MB ZIP file, folks. They've made no provisions for partial downloads...
   
   This must be Prentice Hall's idea of a good way to increase the profit margin on their books. Recently, I've run across a couple other titles from PH-PTR where the CD-ROM mentioned in the preface is no longer included. In some cases, they haven't made the contents available on the web -- or even bothered to tell the book's author that they're dropping the media from the package.



5. The book is good and to the point. Unfortunately, it is sold with
   a cd I have never received.

5 comments about C++ from the Beginning (2nd Edition) (International Computer Science Series).

1. I have bought many books on C++ for college courses, but this one is much easier to learn from. It gives good examples, and builds on these pieces of information to give the user a good understanding. The only suggestion would be to have a book of the exercise answers available to purchase. The course instructor is using this book for background info, and not making assignments from it, so the answers to the exercises would be helpful to my learning effort.



2. I had some prior knowledge about programming concepts before reading this book and I was glad of that. Although the book covers very basic issues as well as fairly complicated issues like data encaptulation, inheritance and polymorphism I found the book to lack a lot of examples. It's my experience that only I can teach my self a given programming language through writing examples and "play" with these. The examples in the book however, are small and always assumes you've just made the prior part of an example a few pages back and that just doesn't work for me! It's not a bad book but you'll need to supplement with another book to show you more examples.



3. Skansholm's book is concise and pragmatic. I have read both of his work on C++ and Java and it trully a must for beginners. The book is very good explaned and all programs can be run from PCs and UNIX machines. There are tons of similiar books on the market but Skansholm's work excel in both interesting examples and academically sound.



4. I purchased this book for a college class in Computer Science. Being already familiar with C, I was expecting that the book would get immediately into the guts of C++, i.e. Object Oriented Programming.
   
   Sad to say, this book spends most of the first 5 chapters attacking C++ from a C perspective. The only new C++ constucts presented early were "cin >>" and "cout <<". The first real discussion of classes isn't until page 63, where the vector, list, and deque classes are discussed as alternatives to arrays.
   
   If you're a C programmer, you'll have no problem following the book, but then you might as well start reading at Chapter 6 (pg. 203!) although you might find yourself wondering why you had to buy the first third of the book (it's ~600 pages total) in the first place.
   
   If you're a fresh, un-"C-tainted" programmer, learn programming from an Object Orientation first. That way you won't learn bad habits that you'll be forced to un-learn later.
   
   jmtc



5. Well, I wanted to comment on this book from the perspective of someone who is a beginner to programming. I do have a little experience in HTML, Latex, and Mathematica. A friend gave me the book, saying it was the perfect book for a beginner, not requiring any prior programming knowledge. In fact, the author makes the claim "There is no onus on the reader to know C, or any other programming language for that matter." Well, here I am. I got through about the first pages of chapter 3, then I gave up (I gave it three shots). The problem is that, e.g. on the first few pages, sentences like the following are basically right next to each other:
   "The diagram shows the most common input and output units for communication with people: a screen (monitor), a mouse, and a keyboard."
   "All declarations in the standard libraries are done in a namespace called std."
   That second sentence was not explained (instead, the author said that it would be OK not to understand this). And that would be my main point of critique: Why would you write that without explaining it? Unfortunately, after a while (for me after ca. 80 pages), these not explained things piled up and made it harder and harder to keep everything together in terms of understanding. Learning started to be no fun at all anymore because I was loosing overview.
   
   The book is probably a good book. It seems pretty well written etc. But if you have about as much experience as I have, chances are you will get lost somewhere within the first 100 pages.

5 comments about How Not to Program in C++: 111 Broken Programs and 3 Working Ones, or Why Does 2+2=5986.

1. This book starts out assuming that you know both NOTHING about programming, and EVERYTHING about it at the same time. The idea for the book is excellent. Here is what is good about the book:
   
   Oualline makes good use of common mistakes in c++ for beginners.
   
   Good use of humor and stories to keep the flow of the book interesting. I actually kept reading most of the time just to hit another story!
   
   Effective use of showing the answer.
   
   Good understanding of of some common mistakes even advanced users make (such as a string actually being a reference and trying to have it returned in a function!)
   
   
   Now for the bad:
   
   Book is poory organized. The answers are all spread out and the hints are the same. This could be done more effectively in any number of other ways.
   
   He uses C code way too much in the book. While it is a good idea to have C code shown because most of the C++ code out there is a hybrid of C/C++, this would be better utilized by having a whole seperate chapter of C/C++ hybrid instead of being spread out in the book (even though there is a seperate chapter for it).
   
   Some of the mistakes are not really mistakes but just an annoying point to show that usually is fixed right away (such as output not having spaces).
   
   Some of the code is too short while others are too long (3 pages of code to spot an error seem okay, buts its hard cause you have to flip back and forth).
   
   All in all this is a good refreshing book to look over sporadically. I hear there is a C book thats the same thats a bit better by the same author. I was originally looking for something to help me better my C++ skills (as I consider myself to be an expert). I highly reccomend any books by Meyers if you are looking to polish your skills rather than "learn" something new.



2. I just began learning how to program in C++ and I actually enjoyed this book a lot.
   
   First of all, it's littered with various stories and jokes that sort of reward you for reading. The general outline is; you debug a program, and then you read a short funny story. It does that mostly throughout the book, until you get to the final chapters.
   
   The rest of the book is full of C/C++ source code that has a bug in it, and you have to figure out what they are. Some of the programs were actually easy to debug, but as a beginner, I found them to be both entertaining and helpful. I now know what kind of things to avoid, and I know how to problem solve a lot better now. This book is helping me gain experience without actually writing out all of these programs.
   
   I wouldn't use this book as a substitute for an actual education, and I wouldn't use this book as my one and only source of experience. It should be used simply as a supplement.
   
   Very funny and overall a very rewarding experience.



3. I enjoy this book, and recommend it. However, to get the most from the book, the reader should know themselves and their C++ level before reading it.
   
   For the novice programmer, this is probably a useful expenditure of time and money. Many of the bugs will be over the head of the novice or student reader. But, perhaps even years into the future, when they first encounter a problem previously seen in this book, they may recognize and fix it much more quickly.
   
   For the experienced programmer, the book is more amusing than educational, but there are still some good challenges. If one expects that every page will present a new puzzle, they will be disappointed, but there are enough challenges to make the book worthwhile.
   
   Finally, for the teacher, this book has some problems which are simple enough to use for a C++ class. For example, I use number 10 in my C++ course - boiled down to its essentials, it's:
   
   float A;
   A = 1/3;
   cout << A;
   
   ...a mistake which experienced C++ programmers still make occasionally.
   
   The organization of the book includes randomized hints in a separate section, so that one can read the hint for problem 23 without seeing the hint for problem 24. The answers are similarly organized. While not straightforward, it does make one work at the solution. I prefer this organization to the other two competing books I own, Andrew Koenig's "C Traps and Pitfalls" and Alan Feuer's "The C Puzzle Book".
   
   A prospective buyer can see some sample problems at the publisher's web site, and this brings me to one drawback: no source code. Some of the problems are fairly long, and an archive of source to avoid re-typing would be welcome, if only to me.
   
   So...before buying this book, know thyself and set your expectations accordingly. Each of the other reviews makes valid points, depending upon the reviewer's experience level and expectations. I personally rate this book five stars.



4. I have not read the whole book yet, but I'm only on page 24 and I saw enough errors to make a review. I like the examples in this book (as a novice C++ programmer), but some of these errors I've seen would make the program error out at compile time.
   
   For example, in Programs 2 & 3 in the book, the author wrote:
   
   return (o); // Now that's the LETTER 'o', not ZERO like it should be
   
   At first I was like, "Alright! That's an easy one." But when I checked the answer, that was not the error the author was looking for.
   
   In Program 3, the function "matrix_multiply" parameters are:
   int result[3][3], // Okay so far
   int matrixl[3][3], // Notice it is 'matrix' and the LETTER 'l', not ONE
   int matrix2[3][3]
   
   And inside the function they use "matrix1" instead of the defined "matrixl". This is one of the errors I thought it might be, but once again, it was not the error the author was looking for.
   
   
   Maybe I'm being a bit harsh, but if you're going to write a book on how to NOT code (but provide the solutions), you should have another programmer review the code, not a regular editor who doesn't know any better. Or at least mention these 'extra credit' errors that I, a novice, found. Speaking of which, I'm really surprised nobody else has mentioned this.
   
   All-in-all, great intent, but they should have reviewed the code a little better.



5. I throughly enjoyed this book. I ran across programs and source code that made me scratch my head trying to figure what the heck is wrong with it, only to find a minor little syntax error. The book is written in a laid back comical approach with lots of code sample, and lots of funny tidbits, theorem and true stories about tech support calls.
   
   A very nice walk down memory lane, reminding all of us of our humble beginnings and the noobish mistakes we once made.

5 comments about Building a 3d Game Engine in C++.

1. I purchased this book in 1995 when I was migrating from C to C++. Stepped through the code in the debugger, and put it aside, as it was for DOS, and I wanted to have a real Window, not DOS screen. Later, with Charles Petzold's "Programming Windows" help, I ported 3D engine DOS code to Windows31 and it worked, but I have to adapt it to the Windows events/kbd/mouse processing. Now in 6 years I recompiled the Windows 31 version on Windows 2000 Advanced Server in VS.NET Beta1 - it compiles and runs(!). I am learning C# these days, and will try to re-write Brian's engine in C#. My point is that the ideas of 3D engine experssed in this book are fundamental, as they are absorbed from the knowledge of many talented people named in the book. The bulk of engine design and the code is solid, it just takes time and patience to gain necessary experience to understand the engine, adopt it to the event-driven model, and move it to the platform of your choice. Overall book is worth the money spent for those who want to learn the core of 3D programming.



2. Tell you 3d thory and 3d texture mapping.
   you must use BC++4.5(under windows98 ME)to compile and link it.
   The whole code can help you building your own 3d system.
   If you are 3d programmer ,must buy it...



3. Back when I was a lot younger I had just enough money to buy a single programming book. That didn't happen very often. Long story short ... I bought this completely worthless book. This is absolutely the worst programming book I've ever seen.
   
   Brian Hook decided to print out his retarded cousin of a "game engine" and sell it to the unsuspecting. After all, how else was he supposed to make any money from this Cleveland Steamer of an engine.
   
   Only buy this book if you intend to coat it in dog feces and fling it through Brian Hook's living room window.
   
   This guy makes Andre Lamothe looks like the kind of guy that DOESN'T walk around all day in a Blade outfit.
   
   [...]
   All of the articles written by Brian Hook are rated the lowest of any on the page.



4. I bought this book many years ago because a friend of mine was going to buy it and asked if he should order one for me too. Yeah sure, why not. At that point even 2D game programming was a challenge for me, so I never read the book.
   
   Now about 5 years later, and after reading "3D Math Primer for graphics and game Development", I wanted to apply some of my new knowledge, to show a simple filled cube on screen.
   
   I started reading the book. Brian Hook at the time had a 486 and the OS was dos. The book does not explain OpenGL or Direct3D. It is completely software 3D. I like this fact. I don't expect to use the result for anyting other than knowledge. I want to know how 3D works under the hood, before I try OpenGL or Direct3D.
   
   The examples are very easy to follow. I have now achieved to show a spinning cube on the screen which was my goal and I'm looking forward to read on and apply texture mapping.
   
   Conclusion:
   Great book if you know matrices and vectors but have no clue about how to apply it to programming.
   
   Great if you only expect the book to help you with the first few steps into 3D programming. Don't expect to create Unreal engine or something like that.
   
   I give it 3 stars. Maybe it deserves more but still, it IS dated and I'm taking this into consideration as well.



5. This is a very old book using very old technology. The author is using raw C++ code and some assembly language to demonstrate a 3D game engine which he calls AST3D. At this point in time, you should not buy the book expecting to extract the code intact and have a state of the art 3D game engine. However, since the code is not wrapped up as part of a larger more complex programming library, the code snippets in the book are very readable and therefore useful as pseudocode to understand the components of a game engine at a building block level, and some of the more basic algorithm information is still useful too. The problem is that modern in-print books on 3D game engine architecture are usually so wrapped up in some very complex code library that it is hard to get a good handle on how to write an engine and the design decisions involved. That is why this book is still useful. The most useful chapter in the book is chapter 16, "The View from the Top", in which the structure of the 3D game engine is explained in text and in block diagram form, referring back to topics in previous chapters. There is a complete code listing in the back of the book, so even if the diskette is missing from your used copy, you can still go through the code and get an idea of what you would need to have in your own game engine. Just don't pay any more than a used-book price. I notice that Amazon does not show the table of contents so I do that here:
   1. An Approach to Games Programming - Designing Real-Time Interactive Games;The Main Loop; Real-Time Interactivity; Fun: The Golden Rule of Programming
   2 Graphics in Two Dimensions - Basic Raster Graphics Theory; Basic VGA Theory; The VGA Class; The ASTPallette Class; Debugging with Dual Monitors;
   3. Fixed Point Math - Why Fixed Point Math?; What is Fixed Point Math?; The ASTFixedPoint Data Type; Mathematical Operations; Function Call Overhead and Borland C++; Why not a C++ Class?;Cumulative Error;
   4. 3D Graphics Primer - 3D Coordinates; Coordinate Systems; Math Classes; Transformations; Trigonometry; Projections;
   5. Optimizing By Design - The Main Loop; Event Driven Programming; The Graphics Pipeline;
   6. Organizing Your Data - The C++ Language; The AstObject Class; Object Definitions; The AstWorld Class;
   7. Input Devices - The Generic Input Device Class; 2D Input Devices; The Thrustmaster Cockpit System; Keyboard;
   8. Hidden Surface Removal - Types of HSR; Backface Culling; Depth Sorting; The Z-Buffer;
   9. Drawing and Object - Transforming from LCS to CCS; Projecting the Vertices; Drawing the Triangles;
   10. Shading - Fundamentals; Flat Shading; Gouraud Shading; Flat versus Gouraud;
   11. Texture Mapping - Linear Interpolation; What is a Texture Map?; Drawing a Texture Mapped Triangle; Loading Textures from a Disk; Room for Improvement;
   12. Environmental Effects - Depth Cuing;
   13. Simplifying for Speed - Object Culling; Distance Abstraction;
   14. Collision and Boundary Detection - Object Collisions; Boundary Collisions;
   15. Automatons - Implementing Automation; Timing and DoSomething(); Automatons in AST3D;
   16. The View From the Top - Overall Structure of AST3D;
   17. Advanced Topics - Custom Hardware; Multiplayer Games;

5 comments about Sams Teach Yourself C for Linux Programming in 21 Days.

1. This is one of the best programming books I have ever worked with/used. I had a program which I had written in Perl to parse and search unformatted log files. It worked, but very slowly. I picked up this book and thought I would try and rewrite it in C during the holidays. Four days latter it was done. I felt like I had really accomplished something, rewritten my program (which is now over a 100 times faster), and learned some C.
   The best thing was that I never ran into an example that didn't work and the examples were so straight forward I didn't have to write and try every one. ( I'm of the ilk that usually writes and tries all the examples). I wish they could all be this good.



2. This book is beyond as good as i said in my last review, well this is an update. After finishing this book, i have an entirely new outlook on why this book is so good! I always find myself looking back for a reminder; if there's something i need a refresh or rescale on, it's got it. it teaches compiling all the way to deployment. This book is desirably the best in my GNU/Linux stash. There are so many extras in this book, you would b surprised why they priced it so low!

   COVERED- Pointers (in depth), functions, all forms of data structures, GTK/GTK+, and more-

   If you the reader are taking any introductory courses in programming, for goodness and gpa get this book! Especially if you have a[bad]teacher as i once did ;)

   Hope this was helpful




3. This book helped me get back with programming in C (one of the most powerful languages out there), and they did a nice job of explaining the Linux environment and how the GNU C compiler (GCC) works. I am pretty new to Linux but had no trouble getting up and running with the book.



4. Going into my first year as a computer science student, I had never programmed before in any language. After realizing how tough it was, I picked up this book that was luckily in a local book store and read the entire book cover to cover. I'm now in my final year preparing to do a Masters in computer science thanks largely in part to this book. Even though it's not a complete C reference, it definatly gets you going in the write direction. From making simple to advanced makefiles in a clear and understandable manner, to structured software development with debugging information and proper coding techniques. It is missing important information like database programming and socket programming, but the things that are missing could be picked up in a more indepth and advanced book on C programming like "Beginning Linux Programming" (big red book with the 2 guys on the cover laughing at eachother). I'd never part with my copy of Teach Yourself C in 21 Days because its a good reference for little things you may forget along the way.



5. The Book: C for Linux Programming in 21 Days by Sam's is published in 2000. It is either so out of date, or inaccurate that even the first example (Hello World!), coding doesn't work. Even after following the instructions multiple times and double checking everything over. Warning their is a number of different downloads that have to be done to apply the information in these kinds of books that never get mentioned it is questionable if books like these serve any purpose other than coffee table decorations. Space too small to give lessons here. Buy only up to the minute beginning books. May things go well with you.