2007 Program | boostcon (original) (raw)

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.

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.

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

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.

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.

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.

Abstract

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

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.

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

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.

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.

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.

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.

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.

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.

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.

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!

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

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.

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 picnic on the Aspen Center for Physics campus. Sponsored by Boost Consulting, Inc.

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.

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.

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.

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.