2007 Program

2007 Resources (Slides, code, etc…)

Sunday, May 13
time Track I Track II
06:00PM Informal Gathering; Drinks. Travelling companions welcome.
Monday, May 14
time Track I Track II
Jeff Garland: Boost Library in a Week – C++ Container Printing
Scott Meyers: A Shotgun Firehose Introduction to TR1 and Boost Jeremy Siek: Generic Programming and the Boost Graph Library
Meyers: Firehose Intro (continued) Siek: BGL (continued)
Meyers: Firehose Intro (continued) Dave Abrahams: Boost Metaprogramming Concepts and Frameworks
Meyers: Firehose Intro (continued) Abrahams: Metaprogramming (continued)
Rene Rivera: Testing Boost: a Design and Planning Sprint
Tuesday, May 15
time Track I Track II
Jeff Garland, Kevlin Henney: Value-Based Programming Eric Niebler: Text Processing with Boost
Garland, Henney: Value-Based (continued) Niebler: Text Processing (continued)
Garland, Henney: Value-Based (continued) Dave Abrahams: Hybrid Development with Boost.Python (and More!)
Garland, Henney: Value-Based (continued) Timothy Shead: Implementing out-of-the-ordinary object models using Boost.Python
Douglas Gregor: ConceptGCC Installfest
Wednesday, May 16
time Track I Track II
Jeff Garland: Network Programming with Boost Douglas Gregor: An Introduction to Concepts in C++0x
Garland: Network Programming (continued) Gregor: Concepts Intro (continued)
Garland: Network Programming (continued) Howard Hinnant: An Introduction to the Rvalue Reference in C++0X (ConceptGCC installation recommended)
Garland: Network Programming (continued) Hinnant: Rvalue Reference (continued)
Sean Parent: A Possible Future for Software Development
Thursday, May 17
time Track I Track II
Kevlin Henney: Hands-on Agile Development Workshop with Boost Eric Niebler: Implementing Domain Specific Embedded Languages using Expression Templates and Boost.Proto
Henney: Agile (continued) Joel de Guzman, Hartmut Kaiser: A cookbook approach to parsing and output generation with Spirit2
Henney: Agile (continued) Douglas Gregor: Evolving a C++ Library to C++0x Concepts
Henney: Agile (continued) Sean Parent: Concept-based runtime polymorphism in the Adobe Source Library
Picnic – bring your families and friends
Friday, May 18
time Track I Track II
Jeff Garland: Boost and Google Summer of Code Joel de Guzman, Dan Marsden: Fusion by example
Gennadiy Rozental: Introduction to Boost.Test Dave Abrahams, Beman Dawes, Jeff Garland, Douglas Gregor: The Future of Boost


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

Spirit2 will debut at the Boost conference. It will be a complete
parsing and output generation system that attempts to cover the whole
spectrum from lexing to output generation. Spirit2 uses an EBNF oriented
syntax to describe a grammar (for parsing) and an output format (for
generation) directly in C++. This allows the construction of programs
able to parse input token sequences conforming to an input grammar and
to generate output token sequences conforming to an output format.

The target audience will be intermediate C++ programmers with basic
background on parsing. We will cover a lot of ground through examples;
lots of them. We will present them in a cookbook style approach. The
workshop will give a thorough introduction to Spirit’s subsystems, their
features, how to use them, how to extend them for special needs. We will
present real world examples from the simplest comma-separated-list
parsing, to simple calculator examples, to the more complex scripting
languages. We will cover semantic processing and backend generation to
complete the picture. We will show how combining the various subsystems
work for language transformations. We will have examples on generating
code for a virtual machine, generation of HTML and XML, and building a
dynamic GUI layout, to highlight a few. All these will be provided
through step by step tutorials.

Speaker: Douglas Gregor
Format: tutorial
Track: Track II

