2009 Program

2009 Resources (Slides, code, etc…)

Sunday, May 03
time Track I 2009 Track II 2009
04:00PM
06:00PM
Conference registration and Sign-In (Meadow lobby)
06:00PM
07:00PM
Break
07:00PM
10:00PM
Informal Gathering at Meadows Bar – Travelling companions welcome.
Monday, May 04
time Track I 2009 Track II 2009
08:00AM
09:00AM
Jeff Garland: Boost Library in a Week — std::rdb (Mon)
09:00AM
10:30AM
Michael Wong: C++0x overview and Compiler support Christophe Henry: The Meta State Machine (Msm) library – Tutorial
10:30AM
11:00AM
Break
11:00AM
12:30PM
Stephan T. Lavavej: Parallel Patterns Library in Visual Studio 2010 Joel Falcou: High-Level Parallel Programming EDSL – A BOOST libraries use case
12:30PM
02:30PM
Break
02:30PM
04:00PM
Troy Straszheim: Icefishing for Neutrinos with Boost Serialization Tutorial and Examples Dave Abrahams: Boost++0x #1: Hands-on rvalue References
04:00PM
04:30PM
Break
04:30PM
06:00PM
Troy Straszheim: Icefishing for Neutrinos with Boost – Hybrid Architecture with Boost Python Abrahams: Boost++0x #1: Hands-on rvalue References (continued)
06:00PM
08:00PM
Break
08:00PM
09:30PM
nothing scheduled
Tuesday, May 05
time Track I 2009 Track II 2009
08:00AM
09:00AM
Jeff Garland: Boost Library in a Week — std::rdb (Tue)
09:00AM
09:45AM
Bill Hoffman, Brad King: A CMake-Based Software Process for Development and Integration Testing Marshall Clow: Extending Boost.Algorithms — A Progress Report
09:45AM
10:30AM
Troy Straszheim: Status of the boost-cmake effort Emil Dotchevski: Boost Exception Authors Corner
10:30AM
11:00AM
Break
11:00AM
12:30PM
Asher Sterkin: State-Oriented Programming Using Boost Statechart Library (BSL) Justin Gottschlich, Jeremy Siek: Boost + Software Transactional Memory
12:30PM
02:30PM
Break
02:30PM
04:00PM
Christophe Henry: The Meta State Machine (Msm) library – Hands-on Dave Abrahams: Boost++0x #2: Hands-on decltype, variadic templates, advanced SFINAE
04:00PM
04:30PM
Break
04:30PM
06:00PM
Michael Wong: Multithreaded C++0x: The Dawn of a New Standard Abrahams: Boost++0x #2: Hands-on decltype, variadic template (continued)
06:00PM
08:00PM
Break
08:00PM
09:30PM
nothing scheduled
Wednesday, May 06
time Track I 2009 Track II 2009
08:00AM
09:00AM
Jeff Garland: Boost Library in a Week — std::rdb (Wed)
09:00AM
10:30AM
Andrei Alexandrescu: Iterators Must Go (Keynote)
10:30AM
11:00AM
Break
11:00AM
12:30PM
Stephan T. Lavavej: C++0x Support in Visual Studio 2010 Troy Straszheim: Kamasu: Parallel computing on the GPU with boost::proto
12:30PM
02:30PM
Break
02:30PM
04:00PM
Joel de Guzman, Hartmut Kaiser: Building a simple language compiler using Spirit V2.1 Thomas Becker: The Boost Smart Pointer Library
04:00PM
04:30PM
Break
04:30PM
06:00PM
de Guzman, Kaiser: Building a simple language compiler using Spirit (continued) Becker: The Boost Smart Pointer Library (continued)
06:00PM
06:30PM
Break
06:30PM
08:30PM
Picnic’09 – bring your families and friends
Thursday, May 07
time Track I 2009 Track II 2009
08:00AM
09:00AM
Jeff Garland: Boost Library in a Week — std::rdb (Thu)
09:00AM
09:45AM
Asher Sterkin: Practical C++ Test-Driven Development with Boost.Test and Bmock Beman Dawes: The Boost Filesystem Library V3 Authors Corner
09:45AM
10:30AM
Sterkin: Practical C++ Test-Driven Development with Boost.T (continued) Dan Marsden: Boost Fusion Authors Corner
10:30AM
11:00AM
Break
11:00AM
12:30PM
Brook Milligan: Dynamic Programming: A Generic Viterbi Algorithm Dan Marsden: An experimental domain specific language for template metaprogramming
12:30PM
02:30PM
Break
02:30PM
04:00PM
Barend Gehrels, Bruno Lalande: A Generic Geometry Library Tom Brinkman: Generic Graphics Programming With GIL
04:00PM
04:30PM
Break
04:30PM
06:00PM
Lucanus Simonson, Gyuszi Suto: GTL (Geometry Template Library) for STL-like 2D Operations Tom Brinkman: Graphics Programming Workshop – Chart Library
06:00PM
08:00PM
Break
08:00PM
09:30PM
Dave Abrahams, Beman Dawes, Jeff Garland: BoostCon 2010 Kickoff Meeting
Friday, May 08
time Track I 2009 Track II 2009
07:45AM
08:45AM
Jeff Garland: Boost Library in a Week — std::rdb (Fri)
08:45AM
09:30AM
Asher Sterkin: Advanced Preprocessor Meta-Programming with Boost.Preprocessor Library Joachim Faulhaber: An Introduction to the Interval Template Library
09:30AM
10:15AM
Sterkin: Advanced Preprocessor Meta-Programming with Boost. (continued) Troy Straszheim: Hands on Boost-cmake
10:15AM
10:30AM
Break
10:30AM
11:30AM
Dave Abrahams, Beman Dawes, Jeff Garland: Future of Boost Panel 2009

