1 comments about Using and Porting GNU CC: for version 2.95.

1. An excellent book on addressing the excellent GNU C compiler. As the previous edition, the author give us enough detial information on porting Gnu CC for different platform. I like the porting part of this book since it is the unique book in this field. For using GNU CC, yeah, you had better ask Richard Stallman, since he know more than others, right? :)

   It is not a book for a beginner, it needs some background on Compiler and GNU CC. It is an Excellent book on this topic!

1 comments about Instant C Programming.

1. This book is actually pretty good! It covers most of the basics of C and I havn't found one compiler error using the source code from the book!

2 comments about The C++ Standard: Incorporating Technical Corrigendum No. 1.

1. I'm not going to review the content; if you know what this is (the formal standard for the C++ programming language) you know that standards are written in dense, formal language, but that at times, no other source of information about the language will do; this is the primary source. If you claim to be an expert on C++ and write a lot of code, eventually you will probably have to look something up in the standard.

   But after looking at a copy close up, I no longer want to purchase it. Why?

   While the paper is acid-free and reasonably thick, the binding is one of the poorest I've ever seen in a hardback book.

   I'm not an expert on book-binding, but most of the hardcover books in my professional library (such as Refactoring, Design Patterns, The C++ Programming Language Special Edition, and various other books from Addison-Wesley and other vendors) have a sturdy strip of cloth embedded in the binding and are strongly glued in place.

   This book, by comparison, had a thin cover, no cloth in the binding, and flimsy gluing; just flipping through some pages, I was afraid the pages were going to start falling out. A second copy had the same flimsy binding.

   For $65.00 we deserve better. Even a solid paperback at this price would have been much more appealing. Steele's Common Lisp: the Language, 2nd edition is a thousand-page paperback, and much, much sturdier. Note to Wiley: just sell a fat paper binding for $50 and leave it at that, charge a few dollars more if you must and give us a book that will last a few years. Don't try to con us with an expensive hardcover which is in reality flimsier than any other programming book on my shelves!




2. I agree with the earlier reviewer and I'll add another reason: For $18.00 you can buy an electronic version of the Standard from ANSI as a PDF file. Same content (except the TR which I think is available separately) and no issues about binding. It won't feel like a book but somehow I doubt that Programming Language Standards are read at bedtime with a cup of cocoa at hand...

No comments about Matrix Calculus and Kronecker Product With Applications and C++ Programs.

2 comments about You Can Program in C++: A Programmer's Introduction.

1. Francis Glasborow is one of the most frequent problem solvers on comp.lang.c++.moderated. And he has done a wonderful job authoring the book.
   
   I can recommend this book to anybody who knows basic programming (in any language) and wants to learn C++. In addition to the coverage of C++ basics that you find in many other C++ primers, you will find invaluable caveats and tricks.
   
   There are a few typos in the example programs in the later chapters. In spite of those, I still rate the book 5 stars as I could learn more C++ from this book than most others. After going thru 388 pages of this book, I find myself capable of taking on advanced C++ books -- like Modern C++ Design.



2. This C++ text is considerably less verbose than most, as it makes some significant assumptions about the reader's prior programming knowledge.
   
   These knowledge assumptions are the book's primary weakness for beginners. Early on the book presents concepts that many readers, even those with prior, but non-C++, programming experience, will not have previously encountered. For example, the author presents the term side-effect without explanation. As early as page 31 basic exception handling is presented in a small program. Iterators are first mentioned without an adequate discussion of what iterators are. Other items from the STL are also presented with explanations so limited that most novice C++ reader's will find the presentations very difficult, if not impossible, to follow.
   
   The author spends too little time providing details for a reader completely new to C++ or object-oriented methods to properly understand many of the new concepts presented, and too little time presenting well-coded exemplars. In chapter 3, e.g., the author states, "I deliberately leave some of these problems in my code because I want you to check code rather than taking my word for it." For beginners, this approach seems fraught with problems. I would have preferred to see programs correctly coded in the presentation sections, with code demonstrating poor practices, explicitly identifying what those poor practices are and providing examples correcting those weaknesses. Otherwise, code with potential problems should be left to the exercises. What reader's need are appropriate examples of good coding practices that they can emulate, not poorly written code examples. Snippets of code can be an excellent approach to presenting key concepts, but fully coded examples should demonstrate appropriate coding practices.
   
   Concepts are "fleshed-out" in later chapters, but "newbies" may find this book does not provide the solid understanding of the basics that they seek.
   
   Additionally, the improved and updated software does not always respond in the same way the earlier software versions used by the author did. For example, in the author's first floating point program, he deliberately leaves off an #include statement and comments that the user will see the compiler complain about this. However, my version of the updated C++ compiler, which is a later release of the one used by the author in preparing the text, accepts this situation without a problem and successfully compiles and runs the program.
   
   Many, in my opinion, unnecessary sections of the book relate to the author's inclusion of a graphic software package he developed called Playpen. This package provides extremely limited capabilities, and simply takes too much time and effort to learn. The package has essentially no value beyond the course. The author would have been better served to provide basic explanations of how to use the built-in graphics capabilities of the major OS systems currently in use. Perhaps he could have selected one, e.g., Microsoft's OS, and as he did for the IDEs mentioned earlier provided additional information on other OSs, e.g., Apple's, presented on the CD. This would have been far more helpful to readers, and have had real value beyond the course. I hope this approach will be followed for latter editions of this work, thus allowing the Playpen package to be removed. This package's limited educational value takes time away from important topics that could otherwise have been covered.
   
   However, in spite of, or because of, the author's conclusion about his readers knowledge level, many readers with some, even limited, background in C++ will appreciate this book's "get to the point quickly" approach. The author is also excellent in presenting appropriate C++ idioms, and showing where idioms carried over from other programming languages, even C, are inappropriate for C++. The author also takes time to explain why they are inappropriate.
   
   In summary, although the book indicates that it is appropriate for those with knowledge of another programming language, I don't concur. However, for those with prior C++ experience or knowledge gained from prior self-study of C++ basics, this is quite a nice book. It gets the reader programming from the start, and provides lots of short, complete, and easily understood programs illustrating key C++ concepts. It provides clear and appropriate short programming exercises throughout. It successfully brings many important advanced features of C++'s together in an authoritative manner.
   
   Thus, although it is not recommended as a first C++ book, it is definitely recommended as a good choice for those with some prior C++ knowledge or experience.