Concepts are a major addition to C++0x that make templates more
robust, more powerful, and easier to write and use. At their most
basic level, concepts provide a type system for templates. Using
concepts, the C++ compiler is able to detect errors in the definition
and use of templates before they are instantiated. One immediately
obvious benefit of this separate type-checking capability is a
dramatic improvement in error messages resulting from improper use of
templates. Look a little deeper and we find that concepts support an
entirely new programming paradigm, Generic Programming, enabling the
construction of a new breed of generic libraries that provide better
extensibility, composability, and usability than what is possible with
today’s C++.

This tutorial will teach concepts from the ground up. We will begin
with an overview of the new features introduced by concepts and how
they will benefit C++ programmers. Then, we’ll dive right into
concepts, building the core components of the C++ Standard (Template)
Library. We will see how these core components are more robust and
versatile than the equivalent components in today’s C++. From there,
we will explore some of the more advanced features of concepts.

Speaker: Howard Hinnant
Format: tutorial
Track: Track II

Rvalue reference is tiny addition to the C++ language which will have a
large impact on the way you design your C++ classes and algorithms. It
will free youto use standard library components in a much more flexible
manner, and without having to worry about the cost of copying huge objects

Have you ever passed a large container by reference to a function as an
“outputparameter” when what you really wanted to do was have the function
return the container by value? Sure, who hasn’t. This session will teach
you how and why C++0X will make it guaranteed-efficient to return standard
containers by value from functions. Learn how to adapt your own heavy weight
classes so that they too can always be returned from functions efficiently.

Have you ever put a non-copyable type on the heap, just for the purpose of
being able to pass it among different scopes? Perhaps you wanted to pass it
into a function, return it from a function, or put it into a container. Such
practice is now a thing of the past. As an example, the standard
(non-copyable) stream types are now movable. They can be put directly
into containers, and returned from functions. This tutorial will explain
how that is now possible so that you can do the same with your own
non-copyable types.

Have you ever wanted to put auto_ptr into a vector, but had to compromise
by using shared_ptr instead? This tutorial introduces unique_ptr, which
in a nutshell is an “auto_ptr that works”. It has the same overhead and
semantics as auto_ptr, but is safe to put into containers.

Have you ever needed to forward a generic argument, either lvalue or rvalue,
without changing its cv-qualification? Or equivalently, have you ever been
frustrated that you can’t pass rvalue (temporary) arguments to boost::bind
functionals? No longer.

All of this and more simply represent applications of the rvalue reference.
Learn the few simple characteristics of the rvalue reference and you will
see how all of the above is now possible, not only for the standard library,
but for your own code as well. Get a head start on C++0X. By doing so you
may well find your own innovative uses of this new tool.

A working installation of ConceptGCC is recommended for all participants

Speaker: Sean Parent
Format: keynote

This talk begins with an overview of software development at Adobe
and a look at industry trends towards systems built around object
oriented frameworks; why they “work”, and why they ultimately fail
to deliver quality, scalable, software. We’ll look at a possible
alternative to this future, combining generic programming with
declarative programming to build high quality, scalable systems.

I’ll demonstrate how these ideas manifest in Boost and the standard
library and how they are being combined and explored in the Adobe
Source Libraries.

Speaker: Scott Meyers
Track: Track I

TR1 is a specification for 14 new kinds of standard library
functionality, 13 of which are already part of the draft version
of C++0x and most of which were based on Boost libraries. Boost
also offers dozens of libraries offering functionality not in
TR1. This tutorial discusses a semi-random collection of
libraries in TR1 and Boost (that’s the shotgun part), giving an
overview of the functionality each offers. It covers a lot of
information in the time available (that’s the firehose part), and
it tries to include insights difficult or impossible to glean
from the usual library documentation.

From TR1, we’ll discuss smart pointers (shared_ptr and weak_ptr), unordered
containers (hash tables), regular expressions, generalized function pointers and
binders, tuples, and fixed-size arrays. From Boost, we’ll cover non-TR1 smart
pointers, static asserts, lambda, file system, conversions, format, and variant.
For a detailed topic outline, consult the description at Scott’s web site.

