2010 Program

2010 Resources (Slides, notes, etc)

Sunday, May 09
time Track I 2010 Track II 2010
04:00PM
06:00PM
Conference registration and Sign-In ’10
06:00PM
07:00PM
Break
07:00PM
10:00PM
Informal Gathering at Meadows Bar ’10 – Travelling companions welcome.
Monday, May 10
time Track I 2010 Track II 2010
08:30AM
08:45AM
General Conference Welcome
08:45AM
09:00AM
Jeff Garland: Boost Library in a Week — Revamping C++ I/O (Kickoff)
09:00AM
10:30AM
Douglas Gregor: Clang: An Open-Source C++ Compiler Library Michael Wong: C++0x update
10:30AM
11:00AM
Break
11:00AM
12:30PM
Jeremy Siek: Generic Programming And the Boost Graph Library Ken Joyner: Demystifying C++ Exceptions – 10 Tips to Effectively Design Exception-Safe Code
12:30PM
02:30PM
Break
02:30PM
04:00PM
Barend Gehrels, Bruno Lalande, Mateusz Loskot: Generic Programming for Geometry Joel de Guzman, Hartmut Kaiser: A Framework for RAD Spirit
04:00PM
04:30PM
Break
04:30PM
06:00PM
Matt Calabrese, Zachary Laine: Instantiations Must Go! de Guzman, Kaiser: RAD Spirit (continued)
06:00PM
08:00PM
Break
08:00PM
09:30PM
Robert Ramey: Is Boost Broken?
Tuesday, May 11
time Track I 2010 Track II 2010
08:00AM
09:00AM
Jeff Garland: Boost Library in a Week — Revamping C++ I/O (Tue)
09:00AM
10:30AM
Stephan T. Lavavej: Data Structure Visualizers in Visual Studio 2010 Michael Wong: C++0x Concurrency
10:30AM
11:00AM
Break
11:00AM
12:30PM
Joachim Faulhaber: Boost.Alabaster: A Law Based Tester Tony Van Eerd: The Basics of Lock-free Programming
12:30PM
02:30PM
Break
02:30PM
04:00PM
Douglas Gregor: C++ Tool-Builders Workshop Vicente J. Botet Escriba, Justin Gottschlich, Dwight Y. Winkler: Reducing the Integration Complexity of Software Transactional Memory with TBoost.STM
04:00PM
04:30PM
Break
04:30PM
06:00PM
Gregor: C++ Tool-Builders Workshop (continued) Michael Caisse: Using Spirit V2: Qi and Karma
06:00PM
08:00PM
Break
08:00PM
09:30PM
Dave Abrahams: Ryppl – A New Platform for Boost Development
Wednesday, May 12
time Track I 2010 Track II 2010
08:00AM
09:00AM
Jeff Garland: Boost Library in a Week — Revamping C++ I/O (Wed)
09:00AM
10:30AM
Maurice Herlihy : Transactional Memory Today – Keynote
10:30AM
10:45AM
Break
10:45AM
11:00AM
nothing scheduled Justin Gottschlich: Overview of Transactional Memory Day
11:00AM
11:30AM
Gennadiy Rozental: Production use of Boost.Test Justin Gottschlich: TBoost.STM Engine
11:30AM
12:30PM
Rozental: Production use of Boost.Test (continued) Tatiana Shpeisman: Draft Specification of Transactional Language Constructs for C++
12:30PM
02:30PM
Break
02:30PM
03:00PM
Michael Caisse: An Asio Based Flash XML Server Michael Wong: IBM’s TM Research
03:00PM
03:30PM
Caisse: An Asio Based Flash XML Server (continued) Mark Moir: Sun’s / Oracle’s TM Research
03:30PM
04:00PM
Caisse: An Asio Based Flash XML Server (continued) Tatiana Shpeisman: Intel’s TM Research
04:00PM
04:30PM
Break
04:30PM
06:00PM
Christophe Henry: The Meta State Machine Library V2 Justin Gottschlich, Maurice Herlihy , Mark Moir, Tatiana Shpeisman, Michael Wong: Transactional Memory – Panel Discussion
06:00PM
06:30PM
Break
06:30PM
08:30PM
Picnic’10 – bring your families and friends
Thursday, May 13
time Track I 2010 Track II 2010
08:00AM
09:00AM
Jeff Garland: Boost Library in a Week — Revamping C++ I/O (Thu)
09:00AM
09:45AM
Stjepan Rajko: AME Patterns Library: a generic library for modeling, recognition, and synthesis of sequential patterns Dean Michael Berris: Techniques in Flexible Header-Only C++ Network Library Implementations
09:45AM
10:30AM
Rajko: AME Patterns Library (continued) Marshall Clow: A MIME library for Boost
10:30AM
11:00AM
Break
11:00AM
12:30PM
Nevin Liber: Type Erasure Joel Falcou, Jean-Thierry Lapreste: The Numerical Template Toolbox : BOOST’ed Generic Array Library for High Performance Computing
12:30PM
02:30PM
Break
02:30PM
04:00PM
Eric Niebler: Practical DSEL Design with Proto David Sankel: Functional Programming in C++
04:00PM
04:30PM
Break
04:30PM
06:00PM
Niebler: Practical DSEL Design with Proto (continued) Roshan Naik: Logic Paradigm for C++
06:00PM
08:00PM
Break
08:00PM
09:30PM
Dave Abrahams, Hartmut Kaiser: BoostCon 2011 Kickoff Meeting
Friday, May 14
time Track I 2010 Track II 2010
08:00AM
09:00AM
Jeff Garland: Boost Library in a Week — Revamping C++ I/O (Fri)
09:00AM
10:30AM
Joao P. R. Abecasis: Cross-platform development with Qt and Boost Joel de Guzman, Hartmut Kaiser: Spirit: History and Evolution
10:30AM
11:00AM
Break
11:00AM
12:30PM
Dave Abrahams, Beman Dawes, Jeff Garland, Douglas Gregor: Future of Boost Panel ’10

Sessions

Speakers: Joel de Guzman, Hartmut Kaiser
Format: tutorial
Track: Track II 2010

One allure of Boost Spirit Parser, compared to traditional parser
generators, is its being embedded in C++. The user of the library
specifies a parser’s grammar directly in C++ code using expression
templates. There are distinct advantages with this approach, but there
are problems as well. The most glaring drawbacks are 1) long compile
times and 2) difficult to understand error messages and 3) Difficulty in
debugging and testing parsers. For small parsing tasks, these can be
tolerated. Yet, after 8 years in active deployment, we’ve come to a
point where Spirit is being used in increasingly more complex parsing
tasks. 2 and 3 can somehow be alleviated by adding more “smarts” to the
expression template engine (using Proto), but that would increase
compile times further to the point where the libary will no longer be
useful.

It would be interesting to have a tool (both stand-alone or library
based) that accepts textual EBNF/PEG expressions and outputs either
parsers that are immediately executable or C++ Boost Spirit code. The
RAD tool can have all sorts of smarts to make writing parsers as
painless as possible (e.g. debugging, error handling, analysis, etc).
After the development of the parser is “set in stone”, one can opt to
have the tool emit C++ code that can then be included in an application.
For more complex parsers, this will be a definite boon.

We would like to present the design and development of such a tool.
Obviously, this “Dynamic Spirit” tool will be written using “static”
Spirit. This would be a practical real world example using Spirit.

