Text Processing with Boost

Speaker: Eric Niebler


Text Processing with Boost February 2007 meeting of the Northwest C++ Users Group. The abysmal support in the C and C++ standard libraries for string handling has driven many programmers to other languages like Perl and Python. Boost aims to reverse that trend. Libraries such as Boost.Lexical_cast, Boost.String_algo, Boost.Regex, Boost.Xpressive and Boost.Spirit are invaluable tools for slicing and dicing strings. If your task is as simple as turning an integer into a string, or as complicated as developing a parser generator for a new scripting language, Boost has a library that can help. In addition to covering all the afore mentioned libraries from a user’s perspective, we’ll also look at how Boost can be used to get more out of the standard IOstreams, and discover some hidden gems in Boost for dealing with Unicode.

No Time for JAVA

Performer: Herb Sutter
Performer: Bjarne Stroustrup

SD Best Practices Boston 2008

Concur and C++ Futures

Speaker: Herb Sutter


Discussions of concurrency & C++ futures September 2006 meeting of the Northwest C++ Users Group.

C++ Exception Handling Cost

Speaker: Kevin Frei


Kevin Frei – Exception Hanlding Cost September 2006 meeting of the Northwest C++ Users Group. Discussion of the assembly language cost of exception handling on the x86 Windows and x64 Windows platform.

Getting C++ Threads Right

Speaker: Hans Boehm


The advent of multicore processors has generated profound debate on the merits of writing parallel programs with threads and locks. Nonetheless, for many application domains, this remains the standard paradigm for writing parallel programs, and at the moment, there is no apparent universal replacement. And it is the focus of this talk.

Somewhat surprisingly, there are a number of often subtle, but generally fixable, industry-wide problems with current approaches to threads programming. We’ll focus on probably the most widely used environments, consisting of C or C++ with a standard threads library. Problems span the spectrum from system libraries through language implementations through supporting hardware. They get in the way both in that they often make it difficult to write 100% reliable multi-threaded software, and in that they confuse even the basics of the programming model, thus making it hard to teach. A surprising number of "experts" do not understand the basic rules. Arguably, these problems really need to be addressed to even allow a meaningful comparison to other parallel programming approaches.

Since solutions to these problems generally require a coordinated industry effort, we helped to persuade the C++ standards committee to address them by pursuing a coherent approach to threads in the next C++ standard. The talk will outline some of the proposed solutions, and give an update on this effort.

Red Code/Green Code – Generalizing Const

Speaker: Scott Meyers


C++ compilers allow non-const code to call const code, but going the other way requires a cast. In this talk, Scott describes an approach he’s been pursuing to generalize this notion to arbitrary criteria. For example, thread-safe code should only call other thread-safe code (unless you explicitly permit it on a per-call basis). Ditto for exception-safe code, code not “contaminated” by some open source license, or any other constraint you choose. The approach is based on template metaprogramming (TMP), and the implementation uses the Boost metaprogramming library (Boost.MPL), so constraint violations are, wherever possible, detected during compilation.

C++0x Initialization Lists

Speaker: Bjarne Stroustrup


Getting initialization right is an important part of programming. Over the years, this has led to a mess of language facilities and techniques. This talk describes how C++0x (most likely) will address two issues: how to get a uniform syntax and semantics for all initialization and how to allow initialization by general lists. Obviously, people will want the solution to be really simple and completely compatible. As ever, the resolution is to be almost completely compatible and almost simple. This talk will describe sequence constructors, homogeneous and heterogeneous initializer lists, and (as far as time allows) fit generalized constant expressions, prevention of narrowing conversions, and variadic templates into this picture.