Sessions
Note: Click the title of any session to visit its start time in the conference schedule.
CORBA C++ API -- Birds of Feather
| Format: | workshop |
|---|
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.
Make Project Creator
| Speaker: | Kevin Heifner |
|---|---|
| Format: | lecture |
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.
Authors Corner: Parameter
| Speaker: | Dave Abrahams |
|---|---|
| Format: | lecture |
| Track: | Track II 2008 |
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.
Boost.Extension and Boost.Reflection
| 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.
Dinner Reception
| Format: | social event |
|---|
A gourmet feast featuring Colorado specialties served in the lobby and patio area of the Aspen Meadows.
Building a simple language compiler using Spirit V2
| Speakers: | Hartmut Kaiser, Joel de Guzman |
|---|---|
| Format: | tutorial |
| Track: | Track II 2008 |
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.
BoostCon'09 Planning Kickoff
| Speakers: | Dave Abrahams, Beman Dawes, Jeff Garland, Douglas Gregor, Eric Niebler, Joel de Guzman |
|---|---|
| Format: | workshop |
To ensure a successful BoostCon'09, we'll need to start planning now. Be a part of the process!
Text Processing using Boost
| Speaker: | Eric Niebler |
|---|---|
| Format: | tutorial |
| Track: | Track II 2008 |
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.
Library in a Week 2008 -- Extending Boost.Algorithms
| Speaker: | Jeff Garland |
|---|---|
| Format: | workshop |
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
Container Streaming Library: Library In a Week 2007 Design/Code Review
| Speakers: | Danny Havenith, Jared McIntyre |
|---|---|
| Format: | workshop |
| Track: | Track II 2008 |
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.
Authors Corner: Wave
| Speaker: | Hartmut Kaiser |
|---|---|
| Format: | lecture |
| Track: | Track II 2008 |
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.
Conference Registration and Sign-In
| Format: | social event |
|---|
Pick up your welcome packet and sign in for the conference. During the week registration will be in the Aspen Center for Physics lobby.
How bugs get reported/fixed in Boost
| Speaker: | Marshall Clow |
|---|---|
| Format: | lecture |
| Track: | Track II 2008 |
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.
Authors Corner: Function
| Speaker: | Douglas Gregor |
|---|---|
| Format: | lecture |
| Track: | Track II 2008 |
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.
Threading with Boost
| Speaker: | Kevin Heifner |
|---|---|
| Format: | tutorial |
| Track: | Track I 2008 |
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.
Authors Corner: Date-Time
| Speaker: | Jeff Garland |
|---|---|
| Format: | lecture |
| Track: | Track II 2008 |
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.
C++0x Today: Features for Building Better Libraries
| Speaker: | Douglas Gregor |
|---|---|
| Format: | tutorial |
| Track: | Track II 2008 |
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.
Boost.Serialization: A Hands-On Tutorial
| Speaker: | Sohail Somani |
|---|---|
| Format: | tutorial |
| Track: | Track I 2008 |
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)
Implementing a mini Boost.Fusion Using C++0x
| Speakers: | Dan Marsden, Joel de Guzman |
|---|---|
| Format: | tutorial |
| Track: | Track II 2008 |
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.
Authors Corner: System & Filesystem
| 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.
High Performance Generic Software Design
| Speakers: | Dave Abrahams, Eric Niebler |
|---|---|
| Format: | tutorial |
| Track: | Track I 2008 |
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.
Network Programming with Boost Asio
| Speaker: | Jeff Garland |
|---|---|
| Format: | tutorial |
| Track: | Track I 2008 |
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.
Future of Boost 2008
| Speakers: | Dave Abrahams, Beman Dawes, Jeff Garland, Douglas Gregor |
|---|---|
| Format: | panel |
Boost has a small group of moderators that keep the mailing list running including approving posts and moderation to keep the mailing list on-topic, respectful, and useful. In addition, they administer internals of the website, source repository and other administrative machinery. And last, but not least, the moderators also act as an informal executive overseeing committee to promote all things Boost.
In this session, each moderator will be given 5 minutes to say something about their vision of the future of Boost, but the majority of the session will be devoted to questions and proposals from the audience. This is your chance to ask or propose absolutely anything about the direction of the Boost community. For example, why we don't adopt a particular policy, tool, or idea.
The Dataflow Library and the Arts
| Speaker: | Stjepan Rajko |
|---|---|
| Format: | lecture |
| Track: | Track I 2008 |
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.
Authors Corner: Proto
| Speaker: | Eric Niebler |
|---|---|
| Format: | lecture |
| Track: | Track II 2008 |
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.
Library in a Week 2008 -- Extending Boost.Algorithms (Fri)
| Speaker: | Jeff Garland |
|---|---|
| Format: | workshop |
Final library in a week session
Visit the full session description
Library in a Week 2008 -- Extending Boost.Algorithms (Thu)
| Speaker: | Jeff Garland |
|---|---|
| Format: | workshop |
Continuation of Library in a Week
Visit the full session description
Library in a Week 2008 -- Extending Boost.Algorithms (Wed)
| Speaker: | Jeff Garland |
|---|---|
| Format: | workshop |
Continuation of Library in a Week
Visit the full session description
Library in a Week 2008 -- Extending Boost.Algorithms (Tue)
| Speaker: | Jeff Garland |
|---|---|
| Format: | workshop |
Continuation of library in a week:
Visit the full session description
A C++ Libraries Wishlist
| Speaker: | Bjarne Stroustrup |
|---|---|
| Format: | keynote |
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.
A New Library for Working with Hierarchical Data Types
| 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 Prospective Boost Lexer Library and its Integration with Spirit V2
| Speaker: | Hartmut Kaiser |
|---|---|
| Format: | lecture |
| Track: | Track II 2008 |
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.
Informal Gathering @ Meadows Bar
| Format: | social event |
|---|
Informal Gathering of Conference Attendees
Introduction to Parallel Programming with the Message Passing Interface
| Speaker: | Douglas Gregor |
|---|---|
| Format: | lecture |
| Track: | Track II 2008 |
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.