Boostcon

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

A Shotgun Firehose Introduction to TR1 and Boost

Speaker:	Scott Meyers
Format:
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.

Picnic

Format:	social event

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

Boost Metaprogramming Concepts and Frameworks

Speaker:	Dave Abrahams
Format:
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 efficiency.

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.

Network Programming with Boost

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

A cookbook approach to parsing and output generation with Spirit2

Speakers:	Hartmut Kaiser, Joel de Guzman
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.

Text Processing with Boost

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.

Hybrid Development with Boost.Python (and More!)

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 capabilities.

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.

Boost Library in a Week - C++ Container Printing

Speaker:	Jeff Garland
Format:	workshop

A Possible Future for Software Development

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.

Hands-on Agile Development Workshop with Boost

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 activities.

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.

An Introduction to the Rvalue Reference in C++0X

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 around.

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

An Introduction to Concepts in C++0x

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.

Fusion by example

Speakers:	Dan Marsden, Joel de Guzman
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.

Evolving a C++ Library to C++0x Concepts

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.

Boost and Google Summer of Code

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 beyond.

Introduction to Boost.Test

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.

The Future of Boost

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.

Testing Boost: a Design and Planning Sprint

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.

Implementing Domain Specific Embedded Languages using Expression Templates and Boost.Proto

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.

Value-Based Programming

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.

Generic Programming and the Boost Graph Library

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.

Implementing out-of-the-ordinary object models using Boost.Python

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, including:

• 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++ counterpart).
• 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!

Informal Gathering; Drinks.

Format:	social event

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

ConceptGCC Installfest

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 C++0x” and “An Introduction to the Rvalue Reference in C++0x,” 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.

Concept-based runtime polymorphism in the Adobe Source Library

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).

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.

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.

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.

Douglas Gregor

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

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.

Howard Hinnant

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.

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.

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.

Scott Meyers

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

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

Sean Parent

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.

Rene Rivera

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 Rozental

Gennadiy is a software developer from Ukraine, who now lives in New Jersey, United States and works for Thomson Financial in New York. 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 enjoy origami making.

Timothy Shead

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

Jeremy is a professor at the University of Colorado at Boulder and a research scientist at LogicBlox inc. Jeremy is the author of several Boost libraries, including the Graph, Iterator Adaptor, Dynamic Bitset, and Concept Check libraries. Jeremy is a long time advocate and practitioner of generic programming. His Ph.D. thesis laid the foundation for the “concepts” feature for C++0X that will greatly improve the language's support for generic programming.

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.