Shop now Shop now Shop now Up to 70% off Fashion Shop All Amazon Fashion Cloud Drive Photos Learn More Amazon Pantry Food & Drink Beauty Shop now Shop Fire Shop Kindle Listen with Prime Shop now Shop now
Profile for Thing with a hook > Reviews

Personal Profile

Content by Thing with a hook
Top Reviewer Ranking: 929,141
Helpful Votes: 482

Learn more about Your Profile.

Reviews Written by
Thing with a hook

Show:  
Page: 1 | 2 | 3 | 4 | 5 | 6 | 7
pixel
Imperfect C++: Practical Solutions for Real-Life Programming
Imperfect C++: Practical Solutions for Real-Life Programming
by Matthew Wilson
Edition: Paperback
Price: £33.99

3 of 3 people found the following review helpful
5.0 out of 5 stars Genuinely new C++ material, 24 Feb. 2007
This is very different from the many 'intermediate C++' books that are on the market. If you've had your fill of reading about pimpls, use of const and which overloaded operators should be members, it's time to read 'Imperfect C++'.

Be warned, it does take a little while to get going, and the author has a rather unusual writing style, which can best be described as an informal hybrid of Aussie and British. And admittedly the opening part of the book covers material reminiscent of the likes of 'Effective C++', albeit with a stronger emphasis on optimisation.

But once it gets going, there's a whole new world opened up, rather remote from the rarefied atmosphere of more theoretical books. Imperfect C++ has a very 'in the trenches' feel, where you need to write programs that talk to C, and on a Windows platform. None of the book is about object oriented design as such, but has a library designer's appreciation for dealing with operating system quirks.

You know how lots of books have advice along the lines of "NEVER do this" or "ALWAYS do this"? Matthew Wilson takes great delight in providing examples where you might want to do the opposite, and covers a wide variety of topics, including defining a portable boolean, a NULL value, and C#/Pascal/Python-like properties.

Purists will almost certainly dislike the fairly heavy use of macros for some of the solutions here, you'll have to get used to the appearance of code with a plethora of underscores in. And the book assumes a reasonably high level of knowledge of C++. In particular, there's little hand holding. Entire class definitions are often provided, but you won't always get example application code to see it in action. This is a little unfortunate, particularly in the chapters where the author introduces his own idioms. It requires careful concentration to work out the physical layout of some of the solutions (e.g. are these free functions or member functions? In the same namespace or a different namespace?). On the other hand, some readers will no doubt welcome the vigorous thought that is required.

Overall, this is a very different, practical book to most of the C++ books out there, with a very high signal-to-noise ratio. Add it to your C++ recommended reading list.


Ruminations on C++: Reflections on a Decade of C++ Programming
Ruminations on C++: Reflections on a Decade of C++ Programming
by Andrew Koenig
Edition: Paperback
Price: £21.99

1 of 1 people found the following review helpful
4.0 out of 5 stars still contains useful insights, 24 Feb. 2007
I was keen to read this expanded and edited collection of columns, given the high quality of the authors' Accelerated C++. This is not quite as good as that book, but it's held up better than some of its contemporaries, like Carroll and Ellis's Designing and Coding Reusable C++.