No comments about Graphics Programming With Microsoft C and Microsoft Quickc.

4 comments about Algorithms, Data Structures, and Problem Solving With C++.

1. I just finished a semester at the University of Texas at Austin in which this book was the text book for an abstract data types class. The book is a good textbook, but not a good desk reference.

   The book is obviously written with students in mind, using rhetorical questions, leaving vital areas unexplained as "exercises for the reader", etc. As an introductory text, in an introductory class, the book served its purpose, though the professor was required to explain some of the details that the book lacked. The code that is included in the book is all written in pseudo-code, most of it does not compile without some tweaking, and when a student is trying to grasp a diffucult concept in graph theory, the last thing that student wants is to have to trace through the program, line-by-line, to catch some error that is irrelevant to the larger problem, such as semicolons that have been left out, unmatched parenthesis, variable names that are not allowed by most of the commercial compilers.

   The book does have a good learning curve, however, and makes for good reading when first approaching a new computer science concept; however, when having to program a particularly hard section of a certain data structure, wading through pages of diatribe against older methods is not what is needed at that time.

   For instance, after spending a large portion of an entire chapter on AVL trees, Weiss proceeds to give example code (that doesn't compile on Borland 5.0, Visual C++, or GNU compilers without some tweaking), but leaves out a crucial method! When first learning about AVL trees, one of the lessons that was drilled into our heads was the diffuculty of AVL deletion... yet the book summed it up in *one* sentence: "As with most data structures, deletion is the hardest task; it is left as an exercise to the reader."

   Argh.




2. This book should be on every C++ programmers list. Of all the books I've read on Data Structures and Algorithms using the C++ language this is the most comprehensive. This book also built my knowledge on the C++ language. I look forward to reading more books by this author.



3. This book is very thorough, but thats really all I can tell you about it's content, because the material (both the algorithm analysis and the data structures material), is presented in such a way as that the author expects you to already have a basic understanding of these concepts. Worst yet, the author's code is extremely poorly documented. Stay away from this book if you are new to advanced data types or algorithm analysis.



4. Tries to cover all topics but leaves many details that are needed by a beginner. Examples of code are difficult to comprehend.

1 comments about C Programming for Unix.

1. Great book, if you need a good reference on C & Unix, this is it.

2 comments about Special Edition Using Borland C++ (Using ... (Que)).

1. The very first program you try to compile and debug tells you that you "Can't debug 16 bit executables." This is because Borland C++ 5 uses the 32 bit debugger as the default. You can compile the example programs and use the 16 bit debugger, but it doesn't allow the ease of use intended for the IDE.



2. Seeing the book rated for "Accomplished" programmers, I thought this would be a great way to learn Windows programming (since I already knew C++ itself). This is a very thick book that spends fully 1/2 of the volume with a C++ tutorial (well written). Then, suddenly, the example programs become Windows applications without much discussion on **what is going on**. Nothing on Windows specific programming is found until page 629, where a discussion of the Grapics Device Interface ensues. I found the Windows section to be very vauge. If I want to learn how to use the Integrated Development Environment, I can read the User's Guide that came with the compiler. This book might be a good reference for C++, and possibly for some advanced Windows programming concepts, but it is certainly not good for learning Windows programming with the OWL library

1 comments about Serial Communications: A C ++ Developer's Guide : A Comprehensive Guide to Writing Serial Communications Applications Using Object-Oriented Techniqu.

1. very goo