Sessions

Note: Click the title of any session to visit its start time in
the conference schedule.

A CMake-Based Software Process for Development and Integration Testing

Speakers: Bill Hoffman, Brad King
Format: lecture
Track: Track I 2009

We will present the Kitware Quality Software Process using our CMake, CTest, CDash, and CPack tools. The talk will focus both on our general process and on how the tools meet the needs of Boost developers and users.

Advanced Preprocessor Meta-Programming with Boost.Preprocessor Library

Speaker: Asher Sterkin
Format: lecture
Track: Track I 2009

According to original C++ vision the usage of "C" preprocessor should kept at minimum and ideally should be avoided at all. Instead C++ templates are supposed to be used as the mainstream meta-programming mechanism. And indeed, the Boost Meta-Programming Library (MPL) makes many, previously inconceivable, miracles possible. Still whenever there is a need for avoiding duplications in C++ code, with automatic naming and/or source file location manipulations involved, the preprocessor level meta-programming turns to be the only practical option preferable over using external code generation tools. In this tutorial (90 minutes) I will demonstrate how the Boost.Preprocessor library could be effectively used for cost-effective automatic generation of C/C++ code. The tutorial is organized as a series of real-life examples including IDL-like function/method annotations, static data structure population, look-up tables, advanced function a method pointers manipulation, big/little-endian bit fields manipulation. Each example demonstrates non-trivial application of Boost.Preprocessor collections and algorithms.

A Generic Geometry Library

Speakers: Barend Gehrels, Bruno Lalande
Format: lecture
Track: Track I 2009

The Geometry Library is a library for geometry and geography. It is based on templates and static polymorphism. It is agnostic in coordinate space and dimensions. Geometry types and algorithms are separated. The library uses concepts for its geometry types. Developers can therefore define and use their own geometry types and specializations. Essential algorithms such as distance calculations, area calculations, point in polygon calculations are provided. A geometry library like described would be a valuable addition to the Boost Library Collection.

An experimental domain specific language for template metaprogramming

Speaker: Dan Marsden
Format: lecture
Track: Track II 2009

Boost.MPL is a powerful library for template metaprogramming in C++. It is heavily used in the development of many other libraries, both within and outside Boost. Unfortunately metaprogramming in C++ is a difficult process, even with the support of the MPL, awkward syntax, unreadable error messages and difficult to diagnose bugs are common place.

This talk will discuss an attempt to address the problems of C++ metaprogramming with the implementation of an experimental DSL for C++ metaprogramming written in Haskell. The DSL aims to exploit the strengths of Haskell to engineer DSLs, to provide cleaner syntax, type checking of functions, generation of Boost.MPL code, and even "running" of the code to aid debugging. No prior knowledge of Haskell will be assumed, and MPL features will be explained as they are needed. Hopefully the talk will be of interest to users of the MPL, developers of DSLs, and people interested in seeing the contrasting features of 2 languages.

An Introduction to the Interval Template Library

Speaker: Joachim Faulhaber
Format: lecture
Track: Track II 2009

The Interval Template Library (Itl) provides intervals
and two kinds of interval containers: Interval_sets and
interval_maps. Interval_sets and maps can be used just
as the sets or maps of elements. Yet they are much more
space and time efficient when the elements occur in
contiguous chunks. This is obviously the case in many
problem domains, particularly in fields that deal with
problems related to date and time.

In addition to common set and map semantics, interval
containers are capable to compute with segmentation.
A segmentation, e.g. a grid of months, can be intersected
into other interval containers and then be iterated over.

Finally interval_maps allow for aggregations on
associated values, if added intervals overlap with
intervals, that are stored in the interval_map. This
feature is called ‘aggregate on overlap’.

Boost.Itl (Interval Template Library) is a proposed library
that will be ready for review until end of March 09.

Boost++0x #1: Hands-on rvalue References

Speaker: Dave Abrahams
Format: workshop
Track: Track II 2009

This is a getting-stuff-done session.

Format: Very short tutorial review by Dave followed by 1/2 day of work adding rvalue references and move semantics to various Boost libraries, in groups of 2-3, using the features in GCC >= 4.3.

The goals of Boost++0x sessions are to:

  • Give BoostCon attendees a chance to play with C++0x features in real-world code
  • Get some useful C++0x features into the Boost Subversion Repository so that Boost is better prepared when C++0x compilers become more commonplace

We will also create a web site with C++0x tutorials, which will be
an important resource for attendees as they are working on upgrading
Boost to C++0x.

Prerequisites:
– have read the tutorials
– a laptop with

  • wireless ethernet connection
  • GCC >= 4.3
  • subversion Client

Boost++0x #2: Hands-on decltype, variadic templates, advanced SFINAE

Speaker: Dave Abrahams
Format: workshop
Track: Track II 2009

This is a getting-stuff-done session.