The chapters are quite short, but they feel cohesive and flow well. The early part of the book is perhaps the most dated. There are discussions of implementing a string class and handle classes - they're treated well, but it's likely you've seen this several times before. Also, I didn't find the 'string picture' chapters, designed to illustrate class design, terribly interesting or illuminating of the underlying principles of object orientation (I didn't like them much in Accelerated C++ either).

However, the section on templates remains relevant, and the discussion of function objects and generic programming is a very good introduction. The later chapters on API design also retain insights. And in particular, the chapter on stream manipulators is very cool. It's also very good at discussing implementation and design issues and the thought processes that go into them. The feel is of someone talking you through how they went about writing some useful C++ and the trade offs involved.

In summary, this is a little dated, but it still has some bits and pieces that you won't find elsewhere. Not one to own at all costs, but keep an eye out for a cheap second hand copy, and when the price is right, pounce.


Multiparadigm Design for C++
Multiparadigm Design for C++
by James O. Coplien
Edition: Paperback
Price: £24.99

2 of 2 people found the following review helpful
3.0 out of 5 stars Disappointing, 24 Feb. 2007
Arguably ahead of its time, given the strong functional borrowings of ostensibly object oriented languages such as Ruby and Python, this book presents an approach to domain analysis and program design using C++, although it's applicable to several programming languages. Readers may also find echos of Eric Evans' Domain Driven Design, particularly in the idea of a domain dictionary to record a vocabulary for use in naming the parts of the finished model.

The main message is that OO is only one of several choices when building software in C++. The author presents the following alternatives: generics, classes without virtual functions, overloaded functions and using the preprocessor. Clearly, some of these suggestions are more niche than others. Some extended examples are provided, involving a text editor/buffer, a function differentiator and a finite state machine.

The other big idea is the concept of commonality and variability analysis. The process goes along the following lines:

1. Create a domain dictionary defining all terms used in the domain.

2. Analyse the domain using experience or intuition to group the domain into subdomains of commonality.

3. For each subdomain, analyse the variabilities with respect to their common core.

4. Decide which paradigm to use, depending upon whether the variability needs to be specified at run time, compile time, etc.

I worked hard to like this book, really I did. One of the biggest problems for me is that I just can't get along with James Coplien's writing style, which reads like a stuffy academic research paper. I find it extremely ponderous and obfuscated, whole sentences flow by without imparting any meaning.

Perhaps as a by-product of my difficulties with Coplien's style, I found it hard to extract much usable content from the book. The four points I outlined above all seem entirely reasonable to me, but reading this book hasn't given me any further insight into them. It's particularly frustrating that Coplien has little to say about how to go about finding commonalities in a domain, apart from appealing to notions of experience and intuition, which is unhelpful. At least he doesn't suggest underlining nouns. There is some mention of design patterns, so if you're looking for more examples in C++, you may get some value from that.

It seems that lots of people liked this book (including the authors of the excellent Design Patterns Explained, where I first heard of it), so maybe if you find Coplien's writing style a bit more readable, you should give it a go. Personally, I got fairly low returns from it.


Advanced C++ Programming Styles and Idioms (Society and Culture in East-Central)
Advanced C++ Programming Styles and Idioms (Society and Culture in East-Central)
by James O. Coplien
Edition: Paperback
Price: £48.79

3 of 3 people found the following review helpful
4.0 out of 5 stars Still extremely interesting, but no longer idiomatic, 24 Feb. 2007
This book still turns up in the recommended reading of nearly every important book on C++ out there, which is pretty remarkable given it was published in the early 90s. Clearly, lots of smart people think it's important, then. But has it been influential? Are the techniques outlined here being used by programmers now? In some ways, yes. In others, the C++ community has marched off in entirely the opposite direction.

The material that has endured is handle/envelope classes (more commonly called pimpls these days) and the discussion of object orientation and polymorphism that covers the different techniques for inheritance versus composition and public versus private inheritance well.

The rest of the book is an attempt to turn C++ into something between Smalltalk and CLOS. There is some extremely clever stuff going on here, but as you might expect, it's not a terribly comfortable fit for C++. Nonetheless, there's a whole bunch of interesting ideas: multiple dispatch, prototype-style object creation, dynamic reloading of classes and garbage collection.

However, I doubt that many people are using these ideas in their C++ code. Arguably, this book's spiritual successor is Alexei Alexandrescu's 'Modern C++ Design', published about a decade later. If you look in there, you'll see the new advanced C++ is a long way from Smalltalk. By the use of template metaprogramming, as much as possible is done at compile time, not run time. Conversely, at least some the ideas are an integral part, not of C++, but Java.

So it's not a book for everyday programming, but if you want to see which interesting directions C++ can be pushed, this is a unique resource.


Large-Scale C++ Software Design (APC)
Large-Scale C++ Software Design (APC)
by John Lakos
Edition: Paperback
Price: £46.99

3 of 3 people found the following review helpful
5.0 out of 5 stars Excellent book on the physical architecture of C++ applications, 23 Feb. 2007
This book assumes you're already proficient in C++ and basic OOP design principles, and considers design at a level one higher than individual classes. You'll learn how to arrange your classes into modules and packages, and then how to organise communication within and between these higher-level constructs. Nonetheless, the book never forgets that the important thing is working C++ code, not diagrams and acronyms, so it's always practical.

There are two core advantages to the designs discussed in this book: maintaining the correct level of abstraction, and reducing recompilation times. Performance issues always run the risk of becoming outdated fairly quickly, and to a certain extent, some of the timing material is no longer relevant. In particular, Sutter and Alexandrescu, in C++ Coding Standards, explicitly disavow the advocated method of external header guards. Additionally, although namespaces are mentioned, they are not used much, and the older method of using prefixes is recommended instead.

The last part of the book drops down to more low level concerns, such as Schwarz counters, operators, and function arguments. This leans heavily on the likes of Effective C++, C++ Strategy And Tactics and C++ Programming Style, and to be honest, you'd be better off looking in more modern books for up to date best practices. For example, in this book assignment is implemented through the copy-and-destroy idiom, which is nowadays considered to be a mistake.

But this is a big book, and you won't be buying it for the lower-level stuff, but for the large amount of higher level material that makes up the bulk. The main practices and metrics remain extremely relevant, the text is clear and well written. And there just isn't many other places where you can go and read about this sort of stuff. It's a must-read.


Designing and Coding Reusable C++
Designing and Coding Reusable C++
by Martin D. Carroll
Edition: Paperback
Price: £27.99

3.0 out of 5 stars not bad, but uninspiring, 23 Feb. 2007
I read this on the basis of Scott Meyers' recommendation in More Effective C++, but I must admit that I was expecting something with a bit more zing to it.

On the positive side, this not yet another style manual, or a collection of gotchas. It looks at designing software at a higher level than coding standards or idioms. There's a fairly solid introduction to thinking about object orientation, and unlike most books, it goes into non coding issues like compatibility and documentation. There's also some material on whether to design a class with a pimpl or factory methods to reduce compile time dependencies. There's even a little bit on contract programming (although they don't call it that). And the chapter on name conflicts is pretty good.

