Reviews (9)

C# No, C++ Yes
The difficult thing about this book for me is that I do hope that I can avoid C# all of my life and C# and C++ are given about equal time throughout this book.As the author points out on page 561, "C# is a wonderful language, but it often leaves you wondering if you can do more, and when you discover that you have reached the limits of the language, you realize it is time to get back to C++."Haven't we had enough of Visual Basic, and Java?Now C#?Why not C++?Why do we have to wade through explanations for both C# and C++ on every subject.If we spent as much time on a real language like C++ as we have spent over the years becoming multilingual we could be C++ masters.I always remember that, other things being equal, faster is better.And I have never seen any other language except Assembler come close to the speed of execution of C and C++.This book would be better if it were two different books - one addressing C++ only and one addressing any other would-be language.

In the Summary of Chapter 7, Mr. Grimes states that "All in all, C++ is the language for .NET development, and I hope that you, like me, will recover from a brief flirtation with other .NET languages and return to the best language for the job: C++."

In Chapter 8, Application Development, Mr. Grimes elects to disregard his own advice and gives every single example in C#. How quickly hope for a return to sanity was dashed!

Disappointing
I'm a big fan of both the DevelopMentor series (from Addison Wesley) and Richard Grimes' previous books, so I was very anxious to read this book. It was all the more disappointing, then, that I didn't particularly like it.

Mr. Grimes' previous books were very straight-forward and task-oriented. I'm constantly lending my copies to other programmer's to reference how to implement something in C++/COM. This book is not task-oriented (not that there's anything wrong with that). However, it didn't really work for me as a theory-oriented book either. Often, it seems to dive down into obscure detail on some feature that I didn't feel had been adaquately introduced. I would have preferred shedding some detail on some of the more obscure topics in favor of more complete examples.

I managed to make myself read the first 500 pages or so (always thinking that things would become better in the next chapter), but it was like pulling teeth. Finally, I set it aside and moved onto a different book (the excellent "Essential ADO.Net").

Editorial Review

Windows XP Secrets does a fine job of documenting the latest Microsoft operating system, largely because its author assumes that you already know a fair bit about Windows from experience. He seems to figure that you're interested in the features that are new in Windows XP, and also in getting it to look and behave the way you want. As a result, this book combines documentation of the new features with some pretty cool hints--a lot of which you likely would not have found on your own, or bothered to hunt for on the Internet--about the appearance and function of Windows XP. You may gripe a bit about the amount of straight documentation Curt Simmons has included--he explains such pedestrian matters as adding a modem and creating a Windows Media Player playlist--but the obscure hints appear in sufficient number to earn the book its selling price.

Particularly cool is Simmons's affinity for third-party software--especially Tweaki and TweakUI--and the depth of coverage he's given the Registry. He's also earned kudos for paying attention to the command line, which remains the best way to do a lot of work, even in super-graphical Windows XP. This book would be better if it included a table that referred the reader directly to the scattered "SECRET" boxes--which contain a lot of the best factoids. But even without such an index this volume is a good guide to Windows XP for power users. --David Wall

Reviews (28)

Mr. Rosenthal Scores Again
With easy to follow photographs, Morris Rosenthal demystifies the PC building experience,providing the hobbyist or experienced technician with an easy to follow approach to building a PC from a barebones case to complex gaming systems.

Discussed are component purchasing, defining what type of system is best for certain applications,and advice on avoiding damage (repeated frquently)

In the back are handy troubleshooting guides.

Another excellent resource.

Great but I want more.
You can't save any money building your own PC. In fact, you'll probably spend more than going down to WalMart or CostCo. But when you build your own, you know what you're getting.

I want a system with a lot of disk performance and memory to do the jobs I ask of it. The only video I need is enough to get the operating system to load, and I usually don't even connect speakers. A heavy duty gamer needs lots more video power, and may want a sophisticated sound card as well. The WalMart/CostCo systems are designed to fit everybody, so they really fit only Mr. Average.

The first thing I did when I got this new 4th Edition was turn to the chapter on building a system using the Athlon 64. Mr. rosenthal was right on the money. He ordered a cheap case, and then immediately replaced the cheap power supply with something heavier duty. He then used an Asus motherboard, again first rate, although (I think) more expensive than some others just as good but with a less valuable name.