Speaker: Stjepan Rajko
Format: tutorial
Track: Track I 2010

This tutorial presents the AME Patterns library, an open source generic C++ library for modeling, recognition, and synthesis of sequential patterns. The library is useful for applications such as gesture and speech recognition, as well as synthesis of such patterns. It can be also used as a general-purpose library for models such as the hidden Markov model. The use of concept-based generic programming gives the library a large degree of flexibility, which is useful since pattern analysis spans many different domains. The library also offers several application programming interface (API) levels which offer different tradeoffs between programming complexity, flexibility, portability, and compile times.

Speaker: Marshall Clow
Format: lecture
Track: Track II 2010

The most common way to encapsulate data in internet protocols is to use MIME or (Multipurpose Internet Mail Extensions). This format is used in HTTP, email and many other protocols.

I will introduce a library for creating, parsing, and manipulating MIME structures, with an eye for inclusion into boost, and talk about the design choices that went into creating this library. The (proposed) Boost.MIME library is (will be) used by Dean Michael Berris’ network library.

A MIME processing library is one of the basic building blocks needed to implement networking protocols (along with threads, network I/O and state machines).

Speaker: Michael Caisse
Format: lecture
Track: Track I 2010

Reactive systems are found everywhere. The temptation to implement them with legions of waiting threads can be strong; however, the result is nearly always disappointing at best.

The Boost.Asio library provides a framework to handle asynchronous resources with specific classes directed toward networking, serial port I/O, timers and more. In this session we will build a server that routes data streams to and from various serial I/O hardware components to TCP connected Flash displays. The Qi parsers and Karma generators developed in an earlier session will be employed to create ASTs that will be shuffled to their appropriate destinations.

This lecture/tutorial will utilize libraries including Asio, Spirit, Fusion, Phoenix, Smart_ptr, Thread, Function and Bind to pull together a server capable of streaming data to and taking requests from a Flash XMLSocket. Attendees will leave with an understanding of the Asio model and various implementation patterns to create their own Asio based servers.

Speaker: Joachim Faulhaber
Format: lecture
Track: Track I 2010

This is a proposal for a boost library that provides automated testing on the basis of formally specified laws or axioms. The test system consists of three parts. A law concept that allows to express axioms or laws as class templates over typelists that represent the law’s instantiation variables. A generator for law instances that randomly generates law instantiations for a given law and a given typelist. A filter, that selects law violations and stores them according to a simplicity ordering. For the development of the Boost Interval Container library, a prototype of Boost.Alabaster has been used for a law based development. Law based testing as technique and tool turned out to be beneficial in many ways:

The quest for formal specification gives rise to deeper rooted design decisions and leads to a design that is more durable. In an evolutionary process, it drags abstraction and abstract reasoning about generic software from the end of software development (testing of laws) to it’s front (specification) even if you did not start your development with ready made axioms. The law based development process produces not only the software but also formal properties that can be guaranteed about that software. The validation of those properties can be replicated at any time. Testing is transformed from a tedious and unloved duty to an extremely creative process that fosters abstraction and quality of design. Law based testing includes all benefits that traditional unit testing can offer and goes way beyond that.

Speakers: Dave Abrahams, Hartmut Kaiser
Format: panel

To ensure a successful BoostCon’11, we’ll need to start planning now. Be a part of the process!

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

C++ iostreams provide a comprehensive set of utilities for input and output of
basic and user defined types. This includes formatting, localization,
buffering and other facilities. While widely used, the existing iostreams
library suffers from issues that cause some C++ users to avoid iostreams. The
issues include performance, lack of formatting facilities as compared to C,
difficulties with internationalization, and complex requirements to extend the
library. In fact several Boost libraries address the domain including
boost::format, boost::IO_State_Savers, and boost::iostreams.

The existing iostreams library was developed long before modern C++,
multithreading, asynchronous i/o and other modern facilities. This library in
a week will look at using the modern facilities of C++ to revamp iostreams to
make it more efficient, more extensible, and more widely useable for C++
programmers. Starting with the existing iostreams and boost libraries the
sessions will look at interfaces and implementations that would be superior to
the current standard library.

The workshop will meet every morning to chart progress, set direction, and
interact with other BoostCon participants. Active participants will sign up to
devote some time during the week to take an assignment to further the library
development — working on the library during conference ‘down-time’ — about
30 minutes a day. Participants won’t necessarily code, but might write docs,
write tests, do research or do other critical tasks.

Each day anyone that’s interested can come to a common public session to be
held in times not conflicting with other sessions (1 hour).

The following is a sketch for how we will proceed subject to course
corrections as needed:

day 1: Discussion of the problem, presentation of boost::format
day 2: Presentation of various directions
day 3: Status Presentation
day 4: Status Presentation
day 5: Final status report

All the results of this collaboration will be shared on the Boost Wiki and
Sandbox.

Workshop Objectives:

This innovative workshop will be an opportunity for participants to become a
contributing Boost library authors by working with other Boost members
collaboratively. Overseen by a veteran Boost library developer all Boost best
practices, tools, and techniques will be applied. Overall the goals are for
participants to:

— develop a deep first-hand experience in Boost library development
— an opportunity to contribute to the C++ community
— an opportunity to learn about C++ i/o in depth
— learn about design tradeoffs first hand by tackling a hard problem

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

C++ iostreams provide a comprehensive set of utilities for input and output of
basic and user defined types. This includes formatting, localization,
buffering and other facilities. While widely used, the existing iostreams
library suffers from issues that cause some C++ users to avoid iostreams. The
issues include performance, lack of formatting facilities as compared to C,
difficulties with internationalization, and complex requirements to extend the
library. In fact several Boost libraries address the domain including
boost::format, boost::IO_State_Savers, and boost::iostreams.

The existing iostreams library was developed long before modern C++,
multithreading, asynchronous i/o and other modern facilities. This library in
a week will look at using the modern facilities of C++ to revamp iostreams to
make it more efficient, more extensible, and more widely useable for C++
programmers. Starting with the existing iostreams and boost libraries the
sessions will look at interfaces and implementations that would be superior to
the current standard library.

The workshop will meet every morning to chart progress, set direction, and
interact with other BoostCon participants. Active participants will sign up to
devote some time during the week to take an assignment to further the library
development — working on the library during conference ‘down-time’ — about
30 minutes a day. Participants won’t necessarily code, but might write docs,
write tests, do research or do other critical tasks.

Each day anyone that’s interested can come to a common public session to be
held in times not conflicting with other sessions (1 hour).

The following is a sketch for how we will proceed subject to course
corrections as needed:

day 1: Discussion of the problem, presentation of boost::format
day 2: Presentation of various directions
day 3: Status Presentation
day 4: Status Presentation
day 5: Final status report

All the results of this collaboration will be shared on the Boost Wiki and
Sandbox.

Workshop Objectives:

This innovative workshop will be an opportunity for participants to become a
contributing Boost library authors by working with other Boost members
collaboratively. Overseen by a veteran Boost library developer all Boost best
practices, tools, and techniques will be applied. Overall the goals are for
participants to:

— develop a deep first-hand experience in Boost library development
— an opportunity to contribute to the C++ community
— an opportunity to learn about C++ i/o in depth
— learn about design tradeoffs first hand by tackling a hard problem

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