But for all that, the coverage is not very deep. Overall, there wasn't much here that was new or fresh. It might be good for an experienced C programmer, who's migrated to C++ and is looking for some an intro to OOP.


Beyond the C++ Standard Library: An Introduction to Boost
Beyond the C++ Standard Library: An Introduction to Boost
by Bjorn Karlsson
Edition: Paperback
Price: £43.99

3 of 4 people found the following review helpful
4.0 out of 5 stars Readable, broad coverage of the core Boost libraries, 23 Feb. 2007
Boost is a series of libraries for C++ that provides extra functionality missing in the C++ standard library. Unless you're forced to only use what's part of the standard, you'll want to lean heavily on Boost. And even if you can't use it for some reason, a lot of it is passing into the next version of C++, so you may as well get familiar with it now.

This book covers the most immediately useful Boost libraries for the general audience. Topics include various smart pointers, including the vital shared_ptr, that makes STL container of polymorphic types much easier to deal with, extra casting operators, regular expressions, and the signal library, that provides a framework for implementing the observer design pattern.

A large chunk of the book is devoted to functional issues, covering the bind, lambda and functional libraries, which work together to substantially extend the functor capabilities of the STL. Code making use of these libraries are a good deal more powerful than what's currently in the standard library, more readable (although that's not necessarily saying much), and might even make the dream of writing loop-free code with functors a reality.

As an introduction to Boost, this is pretty good, which is just as well, given how little competition there is out there. Bjorn Karlsson writes well, and provides plenty of examples of the code in action. None of the examples are very long, however. In many places you'll find just enough to work out the syntax of the libraries, which you can then use with the API details that are also provided to get your own code working. It's not intended to be a very deep treatment of any of the libraries, however.

However, if you're looking for an introduction to Boost's most immediately usable code, this is a good purchase.


C++ Common Knowledge: Essential Intermediate Programming
C++ Common Knowledge: Essential Intermediate Programming
by Stephen C. Dewhurst
Edition: Paperback
Price: £25.99

4 of 4 people found the following review helpful
5.0 out of 5 stars could this be the best intermediate C++ book?, 23 Feb. 2007
Yep, this is perilously close to supplanting Scott Meyers and Herb Sutter as the definitive book for propelling a neophyte C++ programmer towards competence.

