Learn more Shop now Learn more Shop now Shop now Shop now Shop now Learn More Shop now Shop now Learn more Shop Fire Shop Kindle Learn More Shop now Fitbit
Profile for Thing with a hook > Reviews

Personal Profile

Content by Thing with a hook
Top Reviewer Ranking: 3,147,044
Helpful Votes: 496

Learn more about Your Profile.

Reviews Written by
Thing with a hook

Show:  
Page: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
pixel
C++ Programming Style (APC)
C++ Programming Style (APC)
by Tom Cargill
Edition: Paperback
Price: £35.99

1 of 1 people found the following review helpful
4.0 out of 5 stars dated but successful on its own terms, 22 Feb. 2007
C++ Programming Style still gets regularly mentioned as an important guide to intermediate C++. However, from the perspective of 2007, it's looking long in the tooth.

The book was published in 1992, so the modern reader will notice the old fashioned C++ - no templates (therefore no STL), no exceptions, no strings, old style .h headers. The implementation of the assignment operator relies on a check for self assignment (rather than merely using it as an optimisation), and it uses arrays polymorphically. Readers of Exceptional C++ and Effective C++ will know that these are not recommended practices in modern C++. However, I assume that you aren't going to read this without a good grounding in basic and intermediate C++ and can spot the parts which will require modification.

Fortunately, the book is structured as a series of code reviews, so it stands out from the glut of mini-essay type books, and the general principles of class design that the book propounds remain useful. And even fairly advanced programmers probably won't spot all the problems that Cargill highlights, so you'll definitely learn something.

I'm giving it four stars because is still covers a core of C++ that is relevant and you can pick it up cheaply. But don't expect it to be fully up to date.


Exceptional C++ Style: 40 New Engineering Puzzles, Programming Problems, and Solutions (C++ in Depth)
Exceptional C++ Style: 40 New Engineering Puzzles, Programming Problems, and Solutions (C++ in Depth)
by Herb Sutter
Edition: Paperback
Price: £30.99

7 of 7 people found the following review helpful
4.0 out of 5 stars ever so slightly less exceptional than before, 21 Feb. 2007
I had mixed feelings on this one. On the one hand, this is definitely a good book. You won't find a lot of the material here having filtered out to any other book yet. On the other hand, the actual content itself feels more ephemeral than the previous two installments. Personally, I don't have a problem with that; Sutter's work can be read perfectly well as a way to pick up the general principles of solid C++ engineering from an articulate, reliable expert, you don't need him to be spelling out everyday techniques to get something useful from his writing.

As an example, the items that I found most memorable included his investigation of how compilers failed to adhere to the standard when it comes to template friend function look up, with the surprising result that the normally reliable g++ is the worst offender. Additionally, he demonstrates several ways to call private member functions from outside of a class. I'm certain that fans of the last two books will get a kick out of this stuff, but it's not quite at the same level as his work designing for exception safety.

In addition to the usual question-essay-guideline format, the book has a substantial final section dissecting some failings of publicly-available code, which is where I assume the title of the book comes from. Those with fond memories of Tom Cargill's C++ Programming Style will definitely like this bit.

Despite the fact that the material is arguably slightly thinner than usual, the number of pages is actually up on the previous books. Sutter's writing style has also expanded. However, in a couple of places, the writing could have done with some editing. There are some witty asides and extraneous material that take up just a bit too much space.

Nonetheless, Sutter-nutters will probably not be too disappointed by Exceptional C++ Style. I still really enjoyed this book; reading it was time well spent.


More Exceptional C++: 40 New Engineering Puzzles, Programming Problems, and Solutions: 40 More Engineering Puzzles, Programming Problems, and Solutions (AW C++ in Depth)
More Exceptional C++: 40 New Engineering Puzzles, Programming Problems, and Solutions: 40 More Engineering Puzzles, Programming Problems, and Solutions (AW C++ in Depth)
by Herb Sutter
Edition: Paperback
Price: £30.99

1 of 1 people found the following review helpful
5.0 out of 5 stars more excellence from Sutter, 21 Feb. 2007
If you liked its predecessor, you would do well to snap up this one, too. It's more of the same good stuff, in the same format: Sutter poses a question or series of questions, some of which are fairly general and some of which challenge you to spot mistakes in some code, and then uses it as a springboard to outline some best practices. There is more on exceptions, memory management, inheritance and polymorphism. You'll also discover several ways to get a stack trace and how to write a traits class.