One minor complaint - I'd like to see some recommendations on brand names. What brand of Power Supply did he use - why? What about a reference list for mainboards, or a web site that would give recommendations? And while I'd hate to see him create a firestorm, how about an Intel/AMD comparison.

Finally we need another addition. How do you build a dual processor Opteron? I can't afford one, but I'd like to dream. And of course there will need to be a sixth edition with the new dual processor cores that are coming.

Reviews (25)

I found MSDN more useful than this book
Whenever I need help with STL, I open this book only to find that it has nothing useful on it. For those who have MSDN don't bother to buy this book.

Good for Beginners and Intermediate Users
As an advanced programmer, I must say that I'm disappointed that the level of information provided is not as deep and meticulous as I had hoped.

Additionally, both the index and the overall organization of the book leave much to be desired.

The book, however, is a valuable reference for beginning and intermediate programmers.It explains the STL (Standard Template Library) from the ground up, explaining when, where, and why you would use any particular aspect of the STL, how to use the STL, and sufficient examples to understand correct syntax.This book also contains a detailed section of applying the STL to real-life programming examples. Furthermore, the book also contains a comprehensive reference guide for quick and easy access to pertinent information about STL aspects you frequently use and modestly comprehend.

If you are a beginning or intermediate programmer, this book is worth adding to your collection.

Tutorial and Reference Worth Having
This volume is a much improved version of the original of the same title. An additional author has come aboard. The major improvements I noticed were in the examples.There are many more examples and many more STL features now have examples showing how you can use them.

The tutorial aspect of this book, which comprises the first part of the book, makes a strong case for not re-inventing the wheel, but rather using the containers, iterators and algorithms in the standard library. Practical examples come right from the start. This may take some getting used to by those who have never seen STL used before, however, the excitement is tonic.

Also, the approach, of showing STL use before getting into the theories of iterator-based access, has been adopted in several subsequent C++ texts by teachers of C++ and has been found pedagogically sound.

Don't overlook the precision and clarity of the (English) language discussion of the STL in the tutorial.It's worth reading every so often as a refresher.

And the value of the reference section, which is easy to navigate and has everything in it that most other books dealing with STL don't is great indeed.

Editorial Review

Programmers are craftspeople trained to use a certain set of tools (editors, object managers, version trackers) to generate a certain kind of product (programs) that will operate in some environment (operating systems on hardware assemblies). Like any other craft, computer programming has spawned a body of wisdom, most of which isn't taught at universities or in certification classes. Most programmers arrive at the so-called tricks of the trade over time, through independent experimentation. In The Pragmatic Programmer, Andrew Hunt and David Thomas codify many of the truths they've discovered during their respective careers as designers of software and writers of code.

Some of the authors' nuggets of pragmatism are concrete, and the path to their implementation is clear. They advise readers to learn one text editor, for example, and use it for everything. They also recommend the use of version-tracking software for even the smallest projects, and promote the merits of learning regular expression syntax and a text-manipulation language. Other (perhaps more valuable) advice is more light-hearted. In the debugging section, it is noted that, "if you see hoof prints think horses, not zebras." That is, suspect everything, but start looking for problems in the most obvious places. There are recommendations for making estimates of time and expense, and for integrating testing into the development process. You'll want a copy of The Pragmatic Programmer for two reasons: it displays your own accumulated wisdom more cleanly than you ever bothered to state it, and it introduces you to methods of work that you may not yet have considered. Working programmers will enjoy this book. --David Wall

Editorial Review

Coauthored by Brian Kernighan, one of the pioneers of the C programming language, The Practice of Programming is a manual of good programming style that will help any C/C++ or Java developer create faster, more maintainable code.

Early sections look at some of the pitfalls of C/C++, with numerous real-world excerpts of confusing or incorrect code. The authors offer many tips and solutions, including a guide for variable names and commenting styles. Next, they cover algorithms, such as binary and quick sorting. Here, the authors show how to take advantage of the built-in functions in standard C/C++. When it comes to data structures, such as arrays, linked lists, and trees, the authors compare the options available to C, C++, Java, and even Perl developers with a random-text-generation program (using a sophisticated Markov chain algorithm) written for each language.