Format: Very short tutorial review by Dave followed by 1/2 day of work exploiting these C++0x features in various Boost libraries, in groups of 2-3, using the features in GCC >= 4.3.

The goals of Boost++0x sessions are to:

  • Give BoostCon attendees a chance to play with C++0x features in real-world code
  • Get some useful C++0x features into the Boost Subversion Repository so that Boost is better prepared when C++0x compilers become more commonplace

We will also create a web site with C++0x tutorials, which will be
an important resource for attendees as they are working on upgrading
Boost to C++0x.

Prerequisites:

  • have read the tutorials
  • a laptop with
    • wireless ethernet connection
    • GCC >= 4.3
    • subversion Client

BoostCon 2010 Kickoff Meeting

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

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

Boost Exception Authors Corner

Speaker: Emil Dotchevski
Format: tutorial
Track: Track II 2009

Author’s corner presentation — introduction to the Boost Exception library, motivation and use cases, brief history, design decisions, Q&A.

Boost Fusion Authors Corner

Speaker: Dan Marsden
Format: tutorial
Track: Track II 2009

Boost.Fusion is a heterogenous container (tuple) library that is used as infrastructure for several other Boost libraries. This will be a 30 minute
Authors Corner presentation by one of the co authors of Boost.Fusion. It
will discuss some of the history and implementation of the library, give
a quick outline Fusion, and highlight some of the more interesting
features of the library.

Boost Library in a Week — std::rdb (Fri)

Speaker: Jeff Garland
Format: tutorial

C++ is one of the few major languages lacking a standard relational database binding and it hurts. Many C++ developers would like to be able to portably develop applications that access various RDBs with the knowledge that the underlying database engine could be replaced without rewriting code. Further, C++ developers would like database code to mesh seamlessly with other code using the standard library. There has been some activity toward a Boost database library, but never a concerted effort to design an API. This effort will be an attempt to mine the best of available open source and commercial APIs into a proposal suitable for Boost and TR2.

The workshop will meet every morning to chart progress, set direction, and interact with other BoostCon participants. Due to the scope of this task there will be 2 additional 1/2 day workshop sessions to draft interface and do technical work. 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 various existing APIs
day 1 1/2 day session: continuation of existing APIs — scoping and dividing the work
day 2: Presentation / status
day 3: Review of draft API
day 4: Status Presentation
day 4 1/2 day workshop session to wrap up API design work
day 5: Final status reprot

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

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 existing RDB open source C++ bindings
— learn about design tradeoffs first hand by tackling a hard problem

Boost Library in a Week — std::rdb (Mon)

Speaker: Jeff Garland
Format: workshop

C++ is one of the few major languages lacking a standard relational database binding and it hurts. Many C++ developers would like to be able to portably develop applications that access various RDBs with the knowledge that the underlying database engine could be replaced without rewriting code. Further, C++ developers would like database code to mesh seamlessly with other code using the standard library. There has been some activity toward a Boost database library, but never a concerted effort to design an API. This effort will be an attempt to mine the best of available open source and commercial APIs into a proposal suitable for Boost and TR2.

The workshop will meet every morning to chart progress, set direction, and interact with other BoostCon participants. Due to the scope of this task there will be 2 additional 1/2 day workshop sessions to draft interface and do technical work. 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 various existing APIs
day 1 1/2 day session: continuation of existing APIs — scoping and dividing the work
day 2: Presentation / status
day 3: Review of draft API
day 4: Status Presentation
day 4 1/2 day workshop session to wrap up API design work
day 5: Final status reprot

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

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 existing RDB open source C++ bindings
— learn about design tradeoffs first hand by tackling a hard problem

Boost Library in a Week — std::rdb (Thu)

Speaker: Jeff Garland
Format: tutorial

C++ is one of the few major languages lacking a standard relational database binding and it hurts. Many C++ developers would like to be able to portably develop applications that access various RDBs with the knowledge that the underlying database engine could be replaced without rewriting code. Further, C++ developers would like database code to mesh seamlessly with other code using the standard library. There has been some activity toward a Boost database library, but never a concerted effort to design an API. This effort will be an attempt to mine the best of available open source and commercial APIs into a proposal suitable for Boost and TR2.

The workshop will meet every morning to chart progress, set direction, and interact with other BoostCon participants. Due to the scope of this task there will be 2 additional 1/2 day workshop sessions to draft interface and do technical work. 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 various existing APIs
day 1 1/2 day session: continuation of existing APIs — scoping and dividing the work
day 2: Presentation / status
day 3: Review of draft API
day 4: Status Presentation
day 4 1/2 day workshop session to wrap up API design work
day 5: Final status reprot

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

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 existing RDB open source C++ bindings
— learn about design tradeoffs first hand by tackling a hard problem

Boost Library in a Week — std::rdb (Tue)

Speaker: Jeff Garland
Format: workshop

C++ is one of the few major languages lacking a standard relational database binding and it hurts. Many C++ developers would like to be able to portably develop applications that access various RDBs with the knowledge that the underlying database engine could be replaced without rewriting code. Further, C++ developers would like database code to mesh seamlessly with other code using the standard library. There has been some activity toward a Boost database library, but never a concerted effort to design an API. This effort will be an attempt to mine the best of available open source and commercial APIs into a proposal suitable for Boost and TR2.