There's also slightly more advanced material on smart pointer members and copy-on-write implementations of strings, which is pretty extensive, particularly with regard to its problems with threading.

This is not a reference book or the sort of volume you'd reach for to solve a specific problem. And Sutter's influence in the field means there's not a huge amount of fundamental stuff that hasn't diffused throughout the C++ literature since this book's publication, but reading the Exceptional C++ series is one of those things you just have to do if you want to call yourself a C++ programmer and there are few better ways to learn The C++ Way than quality time spent with More Exceptional C++.


Exceptional C++
Exceptional C++
by Herb Sutter
Edition: Paperback
Price: £38.70

10 of 11 people found the following review helpful
5.0 out of 5 stars Must-read intermediate C++ book, 21 Feb. 2007
This review is from: Exceptional C++ (Paperback)
There seems to be a bit of confusion about what level this book is at. Based on some of the reviews I've read, I was a bit concerned that much of this book would fly right over my head, exploring advanced and obscure features. So let's get one thing straight: this is pitched at the same level as Effective C++, and has a similar structure and style.

And it's not just a 'puzzle' book - although it does highlight some tricky issues to do with templates and name lookup, which might conceivably appear in an unimaginative job interview.

And it's not just about the language feature of exceptions. All aspects of the language are covered, but the section on exceptions is particularly good.

Nor is it 'advanced' in the sense that many practitioners of C++ would consider, e.g. template metaprogramming, or non-portable hacks that take advantage of memory layout of compilers. Instead this is advice at an intermediate level, assuming you know the syntax and purpose of C++, but exploring their most appropriate use.

The structure of the book does involve a series of posed questions, but they differ wildly in how specific or general they are. You can see them more as a rhetorical device to frame the subsequent discussion, rather than questions you must answer (unless you want to retrospectively crown yourself guru of the week, of course).

Each question is followed by a significant discussion of a particular language feature, and summarised advice and recommended principles. Therefore the book is similar in structure to Effective C++. There is some overlap between the books, although even where similar material is included, there is differences in how much detail is given.

To some extent, this book is a victim of its own success. A lot of the advice given here can now be found in other books. But its legendary status mean that like Effective C++, this is still essential reading as soon as you've graduated from introductory tomes.
Comment Comment (1) | Permalink | Most recent comment: Oct 20, 2011 1:50 PM BST


Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library: 50 Specific Ways to Improve the Use of the Standard Template Library (Professional Computing)
Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library: 50 Specific Ways to Improve the Use of the Standard Template Library (Professional Computing)
by Scott Meyers
Edition: Paperback
Price: £43.99

2 of 2 people found the following review helpful
5.0 out of 5 stars Does for the STL what Effective C++ did for the rest of C++, 21 Feb. 2007
The man Meyers has worked his magic on the STL. If you've read Effective C++, then you know what to expect, and should invest accordingly. Meyers is on top of his game, finding the right balance of sage advice and dry wit as he guides you through the complexities of the STL. If you haven't read Effective C++, you really ought to before reading this one.

A wide range of advice is dispensed, including: advice on what containers to use, range member functions, avoiding loops, erase-remove, auto_ptr, associative containers, equality vs equivalence, gotchas like const keys in sets and maps and references to reference problems, efficiency in sorting, searching and inserting, iterators, functors and adapting them.

Phew. A lot of ground is covered. You will want to be familiar with the structure of the STL, I don't recommend learning the STL from scratch from this book, and you may want a good STL reference. But those aren't half as much fun to read as Scott Meyers.


More Effective C++: 35 New Ways to Improve Your Programs and Designs (Professional Computing)
More Effective C++: 35 New Ways to Improve Your Programs and Designs (Professional Computing)
by Scott Meyers
Edition: Paperback
Price: £23.24

6 of 6 people found the following review helpful
4.0 out of 5 stars Good, but not as good as its predecessor, 21 Feb. 2007
A sequel to Effective C++. Unlike the prequel, which got a third edition in 2005, this has only been updated via the addition of footnotes in a few places (my copy is the 22nd printing from 2006), so some of it feels a bit dated: the items on templates and keywords such as explicit and mutable are somewhat rudimentary.