C++ iostreams provide a comprehensive set of utilities for input and output of
basic and user defined types. This includes formatting, localization,
buffering and other facilities. While widely used, the existing iostreams
library suffers from issues that cause some C++ users to avoid iostreams. The
issues include performance, lack of formatting facilities as compared to C,
difficulties with internationalization, and complex requirements to extend the
library. In fact several Boost libraries address the domain including
boost::format, boost::IO_State_Savers, and boost::iostreams.

The existing iostreams library was developed long before modern C++,
multithreading, asynchronous i/o and other modern facilities. This library in
a week will look at using the modern facilities of C++ to revamp iostreams to
make it more efficient, more extensible, and more widely useable for C++
programmers. Starting with the existing iostreams and boost libraries the
sessions will look at interfaces and implementations that would be superior to
the current standard library.

The workshop will meet every morning to chart progress, set direction, and
interact with other BoostCon participants. Active participants will sign up to
devote some time during the week to take an assignment to further the library
development — working on the library during conference ‘down-time’ — about
30 minutes a day. Participants won’t necessarily code, but might write docs,
write tests, do research or do other critical tasks.

Each day anyone that’s interested can come to a common public session to be
held in times not conflicting with other sessions (1 hour).

The following is a sketch for how we will proceed subject to course
corrections as needed:

day 1: Discussion of the problem, presentation of boost::format
day 2: Presentation of various directions
day 3: Status Presentation
day 4: Status Presentation
day 5: Final status report

All the results of this collaboration will be shared on the Boost Wiki and
Sandbox.

Workshop Objectives:

This innovative workshop will be an opportunity for participants to become a
contributing Boost library authors by working with other Boost members
collaboratively. Overseen by a veteran Boost library developer all Boost best
practices, tools, and techniques will be applied. Overall the goals are for
participants to:

— develop a deep first-hand experience in Boost library development
— an opportunity to contribute to the C++ community
— an opportunity to learn about C++ i/o in depth
— learn about design tradeoffs first hand by tackling a hard problem

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

C++ iostreams provide a comprehensive set of utilities for input and output of
basic and user defined types. This includes formatting, localization,
buffering and other facilities. While widely used, the existing iostreams
library suffers from issues that cause some C++ users to avoid iostreams. The
issues include performance, lack of formatting facilities as compared to C,
difficulties with internationalization, and complex requirements to extend the
library. In fact several Boost libraries address the domain including
boost::format, boost::IO_State_Savers, and boost::iostreams.

The existing iostreams library was developed long before modern C++,
multithreading, asynchronous i/o and other modern facilities. This library in
a week will look at using the modern facilities of C++ to revamp iostreams to
make it more efficient, more extensible, and more widely useable for C++
programmers. Starting with the existing iostreams and boost libraries the
sessions will look at interfaces and implementations that would be superior to
the current standard library.

The workshop will meet every morning to chart progress, set direction, and
interact with other BoostCon participants. Active participants will sign up to
devote some time during the week to take an assignment to further the library
development — working on the library during conference ‘down-time’ — about
30 minutes a day. Participants won’t necessarily code, but might write docs,
write tests, do research or do other critical tasks.

Each day anyone that’s interested can come to a common public session to be
held in times not conflicting with other sessions (1 hour).

The following is a sketch for how we will proceed subject to course
corrections as needed:

day 1: Discussion of the problem, presentation of boost::format
day 2: Presentation of various directions
day 3: Status Presentation
day 4: Status Presentation
day 5: Final status report

All the results of this collaboration will be shared on the Boost Wiki and
Sandbox.

Workshop Objectives:

This innovative workshop will be an opportunity for participants to become a
contributing Boost library authors by working with other Boost members
collaboratively. Overseen by a veteran Boost library developer all Boost best
practices, tools, and techniques will be applied. Overall the goals are for
participants to:

— develop a deep first-hand experience in Boost library development
— an opportunity to contribute to the C++ community
— an opportunity to learn about C++ i/o in depth
— learn about design tradeoffs first hand by tackling a hard problem

Speaker: Jeff Garland
Format: workshop
Attendee Background: Beginner to Expert

C++ iostreams provide a comprehensive set of utilities for input and output of
basic and user defined types. This includes formatting, localization,
buffering and other facilities. While widely used, the existing iostreams
library suffers from issues that cause some C++ users to avoid iostreams. The
issues include performance, lack of formatting facilities as compared to C,
difficulties with internationalization, and complex requirements to extend the
library. In fact several Boost libraries address the domain including
boost::format, boost::IO_State_Savers, and boost::iostreams.

The existing iostreams library was developed long before modern C++,
multithreading, asynchronous i/o and other modern facilities. This library in
a week will look at using the modern facilities of C++ to revamp iostreams to
make it more efficient, more extensible, and more widely useable for C++
programmers. Starting with the existing iostreams and boost libraries the
sessions will look at interfaces and implementations that would be superior to
the current standard library.

The workshop will meet every morning to chart progress, set direction, and
interact with other BoostCon participants. Active participants will sign up to
devote some time during the week to take an assignment to further the library
development — working on the library during conference ‘down-time’ — about
30 minutes a day. Participants won’t necessarily code, but might write docs,
write tests, do research or do other critical tasks.

Each day anyone that’s interested can come to a common public session to be
held in times not conflicting with other sessions (1 hour).

The following is a sketch for how we will proceed subject to course
corrections as needed:

day 1: Discussion of the problem, presentation of boost::format
day 2: Presentation of various directions
day 3: Status Presentation
day 4: Status Presentation
day 5: Final status report

All the results of this collaboration will be shared on the Boost Wiki and
Sandbox.

Workshop Objectives:

This innovative workshop will be an opportunity for participants to become a
contributing Boost library authors by working with other Boost members
collaboratively. Overseen by a veteran Boost library developer all Boost best
practices, tools, and techniques will be applied. Overall the goals are for
participants to:

— develop a deep first-hand experience in Boost library development
— an opportunity to contribute to the C++ community
— an opportunity to learn about C++ i/o in depth
— learn about design tradeoffs first hand by tackling a hard problem

Speaker: Michael Wong
Format: lecture
Track: Track II 2010

In this talk, I will continue and expand on the C++0x concurrency discussion from BoostCOn09, specifically regarding the C++ memory model, and how concurrency will be handled through the new C++0x library, regarding starting and managing threads, sharing data between threads, and synchronizing concurrent operations.

Speaker: Michael Wong
Format: lecture
Track: Track II 2010

Continuing from BoostCon 2009, I will give additional details on C++0x features, as well as the latest news on the ratification of C++0x, as well as continuing report on the latest compiler implementation status.

Speaker: Douglas Gregor
Format: lecture
Track: Track I 2010

Clang is a new, open-source compiler front end for the C family of languages (C, C++, Objective-C). As a C++ compiler, Clang is a production-quality compiler that provides fast compiles, low memory usage, expressive diagnostics, a strong focus on standards conformance, and optimized code generation for a variety of architectures via the Low Level Virtual Machine (LLVM).

But Clang is more than a compiler. Architected as a set a layered, reusable C++ libraries, Clang is a platform for building great C++ development tools. Clang’s internal data structures provide a detailed view of the program source code, with both complete semantic information (overloaded function calls resolved, implicit conversions explicitly represented) and syntactic information (precise source location information, including full macro instantiation history) available throughout. Its Boost-compatible, BSD-like open source license makes it the ideal base for any tool that depends on parsing C++ code fully and correctly, as well as a potential proving ground for new C++ language features and ideas.

