5 comments about Microsoft Visual C++ .NET 2003 Kick Start.

1. This is an excellent book to start learning C++ .NET 2003. As with many people out there, I find myself often disappointed with the Microsoft on-line help and especially with the fact the many examples are only in VB.NET or C#.NET. I am one of those guys that goes to the local Book Superstore and sits in the corner reviewing several books on a subject trying to find a good selection. If you want to learn C++ .NET, I challenge anyone to go find a copy at a bookstore and look through it. I think you will buy it like I did.
   
   Kate Gregory does an excellent job in describing how to work with Managed and Unmanaged C++ with .NET. She also provides excellent overviews on many aspects of C++.NET. The book doesn't cover everything about C++.NET, no single book possibly could. It will always depend on the target audience. But this is a great book for the beginner and intermediate developer. Her writing is clear and concise with example code that is easily understood.
   
   Bottom line - If you want to learn C++ .NET - CHECK OUT THIS BOOK!



2. This is a very good quick read text to use in moving from C++ to Mananged C++ or .NET. Very clear writing with succinct examples.



3. I've been programming in C++ since the borland D.O.S version, and now I'm inside the .NET world. I think this book is good enough to understand the changes between versions



4. I've purchased serveral books on .NET and this is the first I have finished. I really liked the fact that the book was short and to the point. This made for a quick read.
   
   One of the surprising things in the book is how she takes some time to explain her methodology to application development and give some great examples. You won't find that in any other book.
   
   If you're a C++ programmer looking to move into .NET I highly suggest this book as your first read. You won't be dissapointed.



5. I like Kate Gregory's writing style and her ability to get very complex and detailed information presented in an interesting and informative manner. I especially appreciate her ability to describe the interop capabilities of utilizing both managed and unmanaged C++ code. This book is the best that I have found in explaining this complex subject in a clear manner. This book is a little too complex for a beginner.
   I do not normally write book reviews, but this is an outstanding book by a very proficient author.

No comments about Starting Out with C++: Brief Version Update (4th Edition) (Gaddis Series).

5 comments about C++ and Object-oriented Numeric Computing for Scientists and Engineers.

1. This book intends to be an easy, concise, but rather complete introduction to the ISO/ANSI C++ language, with applications to object oriented numeric computation for students and professionals in science and engineering. It introduces concepts, techniques, and standard libraries of C++ in a manner that is easy to understand using examples such as vectors, matrices, complex numbers, and integrals, which are familiar and useful to a typical student or professonal in science and engineering.
   
   Besides introducing basic and advanced features of C++, the book contains an introduction and C++ programs for many numeric methods such as polynomial interpolation, numerical integration, direct and iterative algorithms for solving systems of linear equations in real and complex domains, methods for solving nonlinear equations, ordinary and partial differential equations with real and complex coefficients. These methods are fundamental in scientific and engineering computing.
   
   This book gives numerous examples and techniques on how to reduce (C and Fortran style) run-time overhead and improve program efficiency and elegancy. Such techniques include function objects, deferred evaluation for operator overloading, expression templates, template metaprograms, and replacing certain virtual functions by templates. It also introduces tools on how to manage source files, create libraries, and debug and profile programs.
   
   The book can be used as a textbook for students in science and engineering and a reference book for experienced scientific C++ programmers.
   
   
   --------------------------------------------------------------------------------
   
   C++, What a Programming Language Should Be!
   
   C++'s object oriented and general programming features enable the programmer to write few codes and support an evolving process of code development. For example, One version of C++ program of preconditioned conjugate gradient and GMRES methods can be used for full (storing every entry of a matrix), banded (zero entries outside of a band along the main diagonal are not stored to save memory), and sparse (only non-zero entries of a matrix are stroed to save memory) matrices, and for real and complex single, double, long double precisions. It would require 18 versions in Fortran 77 or Fortan 90. Six versions of C code may do it, but will be much less efficient. If one later decides to add a symmetric (only store lower triangular part of a matrix to save memory) matrix storage format, then 6 more versions of Fortan code (for real, complex, and single, double, long double precisions) need be added. The same C++ program for conjugat gradient and GMRES methods still can handle this situation without any change. C++ code of preconditioned conjugat gradient and GMRES methods are given in Chapter 11 (last chapter) of the book, which work for full, banded, sparse, and other matrices in real and complex domains.
   
   C++ has features (compound assignment operators, templates, function objects, high performance computing library such as valarray) that can be faster than Fortran 77 and C. For example, passing a pointer to a function as an argument to another function can be avoided in many C++ programs by using templates, which can improve the speed of execution by a factor of 2 on many compilers and machines. Running time comparisons with C and Fortran style function passing are done in various places of the book.
   
   C++ provides standard libraries on data structures such as vector, set, list, map, stack, queue, valarray, and on algorithms such as sort() and find(). They come with any standard C++ compiler and can be much more efficient, convenient, and portable than codes written a typical or expert programmer. For example, using these libraries, it is much easier to write finite element programs on unstructured grids and grid generation programs in C++ than in Fortran and C. A disussion of these standard libraries and algorithms are given in various chapters of the book.
   
   C++ programs resemble numerical algorithms more than in Fortran or C. For exmaple, we can write v = v1 + v2 for vector addition and v1 = m*v2 for (sparse, banded, or full) matrix-vector multiplication. The C++ code for the conjugate gradient method (for solving linear systems of algebraic equations) looks very much like the algorithm, which enhances readibility and maintainability. Besides, such operator overloading from built-in types to user-defined types can be done without sacrifice of run-time speed (see Chapter 6 of the book).



