Customer Reviews

Beyond the C++ Standard Library: An Introduction to Boost

5 star:		(4)
4 star:		(6)
3 star:		(3)
2 star:		(3)
1 star:		(2)

 

 

This book is not just a rehash of the online documentation of the boost library. This book is way more than that, it's a why you should use these libraries and how to book. Not a how to write the libraries, or program in C++. As such this book is geared toward the intermediate to advanced C++ programmer who has heard about www.boost.org but isn't using all of the libraries yet.

This is not an unbiased review, as I reviewed the chapter on Lambda as I'm one of the original authors of the library. However I'm not on the payroll so you can trust me when I say, buy the book, you'll be glad you did.

Why should you care? Well boost is a proving ground for many of the upcoming C++ 0X standard libaries. Before the libraries get accepted by the standards committee, often there is reference implementation done for boost. And those that don't make the standard cut, well, often its not poor quality code, but rather a narrow focus library. Boost may have just the thing you need, so check it out.

And as every good programmer knows, the fastest way to use new code is to get stuff that has documentation (this book) that is tested, and is free. (sorry the book isn't free, but the code is!)

So save yourself several days of head scratching and buy the book.

All professional C++ programmers should become familiar with this freely available source of high quality, peer reviewed C++ code. Boost is a collection of libraries that are designed to complement the C++ Standard Library and provide very useful solutions to difficult program design tasks. This book is a very good introduction to Boost. There is an introductory chapter that gives a brief description of each Boost library (almost 60 of them as of version 1.32). Seven of these libraries have been accepted for the upcoming C++ Standard Library Technical Report which means that they will probably become part of the next version of the C++ standard. The remainder of the book gives a more in-depth tutorial introduction of a good sampling of 12 Boost libraries. This material complements the documentation on the Boost.org web site. It provides clear examples that illustrate the use and usefulness of each library.

My only complaint is that they didn't make the book longer and include more libraries in this detailed treatment. Some of the libraries are very extensive and have other books devoted specifically to them. (See The Boost Graph Library, by Siek, Lee and Sumsdaine; and C++ Template Metaprogramming, by Abrahams and Gurtovoy which covers Boost MPL.) But I think the book would be more valuable if some of the other libraries like Multi-index, Format and Serialization had been explained in more detail. Articles on these have appeared in recent issues of the C/C++ User's Journal. Still, this is a great book to have. I highly recommend it and expect that expanded editions will come out in the future. Already Boost 1.33 has been released with with 5 new libraries and significant updates to existing libraries. C++ programming has never been better.

This is really what the Boost community (www.boost.org) needs to increase the awareness of its excellent libraries! Not to mention how much I needed it to improve my programming!

As a programmer, you have so many task specific features to implement, that you really don't have the time (or even interest) to implement the fundamentals. Yes, you have the C++ standard library to assist you, but the Boost libraries take you to an entirely new level. And the Boost libraries have the absolute top quality, which most of us just can not achieve even if we had all the time in the world. Yet, the libraries *are* fundamental in the sense that they solve common programming issues (and also in many cases show the path to upcoming C++ standards). It is hard to imagine an application making use of *all* the Boost libraries, but I'd say that it is equally hard to imagine one which would not benefit from any Boost library.

[Did you get this far without ever having visited http://www.boost.org? Then now is the time to do that...

Done? Ok, let's continue with the book.]

Without any statistics to support me, I am pretty convinced that the average Boost user is far more experienced in C++ than most of us who make a living out of C++ programming (let alone those who don't). This book will help to flatten out this bias, by making Boost easy to understand and immediately useful for those who read it. It is clearly written - technically correct while never being boring, even if you read from first to last page. It includes many code examples, which repeatedly made me associate to uses in my programming. I would have liked the examples and the Boost libraries on an accompanying CD, but this is no major concern - it's better to get the freshest release from boost.org anyway. I read the book basically from start to end, skimming a couple of libraries that I found no immediate use for. The book covers 12 libraries out of 58 which makes me looking forward to a follow-up book covering yet another 12 or so libraries.

The book is well-written, clear, and honest to the title -- it truly is an intro. In fact, it's honest to the title a bit too much: I found it shallow. It is very much like most of the other recent C++ books (although it's one of the better-written ones), that is it has a distinct publish-or-perish taste to it, like a paper produced by another graduate student who doesn't really want to write it but has to. Not enough depth. It is, however, free from many sins of this PhD-indited flood: it's NOT pompous, it IS simple and clear, it has no pseudo-scientific pretense in it. I mean it's almost good; just not enough indepth.

Someone asked me recently, a bit confrontationally, well, you don't like anything, what's a good book then? No problem: books you tended to get a decade and more back; mostly written by practising professionals rather than CS PhD students; written by people motivated by either love of their work, or vanity, or greed -- all valid motivators, frequently resulting in good products. Unlike, I mean to say, the publish-or-perish imperative of the typical graduate student/newly minted PhD, who produce inflated and unnecessary, poorly written drivel about undeserving minutia. Abrash, Meyers, Stevens wrote good books. If you want STL, fine: Mark Nelson wrote a wonderful book on STL. It is unfortunately out of print (and behind the times a bit), but it's done right -- it really works on things, tweaks them, pokes them with a finger, looks inside, considers alternatives -- you end up really understanding the subject matter. Karlsson's book is well written, but along other books of the same kind (Josuttis, etc.) is limited to a verbal exposition of header files' contents with a teensy-weensy bit of sample code -- waaaaaay too little to be of much practical use. Whoever wants to write an STLish sorta book should check out Mark Nelson's book on STL and use it as a guide.

To summarise: The book is not bad by any means, but is superficial. Bjorn Karlsson writes very clearly, which is good and is not to be taken for granted -- and I hope Bjorn Karlsson will rewrite this book to make it more indepth, augment it with things like, you know: not only WHAT can be done, but HOW it is done (dig into the library itself: for example, how can you not want to stick your nose into the lambda library? It looks magical, I want to know how it's done... It is completely inadequate simply to mention what it can do, add a two-liner example, and be off to something else). OK, so do I recommend this book? Er... uhm... it's OK. A Quick Intro Guide, if you know what I mean. From a fifty-dollar book you'll want more.

So, I say, first go to boost and read what they've got there; I don't feel this book gets you more than the site itself -- jeez, what am I saying, of course it is less, it covers only a small part of the overall deal, but it's better written and more consistent. So, if you got fifty bucks to spare then get the book as well. I mean, it's an OK book. Were it sold for fifteen bucks, I'd give it five stars.

----------------------

PS. Bibliography is deficient: there's a couple of standard formats any style guide will describe; neither is used in here: what we have here is a kind of home-brewn summaries w/o year, publisher, etc., just the title and authors. Also, it seems that only books from Addison-Wesley made it into the bibliography (hmmm....)

Boost is great -- a set of portable libraries for C++ that makes a lot of common development tasks easier, esp. for those of us who target mutiple platforms with out code (Windows, Mac OSX, Linux, etc). However, this book I feel is not much of an introduction at all. The chapter on scoped_ptr, shared_ptr, etc. is good, but there is so much that a beginning Boost developer needs that just isn't anywhere in this book. For instance, I can create a boost::thread on the heap, but I can't seem to wrap a boost::shared_ptr or boost::scoped_ptr around it -- at least, this book doesn't give me a clue how.

Now, Boost is big -- there are dozens of Boost libraries, so I can't fault the book for not going into detail on every one of them. However, as an "introductory" book on Boost, I would have thought that the book would concentrate on the most commonly used Boost libraries -- boost::thread, for one. Every time i've had a question on a Boost library that i'm considering using that I can't find a decent example for, I look in this book and ... don't find any pertinent info about it.

Lets distinguish: Boost is great, but this book is just not well written.
It is technically shallow, it is exhausting and boring to read and the authors attitude seems arrogant and is nerving.

I wouldn't buy this book again but recommend working through the docs on the boost website which are way better.

I feel that the book does an OK job of introducing the reader to several boos libraries. It seems to be a good resource for somebody who never used boost libraries before and wants to learn about them. However, the book seems to lack certain depth. A lot of space is wasted on listings of the header files or listing of all methods and fields in classes. This kind of information is readily available online and does not contribute much to the book. On the other hand, not enough info is given about the concepts that the libraries are based upon.

"Beyond the C++ Standard Library," by Björn Karlsson, describes the Boost template libraries. These are the candidate, soon to be adopted, additions to the C++ language.

The book starts very strong - Karlsson is and enthusiastic evangelist for Boost. Perhaps there are too many exclamation marks, and the description of Boost online documentation as "a great source of information" is laughable, but I took these quirks to be a sincere by-product of Karlsson's enthusiasm. For much of the book, Karlsson's descriptions and explanations are a match for his gusto. Unfortunately, however, I found coverage of several of the Boost libraries to be seriously lacking.

I tore through the first half of the book. The first substantive chapter, which is on shared pointers, probably the single most useful component of Boost, is clear and informative. Later, the chapter on the Boost "regex" facility is outstanding. In fact, it is one of the most clear, comprehensive yet terse descriptions of regular expressions I have ever read.

In the chapter on Boost's "Any" facility I hit a speed bump. `Any" is a robust alternative to pointer-to-void for handling arbitrary types, and is sorely needed by the C++ language.

The first problem I had with the "Any" chapter is that the boiler-plate paragraphs beginning the chapter are so repetitive that I was flipping back to earlier chapters to see whether there had been some of misprint. Afterwards, Karlsson gets to the meat of the library, but he spends the closing half of the chapter to illustrate how one could add support for the output operator `<<' to the "Any" library. As I struggled through this it was clear to me that Karlsson is a wizard at writing tricky templates, but I would have appreciated more discussion on the package as it exists, even lacking support for `<<'.

The wheels come completely off the cart in the section on boost::bind, and re-reading was not a cure. At work, I had what seemed to be a good place to use boost::bind, but could not get compilable code even reading from the book and hitting Google for help.
Personally, what I need to get my head around boost::bind is a small "hello world" example that is subsequently grown into more useful code. The code examples in this chapter did not work that way for me.

The chapter on boost::lamda was worse, and I am completely at home with actual, non-computer library lambda expressions. On sore point that sticks out is that early in the chapter Karlsson has the largely unexplained code sample:

using namespace boost::lambda;
(std::cout << _1 << " " << "_3 << " " << _2 << "!\n")
("Hello", "friend", "my");

No hint is given how to generalize this syntactic marvel. And this eye-candy is incredibly brittle: not only does adding the wrong "#include" introduce compilation errors, but, with VisualStudio 2010 so does replacing ""!\n" with std::endl .

The concluding chapter, on boost:signal, is a refreshing return to clarity, although by this time I had soured quite a bit on the book.

In summary, there are some very solid chapters in this book that make it well worth reading. I am also sure that boost:: bind and boost::lamda could be very useful, but I am equally sure that Karlsson's book is not the vehicle to teach me about them.

This book doesn't add any value over reading the documentation that comes with Boost (and some of the Boost documentation is really terse). It fails to explain concepts clearly and there are almost no diagrams.

If you've been programming in C++ over the last few years, you've probably heard of the Boost set of libraries. These libraries extend and augment the C++ standard library based on years of real-world experience. Now that some of the Boost libraries have been accepted into the Technical Report 1 for inclusion in the C++ standard, no one can afford to ignore them any longer.

This book serves as a good introduction to a number of the Boost libraries. Karlsson did not try to cover all of the Boost libraries. He didn't even cover all of the ones accepted in TR1. But, he does cover a good subset of the tools that Boost provides.

Probably the most valuable portions of the book is a pair of sections in each chapter. The first explains what the library will do for you and your programs. The second tells how the library fits in with the standard library. These two sections give important insight into how you will use each library.

If you are looking to become more familiar with the Boost libraries, you really should take a look at this book.