The material is a mixture of items of a similar level to Effective C++, plus some more advanced topics, like how to find out if your object is allocated on the heap or not, how to prevent an object being allocated on the heap, and the mechanics of the object model, about which C++ users (or the authors of C++ books) seem inordinately fond, at least compared to Java users and Smalltalkers. As a result, the more advanced material has slightly narrower appeal than that in Effective C++ - many of the techniques seem more hassle than they're worth.

That said, a good deal of the material is still universally important, such as exceptions and the new-style casts, which were new at the time of publication, but which are no longer considered 'advanced'. By now, though, this material is covered elsewhere, e.g. in the likes of C++ Coding Standards and Thinking in C++, or in modified form in the third edition of Effective C++. The last item in the book, on the use of the STL, has been superseded by the author's own book-length excursion, Effective STL.

There's also a slight difference in format. The items are in general longer than those in Effective C++. For some topics, it works very well. For example, there's a great treatment of writing a 'smart' pointer and using it for reference counting that takes up 60 pages. That entirely merits the extended format. On the other hand, in some places, the book could have done with editing. Meyers' witticisms are welcome as always, but are sometimes a little too chatty, compared to Effective C++, where the writing is tauter.

It's still a pleasure to read, and this has established itself as another C++ must read, but from the perspective of 2007, it's not quite as genre-defining as Effective C++.


Effective C++: 55 Specific Ways to Improve Your Programs and Designs (Professional Computing)
Effective C++: 55 Specific Ways to Improve Your Programs and Designs (Professional Computing)
by Scott Meyers
Edition: Paperback
Price: £24.99

21 of 23 people found the following review helpful
5.0 out of 5 stars The legend, 21 Feb. 2007
This is the definitive second C++ book, the one you should read after you've read a good introduction. You need to be familiar with the syntax of C++, then this book will teach you about using C++'s features in a non-trivial way.

C++ is not short on books that provide bite-sized mini-essays on the best way to use some feature of the language, but this is the ne plus ultra. It cuts through the bewildering complexity of C++, providing simple guidelines about what to do and what never to do. For example, you may understand the difference between pointers versus references, const versus non-const. But their various combinations as function parameters and return types may be bewildering. Don't worry - Meyers dispenses his wisdom clearly and efficiently. You'll wonder why it confused you in the first place. Then he repeats the trick another 54 times, taking in all of C++, including some template issues, and finding time to mention TR1 and Boost, too.

Like the GoF Design Patterns book, you need to read this or people will think you're an amateur. Fortunately, Meyers is a witty and pithy writer and his examples are always very well judged. Make this the first book you read after you've finished learning the basics.


The Design and Evolution of C++
The Design and Evolution of C++
by Bjarne Stroustrup
Edition: Paperback
Price: £53.19

3 of 3 people found the following review helpful
4.0 out of 5 stars Not essential, but very interesting, 19 Feb. 2007
In this book, C++ creator Bjarne Stroustrup talks us through the genesis of C++, detailing his design philosophies, the history of the language's development, and the various trade offs that make up C++.

If you're curious about why C++ is how it is, then this is a fine read. Stroustrup writes well and without hyperbole. Along the way, you'll pick up plenty of interesting trivia. Did you know, for instance, that the earliest versions of what became C++ had AOP-style before and after methods, but no-one used them, so Stroustrup removed them? Or that language level support for delegation was once in the offing? You'll also find out why keyword arguments for functions were rejected. Additionally, there's a fascinating (albeit too brief) section on how the behaviour of exceptions came to be specified, with resumable semantics rejected for the termination model we have now.

Due to the year of publication, events encompassing the adoption of the STL is missing. On one hand, that's a bit of a pity. On the other, it keeps the length of this book to a manageable length.

From the title, you probably already know if you want to read this book. Will it reveal amazing new techniques to speed up your C++ programs? No. But if you have any interest at all in language design, this is really accessible and there is no type theory or lambda calculus to wrestle with here. Even a committed C++-hater might come away with a new appreciation for the language, warts and all. Well, maybe not, but they might retire a few a few of their arguments against it.


Thinking in C++: Practical Programming: Practical Programming v. 2
Thinking in C++: Practical Programming: Practical Programming v. 2
by Bruce Eckel
Edition: Paperback
Price: £57.99