This talk will introduce the Clang compiler, illustrating how its rich internal data structures provide a great user experience, then shift focus to a tutorial on Clang’s architecture, primary data structures, and libraries for building Clang-based development tools.

Can it compile Boost? Join us to find out.

Format: social event

Conference registration and Sign-In

Speaker: Joao P. R. Abecasis
Format: tutorial
Track: Track I 2010

The idea for this workshop is to provide a brief overview of Qt libraries, present practical solutions for mixing Qt and Boost.

In particular, I propose to go over MOC and the QObject model, build system integration for projects mixing Boost and Qt libraries, and to explore practical aspects of integrating Boost-based components into the QObject signals and slots implementation based on a small sample application.

I would like to gather feedback from the Boost community on interoperability issues and how it can be improved.

Speaker: Douglas Gregor
Format: workshop
Track: Track I 2010

Like most professionals, programmers use a variety of tools to improve
their productivity, and will occasionally fashion their own tools to
address project-specific needs. Unfortunately for C++ programmers,
building good C++ tools is greatly complicated by the inherent
complexity of parsing C++ code. This complexity, coupled with the lack
of open-source libraries that can parse C++ in its entirety, has kept
C++ tools well behind their counterparts in other languages. Clang
(http://clang.llvm.org) is a new, open-source C++ compiler library
intended to help address this disparity by making it easier to build
great C++ development tools.

In this hands-on workshop, attendees will learn how to use the Clang
libraries to build new C++ tools. We’ll start with the basics, parsing
C++ programs and identifying interesting program constructs. From
there, we’ll learn how Clang represents programs from the lexical
structure (tokens, macro instantiations, etc.) to the semantic
structure (classes, functions, expressions, templates, etc.) via its
abstract syntax tree. Finally, we’ll get our hands dirty and build
some C++ tools using Clang. The actual tools we build will be
determined by the attendees, but possibilities include: enforcing
project-specific coding standards, explaining why overload resolution
picked some specific overload at a call site, automatically generating
serialization code for classes, extracting documentation from Boost
libraries, or interactive debugging for template or preprocessor
metaprograms.

Program committee notes: I’m proposing two different sessions based on
Clang. The 90-minute presentation (“Clang: An Open-Source C++ Compiler
Library”) will describe Clang as a compiler, library, and open-source
project: it’s really a high-level overview that won’t be able to go
too deep into the details. The workshop is more of an experiment along
the lines of the hands-on Boost++0x workshop Dave and I ran last year:
for this year, we’d like to see if we can get attendees to build some
cool tools for Boosters to use. From a scheduling perspective, the
presentation should occur earlier in the week than the workshop, since
the presentation doubles as preparation and an advertisement for the
workshop.

Speaker: Stephan T. Lavavej
Format: lecture
Track: Track I 2010

Many STL classes have complicated representations. To make debugging easier, Visual Studio 2005 and 2008 contained “visualizers” that displayed STL objects in a human-readable way. Anyone can write visualizers for other types, such as Boost classes; while this is undocumented and unsupported, it can be very useful. This presentation explains how to write visualizers, and how to take advantage of new features in Visual Studio 2010 that have been used to improve the display of shared_ptr, function, and map.

Speaker: Ken Joyner
Format: lecture
Track: Track II 2010

It is fairly well known that writing exception-safe code is challenging. This leads many developers to conclude that the use of exceptions should be avoided at all cost. However, the problem with this conclusion is that developers are assuming it is easier to write error-safe code without the use of exceptions. I believe this assumption is incorrect. Instead, I believe that in practice many developers do not write error-safe code and exceptions make it more challenging to ignore the errors that occur (unhandled exceptions will cause your program to terminate so they must be handled).
Writing error-safe code is challenging with or without the use of exceptions. And not writing code that is error-safe leads to unpredictable and often unstable code.
My goal in this lecture is to show that using C++ Exceptions can be practical and useful for the majority of developers and companies who develop code in C++. I plan to do this by discussing levels of exception safety (with a few slight modifications) and propose an exception safety recommendation that is more practical for many companies and developers, give a comprehensive set of guidelines that can be followed to achieve the level of safety a company or developer requires, discuss idioms that are particular useful for writing exeptions and discuss a helper library along with specific recommendations for other libraries that will make writing error-safe code using exceptions significantly less challenging along with adding additional benefits to using exceptions.

This paper re-documents the levels of exception safety (with a few slight modifications), provides an exception safety recommendation that is more practical for most companies and developers, gives a comprehensive set of guidelines (many of them borrowed from other sources) that can be followed to achieve the level of safety a company or developer requires and provides a helper library (again many of the ideas are borrowed from other sources) along with specific recommendations for other libraries that will make writing error-safe code using exceptions significantly less challenging along with adding additional benefits to using exceptions.

Speaker: Tatiana Shpeisman
Format: lecture
Track: Track II 2010

An overview of the “Draft Specification of Transactional Language Constructs for C++” a joint effort by HP, IBM, Intel, Red Hat, and Sun / Oracle.

This talk is part of the Transactional survey session.

Transactional memory (TM) is a modern concurrency control paradigm that simplifies parallel programming and supports an open-ended execution model.
This full-day session brings together leading experts in industry and academia to discuss their recent TM research and development with a specific emphasis on C++. Invited speakers from Boost, IBM, Intel, and Sun Microsystems will provide a brief overview of their latest C++ TM work. In addition, Dr. Tatiana Shpeisman will provide an overview of the “Draft Specification of Transactional Language Constructs for C++” a joint effort by IBM, Intel, and Sun.

Speaker: David Sankel
Format: lecture
Track: Track II 2010

Functional programming (FP) techniques produce code that is general, concise,
composable, and correct. Until recently many of these techniques were limited
to the realm of academia and esoteric programming languages. New C++
and boost developments enable us to embed FP in C++ in a seamless way.

We’ll be covering recursive algebraic data types, curried functions, purity,
generic programming, and category theory.

Speakers: Dave Abrahams, Beman Dawes, Jeff Garland, Douglas Gregor
Format: panel

Boost has a small group of moderators that keep the mailing list running including approving posts and moderation to keep the mailing list on-topic, respectful, and useful. In addition, they administer internals of the website, source repository and other administrative machinery. And last, but not least, the moderators also act as an informal executive overseeing committee to promote all things Boost.

In this session, each moderator will be given 5 minutes to say something about their vision of the future of Boost, but the majority of the session will be devoted to questions and proposals from the audience. This is your chance to ask or propose absolutely anything about the direction of the Boost community. For example, why we don’t adopt a particular policy, tool, or idea.

Format: social event

General Conference Welcome, Introduction, Organizational Announcements

Speaker: Jeremy Siek
Format: lecture
Track: Track I 2010

Graph algorithms and data-structures solve problems in diverse areas
such as Internet packet routing, molecular biology, scientific
computing, and telephone network design. Traditional graph library
designs fail to provide enough flexibility, making them difficult to
use in the context of a particular application. Fortunately, Stepanov
and Musser showed how flexibility can be achieved without sacrificing
performance using the Generic Programming methodology and demonstrated
its efficacy by implementing the Standard Template Library (STL). The
Boost Graph Library (BGL) applies the Generic Programming methodology
to the graph domain and the result is a highly flexible and efficient
library for solving graph problems.

However, if you are unfamiliar with the generic programming paradigm,
the design of the BGL may seem odd and you may find it difficult to
use. In this tutorial we will become familiar with generic programming
and its underlying principles, see how these principles are applied in
the BGL, and learn the C++ template techniques used to implement
generic libraries. We will put the BGL to use in several programming
problems and learn how to take full advantage of its power and
flexibility.

For developers interested in creating generic libraries, this tutorial
will provide a valuable example of how to apply generic programming in
a setting somewhat different from the classical sequence algorithms of
the STL.

Speakers: Barend Gehrels, Bruno Lalande, Mateusz Loskot
Format: lecture
Track: Track I 2010

Boost.Geometry has been designed using modern C++ generic
programming techniques. The tag dispatching technique is used
all over the library, and combined with metafunctions, template
metaprogramming, traits, and concept checking. In literature, tag
dispatching normally does not get the attention it deserves; this
article describes this technique step by step and describes how it
can be used and combined with the other techniques, all in the
context of geometry, with some trivial geometry functions as
examples.

Speaker: Michael Wong
Format: lecture
Track: Track II 2010

An overview of recent TM advances at IBM.
This talk is part of the Transactional survey session.

Transactional memory (TM) is a modern concurrency control paradigm that simplifies parallel programming and supports an open-ended execution model.
This full-day session brings together leading experts in industry and academia to discuss their recent TM research and development with a specific emphasis on C++. Invited speakers from Boost, IBM, Intel, and Sun Microsystems will provide a brief overview of their latest C++ TM work. In addition, Dr. Tatiana Shpeisman will provide an overview of the “Draft Specification of Transactional Language Constructs for C++” a joint effort by IBM, Intel, and Sun.

Format: social event

Get to know your fellow Boosters and catch up with old friends. Bring your families and companions.

Speakers: Matt Calabrese, Zachary Laine
Format: lecture
Track: Track I 2010

In an effort to write a simple metafunction as part of a BoostCon09 session,
the presenters tried to do something odd — to write the metafunction without
any template instantiations. After talking to experts much later, this turned
out to be impossible. In the meantime, they discovered an interesting
technique that makes somtimes-scary TMP code look a lot more like regular
functional programming code, and removes the need to instantiate template
definitions (though not declarations) for most metafunctions.

Speaker: Tatiana Shpeisman
Format: lecture
Track: Track II 2010

An overview of recent TM advances at Intel.
This talk is part of the Transactional survey session.

Transactional memory (TM) is a modern concurrency control paradigm that simplifies parallel programming and supports an open-ended execution model.
This full-day session brings together leading experts in industry and academia to discuss their recent TM research and development with a specific emphasis on C++. Invited speakers from Boost, IBM, Intel, and Sun Microsystems will provide a brief overview of their latest C++ TM work. In addition, Dr. Tatiana Shpeisman will provide an overview of the “Draft Specification of Transactional Language Constructs for C++” a joint effort by IBM, Intel, and Sun.

Speaker: Robert Ramey
Format: lecture

Good things about Boost.

  1. Credible “certification” of library quality and completness through formal review process
  2. Credible “certification” of implementation through formal testing, release process.

Boost isn’t scaling well.

  1. Testing time takes longer and longer to complete..
  2. It’s harder for testing to be comprehensive and include less well known compilers
  3. Current testing can’t handle all the possible combinations of compiler settings (rtti on/off, debug/release, stl library, etc.
  4. installation becomes more onerous and fragile as more libraries are added.
  5. Hence, the “cost” or “overhead” of using boost increases with time even though new users will start using only one library. But there is no way to test/deploy just the libraries one is going to use.

Identity crisis – Is Boost

  1. A single (now large) library of core utilities? i) Tools test, release and deployment of boost is one operation. ii) The test, deployment and release of a subset of libraries has been considered necessary. ii) There is one release number for all libraries.
  2. Or a group (now large) of independent, decoupled libraries? i) Many or most libraries depend only on a subset of the total set of other boost libraries.