On the face of it, this is yet another book on 'intermediate' C++, of which there have been many since the early 1990s. The book consists of a few dozen short pieces on how wrestle some complexity of C++ into behaving itself, such as the use of const, how to implement copy constructors and the assignment operator. Do we really need yet another one of these?

But this manages to stand out from the crowd. It covers more basic material such as references and the new cast operators. There's a very nice section on pointers to members. It's also very handy for people coming from other languages, such as Java, particularly as it highlights areas where C++ differs from Java, e.g. name lookup and hiding rules. However, some material assumes knowledge of the handle/pimpl idiom which is normally covered in other intermediate books.

There's also an emphasis on higher level abstractions, general object oriented design principles, like the Hollywood principle, and separate items on design patterns (command, template, prototype).

And nearly half the book is on templates. And it's a very thorough and systematic coverage, including traits, policies and some metaprogramming (e.g. SFINAE). I was very impressed with this part of the book, it is very effective at demystifying a part of the language that even the better introductory books can fail to enlighten fully.

The only negative of this book is that, subjectwise, there is a fair amount of overlap with the author's previous book, C++ Gotchas. If you've already got that, you may find yourself skimming the first half of this one (and it's not a huge book). However, the excellent template section is all new. Nonetheless, you might want to knock a star and a half off my rating.

In short, this is an excellent, well-organised book with clear coverage of beginners topics all the way up to OO principles like those found in Robert C. Martin's Agile Software Development.


C++ Gotchas: Avoiding Common Problems in Coding and Design (Addison-Wesley Professional Computing)
C++ Gotchas: Avoiding Common Problems in Coding and Design (Addison-Wesley Professional Computing)
by Stephen C. Dewhurst
Edition: Paperback

4 of 4 people found the following review helpful
4.0 out of 5 stars solid C++ advice, dispensed in an amusingly grumpy fashion, 23 Feb. 2007
There are unlikely to be many other C++ books where the word 'ignoramus' appears as often. Dewhurst's writing definitely has character. This book contains 99 items on common mistakes made by C++ programmers, and serves up best practices to replace those bad habits.

Does this sound a bit familiar? Well, yeah, there's substantial overlap with books by Scott Meyers and Herb Sutter, so not every item is a revelation. That said, C++ is sufficiently complicated that I can do with all the help I can get.

However, there isn't any material on templates here, and there's quite a lot of overlap with the author's subsequent book, 'C++ Common Knowledge', which I consider to be superior to this one. So while this is a perfectly good book, I would point you towards C++ Common Knowledge.


C++ Strategy and Tactics (APC)
C++ Strategy and Tactics (APC)
by Robert B. Murray
Edition: Paperback
Price: £32.99

3 of 3 people found the following review helpful
4.0 out of 5 stars good as a bridge from introductory to modern intermediate C++ books, 22 Feb. 2007
Like Tom Cargill's C++ Programming Style, this is another widely-recognised classic of the genre which has lost some of its immediacy with the passing of time.

If you're familiar with the works of Scott Meyers and Herb Sutter, then you will probably not find much here that you don't already know (although this clearly predates some of their output). But if you're still fairly new to OO, I recommend this highly as your first non-introductory book. It's got a much more cohesive feel than the Effective C++ and Exceptional C++ books, and unlike the Cargill book, it's sufficiently modern to have covered templates. Bear in mind, though, that the 'advanced' templates chapter is about writing a linked list class. Solid data structure stuff for sure, but not what a C++ practitioner would consider advanced these days.

You can also find lots of solid OOP advice, although you may find it similar to the OOP wisdom dispensed in other C++ of the same vintage. There are some suggestions on 'reusability', although they're more concerned with memory management, and feels more like optimisation. That's not to say that it isn't interesting and accessible, though.

There's a brief introduction to exceptions, but at the time the book was written, they had only just appeared in the language. Likewise, there's nothing about namespaces here.

My 4-star rating takes into account that you can obtain this book cheaply and the material is presented in a clear, readable fashion. If you're already an experienced object oriented programmer, you can safely bypass this book and go straight to the Meyers and Sutter books. If you're not, then this is a good place to start the journey to more advanced work.


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