1 of 1 people found the following review helpful
5.0 out of 5 stars as essential as the first volume, 19 Feb. 2007
After introducing the core of C++ in volume 1, this books covers the rest, including IO streams, exceptions, multiple inheritance, and runtime type inference (although C++'s capabilities are rather puny in the latter regard).

However, the real meat of the book are the chapters on templates and the Standard Template Library. The authors have shown great skill in taking in the voluminous literature of C++ templates and boiling it down into comprehensive yet comprehensible coverage. As you get further into the C++ literature, you will keep on finding stuff that you first saw covered in this book, even in material aimed squarely at the advanced practitioner. Starting from using templates as simple type safe containers, they demystify the angle bracket syntax, and even have a section on the current C++ bleeding edge: template metaprogramming. They do a pretty good job at demystifying and motivating it, too.

The authors then introduce the STL, that particular application of templates that provides a wide ranging set of containers that any modern language is expected to provide. Containers are only half the story with the STL, though, and the authors also cover the algorithms that give the STL its unique generic flavour and which facilitate a quintessentially C++ish (i.e. a bit verbose, ugly and scary-looking) form of functional programming.

There's also substantial coverage of threading, a subject that gets very little play in most of the C++ canon, and is well worth a look, although it's very similar to that found in Thinking in Java.

Also, the authors introduce design patterns. I have to say that, like every book that wants to teach you a programming language and design patterns between two covers, the design patterns section is not as successful as it could be and I did not find much new insight or pedagogical inspiration. Buy this book for its coverage of templates and the STL, then get a book devoted to design patterns - Head First Design Patterns and Design Patterns Explained are the ones I normally recommended.

All told, I felt the writing was marginally less good than in volume 1. I don't know what the division of labour was between Bruce Eckel and co-author Chuck Allison, but the writing is not quite as clear as in the previous volume. There were a couple of 'huh?' moments for me, where the authors skirt around complicated issues, involving function name mangling, and where the word 'template' is necessary. Fortunately, there are other books that can clear this sort of thing up.

That's a minor quibble, though. For most of the 800 pages, this is as good as the first volume, and that's very good indeed.


Thinking in C++: Volume 1: Introduction to Standard C++: Introduction to Standard C++ Vol 1
Thinking in C++: Volume 1: Introduction to Standard C++: Introduction to Standard C++ Vol 1
by Bruce Eckel
Edition: Paperback
Price: £57.99

5.0 out of 5 stars Start learning C++ here, 19 Feb. 2007
If you're looking to learn C++ as your first language, or your first OO language, good luck to you! I tried learning C++ after FORTRAN77, and in retrospect, that was a big mistake. Go and learn another object oriented language first, Python or Java or Ruby (maybe even OO Perl). You probably also want to learn a tiny bit of C, just to get used to pointers and memory management.

Done all that? Good. I will be assuming in this review that you already know how to program reasonably and you're not trying to cram C, C++ and OO into your head at once. So, you just want to learn C++. If that's the case, this is the perfect book to start with.

The book assumes that you're coming to C++ from C, and builds up from C++ as C with a stricter compiler, then onto C++ as 'object-based' language - objects as structs with functions and encapsulating initialization and memory allocation with constructors and destructors. Finally, object orientation (i.e. inheritance and polymorphism) is introduced. Rounding things off is a brief chapter on templates and iterators, but it's only a sneak preview, really.

Only the core of C++ is covered: the standard libraries and other topics (like exceptions) are deferred until volume 2. This leaves volume one as a lean and mean exposition of the core of the language. This is quite an achievement, especially as it manages to be both comprehensive and readable. The somewhat begrudgingly object oriented flavour of C++ is also on display in this book, particularly when compared to Thinking In Java from the same author: there are interesting explanations of what the compiler is getting up to behind the scenes, which should presumably assuage the fears of the more paranoid C programmer. There are copious code examples, although the expected output is not given, which would have been helpful. The introduction to the make utility will also be very welcome to many (including me).

This is not quite as good as Thinking in Java, perhaps because of its C-centric opening section, which may require you to familiarise yourself with the differences between C99 and C++ simultaneously (this is particularly apparent in the discussion of the static and const keywords).

But it's still a great introduction to C++, and it doesn't waste time with the basics of variables, loops and conditionals. Between this, the second volume, and Koenig and Moo's Accelerated C++, you have all you need to graduate onto the intermediate C++ books, like the Exceptional C++ and Effective C++ series.


Page: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9