My argument is that it looks like boost started out as the former
and is evolving towards the latter.

It’s been a great 10 years for Boost. But to continue to be succeesful it’s going to have to evolve. This presentation describes how I think boost has to change.

Speaker: Roshan Naik
Format: lecture
Track: Track II 2010

The Logic paradigm (LP) is a powerful, Turing-complete programming paradigm that has seen little representation in mainstream languages as compared to the Object-Oriented, Imperative and Functional paradigms. LP is an important approach in Computer Science towards what is sometimes referred to as the Holy-Grail of programming “The user states the problem, the computer solves it”. Origins of the theory underlying Logic dates back to about 300 B.C. when Aristotle founded Formal Logic to bring rigor to logical inferencing. The theory matured into Modern Logic more recently (early 1900s) when Russell & Whitehead showed that all of Mathematics could be reduced to Logic.

This talk centers around Castor, a new opensource C++ library which is intended to be proposed for inclusion into Boost. Besides extending Boost’s abilities to support LP, this will allow Boost programmers to combine facilites from the functional paradigm with LP and enable integration of streams, algorithms and containers without need for iterators or ranges.

This talk will provide an introduction to the basics of LP in C++, followed by plenty of examples to get you thinking in terms of this paradigm. We will observe how it naturally blends with existing Boost and C++ concepts. Finally, we shall broaden the scope to see how powerful multiparadigm solutions emerge when programmers can freely mix and match paradigms. It will be evident from this talk, how a clean and deep integration of LP makes C++ a fountainhead for the many design patterns yet to be discovered.

Speaker: Justin Gottschlich
Format: lecture
Track: Track II 2010

Short overview and introduction about the scheduled Transactional Memory session

Format: social event

A picnic on the Aspen Center for Physics campus.

Speaker: Eric Niebler
Format: lecture
Track: Track I 2010

This presentation will focus on how to build useful DSELs rapidly with Boost.Proto. The session will step through the design and implementation of several real-world DSELs, starting with the simple (e.g., Boost.Assign’s map_list_of()), moving on to the intermediate (e.g., Howard Hinnant’s future groups), and finishing with the design for a simplified Phoenix library. The emphasis will be on practical solutions to real-world library design problems. Through the exploration of specific real-world problems, the value of DSELs in general will become apparent, as will the value of implementing them in C++ with Proto. Usability issues such as compile times and template error messages will also be discussed.

Speaker: Gennadiy Rozental
Format: lecture
Track: Track I 2010

This session will cover various usage scenarios of Boost.Test in production components. Specifically following subject are going to be covered:

  1. Usage of execution_monitor to guard function execution. Various configuration options. (New) Handling of floating point exceptions. (New) Trap site callbacks.
  2. Usage of program_execution_monitor for high level program execution guard.
  3. (New) Usage of Boost test tools in production components.
  4. In place unit testing: 2 approaches to built component unit test inside the implementation itself: a) using compile time switches, b) Using console test runner and implementation built as shared library.

Speakers: Vicente J. Botet Escriba, Justin Gottschlich, Dwight Y. Winkler
Format: lecture
Track: Track II 2010

Transactional memory (TM) is a concurrency control paradigm
that reduces the difficulty of writing parallel programs and
supports the efficient execution of some concurrent workloads.
While TM offers advantages over other abstractions, it can
sometimes require complex hardware, programming language
extensions, specific compiler support, or enforce impractical
software design, making it unrealistic for early adopters.

In this paper, we explore recent advances in TBoost.STM, a
software TM library, that support a wider array of C++’s control
flow statements and simplify the integration of transactions into
programs without transactions.

Speaker: Dave Abrahams
Format: tutorial
Attendee Background: Any Developer