Subsequent sections cover debugging tips (including how to isolate errors with debugging statements) and testing strategies (both white-box and black-box testing) for verifying the correctness of code. Final sections offer tips on creating more portable C/C++ code, with the last chapter suggesting that programmers can take advantage of interpreters (and regular expressions) to gain better control over their code. A handy appendix summarizes the dozens of tips offered throughout the book.

Reviews (13)

I did not find those books ...
Strict Evaluation (Seattle, WA USA) recomends two books: Fowler's book and the two-volume work by Hueberhuber.
Searching amazon site, I found 5658 Fowler's books and no Hueberhuber book. Please, provide at least the author name AND the book title.

It's an OK book but no more than that and here's why:
The problem with this book, in my view, is that it attempts to cover two separate grounds in one shot and consequently fails to do justice to either.

The C++ part of the book (the book is mostly about C++, make no mistake about it -- it is a C++ tutorial of sorts) is insufficiently extensive, deep, it's too cursory, I feel. Even though I do not particularly cherish BS's TCPL as a tutorial, I would still recommend it over Yang's book. As a C++ programmer you have to have TCPL anyway... (I'm sure there are other good C++ tutorials now, I'm simply not current here anymore so I mention TCPL because it's famous and everyone will know what I'm talking about.)

As far as numeric programming, there's so little and I would say, accidental (selection of topics) in this book that it is definitely insufficient to give a good grounding in the area. I looked at this book when I was searching for something on numerical computing, and I found it inadequate in that department.