The workshop will meet every morning to chart progress, set direction, and interact with other BoostCon participants. Due to the scope of this task there will be 2 additional 1/2 day workshop sessions to draft interface and do technical work. 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 various existing APIs
day 1 1/2 day session: continuation of existing APIs — scoping and dividing the work
day 2: Presentation / status
day 3: Review of draft API
day 4: Status Presentation
day 4 1/2 day workshop session to wrap up API design work
day 5: Final status reprot

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

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 existing RDB open source C++ bindings
— learn about design tradeoffs first hand by tackling a hard problem

Boost Library in a Week — std::rdb (Wed)

Speaker: Jeff Garland
Format: tutorial

C++ is one of the few major languages lacking a standard relational database binding and it hurts. Many C++ developers would like to be able to portably develop applications that access various RDBs with the knowledge that the underlying database engine could be replaced without rewriting code. Further, C++ developers would like database code to mesh seamlessly with other code using the standard library. There has been some activity toward a Boost database library, but never a concerted effort to design an API. This effort will be an attempt to mine the best of available open source and commercial APIs into a proposal suitable for Boost and TR2.

The workshop will meet every morning to chart progress, set direction, and interact with other BoostCon participants. Due to the scope of this task there will be 2 additional 1/2 day workshop sessions to draft interface and do technical work. 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 various existing APIs
day 1 1/2 day session: continuation of existing APIs — scoping and dividing the work
day 2: Presentation / status
day 3: Review of draft API
day 4: Status Presentation
day 4 1/2 day workshop session to wrap up API design work
day 5: Final status reprot

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

All the results of this collaboration will be shared on the Boost Wiki and Sandbox. By the end of the week we should have a draft API with documented tradeoffs.

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 existing RDB open source C++ bindings
— learn about design tradeoffs first hand by tackling a hard problem

Boost + Software Transactional Memory

Speakers: Justin Gottschlich, Jeremy Siek
Format: lecture
Track: Track II 2009

Transactional memory (TM), a recently devised parallel programming concept, is rapidly increasing in popularity. Transactions simplify parallel code by shifting the complexity of shared memory management away from the programmer’s view into the TM subsystem. Transactions improve the performance of parallel programs by permitting more than one thread to concurrently execute the same critical section. Furthermore, transactions aggregate parallel components by composing several independent transactions together to form a single, indivisible transaction.

In this talk we explain DracoSTM, a C++ software transactional memory (STM) library. We demonstrate how users interface with DracoSTM to create simple, yet efficient parallel programs. We then discuss DracoSTM’s implementation and how it combines automatic objects and preprocessor macros to construct its programming model. This talk also provides a brief survey of TM and explains how DracoSTM solves, or plans to solve, many of the open problems in TM. In closing, we propose a road map to integrate DracoSTM into Boost as an important addition to its world-class library suite.

Building a simple language compiler using Spirit V2.1

Speakers: Joel de Guzman, Hartmut Kaiser
Format: lecture
Track: Track I 2009

The session will provide a walkthrough presentation and tutorial on how to write language parsers and compilers using Spirit V2. The tutorial will be presented in a pragmatic manner with less emphasis on theory.
All aspects of compiler development from lexical analysis (using Spirit.Lex), parsing, tree generation, semantic actions (using
Spirit.Qi) and analyzing and transforming the generated parse tree and generating the intermediate language (using Spirit.Karma) will be covered. At the end of the session, we will have written a new programming language, and built a working compiler usable as a reference for building similar systems.

Spirit V2 is a complete parsing and output generation system with a symmetrical architecture that covers the whole spectrum from lexing to output generation. Spirit2 uses stylized PEG (Parsing Expression Grammar; similar to EBNF (Extended Backus Naur Form)) to describe a grammar (for parsing) and a output format (for generation) directly in
C++. This allows us to construct programs that are able to parse input
token sequences conforming to an input grammar and to generate output token sequences conforming to an output format.

The session will give a thorough introduction to Spirit’s subsystems, their features, how to use them, how to extend them for special needs.
All the details will be presented based on the compiler example. The session will cover semantic processing and backend generation to complete the picture. It will also show how combining the various subsystems work for language transformations.

C++0x overview and Compiler support

Speaker: Michael Wong
Format: lecture
Track: Track I 2009

As a member of the C++ Standard committee, I will give an overview of the C++0x core language features with a brief description of their motivations, and usage. This will range from common initializations, constant expressions, concepts, delegating constructor, namespace association, auto, long long, improved enums, template aliases, and many others. As an added bonus, I will also present a current view of what many common compilers seems to be offering to support C++0x based on publicly available information.

C++0x Support in Visual Studio 2010

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

Five C++0x language features are being added to Visual Studio 2010: lambdas, auto, static_assert, rvalue references, and decltype. Many C++0x library features are also being added, such as make_shared<T>() and forward_list. This presentation covers these features, including how they interact with (and sometimes supersede!) parts of Boost.

Conference registration and Sign-In (Meadow lobby)

Format: social event

Conference registration and Sign-In

Dynamic Programming: A Generic Viterbi Algorithm

Speaker: Brook Milligan
Format: lecture
Track: Track I 2009