2. I used to write C and Fortran code for a living, using (although not necessarily as an expert) numerical methods to solve real-world problems. Like many, I have tried to catch up to C++ and OOPS to see what the fuss is about; like many "practical" people, I've been discouraged by the overhead burden of complexity that C++ introduces relative to C and procedural approaches. I am now using this book to teach myself the basics of C++, and can vouch that it helps the non-specialist who wants to learn a bit about both C++ and numerical methods.
   
   I agree with the reviewers that this book will teach you a lot more about C++ than about numeric computing (although the non-specialist like me will learn something there too.) This book has, to my mind, a number of virtues:
   
   1) It helps a scientist/engineer understand WHY ON EARTH s/he would want to pay the price of additional complexity over C or Fortran for scientific/numeric applications. It does this through showing how such standard applied math tools as vectors, matrices, complex numbers etc can be more cleanly handled in C++, and showcases a number of the language's other key features (e.g. templates).
   
   2) The problems are great...If you don't work the problems, I don't think you can learn much, but I have found nearly every problem instructive... even those that seem "plug and chug". Downloading the code from the website minimizes the tedium.
   
   3) It is reasonably clear, (although could be better.)
   
   4) By the end, you will have some code you can probably use as a base for your own developments...
   
   I have tried to learn C++ from other books, many of which are clearer and more accessible, but this is the only one that has helped me understand why, as an engineer, I should think about working in C++ rather than C.
   
   I agree that the book does not necessarily represent a fully "object oriented approach" to software design, but I'm not quite sure what that means anyway. If you are serious about C++, this will certainly not be the last book you read, but it will help you get up and running to the point where you WANT to know and do more, and you'll have fun writing code that works in the process.



3. I was required to read this book for a class, and am quite glad I did read it. It proviedes a very good introduction to C++ for those who aren't familiar with it. Even more importantly, however, are the great examples of how to use C++ for Numerical Methods, which makes it a good book for more experienced programmers as well.



4. Yang's book on Numeric Computing is an interesting and useful book that caters to a very specific sort of person. It focuses on explaining how to use C++ syntax and structures as applied to numerical analysis. There are lots of well dissected examples for solving ODEs or working with matrices, and plenty of questions that cement in the concepts. On the C++ front, the book is far from comprehensive. There are many syntactical omissions that will force you to consult one of the big C++ bibles if you wish to write anything but the simplest of code.
   
   In the end the book is very good at what it does, which is to introduce the technical person to the basics of C++ in application to numeric computing. Be warned though, this is not a standalone instructional text.



5. There is widespread agreement that Kernighan & Richie's introduction to C is one of the best books on any programming language ever written. Sadly, no book on C++ has achieved this distinction. The complexity of the language is mostly to blame. Personally, I am averse to any 1000-page "primer" that aims to explain C++ from scratch up to intermediate level, with plenty of diversions, illustrations of secondary language features and a menagerie of typographic symbols, all the same getting to discuss classes at page 500. Those are better thought of as bloated references. Instead, C++ a third language, and C a second if only because a) C is not for absolute beginners and b) C programming style is often found in C++ legacy code. But if this is the case, the reader can read and understand succinct explanations of the new features of C++, and be quickly reminded of its similarities with C, or warned of the differences.
   
   If you agree with my own preferences, this book is for you. It goes to the point and follows a linear, focused thread. Knowledge of C is not strictly required, but I can't see how can you accept double pointers as your personal saviours if you haven't seen them before. It's rather complete, but not all-encompassing. Topics are discussed clearly and the organizing principles are emphasized first, with the inevitable exceptions coming later. Examples are many. They are sometime thought in C but written in C++, which is no mortal sin. Because of the plain, assured style, and the approach to its subjects, the book reminds me of K&R. Not a small compliment to pay.
   
   The book also offers advice on programming style, mostly with an eye on numerical computing. It can be used a very high-level reference, to be complemented by a comprehensive one (my favorite is C++ in a nutshell). And each advanced subject of C++ deserves its own book, especially templates and metaprogramming. Avoid the "primers".
   
   Summing up, this is not a book for complete beginners, but more a textbook for a course or self-instruction. It's by no means a first and last book on C++. Such book has not been written yet. Know your needs and what you get.

