Note: Click the title of any session to visit its start time in
the conference schedule.
What libraries do the C++ community need? What design principles are appropriate for such libraries? What can be done to make a library easy to adopt? These are hard and important questions, which have no clear, simple, and objective answers. I will suggest answers based on personal experience and a bit of input from friends. Distribution of libraries, tutorial aspects, run-time and compile-time performance, and maintainability will be considered.
| Speaker: |
Dan Marsden |
| Format: |
lecture |
| Track: |
Track II 2008 |
The (provisionally named!) Traversal library is a new library under development, for working with heirarchical data structures. Based on techiques originating in the Haskell community, the library provides a rich collection of algorithms and function object combinators for building traversals over complex data structures.
The session will cover the ideas behind the traversal library, discuss some of the challenges involved in "borrowing" ideas developed in a different programming paradigm, and lead into some practical examples of how the library can be used. It will take in functional programming, a bit of Haskell, some interesting perspectives on generic programming, many Boost libraries, and plenty of C++. The talk will end with discussion of additional capabilities that would be required of a fully fledged data structure traversal library, and details of future directions the library may take.
The Boost.Date-Time Library
Author’s corner represents an exciting new concept for BoostCon 2008. Author’s corner sessions are short sessions by Boost Library Authors that provide an overview of their library including: purpose and motivation, usage tips, and concepts. In addition, they will describe some of the hidden design gems inside their libraries, and, of course, answer any questions.
The Boost.Function Library
Author’s corner represents an exciting new concept for BoostCon 2008. Author’s corner sessions are short sessions by Boost Library Authors that provide an overview of their library including: purpose and motivation, usage tips, and concepts. In addition, they will describe some of the hidden design gems inside their libraries, and, of course, answer any questions.
The Boost.Parameter Library
Author’s corner represents an exciting new concept for BoostCon 2008. Author’s corner sessions are short sessions by Boost Library Authors that provide an overview of their library including: purpose and motivation, usage tips, and concepts. In addition, they will describe some of the hidden design gems inside their libraries, and, of course, answer any questions.
The Boost.Proto Library
Author’s corner represents an exciting new concept for BoostCon 2008. Author’s corner sessions are short sessions by Boost Library Authors that provide an overview of their library including: purpose and motivation, usage tips, and concepts. In addition, they will describe some of the hidden design gems inside their libraries, and, of course, answer any questions.
| Speaker: |
Beman Dawes |
| Format: |
lecture |
| Track: |
Track II 2008 |
The Boost.System and Boost.Filesystem Libraries
Author’s corner represents an exciting new concept for BoostCon 2008. Author’s corner sessions are short sessions by Boost Library Authors that provide an overview of their library including: purpose and motivation, usage tips, and concepts. In addition, they will describe some of the hidden design gems inside their libraries, and, of course, answer any questions.
The Boost.Wave Library
Author’s corner represents an exciting new concept for BoostCon 2008. Author’s corner sessions are short sessions by Boost Library Authors that provide an overview of their library including: purpose and motivation, usage tips, and concepts. In addition, they will describe some of the hidden design gems inside their libraries, and, of course, answer any questions.
To ensure a successful BoostCon’09, we’ll need to start planning now. Be a part of the process!
| Speaker: |
Jeremy Pack |
| Format: |
lecture |
| Track: |
Track I 2008 |
The presentation will focus on a case study using the proposed Boost.Extension and Boost.Reflection in the design and implementation of a simple cross-platform GUI-based image processing application. I will show how to add plug-in functionality to dynamically decide what types of imagery to load, and then use different algorithms and visualizations depending on the type of image loaded. I will describe writing the program in such a way as to handle new types of image or new algorithms in the future, without being required to even recompile the original application.
Boost Serialization is a library which provides the ability
to deconstruct and reconstruct an object graph in memory. One possible
use of serialization is communication between distributed software
components. Another is ad-hoc/proprietary file formats. Yet another
could be storing binary blobs in a database.
This tutorial will throw participants into the deep end of the
Boost.Serialization library covering many practical considerations
necessary when implementing serialization. Laptops with working C++
compilers and a working installation of the 1.34.1 release of Boost are
required to get the best out of the session. Participants are not
expected to be familiar with the Boost.Serialization library.
- Attendees will learn about:
-
- Serialization design overview
- Serialization of primitive C++ types and collections
- Serialization of pointers and smart pointers
- Serializing user defined types
- Serializing third-party types
- Selecting the right Archive type: xml, text, binary
- Serializing a class hierarchy including templates in a multiple translation-unit world
- Practical considerations such as multiple threads, multiple platforms, multiple compilers and cross-language communication.
- What to do when an object is Streamable but not Serializable.
- If there is time:
-
- Creating file formats
- Workshop to create an XDR archive (or other portable binary archive)
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.
The next ISO C++ standard, dubbed C++0x for its probable publication date before the end of this decade, is nearly feature-complete and will soon be available as a Committee Draft for public comment. Although complete implementations of C++0x are still a few years off, recent and upcoming compiler releases provide some interesting features that we can start working with today.
In this tutorial, we will explore some of the new C++0x features available today that help us to build better C++ libraries more easily. Major features to be discussed include variadic templates, which enable the expression of templates with a variable-length template argument list and have many applications in the realm of template metaprogramming; rvalue references, which provide the ability to distinguish rvalues from lvalues for optimization via move semantics and provide perfect forwarding of function arguments; and improvements in the realm of type deduction, including decltype and auto. Since many of the most interesting results come from the interaction among features, we’ll delve into the ways in which these features combine to improve the quality and expressibility of C++ libraries.
Pick up your welcome packet and sign in for the conference. During the week registration will be in the Aspen Center for Physics lobby.
The BoostCon 2007 library in a week project attempted to develop a library to print containers to text. In this review, we will look at the stream based implementation that we are proposing for acceptance into boost. Come get an overview of this new library, participate in the following design and code review, and help us determine what path the library should take before it is brought up for formal review.
Goals of this workshop:
- Brief presentation on how to use the library and its features
- Review history and design decisions
- Walk through of important code sections and workshop of code, design, and documentation in order to inform future development.
- Determine whether the current design should be brought up for formal review, and what changes should be made beforehand.
An informal session to discuss CORBA to C++ API binding. The current CORBA/C++ binding was creating prior to ISO standard C++ and has many issues and limitations. The OMG has recently decided to reopen the C++ binding. In this session we will discuss how the binding might be improved.
A gourmet feast featuring Colorado specialties served in the lobby and patio area of the Aspen Meadows.
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.
The appearance in the mid 1990s of the STL was a huge leap forward for C++ programmers. Finally, we had a fast, general-purpose library of containers and algorithms with real design integrity. Today, the STL components are widely considered indespensible tools of the well-rounded C++ professional, but the components are actually just the tip of the iceberg. With the STL we gained a new design process that for the first time allows generality and code reuse without loss of performance.
Generic software design is an iterative, algorithm-centric process that involves:
- Surveying different implementations of an algorithm to find its true essence.
- Factoring out and clustering algorithmic requirements as "concepts."
- Arranging concepts into refinement hierarchies based on fundamental capabilities.
- Refining algorithms to capitalize on those capabilities.
In this hands-on workshop, we’ll see how these ideas are expressed in the STL, and we’ll apply the process and techniques ourselves to new problems. By the time we’re done, you’ll have some new tools for writing high-performance code, and just maybe, a whole new way to think about programming.
Like all software projects, boost code contains bugs, inefficiencies, and other problems. As the language evolves, and new versions of compilers are released, more problems are revealed. How does Boost, as an group, handle these problems? Where is the best place to report a problem that you’ve found? Where should you go if you have found "a better way" to implement a feature in a boost library?
This talk will describe on the existing procedure, including the mailing lists and the Trac system (including examples), and will follow with a discussion about problems and possible enhancements.
Boost.Fusion is a library that can benefit heavily from many of the features being
proposed for C++0x. The aim of the session will be to explore how these new language
features can be used to improve the implementation of a (subset of) a well known Boost library.
The session aims to be beneficial for both library authors and users of Boost libraries.
The session will start with an outline of a custom made "Mini Fusion". This custom code
will eliminate all the preprocessor magic and other distracting features of the full version,
and implement only a limited subset of features that are sufficient to illustrate the advantages
of the C++0x features to be covered.
Specifically "Mini Fusion" will comprise:
- Iterator protocol
- A cons list and a vector
- One or two algorithms
- One or two views
Following the introduction, users will work through a series of exercises, improving the
code with different new language features, steadily progressing along a planned path
from "classic" Fusion to Fusion 0x.
By the end of the session, users will have implemented / extended a Fusion container,
an iteration mechanism, and a few illustrative algorithms. Users will have used rvalue
references, variadic templates, decltype and auto, static assertions, using GCC 4.3.
To complete the picture, a concept enabled Fusion will also be demonstrated using
ConceptGCC, although this will not be an interactive exercise, given the practical
difficulties of getting ConceptGCC working on many users machines.
The session will coordinate with Doug Gregor’s C++0x session to provide
the best overall instruction for the attendees. Doug has generously offered to attend our
session and provide additional C++0x support for attendees during the exercises.
Informal Gathering of Conference Attendees
The Message Passing Interface (MPI) is a standard library for writing
high-performance parallel applications on the desktop, clusters, and
supercomputers. Since its definition by the MPI Forum in 1994, MPI has
grown to become the de facto standard for writing large-scale parallel
applications, and is widely supported through both commercial vendors
and the open source community.
This tutorial will introduce attendees to the Message Passing
Interface using the new Boost.MPI library, which provides a clean C++
interface to the (otherwise low-level) standard C bindings for
MPI. This tutorial will cover the development of MPI applications,
from the basics of compiling and executing MPI programs in a cluster
environment to the optimization of inter-process communication in
Boost.MPI programs. We will explore the core features and ideas of
MPI, including communicators, point-to-point communication, collective
communication, and non-blocking (asynchronous) communication. No prior
MPI experience is necessary for this introductory tutorial, but even
MPI gurus will benefit from the unique interface to MPI provided by
Boost.MPI.
The design of the STL provides a framework for writing algorithms that can work against iterators. The C++ standard library includes a set of basic algorithms useful in many programs. However, the collection provided in the standard library just scratches the surface of useful re-usable algorithms. Consider the long list of algorithms collected on the Boost User Wiki (http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl?STLAlgorithmExtensions). The following is a small sample:
- all_if – returns true if the predicate is true for all elements in the range
- copy_if – copy if predicate is true
- copy_while – copy until predicate is false
- is_sorted – return true if range is sorted
- various algorithms for maps
The workshop will meet every morning to chart progress, set direction, and interact with other BoostCon participants. Active participants will sign up to devote some time during the week to take an assignment to further the library development — working on the library during conference ‘down-time’ — about 30 minutes a day. Participants won’t necessarily code, but might write docs, write tests, do research or do other critical tasks.
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 number of algorithms ready for Boost review, or at least well on the way.
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
- deeper understanding of STL algorithm design
Final library in a week session
Visit the full session description
Continuation of Library in a Week
Visit the full session description
Continuation of library in a week:
Visit the full session description
Continuation of Library in a Week
Visit the full session description
This presentation will provide an overview of MPC (Makefile, Project, and workspace Creator). It will show how MPC can be used to create and maintain multiple build tool files for a multi-platform project. MPC generates GNU Makefiles, Visual Studio project files, Borland project files, and many others from simple description files with common sense defaults. MPC fully supports Boost libraries and can quickly create build files for you.
Examples will be given showing how easy it is to get started with MPC. One example will show how to build boost itself from Visual Studio with just a few simple mpc files.
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.
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.
This presentation will introduce the proposed Boost.Dataflow library, with an overview of its history development, and a tutorial on its use. This library was inspired by dataflow-oriented programming environments which are widely used in interactive art installations, presumably because of the ease of development which they offer. My initial goal was a C++ dataflow framework based on Boost.Signals, but this later morphed into a generic dataflow library.
The resulting library, which is now proposed for a Boost formal review is an interesting combination of dataflow features ranging from compile-time to run-time, and programming interfaces ranging from metaprogramming to GUI-based development.
The prospective Boost Lexer library is a programmable lexical analyzer generator inspired by ‘flex’. Like flex, this library is programmed by the use of regular expressions and outputs a state machine as a number of deterministic state machines (DFAs) utilizing equivalence classes for compression. Unlike flex it is not limited to outputing source code and allows the user to build a lexical analyzer at run time and utilize it immediately.
Spirit V2 is a complete parsing and output generation system with a symmetrical architecture that covers the whole spectrum from lexical analysis to output generation. The session will consist out of two parts:
- Part one provides an overview of Ben Hanson’s prospective Boost Lexer library and a tutorial on how this library may be used for high performance lexical analysis. Based on a pragmatic presentation containing minimal theory the tutorial will explain the possibilities of the Lexer library and how to use it to build static and dynamic lexical analyzers. The presentation will give functional and performance comparisons allowing participants to make decisions about which library feature(s) to use.
- Part two will describe how the prospective Boost Lexer library has been integrated with Spirit V2. Adding capabilities for lexical analysis to the Spirit parser framework enables the user to build complete parser applications with less effort. The integration with Spirit V2 is twofold: for one it provides a simple interface to the user for the association of the regular expressions with the Lexer. Additionally it provides an iterator based interface to the Lexer for its seamless integration with Spirit’s parser framework.
This tutorial will give an introduction to the Boost.Thread library. The tutorial begins with an introduction to threading and issues involved. It then dives into the Boost thread library. Focusing on core features; the library is presented with many examples to reinforce and provide easy application of the library.
The tutorial covers thread, thread_group, mutex, and condition. A thread pool implemented with Boost thread is shown as a working example. An hands-on exercise to create a delayed logger with a dedicated thread for logging will help the attendees get started with threading.