Dynamic programming forms the centerpiece of many solutions to computational problems across all application domains. In many cases, the Viterbi algorithm is an optimal implementation for dynamic programming problems. First developed as an optimal means of decoding a serial signal in the presence of noise, it has found applications in a diversity of areas. Digital communication, for example, relies heavily on convolutions codes interpreted by Viterbi decoders to ensure efficient satellite communication, to operate cell phone networks, and to control Bluetooth devices. The Viterbi algorithm is used in computational biology to detect genetic signal sequences within genomes and even to decipher genome sequences themselves. It is also used in such diverse applications as decoding and classifying textual documents, recognizing gestures, quantifying the difference between two documents, and optical character recognition.

Although the Viterbi algorithm follows a standard and reusable pattern. each domain of application generally reimplements a domain-specific solution. Given the breadth of application of the Viterbi algorithm, this represents massive duplication of effort and slows the development of new solutions based upon the algorithm.

The focus of this presentation is on a generic version of the Viterbi algorithm, one that fully separates the algorithm itself from the domain-specific components. This separation is obtained by leveraging the power of the Boost Graph Library (BGL) to provide a generic framework for the algorithm. The BGL is extended with several generic algorithms and concepts. In practice, only a few domain-specific classes, each modeling well-defined concepts making up the Viterbi algorithm, are required to solve concrete application-domain problems. A generic version of an algorithm as widely used as the Viterbi should greatly improve the efficiency with which new problems may be solved. Even when it remains advantageous to rely ultimately upon hardware- or custom-encoded solutions, their development may be simplified by using a generic algorithm during the design and verification stages. However, the separation of the algorithm from the domain-specific parts also enables improvements in efficiency to be transfered across domains. Indeed, one goal is to improve the performance of the generic algorithm so it competes with custom-coded solutions that are much more difficult to develop and maintain.

Extending Boost.Algorithms — A Progress Report

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

Last year’s BoostCon Library in a week focused on writing new STL algorithms. During the week some initial algorithms were written, but work continued after the conference. This session will provide an update on progress since last year’s BoostCon and talk about future directions.

Future of Boost Panel 2009

Speakers: Dave Abrahams, Beman Dawes, Jeff Garland
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.

Generic Graphics Programming With GIL

Speaker: Tom Brinkman
Format: lecture
Track: Track II 2009

Requirements:
1) Boost Libraries

Presentation Objectives:
1) Learn Generic Graphics Programming Techniques
2) Learn how to use GIL
3) Learn how to create Generic Graphics Algorithms

Graphics programming is a enormous topic and will take a lifetime to master. Most people
only master a small percentage of the topic. Its endlessly interesting and never fails to
fascinate.

This session will be a gentle introduction to generic graphics programming using GIL.
GIL was developed by Adobe and has been part of boost for two years now.
This session will demonstrate how to generically create graphics algorithms
that are independent of the image representation. GIL is designed to compliment
STL and work natively on raw pixel data. Its design is orthogonal,
allowing virtually every component (channels, color spaces, pixels, pixel iterators,
locators, views, images and algorithms) to be replaced.

Developing graphics algorithms traditionally has come down to a choice
between two mutually exclusive objectives, genericity and performance.
Is there a way to design a graphics algorithm that is both performant
and generic?

What if I were to tell you that there is a way to do this. To avoid
having to make the choice between these two seemingly mutually exclusive desires.
With the use of functional programming techniques and the use of GIL,
this is in fact possible. That is why I am so excited about GIL. The patterns that we will
discuss in this session, allow you to achieve both, with no compromise.

Graphics Programming Workshop – Chart Library

Speaker: Tom Brinkman
Format: workshop
Track: Track II 2009

Building on our previous discussion, lets build a chart library.
I’ll demonstrate how to do this using GIL, using only functional
programming techniques. This will be a hands on workshop. You
will be encouraged to compile code and contribute to the
discussion about the api.

Our friends in the other room are discussing a geometry library.
What better way to contribute to that effort than be creating
a charting library to display their data.

Techniques demonstrated will include:
1) Drawing Lines (Wuline algorithm)
2) Drawing Text
3) Graphics primitives

GTL (Geometry Template Library) for STL-like 2D Operations

Speakers: Lucanus Simonson, Gyuszi Suto
Format: lecture
Track: Track I 2009

There is a proliferation of geometric algorithms and data types with no existing mechanism to unify geometric programming in C++. The generic geometry library provides geometry concepts and concept mapping through traits as well as algorithms parameterized by conceptual geometric data type to provide a unified library of useful geometric algorithms that is interoperable with existing geometric data types. Specific concepts and algorithms provided focus on high performance/capacity 2D polygon manipulation. The API for invoking those algorithms is based on overloading of generic free functions on concept. Overloaded generic operator syntax for Booleans (set operations) on polygon data and the supporting operator templates are provided to make the API highly productive and abstract away the details of algorithms from their usage. The library was implemented in Intel Corporation to converge the programming of geometric manipulations in C++ while providing best in class runtime and memory performance. This paper will discuss the specific needs of generic geometry programming and how those needs are met by the concepts based type system that makes the generic API possible.

Hands on Boost-cmake

Speaker: Troy Straszheim
Format: lecture
Track: Track II 2009

Building and testing boost on all platforms, posting test results to dashboards, writing cmakefiles and generally exercising the build system. The boost-cmake developers will be there to give one on one support.

High-Level Parallel Programming EDSL – A BOOST libraries use case

Speaker: Joel Falcou
Format: lecture
Track: Track II 2009