As Boost has grown, it
has become harder and harder to manage, Subversion is getting slow,
our issue tracker is full to overflowing, and the release process is a
full-time job. It’s time to make Boost development fun again.

Ryppl is a system designed for development, testing, release, and distribution of multiple, interdependent projects, like—but not limited to—Boost
libraries. It has the potential to change the face not only of
Boost, but of open-source software in general.
This session will formally unveil Ryppl and demonstrate it in action. By the time of BoostCon, ryppl will be live, and we’ll be able to use
it to work on Boost and other projects.

Speakers: Joel de Guzman, Hartmut Kaiser
Format: lecture
Track: Track II 2010

This year, we celebrate Spirit’s 10th anniversary from its early
beginnings as an offshoot from a much larger GUI library in the 90s and
debuted into Boost in May 2001 in the typical “Is there interest in this
library?” fashion like all would be Boost libraries. From a humble 7
header file library, Spirit has grown to be one of the most
sophisticated Boost libraries and along the way became the incubator of
other Boost libraries such as Boost.Fusion, Boost.Phoenix, and Boost.Wave
and played a significant role for Boost.Proto getting mature.

We would like to present Spirit (and the libraries it inspired) in a
historical perspective. The presentation will aim to provide a lighter,
more intimate perspective into the development of at least 4 libraries
with almost a decade’s worth of experience being Boost authors and
bonafide crazy template metaprogrammers who abuse operators like Mad
Scientists. Of course, we can’t help it if we show off some C++ tricks
here and there, but we’ll try to keep it as light as we can.

Speaker: Mark Moir
Format: lecture
Track: Track II 2010

An overview of recent TM advances at Sun / Oracle.
This talk is part of the Transactional survey session.

Transactional memory (TM) is a modern concurrency control paradigm that simplifies parallel programming and supports an open-ended execution model.
This full-day session brings together leading experts in industry and academia to discuss their recent TM research and development with a specific emphasis on C++. Invited speakers from Boost, IBM, Intel, and Sun Microsystems will provide a brief overview of their latest C++ TM work. In addition, Dr. Tatiana Shpeisman will provide an overview of the “Draft Specification of Transactional Language Constructs for C++” a joint effort by IBM, Intel, and Sun.

Speaker: Justin Gottschlich
Format: lecture
Track: Track II 2010

TBoost.STM Engine: An overview of recent advances in the engine of TBoost.STM.
This talk is part of the Transactional survey session.

Transactional memory (TM) is a modern concurrency control paradigm that simplifies parallel programming and supports an open-ended execution model.
This full-day session brings together leading experts in industry and academia to discuss their recent TM research and development with a specific emphasis on C++. Invited speakers from Boost, IBM, Intel, and Sun Microsystems will provide a brief overview of their latest C++ TM work. In addition, Dr. Tatiana Shpeisman will provide an overview of the “Draft Specification of Transactional Language Constructs for C++” a joint effort by IBM, Intel, and Sun.

Speaker: Dean Michael Berris
Format: lecture
Track: Track II 2010

This paper highlights the various techniques used by the cpp-netlib project to deliver simple yet powerful header-only C++ networking libraries on top of Boost.Asio. Some of the techniques used are borrowed from other existing libraries while some arise from best practices following generic programming principles. The paper aims to highlight the organization of the different parts of the library as well as the idioms used to achieve highly modular and flexible implementations of a common message type, a type-safe URI parser and object representation, and a semantically consistent HTTP client. This paper serves as an introduction to the cpp-netlib project as well as a survey of the modern C++ techniques used throughout the implementation of the various modules of the library.

Speaker: Tony Van Eerd
Format: lecture
Track: Track II 2010

Starting from the very basics, showing problems of accessing shared data, slowly expose the problems, and then lock-free solutions to the problems. Including:
Explain atomicity.
Explain the CAS instruction, and CAS-loops.
Review the perils of the Double-Checked-Locking Pattern (DCLP), and how to avoid it (ie by using memory barriers).
Review memory barriers by presenting an understandable model of how multiple CPUs work, based on the ideas of a read-request queue and a write-request queue.
Present a lock free stack.
Explain ABA and ways to avoid it.
Touch upon some bleeding edge developments in lock-free programming (optimistic relaxed memory operations), etc.
Touch upon Boost and C++0x and how they will affect lock-free programming moving forward.

Speaker: Christophe Henry
Format: tutorial
Track: Track I 2010

My BoostCon09 article about MSM v1 was showing the main features of the library with the goal of facilitating a MDA (Model-Driven-Architecture), also called MDD (Model-Driven-Development) approach. Concretely, the talk was insisting on the descriptive and expressive nature of MSM.
This paper will first sum up the main supported UML features and show their usage with the new front-ends provided by MSM v2.
In the second part of this paper, we will see how MSM now moved further on the MDD way by providing more capabilities usable in a MDD context.

Speakers: Joel Falcou, Jean-Thierry Lapreste
Format: lecture
Track: Track II 2010

Performing large, intensive or non-trivial computing on array like
data structures is one of the most common task in scientific
computing, video game development and other fields. This matter of
fact is backed up by the large number of tools, languages and
libraries to perform such tasks. If we restrict ourselves to C++ based
solutions, more than a dozen such libraries exists from BLAS/LAPACK C++
binding to template meta-programming based Blitz++ or Eigen2. If all
of these libraries provide good performance or good abstraction, none
of them seems to fit the need of so many different user types.

In this talk, we present the Numeric Template Toolbox (NT2), which is
a template meta-programming, array based scientific computing library
which aims at providing a rock-solid implementation to enforce good
performance with respect to architectural concerns like memory
handling and automatic parallelism while providing an intuitive yet
extensible user API and developer SDK. We also emphasize on the added
value of using Boost.Components (MPl,Proto,Fusion,PP,Serialization
among other) to the overall library design and performances.

Speakers: Justin Gottschlich, Maurice Herlihy , Mark Moir, Tatiana Shpeisman, Michael Wong
Format: panel
Track: Track II 2010

The TM experts panel brings together transactional memory (TM) experts from academia and industry. The panelists will discuss near- and long-term challenges of TM and will also provide specific insight into C++ related issues in TM. If time permits, the moderator will also take questions from the audience.

Speaker: Maurice Herlihy
Format: keynote

The term “Transactional Memory” was coined back in 1993, but even today, there is a vigorous debate about what it means and what it should do. This debate sometimes generates more heat than light: terms are not always well-defined and criteria for making judgments are not always clear. This talk will try to impose some order on the conversation, focusing on what TM promises to do in different areas, and how well it seems to be working out.

Speaker: Nevin Liber
Format: lecture
Track: Track I 2010