If you need to learn C++, get a book that teaches C++ and nothing more; it's important to work through a careful, understandable, unhurried tutorial -- with many examples, covering everything; a book like that is bound to be sizeable even w/o anything numeric in it. And when you're ready to learn numeric programming, get *another* book, something that deals exclusively with "numericity".A few good options come to mind: Fowler's book is based on C++ as well, but assumes that the reader already knows it and doesn't need handholding; it is all about numerical calculations and it does achieve its goal (in the C++ context). This book is very practical, a lot of code in there. Otoh, if you have time, you may want to get something even more fundamental, something on numerical analysis (which is bound to be more mathematical with less programming in it); there are tons of books like that; I think the two-volume work by Hueberhuber (Springer, if I'm not mistaken) is very good, and still not terribly academic.

In other words, I like to approach different things separately: when learning C++, concentrate on C++; when getting into numerics, stick with numerics for a while w/o distraction; do one thing at a time and use the best and most appropriate to the task and personal taste materials you can find. Trying to save effort by mixing all things together will backfire -- due both to the likely mental confusion, AND having to use textbooks of a lower quality. Remember the story of a Zen teacher who told that studying with him takes seven years, and when an impatient student asked how long it will take if he works REAL hard and studies day and night, replied: then 14 years.

At the same time, I can't say the book is bad; I think it's well written; the problem, in my view, has more to do with its intent, conceptual design, than the actual exposition or correctness; perhaps it's good to have it in addition to other books... though if you have, say, TCPL *and* a good text on numerics, I can't see why you'd need to.

Editorial Review

Aimed at advanced C++ developers who want to hone their programming chops even further, Herb Sutter's More Exceptional C++ borrows the format of his earlier title, Exceptional C++, and delivers some of today's best-available thinking on the language in a handy and effective format. A compilation of the author's own experience and research on the thornier aspects of C++, this book will serve as a worthy resource for making sure you get the most out of this powerful language.

The concise text covers a range of challenging topics in C++ without attempting to be comprehensive. Each "item" is presented as a question to try and solve yourself before the author presents his solution, plus additional detail as needed. For most topics, Sutter ends by giving his advice on the best practices (and gotchas to avoid).

Early sections concentrate on using Standard Template Library (STL) container classes, like removing items effectively, and the subtle differences between container types. Standout sections on designing custom templates (using specialization techniques) and exception-safe classes will help you do more with your own classes. One entertaining problem here shows a number-guessing game (Mastermind) built as efficiently as possible using STL code (including expert-level use of generic functions to do much of the work).

Several problems on copy-on-write (COW) semantics for more efficient classes point out the issues surrounding code optimization. (The author argues against a simplistic approach to optimizing code, including an overreliance on inlining functions. Several times he points out the difficulty of getting COW code to work in multithreaded projects.)

There has been a debate in the C++ community for years about whether it's possible to design truly "exception-safe" classes. Sutter points out the difficulty with a precise analysis of the issues surrounding exceptions and C++ constructors. Material on the finer points of inheriting classes (including when to avoid and when to use multiple inheritance in C++) will extend your class design options. A good section here is the author's explication of how to simulate COM/Java style interfaces in C++, which isn't immediately obvious, even to experienced C++ developers.

Later sections delve into code maintenance issues, including advice for using macros, typedefs, and namespaces. (Advice on migrating existing C++ code into namespaces will help you combine legacy code with other libraries.) A final appendix shows off some benchmarks for optimizing strings using a variety of techniques.

Intelligent, provocative, and demanding, More Exceptional C++ shows why C++ continues to be a rich, complex, and challenging language. Armed with titles like this one, experienced C++ programmers can write better code and avoid pitfalls buried in the outer edges of their favorite language. --Richard Dragan

Editorial Review

Fourteen years after it was first issued, C++ expert Jon Bentley reinvents a true classic with the second edition of his Programming Pearls. Completely revised and brought up to date with all new code examples in C and C++, this book remains an exceptional tutorial for learning to think like a programmer.

The "pearls" in question center not only on choosing the right algorithms (like binary searches, sorting techniques, or sparse arrays) but also on showing how to solve problems effectively. Each chapter frames a particular programming task--such as sorting numbers, creating anagrams, or counting the words in a block of text--many drawn from Bentley's experiences in his long career as a developer. The book traces the process of arriving at a fast, efficient, and accurate solution, along with code profiling to discover what works best. After refining the correct answer, each chapter enumerates programming principles that you can use on your own.

The author also challenges you to think like an engineer, and each chapter ends with about a dozen problems to get you thinking creatively about design issues. (Sidebars on such historical topics as the first computer solutions to computer chess, spell-checking, and even architectural design help create a perspective on successful problem solving and make for a truly educational and enjoyable tour of how to become a better programmer.) Bentley also asks the reader to think analytically about the world with "back of the envelope" estimation techniques drawn from engineering. Appendices list the algorithms and code rules covered in the book, plus some sample solutions.

Fans of the first edition of this title will be pleased to see this favorite computer text brought up to date for today's faster hardware. Whether you want to improve your command of algorithms or test your problem-solving skills, the new version of Programming Pearl is a challenging, instructive, and thoroughly entertaining resource. --Richard Dragan

Reviews (27)

Poorly Written, No Answers to Exercises, Avoid purchase.
Another drab computer science book written by someone who likes to complicate the obvious and oversimplify the complicated.
It is obviously geared toward dry mathematical types, and if you're one of those it might possibly be partially stimulating. The mathematical notation is unfortunately quite poor, many letters (which seem to represent constants and sometimes variables?) are ambiguously defined. Not to mention how half assed the "proofs" are.My linear algebra and differential equations teacher would roll over in her proverbial grave.

The code examples are halfway decent, however using one letter variable names is something a beginner quickly learns to stop doing.Why does this guy do it?
The one thing that I like is his use of line up curley braces.
Requiring readers to visit some website to obtain portions of missing code defeats the purpose of writing a book.
Why don't I just read a bunch of webpages instead of buying this flavorless thing.Code "snipits" are another big mistake, they're only understood if their context is explained well, which this shabby author cannot do. He seems to assume we have some clairvoyant abilities.A hint of color might at least keep me awake, but I guess that would have required putting some thought into the book's layout.

The hash table chapter is a wonderful example of how this author is a detached weirdo who can't put himself in the place of his readers. Saying "in the above example" in reference to an example that was FOUR pages ago is thoroughly idiotic and unnecessarily confusing. Several "examples" appeared after the one he referred to. Naming the page number would only take a few more letters i.e. "in the above example(p.54)"
And saying "using the same hash function" after showing us 3 different hash functions has the same perplexing effect.How about "again using h(x) = x%10," it would use less ink and make more sense.

The true reason I hate this book though, is that its exercises have no answers, not even to the odd questions or just some selected questions.Nothing.
Thus, the exercises are completely useless.
In order to prepare for my exam I've had to check out other books because this one doesn't cut it.I even found a much older edition of this book and by its similarity it's clear he's just recycling it for financial gain. Again Exercises and no solutions. How do I know if I'm doing them correctly?! As with physical exercise, exerting yourself the wrong way can be quite detrimental!
This author needs to take a communication 101 class or read some of Deitel & Deitel's books.Avoid purchasing this book unless you have to!

Read description: for ADVANCED data structures course
Many people on here have complained that this book goes way over the head of students not already familiar with some C++ and data structures. To these comments, I refer you to the product description (or editorial review, whichever) that specifically says this is an advanced text. I apologize to those whose professors ordered this book for intro data structures--I can understand why this book would go past the scope of that class. However, if you know any Object Oriented programming (Java or C++ preferably) and know some basic algorithms and structures (matrices, sorts, recursion, trees, queues, etc.) this book will take you far. I don't even mean that you must be proficient in these structures, just have some basic understanding of how they work. For example, you should know what a tree is (root, leaves, implemented with pointers and nodes) and book will tell you how to use trees (B-Trees, Binary trees, etc.). By the point you are using this book, hopefully you'll have taken the math and programming classes needed to comprehend this text. Otherwise, do not blame the text for being targeted to an advanced audience.

Reviews (14)

Good for professors, bad for students
All of the practical algorithms are left as un-answered exercises!Great in depth discussion of introductory algorithms, but very few examples, mostly pseudo-code.

INFURIATING FOR INDEPENDENT STUDY, but good if you have a professor to explain everything as you go.

Knowledge is Power and Painful, too
Well, I have to admit I did not expect much from this book.But to my overly pleasant surprise, I found this volume quite useful both as a resource for algorhythms and data processing...Forget the Bible, this is the only book one truly needs.And it's fun to say "Java."Amen.

somewhat useless
This book is next to useless, because of its superficial approach to almost any topic it covers.You would be hard-pressed to find a single data structure, clearly presented and explained conceptually and with examples.Many times the author would skip on the concept and would attempt to explain to you something, from the start based on examples, which would be represented by the start point and the end point with no explanation in between.

I would understand if the author would omit some topics based on the premise that students should already know them, but instead he chooses to contain everything( and as a result contain nothing in particular).

Reviews (5)

fantastic!
I used the source code in this book when I implemented buddy system in my OS.
Bruno's code is very effective and the design is excellent too.
I've learned a lot of things in this book.
So, I'd like to recommend this book absolutely!

A perfect book for starters in Data Structures using C++
This is a great book for one who has had a formal study of undergraduate Calculus/Algebra and a very good understanding of the C++ language. The book starts off with explaining the fundamentals that will be applied to measure the effectiveness of a piece of code, and is very helpful for those who wants to understand the basic theory applied in the later chapters. This books treats almost all the basic data structures and have been presented in a very simple non-profounding way, like keeping the class design and hiearchy the same throughout. All the data structures have been explained using the (easy to use) arrays as well as link-lists. This makes it easier for a novice to grasp the fundamentals and go on to implement more complex and effective data structures using link lists. Overall, I found this book extremely helpful in getting a sound footing on this topic.

Data Structures and Algorithms for Math Students
Believe the summary...this book is for 2nd and 3rd year post-secondary students.I am an experienced C++ programmer, but Grade 12 math isn't enough to cut through the explanations to get to the code, which I can understand perfectly well.

Who should buy this book?Students with a good grasp of basic calculus, who want a thoroughly academic treatment of algorithms in C++ in order to pass Computer Science.

Who should not?A C++ programmer that wants clear, effectively presented information on implementing standard algorithms and data structures in order to get their project done.

I'm of the Keep It Simple school of thought, and the practical theory and implementations in this book could have been presented much more effectively without the adademic bafflegab.

Isbn: 020172684X
Sales Rank: 52998
Subjects:  1. Computer Bks - Languages / Programming    2. Computer Books: General    3. Computer Science    4. Computers    5. Data Modeling & Design    6. Programming - Algorithms    7. Programming Languages - C++   

Reviews (21)

Excellent book with quality content and is easy to read.
This book is very easy to read and understand.Herb presents its content in a useful, directed and thoughtful approach that is representative of his ability to communicate clearly and concisely even difficult concepts.

I use this book primarily as a reference because I'm always questioning something important about the STL that is a lot harded to dig through with other books.If you buy only one book on the STL, be sure that this is it.I've got nearly every other book on the topic, and feel that this one is best for thumbing or reading for C++ developers at all skill levels.

Good examples, bad index
I found this book very useful for its tables that list out the various APIs with quick explanations, as well as the examples it gives.For example, it showed how to create a map of strings with the appropriate compare function.However, the index is paltry and pretty much useless.Too bad, because I'd otherwise recommend it.Consider Addison Wesley's STL Tutorial instead.

Great book
Schildt writes books that help programmers get the job done. I first moved from assembly to C programming with the help of his books in the late 80's, and this book continues to show why he's a best selling author.This is not a reference and it is not an in-depth guide to all of STL programming. STL Programming from the Ground Up is an introduction to STL programming for those who want to start working with the STL quickly.

Reviews (6)

Required reading for all OpenGL programmers
This is a concise, easy to read tutorial and reference for OpenGL programmers.The examples are easy to reuse and short enough that they don't bog you down in irrelevant details.The book is well organized.You can read it cover to cover or just skip right to the topic that you're interested in.

I found the section on the GLU tessellator invaluable.The chapters on viewing and lighting are the easiest to follow discussions of these topics that I've ever read.

Programmers with no previous graphics experience will be able to follow this book and become productive with basic OpenGL operations.

My only complaint is that it's not longer.It gives you enough information to get started and complete most tasks but won't answer your very specific questions.But there's plenty of information elsewhere on more advanced topics.

An Excellent Beginning Reference for OpenGL
When learning computer graphics, theory relies upon some sort of actual rendering environment to make life a lot easier for the programmer.This text helps to alleviate these problems by making the OpenGL architecture available in a structured way.The most positive aspects of the text are its pure devotion to teaching OpenGL as well as its copious, yet succinct examples provided for the presented topics.

The text does not proclaim to be a full text for teaching computer graphics.It claims to be a guide to programming using OpenGL.It completely fulfills that claim.While it does not treat every aspect of OpenGL, the text presents the major topics which are important in writing programs that will render their 3D graphics using OpenGL.It progresses from simple topics through more advanced topics in a seemless way and also is noted in such a way that it functions as an excellent reference when memory alone can not remember syntax for rendering functions.

The code provided with the book provides examples of topics that are presented but do not overwhelm the reader.It is an awful thing to buy a book and have it be predominantly code.Everything presented is succinct, expressing only the newly presented facets of OpenGL.This is grand when one wants to see how a given new topic may be implemented.

It would probably be best to view this text as an ancillary text for learning computer graphics.It is important to remember that the mathematics and algorithms necessary for thorough graphics simulation are of prime importance.However, after the mathematics and algorithms are known, one must know how to perform the operations necessary to render their worlds in the context of a 3D rendering library.This book allows for learning that for the OpenGL rendering architecture.

Editorial Review

The OpenGL Programming Guide, now in its third edition, is the definitive volume for programmers using this evolving graphics interface standard. Written by members of the OpenGL Architecture Review Board, this book offers understandable tutorials and lessons on getting up to speed and getting the most out of the latest version of OpenGL, version 1.2.

The guide uses code examples in C and is targeted at programmers who have experience in coding yet are new to coding for OpenGL applications. The opening chapters go into descriptive detail of how OpenGL, the software interface for hardware 3-D chipsets, works and what you can expect from it, which turns out to be much more than you might have thought. Color plates are used, for example, to show how OpenGL handles such effects as motion blur and depth-of-field blur, in addition to shadows and texture mapping.

This is not a beginner's guide to programming computer graphics. Some previous knowledge of both programming in general and computer graphics in particular is required. For example, code snippets are used to describe how to implement these effects, but because OpenGL is platform-independent, some code examples may need to be modified when used with your specific compiler.

Reviews (4)

Excellent
Almost every article in there is still valid although it was written years a go. The greatest authors on OO programming and C++ edited by the GURU MARTIN, (Uncle Bob).If you consider yourself an OO P/A/D and C++ is of interest to you don't miss this book!! Oh and do yourself a favor get the more C++ gems too...

I Don't Like It
Though I like "Pattern Hatching" in it, I dislike this book.

Definitely not C++ for Dummies
C++ has reached maturity and still doesn't know exactly what it wants to be.This makes C++ both difficult and rewarding.One can approach C++ as a medium for expressing programs, but the richer rewards come when C++ is approached as a medium for expressing design.

C++ Gems is an admirable collection of papers by masters of the art of balancing design against pragmatism.For those who want a comforting guiding voice, Koenig's "Ruminations on C++" is probably a better choice.But for those who want to cut a wide swath over all that C++ offers, at the level where each advance poses as poses as many problems as it solves, C++ Gems is hard to beat.

Reviews (3)

Useful book.
You can read the State Pattern in the famous "Design Patterns" book, but the article in this book, "Finite State Machines: A Model of Behavior in C++" by Immo Huneke, explains why the State Pattern is the way it is.That explanation was missing from the "Patterns" book.Also, Robert Martin's intro to this article was helpful. Mr. Martin mentioned he has a freeware "State Machine Compiler". I downloaded it, and it works! Really cool.This one article alone was worth the price of the book.

Useful implementation (and design) tips.
This book contains a number of very useful columns from the recentlydeceased C++ report. I found particularly useful the articles onimplementation of assignment operators, exception safety, and the innerworkings of the standard library containers (Gillan, Austern, Sutter). Actually,they are all really about exception safety - clues on how towrite robust code that I needed to learn.

The introduction to Lakos'Large Scale Programming tome was also a useful tipoff about physicalarchitecture: I've been using Rational Rose for about 18 months, and nowhave a better overall picture about what the component diagrams are tryingto do apart from represent the receptables my classes get put in.

A ruleone might apply is: if the cost of the book is less than your time spent toremove the errors you'd make if you didn't read it, then buy it. This onepasses the test with ease.

Reviews (4)

Good on its topic
This book is a very nice choice for learning .NET 1.1 programming with C++, provided that you have enough knowledge of the C++ language itself (as always is the case when programming with C++ in some platform).

Alright could of been better
Much like others have said he spent far too much time on areas in which are less important atleast in my eyes

While this book gives you a basic understanding in VC++ I found that it spent far too much time in the commandline
programing (MC++) when you could teach from the start learning doing it via text boxes/lables which would condence alot of the
reading making it less balky.Over 1/3rd of the book was on MC++ commandline programming! This book was also intended for
college courses and answers to the questions are not answered for those of us learning on our own which is a real downside
and made me skip ALOT of the questions at the end of chapters.

This book doesn't get into real detail about data structors which isan important aspect of programming in general which made me disapointed..

As Jody Blau said:
"Also, I found that its style of giving a few pages of code, followed by a few pages of explaining the code, could have been used much more effectively. Often the "explanations" involved simply stating "what" they did and not "why". "
is So true.


All in all I feel this book is alright but I'm sure theres better out there.

Reviews (3)

Clear, with numerous helpful examples
First, I should mention that I got this book in Dec. 2000 and had no trouble installing the disk on Windows98.Hopefully the problem pointed about by another reviewer has been resolved.Incidentally, I find the SOLID server very easy to set up and use, with a simple but friendly user interface.OK, now for the book.It is very clear and includes numerous detailed examples, along with step-by-step discussion as to why the syntax works the way it does.This is particularly helpful when grouping, subqueries, joins, etc., or combinations thereof are involved.Sometimes he'll solve a problem in more than one way, which is good to see.Occasionally, too, like a good teacher he will have a snare for the unwary and go on to say, "Wait, this isn't working the way intended," and use the pitfall as a way of bringing home a point. Another thing I like is the adaptation of Backus-Naur Form that he uses in specifying languages -- if you've never seen BNF before (which included me before reading this book), that may sound a little daunting.Actually, it makes correct usage really clear.One more thing to mention about this book is its excellent range of topics without bogging down on them.In addition to covering the core keywords "select", "from", "where", and so forth, he talks about imbedded SQL (which I rely on heavily when I use VB or work on web pages), stored procedures, and what ODBC is, to mention only a few extra topics.Finally, the translator should be commended for readable, fluent English.

WARNING !!!
The disk supplied with the book (contains the database to work the exercises) will not easily install on Windows NT.I have contacted the author (via e-mail) and the database manufacturer for more installationinstructions but have not yet received any help.Without the informationon the supplied disk the learning process is less than complete.