Parallel programming is becoming a concern for a growing audience of developers. Various programming models and tools have been proposed but never became largely accepted
in the community. This paper shows how a Embedded Domain Specific Language has been defined using Boost libraries like MPL and Proto and how it solves various typical problem of high-level parallel programming tools like reusing legacy code or preserving developer habits.
This EDSL – Quaff – is able to map data-flow applications over clusters, multi-cores and CELL processor using algorithmic skeletons. Realistic application is presented and assess Quaff expressiveness and eciency.

Icefishing for Neutrinos with Boost – Hybrid Architecture with Boost Python

Speaker: Troy Straszheim
Format: lecture
Track: Track I 2009

The IceCube Collaboration (http://www.icecube.wisc.edu) is in the process of building the world’s largest Neutrino Detector (over one cubic kilometer of instrumented ice) two kilometers beneath the surface at the geographic south pole.
A boost-heavy software framework, IceTray, is used to handle the data
collected both at the south pole and in simulation/analysis scenarios
in the north. IceTray is also being used by the European KM3Net collaboration (http://www.km3net.org), currently operators of three different neutrino telescopes underwater in the Meditteranean sea.

This presentation will start with an overview of the
IceCube project (usually entertaining and a bit outlandish
to those who are not familiar with high energy physics), and then
review what boost::serialization and boost::python contribute to the
architecture of the IceTray framework and what design patterns they
enable.

The boost::serialization part of the talk will touch on most aspects
of the library, with emphasis on certain pitfalls such as how to
manage large datasets, backwards compatibility considerations,
environments involving lots of dynamic linking / plugins containing
serializable objects, and design of a file format around boost::serialization.

The boost::python section of the talk will start with an overview of
creating python bindings similar to Timothy Shead’s talk at boostcon
#1. The later parts of the talk will be more of a design study of how
boost::python functions architecturally in the IceTray framework
(IceTray has extensive python bindings and interoperability): python
is used as a testing tool, a physics analysis language, a prototyping
environment, a config file language,

The content of this talk is slated to become a chapter in a
upcoming O’Reilly book called "Beautiful Data", a follow-on to the
earlier "Beautiful Code".

Icefishing for Neutrinos with Boost Serialization Tutorial and Examples

Speaker: Troy Straszheim
Format: lecture
Track: Track I 2009

The IceCube Collaboration (http://www.icecube.wisc.edu) is in the process of building the world’s largest Neutrino Detector (over one cubic kilometer of instrumented ice) two kilometers beneath the surface at the geographic south pole.
A boost-heavy software framework, IceTray, is used to handle the data
collected both at the south pole and in simulation/analysis scenarios
in the north. IceTray is also being used by the European KM3Net collaboration (http://www.km3net.org), currently operators of three different neutrino telescopes underwater in the Meditteranean sea.

This presentation will start with an overview of the
IceCube project (usually entertaining and a bit outlandish
to those who are not familiar with high energy physics), and then
review what boost::serialization and boost::python contribute to the
architecture of the IceTray framework and what design patterns they
enable.

The boost::serialization part of the talk will touch on most aspects
of the library, with emphasis on certain pitfalls such as how to
manage large datasets, backwards compatibility considerations,
environments involving lots of dynamic linking / plugins containing
serializable objects, and design of a file format around boost::serialization.

The boost::python section of the talk will start with an overview of
creating python bindings similar to Timothy Shead’s talk at boostcon
#1. The later parts of the talk will be more of a design study of how
boost::python functions architecturally in the IceTray framework
(IceTray has extensive python bindings and interoperability): python
is used as a testing tool, a physics analysis language, a prototyping
environment, a config file language,

The content of this talk is slated to become a chapter in a
upcoming O’Reilly book called "Beautiful Data", a follow-on to the
earlier "Beautiful Code".

Informal Gathering at Meadows Bar

Format: social event

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

Iterators Must Go

Speaker: Andrei Alexandrescu
Format: keynote

Well, the title says it all: Iterators Must Go

Kamasu: Parallel computing on the GPU with boost::proto

Speaker: Troy Straszheim
Format: lecture
Track: Track II 2009

Kamasu" is a new library, built on top of boost::proto, the standard
library, and CUDA (NVIDIA’s general-purpose GPU computing development
kit) that allows one to do various mathematical tasks on the GPU
without touching the underlying GPU programming APIs and tools. For
instance,

kamasu::array<float> a(10, 10, 3, 7), b;
b = a * 3;

assigns to ‘b’ the result of the 4 dimensional array ‘a’ with each
element multiplied by the scalar 3.0. The underlying math is
performed in parallel on the system’s GPU. Temporary variables are
managed with help from some C++ type system tricks. The design of the
multidimensional array type is informed by boost::multi_array and
numpy’s multidimensional arrays.

The proposed talk will explain how the package works, and what it can
currently do. Those who have passing familiarity with underlying
technologies should find the library and talk interesting as an
architectural exercise. Included will be:

  • Brief introduction to boost::proto and CUDA.
  • managing temporaries by embedding ‘rvalueness’ in the type system
  • slicing
  • several real world examples with comparisons to performance on regular
    CPUs
  • extending the library
  • (maybe) demonstration of python bindings to the library.

Multithreaded C++0x: The Dawn of a New Standard

Speaker: Michael Wong
Format: lecture
Track: Track I 2009

C++0x Concurrency: The dawn of a New Standard
In 2010, a new C++ Standard will likely emerge fully prepared for concurrency. In addition to a new Memory Model, it will have new language changes. This will include standardizing Thread Local Storage, atomic variables, lambda expressions, initialization and termination of static-duration variables. We are also working closely with POSIX to establish a new binding for C++ that is compatible with the new Standard. The new C++ Standard will enable today’s abstractions for concurrency, such as threads, messages, and locks, and provide a platform to build towards future abstractions such as futures, transactional memory, and concurrent collections.

Parallel Patterns Library in Visual Studio 2010

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

The Parallel Patterns Library (PPL) being added to Visual Studio 2010 simplifies the writing of concurrent code by providing a familiar STL-like programming model. This presentation introduces the abstractions provided by the PPL, such as its concurrency primitives (like tasks and task groups), concurrent algorithms, and concurrent containers.

Picnic'09

Format: social event

A picnic on the Aspen Center for Physics campus.

Practical C++ Test-Driven Development with Boost.Test and Bmock

Speaker: Asher Sterkin
Format: lecture
Track: Track I 2009

The Boost.Test library provides basic ingredients necessary for making TDD in C++ possible: test suites, test, test runner, XML reporting. However applying TDD to large-scale C++ applications development (especially in the embedded software world) is too often blocked due to inability to deal effectively with all kinds of arcane APIs not available in development environment. As the result many C++ developers abandon TDD altogether and spend more and time developing on the "real" platform, which is too slow and error prone. In Java, C# and dynamic languages external APIs are not a problem at all since one could always "mock" them using one of the open source or commercial mock frameworks (e.g. EasyMock). In C++ it’s not that easy due to the lack of reflection, on which the whole mocking technology is currently based. In this tutorial (90 minutes) I will demonstrate how TDD in C++ could be facilitated using Bmock library (developed by this author, fully integrated with Boost.Test). Outline of TDD process with mocks will be presented. Technical details about Bmock internal structure and usage of various Boost libraries will be presented. Features comparison with other popular C++ mock libraries (Google Mock, MockItNow) will be provided.

State-Oriented Programming Using Boost Statechart Library (BSL)

Speaker: Asher Sterkin
Format: lecture
Track: Track I 2009

When developing reactive systems (non-trivial UI, protocol converters, complex work flow automation) there is a need to encode state-driven behavior. For that purpose UML statecharts formalism is normally applied. There are a number of commercial and free UML graphical tools which could generate C/C++ code from statehcart diagrams automatically. The main disadvantage of this approach is that generated code is usually completely unmaintainable and developers just do not trust them enough. Direct representation of statecharts in the code seems to be much more attractive option. For that reason I coined a term "State-Oriented Programming" as a parallel to Object-Oriented and Functional Programming paradigms. More specifically we are talking about embedding statecharts Domain-Specific Language (DSL) in a host general purpose programming language. For C++ the Boost Statecharts Library (BSL) provides a superior solution. In this tutorial (90 minutes) I will demonstrate how to program statecharts directly in C++ using BSL. Real-life examples from consumer electronics software (Digital TV Electronic Program Guide) will be used. Specifics of testing State-Oriented software will be discussed.

Status of the boost-cmake effort

Speaker: Troy Straszheim
Format: lecture
Track: Track I 2009

A tutorial introduction to boost-cmake. How to: build boost, test
boost, develop boost libraries with cmake.

The Boost Filesystem Library V3 Authors Corner

Speaker: Beman Dawes
Format: lecture
Track: Track II 2009

Filesystem V3, and what it can teach us about Unicode string classes. Boost.Filesystem V3’s class path adapts at compile time to Unicode and other character sets. This author’s corner discussion will focus on how this adaptation works and the lessons it can teach us as we consider designs for Boost Unicode strings.

The Boost Smart Pointer Library

Speaker: Thomas Becker
Format: lecture
Track: Track II 2009

The Boost Smart Pointer Library provides a family of pointer wrappers that automate the management of heap-allocated memory. Boost smart pointers are as robust, safe, and easy to use as they come. However, there are a number of fine points which casual users of the library are not always aware of.

The talk will alternate between two views of the library. The zoom-out view will explain what smart pointers there are, how they relate to each other, and when to use which one. The zoom-in view will focus on the fine points of using each of the available smart pointers.

The Meta State Machine (Msm) library – Hands-on

Speaker: Christophe Henry
Format: workshop
Track: Track I 2009

The first part of this session is a tutorial aiming to teach attendees how to use the Msm (Meta State Machine) library, a framework allowing developers to easily define high-performance UML 2.0 state machines in C++ with the stated goal of facilitating a MDA (Model-Driven-Architecture) process.
The tutorial first briefly explains the objectives and principles of the library. It then proceeds to describe the concepts defined by the UML 2.0 standard for state machine diagrams, their use in the light of a Model-Driven Development process, and their implementation using Msm.
The second part of the session is a hands-on course in which we will try to implement a mock-up of an iPod nano’s user interface. While this sounds like a lot of work, we will see how easy it becomes using Msm.

The Meta State Machine (Msm) library – Tutorial

Speaker: Christophe Henry
Format: tutorial
Track: Track II 2009

The first part of this session is a tutorial aiming to teach attendees how to use the Msm (Meta State Machine) library, a framework allowing developers to easily define high-performance UML 2.0 state machines in C++ with the stated goal of facilitating a MDA (Model-Driven-Architecture) process.
The tutorial first briefly explains the objectives and principles of the library. It then proceeds to describe the concepts defined by the UML 2.0 standard for state machine diagrams, their use in the light of a Model-Driven Development process, and their implementation using Msm.
The second part of the session is a hands-on course in which we will try to implement a mock-up of an iPod nano’s user interface. While this sounds like a lot of work, we will see how easy it becomes using Msm.

Speakers

Dave Abrahams

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.

Andrei Alexandrescu

In the programming community, Andrei is best known for his two books, C++ Coding Standards (coathored with Herb Sutter) and Modern C++ Design. The latter book engendered the Loki library, used in a variety of products, including Windows Vista (see attribution) and some Adobe products (see attribution), and available as a package on a variety of Linux distributions (under name libloki). Also, Andrei is a former columnist for C/C++ Users Journal and a former columnist for the C++ Report.

Thomas Becker

Thomas Becker holds a Ph.D. in mathematics from the University of Heidelberg, Germany. He is a former contributing editor of the now defunct C/C++ Users Journal. He has also written for C++ Report, Dr. Dobbs, and The Cpp Source. Currently, Thomas works as a senior scientific software developer for Zephyr Associates, Inc. in Lake Tahoe, Nevada.

Tom Brinkman

Tom Brinkman has been programming computers since the mid 80s. After working in various fields in computer science and in the game biz, he’s now employed as a software engineer with a large silicon vallley hardware company. His current main focus is developing high quality graphic algorithms and APIs. When not polishing pixels, he spends his time behind his guitar and rollerblading.

Marshall Clow

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

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

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.

Emil Dotchevski

Emil is a veteran of the video games industry. He got bored with writing 3D engines and went astray working on computer vision GPU applications for the University of South Carolina, and simultaneously launching the startup Reverge Studios. Emil is a Sofia University Graduate (Computer Science). He loves C++ and has two lazy cats.

Joel Falcou

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

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

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

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

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.

Christophe Henry

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.

Bill Hoffman

Bill Hoffman is Vice President and CTO of Kitware. He is a founder of
the company and has been part of the management team since 1999. Bill
has over 18 years of experience with large C++ systems. He is a lead
architect of the CMake cross-platform build system and co-author of
the Mastering CMake book. Mr. Hoffman is also involved in the
development of the Kitware Quality Software Process, and the CDash
software testing server.

Hartmut Kaiser

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.

Brad King

Brad King is a Research and Development Engineer at Kitware, having
joined the company in June 2000. He is a core developer and
maintainer of CMake and GCC-XML, and has contributed heavily to
ParaView, VTK, and ITK development. Brad received his Ph.D. in
Computer Science at Rensselaer Polytechnic Institute in December 2008.
His research focused on analysis of 3-D range data acquired from
real-world outdoor scenes.

Bruno Lalande

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.

Stephan T. Lavavej

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.

Dan Marsden

Dan Marsden is a professional C++ developer based in the U.K. He has contributed code and documentation to the Boost.Fusion library, and the Phoenix lambda library supplied with Boost.Spirit.

Brook Milligan

Brook is a Professor of Biology at New Mexico State University. His research interests include population genetics, molecular evolution, and phylogenetics. In connection with this, he has focused effort on improving biological models, a process that entails decoupling common mathematical cores from the domain-specific biology. This leads to Brook’s strong interest in using generic programming techniques to increase both the biological realism and the extensibility of computational models used to analyze biological data. To this end, Brook is developing a series of generic scientific software libraries and would like to see Boost expand its reach into scientific computing.

Jeremy Siek

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.

Lucanus Simonson

MS in EE from UCLA, 2004 with research focus on VLSI design automation. Luke has been working for Intel since 2004 on physical layout design tools, layout processing infrastructure and computational geometry library design and implementation. Enjoys programming contests, mathematical puzzles and difficult problems like working around compiler bugs to write portable code.

Asher Sterkin

Above 30 years of professional experience in software engineering: C++, Java, Ruby, Python. 13 years of experience in Digital TV technology. Occupy Principal Engineer position at Jerusalem office of NDS Limited (http://www.nds.com/). During last couple of years lead cross company efforts on adopting Agile Practices to embedded software development in C++ and Java.

Troy Straszheim

Troy D. Straszheim has been programming in C++ on various unices since
1993. His clients and employers have included Northrop Grumman
Corporation, Courant Institute of Mathematical Sciences (at New York
University), Lawrence Berkeley National Laboratory, Commerzbank
Captial Markets Corporation, ivillage.com, and Ovid Technologies.

Since 2005 he has been with the department of Physics at the
University of Maryland, College Park, as the Software Architect At
Large for the IceCube Collaboration (http://www.icecube.wisc.edu), a
kilometer-scale neutrino telescope experiment at the Admunden-Scott
South Pole Station. He also runs a small Washington, DC based
consulting firm, Resophonic Systems, Inc.

Gyuszi Suto

MS in CS from Polytechnic Institute Cluj, Romania 1987. Working for Intel (Oregon) since 1993 – on microprocessor-related CAD software development with emphasis on physical layout routing and process technology formal modeling. Teaches C++ at Intel U (Intel’s own internal university). Organizer of internal programming contest. Likes puzzles, geometry and hard-to-solve problems (like how to make 1 billion transistors peacefully coexist on one single piece of silicon.

Michael Wong

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.