Speaker: Jeff Garland
Format: experience report
Track: Track I

Google Summer of Code (SOC) is a program by Google to encourage students to
develop open source code while providing a chance to be employed. In 2006
Boost became a mentoring organization for SOC. As an organization, Boost was
quite unprepared for the avalanche of interest in 2006: some 174 project
proposals. Ultimately, Boost mentored 10 projects, but it was a scramble to
recruit mentors, review all the proposals, and correctly mentor the students.

This talk will cover:

  • Basic overview of Google SOC and Boost Participation
  • Overview of the 10 2006 SOC projects
  • Results of 2006 Boost SOC projects
  • Lessons learned from 2006
  • An overview of Jeff’s trip to the Googleplex to meet other SOC mentors
  • A look ahead to SOC 2007

In addition to the talk the session will include time for questions and
brainstorming about how the Boost Community can better support SOC in 2007 and

Speaker: Jeff Garland
Format: workshop


It’s an embarrassment that there is no standard way to print the contents of a container in C++. Despite all the progress in Boost this remains one area where there is no solution. The intent of this ‘all week workshop’ is to bootstrap the development of a full blown Boost library during BoostCon. This will allow developers to see and participate in library development directly. In fact, it will be great way to actually becoming a contributing Boost developer.

The workshop will work like this: there will be a core of active 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). There will also be a 30 minute private meeting between active participants. During these times the group will collaborate on the development of this library. The following is a sketch for how we will proceed subject to course corrections as needed:

  • day 1: Requirements for container printing, other libs, why previous attempts have failed
  • day 2: API sketches, type requirements
  • day 3: write initial user docs and tests, initial code
  • day 4: coding and redesign
  • day 5: final coding and wrap up

All the results of this collaboration will be shared on the Boost Wiki/Vault and on posters displayed in the conference area for everyone to see, comment, and discuss. And hopefully by the end of the week we will have a library ready for Boost review, or at least well on the way.

Workshop Objectives

This innovative workshop will be an opportunity for participants to become a contributing Boost library author 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
  • deeper understanding of C++ containers and input output

Speaker: Dave Abrahams
Attendee Background: Mostly people who write libraries and code that will be reused.
Track: Track II

Have you ever wondered what makes the difference between “spaghetti
code” and pure poetry? It’s abstraction. Many of the worst code
integrity problems stem from programming at a level of abstraction
far below that of our mental model. Boost libraries use
metaprogramming to provide interfaces that directly reflect the
programmer’s domain model and notation, all without loss of

This session explores both “big picture” ideas and practical tools.
We’ll discuss what metaprogramming is, why it matters, and show how
the unique combination of features in C++ make it an especially
powerful language for metaprogramming. We’ll also get a taste of
high-level metaprogramming abstractions by using several Boost
metaprogramming libraries—MPL, Preprocessor, and the Fusion
tuple library—to solve real problems.