3 comments about Crafting a Compiler with C.

1. This book has a nice balance of theory and practical algorithms. There is enough detail to allow a (patient) reader to implement his own compiler tools, though like most other books on the subject, this book leaves you with the feeling that the area might have died about twenty years ago (no insult intended!); an update needed, to include OO languages, some treatment of the complexities associated with parsing modern languages, C++ etc. All things considered, still a great book, well worth the money.



2. I teach compiler construction and I personally hate the "Dragon book" because it is beyond the level of many students. Fischer and LeBlanc present most of the same material and they make it readable. Theirs was the first book to devote an entire chapter to symbol tables, the central data structure that all components of a compiler use. There should be a law mandate that compiler courses should use either this book or Thomas Parsons'.



3. This book is quite dense and requires some serious work to be understood properly. It is quite complete even if it is a bit old compared with the latest twists in compiler theory. It is a mix between theory and pratical implementation. This is its main strength and its main weakness: it is not a comprehensive theorical work on compilers neither a complete "pratical" tutorial. Anyway it is a good introduction for the (college-level) student who is willing to do some serious work.

2 comments about The Elements of C++ Style (Sigs Reference Library).

1. This book is too small to be used as a physical weapon in the "style wars." Nevertheless, it is large in terms of content. Nearly all of the areas of style differences and disputes are covered. The authors do a good job in presenting their solutions to style difference problems without resorting to evangelical techniques. They express their opinions, justify them and then move on to the next style issue. Small segments of code, demonstrating both the right and wrong ways, are used to illustrate the point.
   The issues are placed into several groups:

   * General principles.
   * Formatting conventions.
   * Naming conventions.
   * Programming principles.
   * Programming conventions.
   * Packaging conventions.

   The 175 style issues are summarized into a set of short rules at the end of the book, which makes it easier to find specific elements.
   This book is not a bible, setting down the commandments for the proper style to be used in creating C++ code. It is a set of suggestions, and if you read it with that in mind, you will find this book of value.




2. Packed into a deceptively-diminutive size paperback package is an essential programmer's guide which should be a reference bible for all C++ programmers: a survey of the basic elements of formatting, naming, documentation and programming which provides a foundation of rules for writing in C++. Organized by programming conventions and principles, Elements Of C++ Style is invaluable for the programmer who would produce consistent, accurate documentation.