Beginning with the definition found in C++ Template Metaprogramming, I’ll talk about what is type erasure and how does it work, as well as its advantages and costs. I’ll start with an example taking an inheritance based interface and converting it to one using type erasure. I’ll cover the implementation of Boost.Any, as well as a simplified version of Boost.Function. I’ll touch upon the notion of regular types and classes that work (<http://stlab.adobe.com/wiki/index.php/Image:2008_06_26_classes_that_work.pdf>). I’ll compare using containers of Copyable/Assignable types with that of using containers of Boost.shared_ptr and Boost.Pointer Containers.

Speaker: Michael Caisse
Format: lecture
Track: Track II 2010

Machinery, sensors, equipment, client/server communications, even file formats… Parsing and producing communication streams is everywhere you look. Often these tasks are simple or small enough to tempt ad-hoc solutions. The Spirit 2.1 library provides a model that is simple enough to tackle those “quick hacks” and easily scales for full-featured AST generation.

This session will explore real-life experiences with the parser and generator (Qi/Karma) portions of the Spirit library. As we look at various small and medium-sized parsers/generators employed in various products we will establish some “rules-of-thumb” and guidelines for tackling the parser/generator domain with Qi/Karma. The session will end with the implementation of a usable XML parser and a simplified XPath-like node extractor.

The session will include some lecture and a lot of tutorial. Attendees will walk away with the knowledge and tools to begin parsing and generating with Spirit Qi/Karma.

Speakers

Nokia, Qt Development Frameworks

Dave Abrahams is a founding member of boost.org and an active
participant in the ANSI/ISO C++ standardization committee. He
has been a software professional since 1987, his a broad range of
experience in industry including shrink-wrap software
development, embedded systems design and natural language
processing. He has authored eight Boost libraries and has made
contributions to numerous others.

Dave made his mark on C++ standardization by developing a
conceptual framework for understanding exception-safety and
applying it to the C++ standard library. Dave created the first
exception-safe standard library implementation and, with Greg
Colvin, drafted the proposals that eventually became the standard
library’s exception-safety guarantees.

In 2001 he founded Boost Consulting to deliver on the promise of
advanced, open-source C++ libraries, and has been happily
developing C++ libraries, teaching about C++ and Boost, and
nurturing the Boost community ever since.

Sampaloc, Manila

Vicente J. Botet Escribá got a Master in Computer Science from University Complutense of Madrid- Spain in 1986. More than 20 years of experience on software engineering for fault tolerant systems and more than 10 years of C++ experience. His main research area is on Transactional Memory (TM), Concurrent Systems, and Parallel Computing. Since January 2008 contributes actively to the Boost community. Author of the on review schedule libraries Boost.Conversion, Boost.Bitfields, Boost.Interthreads and the under active development Async, LUID, Role, Rendez-vous and Synchro libraries which would be proposed also to Boost. Since January 2009 he has taken the responsibility to boostify DracoSTM which became TBoost.STM. He is software engineer at Alcatel-Lucent France where he focuses on adaptation of very large telecom systems to multi-core platforms.

Michael Caisse is owner of Object Modeling Designs where his mission is to solve engineering problems for his clients. Solutions include turn-key product development, electronics and software design, optics, image and signal processing, machine control and user interfaces. He has also been known to write business plans and marketing strategies for small businesses.

Michael wrote his first lines of C++ 19-years ago. Since then he has pecked out code in 12 countries, delved into the bowels of microcoding, designed 4096-core super computers, fought with robots, founded a startup, worked in executive management, and became a consultant.

Matt Calabrese is a C++ enthusiast who worked on Boost through Google’s Summer
of Code program in 2006. He has since been a developer at Big Huge Games in
Timonium, Maryland and now does his best to pay his bills as a production
assistant in New York.

Marshall is a long-time boost participant. He is one of the moderators of the Boost-Users mailing list, and helps keep the Trac system running. He has contributed snippets of code to a couple of libraries. Marshall is a principal engineer at Qualcomm, Inc. in San Diego.

Beman Dawes is a software developer from Virginia in the United States and the founder of boost.org.
He is the author of the StreetQuick geographic atlas library used by digital map publishers to help people get really, really, lost. He wrote his first computer program 40 years ago, and does not mourn the passing of bi-quinary arithmetic. Beman has been a voting member of the ANSI/ISO C++ Standards Committee since 1992, and chaired the Library Working Group for five years.
He enjoys travel, sailing, hiking, and biking. He is married, and he and his wife have three cats.

Joel de Guzman is the author of the Boost Spirit Parser Library, the
Boost Fusion Library and the Phoenix Functional-C++ library. He is a
highly experienced software architect and engineer with over 18 years of
professional experience, with specialization and expertise in generic
C++ cross platform libraries and frameworks. Joel is a consultant at
Boost Consulting since 2002 and has provided support and development
services focused on the Boost libraries. His interests include Parser
Generators, Scripting language interpreters and compilers, Domain
Specific Embedded Languages, 2D graphics and GUI frameworks.

Joel Falcou is an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d’Informatique in Orsay, France. His work focuses on investigating high-level programming models for parallel architectures (present and future) and providing efficient implementation of such models using high-performance language features.

Joachim Faulhaber is computer scientist and software developer. He studied computer science and psychology at the Technical University of Berlin where he graduated in 1992. He worked in research projects on problem solving and software development methods. For the last decade he developed software for hospital information systems with a special focus on time and interval related generic programming. Joachim is author of the ITL library of interval containers that has been recently accepted into boost.

Jeff Garland has worked on many large-scale, distributed software projects
over the past 20+ years. The systems span many different domains including
telephone switching, industrial process control, satellite ground control,
ip-based communications, and financial systems. He has written C++ networked
code for several large systems including the development high performance
network servers and data distribution frameworks.

Mr. Garland’s interest in Boost started in 2000 as a user. Since then he has
developed Boost.date_time, become a moderator, served as a review manager for
several libraries (including asio and serialization), administered the Boost
wiki, and served as a mentor for Google Summer of Code. Mr. Garland holds a
Master’s degree in Computer Science from Arizona State University and a
Bachelor of Science in Systems Engineering from the University of Arizona. He
is co-author of Large Scale Software Architecture: A Practical Guide Using
UML. He is currently Principal Consultant for his own company: CrystalClear
Software, Inc.

Barend Gehrels (42) is a physical geographer having 18 years experience in GIS, software development and architecture. He’s working at Geodan, Amsterdam for 15 years. In 1995 he toke the initiative for Geolib, a library for Geographic Information Systems. He has worked on that library and geography / geometry related problems and algorithms since then, programming in C++ and Delphi. He started in 2007 to completely revise the geometry core of Geolib and make it Open Source, which is the GGL now.

Justin Gottschlich is a Ph.D. student at the University of Colorado at Boulder in the Department of Electrical and Computer Engineering. His co-advisors are Professors Jeremy G. Siek and Manish Vachharajani. Justin conducts research in the area of transactional memory (TM) and has co-authored seven peer-reviewed TM publications. Justin is the creator of DracoSTM, a C++ software transactional memory (STM) library, and a contributor to RSTM, University of Rochester’s High-Performance Synchronization Group’s C++ STM library. Justin also created and runs an online multiplayer game, Nodeka, which he wrote entirely in C++. He is also an engineer at Raytheon where he focuses on parallel computing and artificial intelligence.

Doug is a long-time Boost moderator and developer. He has
authored several Boost libraries, including Function (part of the
first C++ library extensions technical report), Signals, and MPI. As a
member of the ISO C++ standards committee, Doug is active in both the
library and evolution working groups and is leading the effort specify
and implement concepts for C++0x. Doug is a post-doctoral researcher
in the Open Systems Laboratory at Indiana University.

Christophe Henry is a French guy living in Germany. He has been working as a software engineer since 10 years and enjoys it.
He was born in Versailles in 1974 and spent his youth playing with all possible electronic devices.
After a small boring detour programming Java, which gave him his motto “a template a day keeps Java away”, he programmed only in C++ and loves it.
Christophe has a wonderful (and really patient) wife and a 5.5 year-old-son and when he is not spending his free time with them, you will find him programming in the night in his PC zone or reading again and again the C++ In-Depth-Series or Joel on software.

Maurice Herlihy is a Professor in the Computer Science Department in Brown University. His’s research centers on practical and theoretical aspects of multiprocessor synchronization. His 1991 paper “Wait-Free Synchronization” won the 2003 Dijkstra Prize in Distributed Computing, and he shared the 2004 Goedel Prize for his 1999 paper “The Topological Structure of Asynchronous Computation.” His 1993 paper that coined the term “Transactional Memory” won the ISCA Influential Paper award in 2008. He is a Fellow of the ACM.

Actel Corporation

After 15+ interesting years that Hartmut spent working in industrial
software development, he still tremendously enjoys working with modern
software development technologies and techniques. His preferred field of
interest is the software development in the area of object-oriented and
component-based programming in C++ and its application in complex contexts,
such as grid and distributed computing, spatial information systems,
internet based applications, and parser technologies. He enjoys using and
learning about modern C++ programming techniques, such as template based
generic and meta-programming and preprocessor based meta-programming.

Zach Laine is a programmer at Applied Research Laboratories at the Univeristy
of Texas at Austin. He specializes in data visualization, Kalman tracking,
and in-house Boost proselytizing.

Bruno Lalande (29) is a software engineer based in Paris and working on information systems, specifically image and sound analysis, using C++.
He’s been developing 3D engines and playing with real-time 3D algorithms for a while. He obtained his background on geometry by these 3D-related activities. Bruno joined the GGL project in April 2008, approaching it from geometry/gaming/mathematical perspective.

Jean-Thierry Lapresté is a french professor at the Blaise Pascal University of Clermont-Ferrand. He was born in Paris in 1949. He has a mathematical formation and worked 10 years in the field of Banach spaces theory, then he turned (up to now) to artificial vision. Not speaking of proper vision works related with tracking and in image geometry, he is working with J. Falcou to provide efficient and extensible C++ HPC library usable by end users (with no esoteric knowledge of programming techniques) but providing seamless access at the power of the new hardware architectures nowadays currently on the shelf.

Stephan T. Lavavej joined the Visual C++ Libraries team in January 2007. He works with Dinkumware to maintain Microsoft’s Standard C++ Library implementation. He originally joined Microsoft in July 2004, after graduating from Caltech, and worked on Outlook 2007 Search.
His name is pronounced “Steh-fin Lah-wah-wade”, or just “STL”. His favorite data structures are the vector and the suffix tree, and his favorite algorithms are Huffman coding and the Burrows-Wheeler Transform.

Mateusz Loskot is a Senior Programmer at Cadcorp in UK. He has been a long time contributor involved in number of Open Source Software projects developing GIS and Remote Sensing tools like GDAL/OGR, libLAS, GEOS, PostGIS and WKT Raster and others. A few months ago he joined Boost.Geometry team.

Mark Moir is a Distinguished Engineer a Sun Microsystems, and is the Principal Investigator of the Scalable Synchronization Research Group at Sun Labs. Moir received the B.Sc. (Hons.) degree in Computer Science from Victoria University of Wellington, New Zealand in 1988, and the Ph.D. degree in Computer Science from the University of North Carolina at Chapel Hill, USA in 1996. From August 1996 until June 2000, he was an assistant professor in the Department of Computer Science at the University of Pittsburgh, after which he joined Sun Labs.

Roshan Naik (roshan AT mpprogramming.com) specializes in multiparadigm programming techniques. Roshan is author of Castor (www.mpprogramming.com/cpp), an open source library which brings the Logic Paradigm to C++.

Eric Niebler has been a professional C++ developer for over 10 years. He
has helped develop natural language processing software for Microsoft
Research and template libraries for Visual C++. Since 2003, Eric has
worked as a Boost consultant with David Abrahams. He is especially
interested in text processing, pattern matching and the design of
domain-specific embedded libraries. Eric authored the popular GRETA
regular expression template library in addition to the Boost libraries
Foreach and Xpressive. He also has assisted in the development of
several other Boost libraries and has two more Boost libraries awaiting
review. Eric has written articles for the C/C++ Users’ Journal, MSDN
Magazine and The C++ Source, and spoken about C++ at OOPSLA/LCSD and C++
Connections.

Stjepan just completed a Master of Fine Arts degree in Dance and a Ph.D. in Computer Science, both with concentrations from the School of Arts, Media and Engineering at Arizona State University. He still works at the university as an Assistant Research Scientist, and is also a Director of urbanSTEW, a non-profit organization that integrates arts and technology. He greatly enjoys developing open source software, and thanks the Boost community for a wonderful collection of libraries.

Robert Ramey Software Development

Gennadiy is a software developer originally from Ukraine, who now lives in New Jersey, United States and works for QR team in JPMorgan Chase. He is married, with son and daughter.

Gennadiy graduated from MIPT: Moscow Institute of Physics and Technology with Master degree in computer science. Ever since then Gennadiy has been programming mostly in C++.

In his spare time he not only works on Boost, but also enjoys origami making.

David Sankel is a professional software developer/architect based in the USA.
His prolific software developments have included CAD/CAM, visual programming
languages, web applications, computer vision, and cryptography.

David’s current research interests include statically typed language and applied
functional programming, especially in the areas of EDSLs and functional
reactive programming. He is currently the Principal Consultant of his own
company, Sankel Software.

Intel

Jeremy Siek is an Assistant Professor at the University of Colorado at Boulder. Jeremy’s areas of research include generic programming, programming language design, type systems, and compiler optimizations for high-level languages. Jeremy received his Ph.D. at Indiana University in 2005 for his thesis “A Language for Generic Programming” which laid the foundation for the constrained templates feature that will appear in the next version of the C++ Standard.
Also while at Indiana, Jeremy developed the Boost Graph Library, a C++ generic library for graph algorithms and data structures. After leaving Indiana, Jeremy was a post-doc at Rice University and worked on the Concoqtion project, melding the MetaOCaml language with the Coq theorem prover and Jeremy developed the idea of gradual typing: a type system that integrates both dynamic and static typing in the same programming language.
Jeremy is currently working on a gradually-typed version of Python, on a language for reflective metaprogramming, and on software transactional memory with his graduate students at CU.

Tony Van Eerd has been coding professionally for over 20 years. Most of that time has been in the video/film/broadcast industry, for Inscriber Technology and Adobe Systems Inc., writing everything from device drivers to image processing to text processing to UI to anything in between. Once upon a time he also helped write software for the blind, and a C program that wrote C programs. Recently he began working for the UI team at RIM, the makers of BlackBerry mobile devices, and even writing some java. To counter-balance that he researches lock-free programming in his ‘spare time’.

While he has yet to contribute to Boost except via his 2 cents worth of emails, an actual code contribution is still a goal he looks forward to.

Department of Computer Science California State Polytechnic University, Pomona

Michael Wong is the IBM and Canadian representative to the C++ Standard and OpenMP Committee and is the co-author of a number C++0x/OpenMP features including generalized attributes, extensible literals, inheriting constructors, weakly ordered memory models, and explicit conversion operators. He is the past C++ team lead to IBM’s XL C++ compiler and has been designing C++ compilers for fifteen years. His current research interest is in the area of parallel programming, C++ benchmark performance, object model, generic programming and template metaprogramming. He holds a B.Sc from University of Toronto, and a Masters in Mathematics from University of Waterloo.

Comments are closed.