This course is based on “C++ Template Metaprogramming: Concepts,
Tools and Techniques from Boost and Beyond,”
(http://www.boost-consulting.com/mplbook), although familiarity
with the book is not a prerequisite. For those who have read it,
some new material will also be covered.

Speaker: Sean Parent
Format: lecture
Track: Track II

The Adobe Source Library (ASL), http://opensource.adobe.com ,
provides peer-reviewed and portable C++ source libraries. The libraries are
intended to be widely useful, leveraging and extending both the C++ Standard
Library and the Boost Libraries. In order to obtain maximal reuse ASL
strives to avoid entangling separable components. Parts of ASL need to make
use of runtime polymorphism traditional object oriented design is too
intrusive to support the required level of modularity. In this session, we
explore the benefits of the Concept-based approach used in ASL to achieve
runtime polymorphism in a non-intrusive, regular manner using “runtime
concepts” (which can be viewed as generalizations of boost::any).

Speaker: Douglas Gregor
Format: workshop

ConceptGCC is an experimental version of GCC that includes
prototype implementations of several features to be included in the
upcoming revision of ISO C++, dubbed C++0x. Participants in two
hands-on tutorials at BoostCon, “An Introduction to Concepts in
” and “An Introduction to the Rvalue Reference in
,” will use ConceptGCC to explore these new C++ language
features. At this “Installfest,” ConceptGCC developers will be on
hand to help you install ConceptGCC on your laptop, so you’ll be
ready to go for Wednesday’s C++0x tutorials or to explore C++0x on
your own.

Speaker: Douglas Gregor
Format: tutorial
Track: Track II

Concepts are a major addition to C++0x that make templates more
robust, more powerful, and easier to write and use. At their most
basic level, concepts provide a type system for templates. Using
concepts, the C++ compiler is able to detect errors in the definition
and use of templates before they are instantiated. One immediately
obvious benefit of this separate type-checking capability is a
dramatic improvement in error messages resulting from improper use of
templates. Look a little deeper and we find that concepts support an
entirely new programming paradigm, Generic Programming, enabling the
construction of a new breed of generic libraries that provide better
extensibility, composability, and usability than what is possible with
today’s C++.

This tutorial will delve into the evolution of existing C++ libraries
to use concepts. We will discuss the translation of today’s
documentation-only “concepts” into C++0x concepts and the introduction
of concepts into existing templates. Our focus throughout is on
evolving libraries without requiring extensive rewrites and without
breaking existing user code.

Speakers: Joel de Guzman, Dan Marsden
Format: tutorial
Track: Track II

Fusion is a library of hetrogenous containers (tuples) and associated algorithms that was recently accepted into Boost. This talk will introduce Boost.Fusion and illustrate some of its features by building up a series of examples that apply the library.

The emphasis for the examples will be on using Boost.Fusion in application code, rather than as infrastructure for library developers.

Speaker: Jeremy Siek
Format: tutorial
Track: Track II

Many programming problems in diverse areas as Internet packet routing, molecular biology,
scientific computing, and telephone network design can be solved by using graph algorithms
and data-structures. Traditional approaches to implementing graph libraries
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 Generic Programming and demonstrated this
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.

Speaker: Kevlin Henney
Format: workshop
Track: Track I

Agile development processes are intended to help developers avoid the
problems of analysis paralysis, big up-front design, rushed testing and
changing requirements. They treat analysis and design as continuous
activities that start early in development but continue throughout,
rather than as segregated phases divorced from other development

Development is dynamically planned as incremental and iterative. Coding
and testing are considered together and from an early stage in
development. In particular, incremental design, continuous testing and
responsive refactoring make up the programmer-facing discipline of
Test-Driven Development (TDD). The goal of this workshop is twofold: (1)
it aims to offer attendees hands-on experience of many of the practices
involved in the construction phase of a development lifecycle and (2) it
introduces some of the common Boost libraries to raise development above
the level of standard C++ libraries.

As its title suggests, this workshop actually is a workshop! Attendees
will learn about the development side of agile development by doing it
and some common Boost libraries by using them. The workshop is based on
undertaking four rapid sprints of development, working on a clearly
bounded and well-defined problem. The technical emphasis is on the role
of libraries in promoting responsive and streamlined development, with
Boost as a leading concrete example. The process emphasis is on scope
management, iteration planning, TDD, pair programming and other
practices and principles drawn from agile approaches such as Extreme
Programming, Scrum and Lean Software Development, with guidance and
feedback both during and in between iterations.

Speaker: Dave Abrahams
Format: tutorial
Track: Track II

Python and C++ are in many ways as different as two languages could
be: while C++ is usually compiled to machine-code, Python is
interpreted. Python’s dynamic type system is often cited as the
foundation of its flexibility, while in C++ static typing is the
cornerstone of its efficiency. C++ has an intricate and difficult
compile-time meta-language, while in Python, practically everything
happens at runtime.

Yet for many programmers, these very differences mean that Python
and C++ complement one another perfectly. Performance bottlenecks
in Python programs can be rewritten in C++ for maximal speed, and
authors of powerful C++ libraries choose Python as a middleware
language for its flexible system integration

Boost.Python is a C++ library that provides a concise IDL-like
interface for binding C++ classes and functions to Python.
Leveraging the full power of C++ compile-time introspection, and of
recently developed metaprogramming techniques, this integration is
achieved entirely in pure C++, without introducing a new
syntax. Boost.Python’s rich set of features and high-level
interface make it possible to engineer packages from the ground up
as hybrid systems, giving programmers easy and coherent access to
both the efficient compile-time polymorphism of C++ and the
extremely convenient run-time polymorphism of Python.

In this tutorial, we describe the models for integrating C++ and
Python, show how Boost.Python improves on the facilities provided
by Python’s ‘C’ API, and walk through the key concepts of the
Boost.Python library. We’ll briefly discuss the Py++
code-generating front-end, which parses C++ header files and
generates Boost.Python binding code. Finally, we’ll spend a little
time discussing the Boost.Langbinding concept, an architecture that
would integrate the functionality of Boost.Python and its many
imitators that target other dynamic languages, using pluggable
backends for each supported dynamic language.

Speaker: Eric Niebler
Format: tutorial
Track: Track II

Expression Templates are an advanced technique that C++ library
developers use to define embedded mini-languages that target specific
problem domains. The technique has been used to create hyper-efficient
and easy-to-use libraries for linear algebra as well as to define C++
parser generators with a readable syntax. But developing such a library
involves writing an inordinate amount of unreadable and unmaintainable
template mumbo-jumbo. Boost.Proto, a new library currently under
development, eases the development of domain-specific embedded languages
(DSELs). Use Proto to define the primitives of your mini-language and
let Proto handle the operator overloading and the construction of the
expression parse tree. Immediately evaluate the expression tree by
passing it a function object. Or transform the expression tree by
defining the meta-grammar of your mini-language, decorated with an
assortment of tree transforms provided by Proto or defined by you. Then
use the meta-grammar to give your users short and readable syntax errors
for invalid expressions! No more mumbo-jumbo — an expression template
library developed with Proto is declarative and readable. Proto is a
DSEL for defining DSELs.

Proto was initially developed as a part of Boost.Xpressive. It is now
being used in the Spirit-2 rewrite (under development) and in another
future Boost DSEL library called Karma. Proto is the key to making these
three DSEL libraries play well together. It will eventually be proposed
as a stand-alone Boost library.

Speaker: Timothy Shead
Format: lecture
Attendee Background: assumes some prior knowledge of Boost.Python.
Track: Track II

One mark of a good library is its ability to handle
out-of-the-ordinary use cases. After several years observing
Boost.Python from afar, I set out in mid 2006 to see if it could
replace a large body of home-grown Python wrapping code
written for embedding in a 3D modeling and animation package.
Along the way I developed a number of simple techniques dealing
with “real-world-messiness” that are the focus of the presentation,

  • Embedding Boost.Python wrappers in your executable (rather
    than loading them into Python)
  • Mixing class-methods with non-intrusive methods (what to do
    when your Python object needs to differ slightly from its C++
  • Wrapping C++ template classes.
  • Handling weakly-typed arguments and return-values in C++.
  • Bypassing Boost.Python to implement “special” Python methods –
    __str__, __len__, etc.
  • Module attributes
  • And more!

Format: social event

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

Speaker: Gennadiy Rozental
Format: tutorial
Track: Track I

Boost.Test provides a matched set of components for writing test programs ranging from a few simple test cases up through complete test suites, and controlling their runtime execution.

This tutorial introduces Boost.Test and shows how to use its components. Along the way concepts such as unit testing, interaction-based testing, and test-driven design are explained and related to Boost.Test components. Other topics include static versus dynamic library testing, off-line library compilation, test module initialization, fixtures support, test tree construction, test tools including floating-point tools, and output customization.

Speaker: Jeff Garland
Format: lecture
Attendee Background: Attendees should have a basic background in C++.
Track: Track I

This tutorial will provide an introduction to network programming with
Boost. With the adoption of the Asio library, Boost finally has a library
that provides networking capabilities. This tutorial will provide a basic
introduction to using Asio to write network enabled programs.

Starting with a simple synchronous, iostream-based example to retrieve a web
page the tutorial first introduces basic network programming concepts such as
clients, servers, endpoints, and buffers. After looking at a synchronous
version, the web page retrieval program is converted to use asynchronous i/o
introducing multiplexing and handler-based programming.

In the next section, the a distributed “hello world” client and server is
developed introducing additional networking concepts such as acceptors,
connectors, and timers. This example is then extending using
Boost.Serialization to exchange message objects between peer processes.

The tutorial concludes with a survey of other related topics including the
relationship of Asio and Boost.threads, encrypted socket handling using Secure
Sockets, and connection-less protocols (UDP).

There will be at least 2 hands-on exercises to help students get started with
network programming.

Exercise 1: Students will re-write sync client as an async program.

Exercise 2: Students will write a basic server using async handling.

Tutorial Objectives
– Provide students with the basics of writing networked programs

  • Provide an understanding of using Asio to write network enabled programs including:
    – an understanding of ‘asynchronous programming’
    – basics of TCP based sockets
    – integration of sockets and i/o streams
    – understanding of using timers in network programming
  • Using serialization with Asio to build a general object messaging frameworks

Format: social event

A picnic on the Aspen Center for Physics campus. Sponsored by Boost Consulting, Inc.

Speaker: Rene Rivera
Format: workshop

It’s clear we have some growing pains in Boost, and one of the most notable is the testing infrastructure. We intend to take this opportunity to come up with a comprehensive design and plan to make the test system everything we need to be. In the sprint we will move from our current testing, to a solution:

  • Overview of current system, and it’s problems.
  • Boost requirements for a test system.
  • Existing technology review.
  • Design/plan solutions.

In this group effort we will cover how the current test system works, in its varied parts, and indentify which parts need improvements and what parts are missing. We will be discussing the complete testing cycle from the Boost.Build end, through the regression result pages. We want to consider how, and which, technologies we can use to get wide-spread test results to library authors as effectively as possible. Since we want to make sure we get a good momentum built, we will be holding the sprint open as long as people are willing to endure.

To move forward as quickly as possible we are requesting people come prepared to get busy to work out solutions to our testing problems. What does this preparation entail? If you have ideas as to how testing is broken, how it should work, or what technologies will solve our problems, we want to know about them before the conference. So send your ideas to rrivera-AT-acm.org.

Speaker: Eric Niebler
Format: tutorial
Track: Track II

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

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

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.

Speakers: Jeff Garland, Kevlin Henney
Format: tutorial
Track: Track I

Value-based programming is an expressive approach that should be found in the core of any modern design model. Value objects represent fine-grained pieces of information whose use is governed by their state, i.e. their value, and for which object identity is not significant, such that copies of the same value object are necessarily considered equivalent. General-purpose value types include strings and integers, more domain-specific value types include dates and money.

In spite of the clarifying and simplifying role value types can have in a design, relatively little has been written about the tools and techniques to building solid value types. Furthermore, there is no standard toolkit for helping C++ developers to write new value types. Boost has several of the elements, but they haven’t been pulled together in a coherent way.

The goal of this all-day session will be to educate developers on the best uses of value types and develop a roadmap of missing libraries that can be developed as part of Boost to support rapid value type development. The idea is to work on figuring out what’s missing from the ‘value programmers toolbox’ and how this might be rectified. We’ll be mining best practices from libraries like boost.any, boost.rational, boost.date_time, etc. As one example, the constrained_value template used in Boost.date_time allows for the simple definition of constrained numeric types.

To keep things concrete we’ll use a couple of as yet unbuilt libraries (SafeInteger and Money) as examples in our discussion of value types. We’ll use these value types to motivate the requirements and overall design of the value programmer’s toolkit.

The day-long session will be divided into four 90-minute parts, mixing lecture and workshop sessions:

Part 1: Lecture
– Introduction to Value Types: what they are, why they’re useful, why they are different from other object types, how to identify them, how they affect design.
– Available Value Type libraries: some of the currently available including constrained_value, Boost.operators, proposed boost_enum, etc.

Part 2: Workshop
– Group attempt to create some new value type libraries.
– Introduction of example value types ‘SafeInt and Money’.
– Brainstorming of interfaces for the value types.

Part 3: Workshop
– Analysis of new value types and needs for a value type toolkit.
– Development of a list of commonalities among the value types.
– Brainstorming of libraries that could be utilized in creation of value types.

Part 4: Workshop
– Documentation of workshop results.
– Documentation of the ‘value type library roadmap’ (list of library tools that should be developed to support building of value types).
– Documentation of useful tools and techniques.


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.

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.

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.

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.

Kevlin Henney is an independent consultant and trainer based in the UK.
He specialises in programming languages and techniques, patterns and
software architecture, and agile development, with a particular emphasis
on bringing these often separated worlds together.

He has been a columnist and contributor for various magazines, including
Application Development Advisor, C++ Report, and C/C++ Users Journal
online. He is currently a columnist for The Register’s Reg Developer.
Kevlin is coauthor of two forthcoming volumes in the Pattern-Oriented
Software Architecture series. He is a long-time member of the ACCU and a
past contributor to Boost. For better or for worse, he has found himself
drawn into various committees, including the one for the C++ standard,
the one for The C++ Source, and the one for this conference.

Currently employed with Apple as a software engineer. Previously with
Metrowerks/Motorola/Freescale and author of the CodeWarrior C++ standard
library. C++ committee member currently serving as Library Working Group
Chairman. Co-author/co-inventor and head cheerleader of the rvalue reference
proposal for C++0X.

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.

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.

Scott Meyers is one of the world’s foremost authorities on C++;
he provides training and consulting services to clients
worldwide. He wrote the best-selling Effective C++ series
(Effective C++, More Effective C++, and Effective STL), designed
the innovative Effective C++ CD, is Consulting Editor for Addison
Wesley’s Effective Software Development Series, and serves on the
Advisory Board for The C++ Source
(http://www.artima.com/cppsource). He has a Ph.D in Computer
Science from Brown University. His web site is aristeia.com.

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++

Sean Parent is a principal scientist at Adobe Systems and engineering manager of
the Adobe Software Technology Lab. One of his team’s current projects is the
Adobe Source Libraries, including two libraries
for declarative user interface logic and layout. Sean has been at Adobe since
1993 when he joined as a senior engineer working on Photoshop. From 1988 through
1993 Sean worked at Apple where he was part of the system software team that
developed the technologies allowing Apple’s successful transition to the PowerPC
RISC processor. Sean holds a number of software patents and is a graduate of
Seattle University.

René Rivera has been developing software on a variety of computer languages and platforms for over 20 years. In recent years this has entailed contributing to Boost with the maintenance and development of Boost.Build, the new Boost.org web site, and mentoring the development of a Boost.Tree library. In addition, running Redshift Software, Inc. creating software development tools for game developers, development of PC and web based games and web sites. In the past, he was doing game development in a combination of Java and C++ for Jellyvision Inc ®. The most notable projects he worked on were “You Don’t Know Jack: The 5th Dementia®” and “Who Wants To Be a Millionaire®”. Before the wonderful world of game development, he worked on multimedia learning applications using artificial intelligence concepts for Northwestern University. René has an uncanny ability to do whole application design while still keeping the details clearly focused. This is of particular importance when performing his favorite aspect of software development, user interface design.

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.

Timothy M. Shead is an application-level software engineer at
Sandia National Laboratories with an extensive background in
C++, 3D graphics, and animation.

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.

Comments are closed.