5 comments about An Introduction to Design Patterns in C++ with Qt 4 (Bruce Perens' Open Source Series).

1. I am extremely impressed by this book - not only does it provide excellent information on design patterns, and using Qt 4, but its written so that those new to C++ and Qt can understand and progress throughout. This book is heft, but extremely informative, and I would recommend it to anyone interested in C++ development!



2. If Qt is what you are interested in, go to trolltechs website or another online resource and don't waste you money on this book. The book is not very well laid out, the exercises are ambiguous and you have to work on the example code to get them to work. Although a lot of material is covered, the coverage of certain topics is barely adequate, although they do supply information on where you can get additional information.



3. The book is an easy read and has good examples, but unless you already know how to use Xcode or have KDE on your Mac this book is not for you, because you will find that the build instructions found in the book do not work in Mac OS X. Has anyone tested them on Unix or with KDE? I can only assume that they work there.
   
   Qt4 is not compatible with Xcode. (It is not possible to display Qt4 Objects like QString in the Xcode debugger. This used to work with Qt3, but was lost in Qt4.) While this is not the book's fault, it makes it very difficult to step through the examples or debug your own coding efforts in the exercises.
   
   I like the way the book introduces topics a chapter or two before going into detail. Also, the book makes an effort to reinforce what was learned in previous sections and chapters, making it a very good learning tool for anyone new to the topic.



4. This is a very good good which teaches you C++, Qt and design patterns.
   
   I am surprised by the commentaries saying this is not an introductory book. Quite the opposite: this is the perfect book if you do not know any one of Qt, C++ or design patterns but you want to use them together.
   
   Some may say the book worries too much about syntax. Wrong. The authors want to make sure you understand C++ perfectly well because subtle differences (such as the 'static in declaration' vs 'static in definition', introduced in chapter 2) may have devastating effects in your software. The same goes for Qt macros: the book explains them because when you know and understand them, you will write better code; the book by Blanchette and Summerfield barely names them.
   
   As the title says, this book is only an introduction. There are three natural companions you should get if you want to delve deeper in the wonderful world of Qt and design patterns:
   * A Complete Guide to Programming in C++ by Prinz and Prinz
   * C++ GUI programming with Qt by Blanchette and Summerfield
   * Design Patterns: Elements of Reusable Object-Oriented Software by Gamma et al.



5. I don't major in CS but I have to use C++ and QT for my PhD research. Although I had pretty good general understanding of IT and some experience in web programming, I struggled to teach myself C++ from scratch. I tried a few popular books, but none of them worked very well. As someone said, "the trouble with C++ is there's an awful lot to remember". Those big thick books are often quite easy to follow from page to page, but very quickly all the details become overwhelming. C++ is a powerful and flexible language that incorporates different paradigms so there're always many different ways of doing things but quite often (particularly for beginners) we only need to know the best practices. As Bjarne suggests: "A focus on details can be very distracting and lead to poor use of the language. You wouldn't try to learn a foreign language from a dictionary and grammar, would you?" (http://www.research.att.com/~bs/learn.html). Ironically, most of the big books I read did exactly the same for me. They all tend to provide too many details upfront. You could end up reading 500 pages but still don't have a clue what's the correct way of programming in C++. Plus you'll probably forget what read before...
   
   
   
   I felt a great relief when I came across this book. I would say the authors have done a marvellous job. From the very beginning they teach you how to program in the C++ way, more precisely in the Qt way. The book suggests Qt coding style is not "pure" C++ but that's a different story. By throwing away all the irrelevant bits, they give you a good idea of the whole picture so that you'll be on the right track very quickly. Then you can let you knowledge grow by accumulating more technical details - it's just a matter of time and practice. Of course, a big thick book is still needed as reference. If you don't know anything about programming, I would suggest you read the first few chapters of one of the primers, then switched to this book. I feel it still requires some basic programming background.
   
   
   
   I would definitely give it a five star and recommend to anyone learning Qt

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.

5 comments about Object Oriented Programming in C++.

1. I am an engineer (not a computer scientist), and my primary computer language is Visual Basic. I have written a good amount of code and I appreciate VB technology very much. (The fact is that this technology works good and cheap enough in wide scope of practical needs).
   I wanted to extend my knowledge in computer programming languages and I began to study C++ computer language. At some point I discovered about the existence of the Standard C++ and I understood that, in my case, the right approach must be studying exactly the Standard C++. Finally I did find my personnel "Entry Point" within Nicolai's very nice book! While I often refer to other books as well, I do use the "Object Oriented Programming in C++" as main base point.
   The Author demonstrated:
   1. Deep understanding of the subject.
   2. Strong defending of the idea of the Standard C++.
   3. Carefully marking the commons and differences between C++ and C programming languages.
   4. Great attention to the detail.
   5. Clear explanations of the definitions.
   6. Perfect cross references.
   7. Generous sharing with the reader.
   8. Excellent style!
   Thanks a lot for the excellent job!
   The Publisher did a good job as well. The book is easy to read and follow. Thanks!



2. In my point of view, this book is one if not the best book I have ever read so far in C++. The author knew exactly what the reader needs to know and presented them in a clear and concise manner. It has very well written & easy to read C++ code samples. For a beginner to intermediate in C++, I think this book is for you as it walks you through a step by step approach to learning C++. The knowledge you would learn at the end of reading will make you feel better and comfortable in using C++. There are books out there that I've found boring if not too advanced at my level, I wish this influence you not to put yourself into that experience.

   Thanks Nicolai for putting this together, a wonderful book that will surely help many people that are interested to learn C++.




3. THIS IS A GOOD C++ BOOK BUT THE AUTHOR DOES NOT RESPOND TO E-MAILS AND THE BOOK SELLS FOR $55.00 RETAIL, BUT PRICED HERE AT $60.00.



4. This is a quite good book for professional programmers who are new to c++. Especially for designers and architects. In other words, without the knowledge described in this book, you can never design professional quality software written in C++. Also good for those who want to graduate from 'C++ as better C'.



5. Nicolai clearly knows his material very well, yet is able to talk at a comprehensible level. He doesn't dwell on the basics (what is a loop?), and on the other hand, doesn't get into all the arcane features of C++. I think it is a good book for anyone who already knows some programming (not necessarily C or C++), but is still enjoyable and informative for people familiar with C++.
   
   Most examples are complete, concise programs demonstrating the concept. Code is well written and commented. He first gives the file listing, then dissects each new piece to explain what it does and why. Common errors and subtleties are explained. Often he shows several alternative ways of implementing a feature, and explains the pros and cons of each. For instance, implementing an operator first as a member function and then as a global function.
   
   Where a feature may be better implemented with topics covered later, or is covered in more depth later, a page reference is provided. For example, input is first covered with rudimentary error handling, with a forward page reference to the version with improved error handling available using exceptions.
   
   Some of the design rationale behind C++ and the standard library is also given, such as why the std::stack pop() function doesn't return the top element, for exception safety. This helps the reader appreciate the inherent difficulties and to incorporate similar solutions into their own code.
   
   He covers the standard library (STL) and templates in enough detail to be useful, but really a separate reference on these topics is required. In this respect, his C++ Templates book is an excellent companion. (I expect his book The C++ Standard Library to be useful, but can't yet say from experience.)

5 comments about Data Structures: A Pseudocode Approach with C, Second Edition.

1. I had to buy this book for a computer science course. Thankfully I got a refund on it when I tested out of the course two weeks later. For those who are forced to learn the contents of this book, here is what to expect, as I read the entire book.

   Since I was already very familiar with most concepts ( ie. actually programmed them ), I have to say that no book has made me more confused or angry than this one. Ideas that are simple are obscured with inappropriate examples / wordings, so I actually had to read many paragraphs TWICE, to get the point of the author. Even the pictures are far from refined, and the presentation is quite amateur. There were several times I just wanted to throw the book at the wall in disgust.

   As a first (and unbelievable) example, from page 2 you are given the "Commandments" of good Pseudocode. One such rule is never to use identifiers such as 'i' or 'j', as they should instead be given an 'english' name such as 'student'. On page 6, we have the first code example, where they proceed to use 'i' and 'j' within the code. Then they explain that, oh yes, 'i' and 'j' is actually a loop tradition in C++! So we're already confused! By page 6. Now, the beautiful thing is that you can read this for yourself right now, with Amazon's page excerpts. This sets the level of presentation for the rest of the book.

   My apologies to those who may like this book, but please take time to explore other books before this one. Programming is far easier than is explained in this book. At this level of programming development, a bad experience can be most discouraging. And this book is very, very bad.




2. In order to understand the book, one must understand the author. Gilberg is the type of professor that concerns himself more with flowcharts and whether students staple assignments properly. The book was originally riddled with algorithmic mistakes that were not obvious because, guess what? You cannot compile pseudo-code.

   The author seems to come from the school of thought that places importance on theory over practice. Is it no surprise that the C++ portions (from the helper site) are no more than converted C code with couts? In today's market, you have to write code, not pseudo-code. You have to compete in a global market. This fossilized notion of pseudo-code not only hides the fact that possibly the lazy professors couldn't write code to save their lives, but also is a disservice to students who WANT to not only learn data structures in the context of MODERN engineering practices, but also want to know how to IMPLEMENT data structures - be it C++, C#, Java - as well.

   I'll wrap up with a final word for students and professors:
   - Professors: Please don't torture your students with this book.
   - Students: If your professor uses this book... Run!!




3. Another book killed my interest on computer programming.



4. I am an instructor and I have used this book for the data structure course based on the recommendation of the department. After a few weeks I decided to replace it by Horowitz's "Fundamentals of Data structures in C". Really Gilberg's book is too bad. It make the subject too complicated. For example, it explains "stack" in 60+ pages long chapter! Really it gives the reader the impression that stack is a complex subject. In a nutshell, avoid this book! Go for Horowitz's book. It is more concise and easier to read.



5. This book is great and I don't know why so many people rated it negatively. I don't know if it's the best in data struct books because I haven't read all of them, but it's surely one of the top ones. Text is clearly written, very understanding step-by-step explanations accompanied with illustrations, diagrams, graphs, and charts. You don't need an instructor with this book, in fact, this is how I'm learning data struct now--on my own! Projects and excersises are very interesting and relevant to material studied in the chapter. I strongly recommend this book! :)

1 comments about C and UNIX: Tools for Software Design.

1. I just completed a college course titled "Introduction to the C language and Unix". Our instructor used this book, and I found that, as a beginner, I had a very hard time following the concepts. I constantly had to turn to "The Waite Group's - C Primer Plus" for detailed explanations. And it only provides just a short sampling of the Unix environment. If you have used the C language and Unix, and are somewhat comfortable with it, this book will probably serve you well. If you have never used C or Unix, look elsewhere!