Sessions
Note: Click the title of any session to visit its start time in the conference schedule.
AME Patterns Library: a generic library for modeling, recognition, and synthesis of sequential patterns
| Speaker: | Stjepan Rajko |
|---|---|
| Format: | tutorial |
| Track: | Track I 2010 |
This tutorial presents the AME Patterns library, an open source generic C++ library for modeling, recognition, and synthesis of sequential patterns. The library is useful for applications such as gesture and speech recognition, as well as synthesis of such patterns. It can be also used as a general-purpose library for models such as the hidden Markov model. The use of concept-based generic programming gives the library a large degree of flexibility, which is useful since pattern analysis spans many different domains. The library also offers several application programming interface (API) levels which offer different tradeoffs between programming complexity, flexibility, portability, and compile times.
A MIME library for Boost
| Speaker: | Marshall Clow |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
The most common way to encapsulate data in internet protocols is to use MIME or (Multipurpose Internet Mail Extensions). This format is used in HTTP, email and many other protocols.
I will introduce a library for creating, parsing, and manipulating MIME structures, with an eye for inclusion into boost, and talk about the design choices that went into creating this library. The (proposed) Boost.MIME library is (will be) used by Dean Michael Berris' network library.
A MIME processing library is one of the basic building blocks needed to implement networking protocols (along with threads, network I/O and state machines).
An Asio Based Flash XML Server
| Speaker: | Michael Caisse |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
Reactive systems are found everywhere. The temptation to implement them with legions of waiting threads can be strong; however, the result is nearly always disappointing at best.
The Boost.Asio library provides a framework to handle asynchronous resources with specific classes directed toward networking, serial port I/O, timers and more. In this session we will build a server that routes data streams to and from various serial I/O hardware components to TCP connected Flash displays. The Qi parsers and Karma generators developed in an earlier session will be employed to create ASTs that will be shuffled to their appropriate destinations.
This lecture/tutorial will utilize libraries including Asio, Spirit, Fusion, Phoenix, Smart_ptr, Thread, Function and Bind to pull together a server capable of streaming data to and taking requests from a Flash XMLSocket. Attendees will leave with an understanding of the Asio model and various implementation patterns to create their own Asio based servers.
A Survey of Transactional Memory
| Speakers: | Justin Gottschlich, Maurice Herlihy , Mark Moir, Tatiana Shpeisman, Michael Wong |
|---|---|
| Format: | panel |
| Track: | Track II 2010 |
Transactional memory (TM) is a modern concurrency control paradigm that simplifies parallel programming and supports an open-ended execution model. This full-day session brings together leading experts in industry and academia to discuss their recent TM research and development. Invited speakers from Boost, IBM, Intel, Microsoft, and Sun Microsystems will provide a brief overview of their latest work. The session will conclude with a panel where the invited speakers will present their thoughts on the near- and long-term challenges of TM. In closing, the moderator will take questions from the audience.
A Survey of Transactional Memory - Panel
| Speakers: | Justin Gottschlich, Maurice Herlihy , Mark Moir, Tatiana Shpeisman, Michael Wong |
|---|---|
| Format: | panel |
| Track: | Track II 2010 |
Transactional memory (TM) is a modern concurrency control paradigm that simplifies parallel programming and supports an open-ended execution model. This full-day session brings together leading experts in industry and academia to discuss their recent TM research and development. Invited speakers from Boost, IBM, Intel, Microsoft, and Sun Microsystems will provide a brief overview of their latest work. The session will conclude with a panel where the invited speakers will present their thoughts on the near- and long-term challenges of TM. In closing, the moderator will take questions from the audience.
Boost.Alabaster: A Law Based Tester
| Speaker: | Joachim Faulhaber |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
This is a proposal for a boost library that provides automated testing on the basis of formally specified laws or axioms. The test system consists of three parts. A law concept that allows to express axioms or laws as class templates over typelists that represent the law's instantiation variables. A generator for law instances that randomly generates law instantiations for a given law and a given typelist. A filter, that selects law violations and stores them according to a simplicity ordering. For the development of the Boost Interval Container library, a prototype of Boost.Alabaster has been used for a law based development. Law based testing as technique and tool turned out to be beneficial in many ways:
The quest for formal specification gives rise to deeper rooted design decisions and leads to a design that is more durable. In an evolutionary process, it drags abstraction and abstract reasoning about generic software from the end of software development (testing of laws) to it's front (specification) even if you did not start your development with ready made axioms. The law based development process produces not only the software but also formal properties that can be guaranteed about that software. The validation of those properties can be replicated at any time. Testing is transformed from a tedious and unloved duty to an extremely creative process that fosters abstraction and quality of design. Law based testing includes all benefits that traditional unit testing can offer and goes way beyond that.
BoostCon 2011 Kickoff Meeting
| Speakers: | Dave Abrahams, Hartmut Kaiser |
|---|---|
| Format: | panel |
To ensure a successful BoostCon'11, we'll need to start planning now. Be a part of the process!
C++0x Concurrency
| Speaker: | Michael Wong |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
In this talk, I will continue and expand on the C++0x concurrency discussion from BoostCOn09, specifically regarding the C++ memory model, and how concurrency will be handled through the new C++0x library, regarding starting and managing threads, sharing data between threads, and synchronizing concurrent operations.
C++0x update
| Speaker: | Michael Wong |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
Continuing from BoostCon 2009, I will give additional details on C++0x features, as well as the latest news on the ratification of C++0x, as well as continuing report on the latest compiler implementation status.
Clang: An Open-Source C++ Compiler Library
| Speaker: | Douglas Gregor |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
Clang is a new, open-source compiler front end for the C family of languages (C, C++, Objective-C). As a C++ compiler, Clang is a production-quality compiler that provides fast compiles, low memory usage, expressive diagnostics, a strong focus on standards conformance, and optimized code generation for a variety of architectures via the Low Level Virtual Machine (LLVM).
But Clang is more than a compiler. Architected as a set a layered, reusable C++ libraries, Clang is a platform for building great C++ development tools. Clang's internal data structures provide a detailed view of the program source code, with both complete semantic information (overloaded function calls resolved, implicit conversions explicitly represented) and syntactic information (precise source location information, including full macro instantiation history) available throughout. Its Boost-compatible, BSD-like open source license makes it the ideal base for any tool that depends on parsing C++ code fully and correctly, as well as a potential proving ground for new C++ language features and ideas.
This talk will introduce the Clang compiler, illustrating how its rich internal data structures provide a great user experience, then shift focus to a tutorial on Clang's architecture, primary data structures, and libraries for building Clang-based development tools.
Can it compile Boost? Join us to find out.
Conference registration and Sign-In '10
| Format: | social event |
|---|
Conference registration and Sign-In
Cross-platform development with Qt and Boost
| Speaker: | Joao P. R. Abecasis |
|---|---|
| Format: | tutorial |
| Track: | Track I 2010 |
The idea for this workshop is to provide a brief overview of Qt libraries, present practical solutions for mixing Qt and Boost.
In particular, I propose to go over MOC and the QObject model, build system integration for projects mixing Boost and Qt libraries, and to explore practical aspects of integrating Boost-based components into the QObject signals and slots implementation based on a small sample application.
I would like to gather feedback from the Boost community on interoperability issues and how it can be improved.
C++ Tool-Builders Workshop
| Speaker: | Douglas Gregor |
|---|---|
| Format: | workshop |
| Track: | Track I 2010 |
Like most professionals, programmers use a variety of tools to improve their productivity, and will occasionally fashion their own tools to address project-specific needs. Unfortunately for C++ programmers, building good C++ tools is greatly complicated by the inherent complexity of parsing C++ code. This complexity, coupled with the lack of open-source libraries that can parse C++ in its entirety, has kept C++ tools well behind their counterparts in other languages. Clang (http://clang.llvm.org) is a new, open-source C++ compiler library intended to help address this disparity by making it easier to build great C++ development tools.
In this hands-on workshop, attendees will learn how to use the Clang libraries to build new C++ tools. We'll start with the basics, parsing C++ programs and identifying interesting program constructs. From there, we'll learn how Clang represents programs from the lexical structure (tokens, macro instantiations, etc.) to the semantic structure (classes, functions, expressions, templates, etc.) via its abstract syntax tree. Finally, we'll get our hands dirty and build some C++ tools using Clang. The actual tools we build will be determined by the attendees, but possibilities include: enforcing project-specific coding standards, explaining why overload resolution picked some specific overload at a call site, automatically generating serialization code for classes, extracting documentation from Boost libraries, or interactive debugging for template or preprocessor metaprograms.
Program committee notes: I'm proposing two different sessions based on Clang. The 90-minute presentation ("Clang: An Open-Source C++ Compiler Library") will describe Clang as a compiler, library, and open-source project: it's really a high-level overview that won't be able to go too deep into the details. The workshop is more of an experiment along the lines of the hands-on Boost++0x workshop Dave and I ran last year: for this year, we'd like to see if we can get attendees to build some cool tools for Boosters to use. From a scheduling perspective, the presentation should occur earlier in the week than the workshop, since the presentation doubles as preparation and an advertisement for the workshop.
Data Structure Visualizers in Visual Studio 2010
| Speaker: | Stephan T. Lavavej |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
Many STL classes have complicated representations. To make debugging easier, Visual Studio 2005 and 2008 contained "visualizers" that displayed STL objects in a human-readable way. Anyone can write visualizers for other types, such as Boost classes; while this is undocumented and unsupported, it can be very useful. This presentation explains how to write visualizers, and how to take advantage of new features in Visual Studio 2010 that have been used to improve the display of shared_ptr, function, and map.
Distributed parametric optimization with the Geneva library
| Speaker: | Ruediger Berlich |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
This presentation introduces Geneva, an Open Source library of distributed optimization algorithms. Geneva allows the solution of large-scale parametric optimization problems on multi-core systems and clusters, and can even be used in Grid- and Cloud-environments. Geneva has been tested with up to 1000 clients, simultaneously working on optimization problems.
The talk discusses the topic of parametric optimization in the context of distributed computing. As Geneva is heavily based on Boost, the talk comprises an overview of the experiences made with this library collection.
If sufficient time and network connectivity is available, a practical demonstration of the Geneva library will be given.
Functional Programming in C++
| Speaker: | David Sankel |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
Functional programming (FP) techniques produce code that is general, concise, composable, and correct. Until recently many of these techniques were limited to the realm of academia and esoteric programming languages. New C++ and boost developments finally make these advanced techniques accessible.
This first part of this session explores the how and why of the FP techniques that are now possible. We'll be covering algebraic data types, point free higher order functions, purity, generic programming, type families, category theory, and applicative functors.
In second part of the session we'll be taking a close look at case studies of FP. The first is an embedded domain specific languages (EDSL) based on a motion controller. The second is a generic XML serialization framework like no other.
Future of Boost Panel '10
| 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.
General Conference Welcome
| Format: | social event |
|---|
General Conference Welcome, Introduction, Organizational Announcements
Generic Programming And the Boost Graph Library
| Speaker: | Jeremy Siek |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
Graph algorithms and data-structures solve problems in diverse areas such as Internet packet routing, molecular biology, scientific computing, and telephone network design. Traditional graph library designs 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 the Generic Programming methodology and demonstrated its efficacy 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.
Generic Programming for Geometry
| Speakers: | Barend Gehrels, Bruno Lalande, Mateusz Loskot |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
Boost.Geometry has been designed using modern C++ generic programming techniques. The tag dispatching technique is used all over the library, and combined with metafunctions, template metaprogramming, traits, and concept checking. In literature, tag dispatching normally does not get the attention it deserves; this article describes this technique step by step and describes how it can be used and combined with the other techniques, all in the context of geometry, with some trivial geometry functions as examples.
Informal Gathering at Meadows Bar '10
| Format: | social event |
|---|
Get to know your fellow Boosters and catch up with old friends. Bring your families and companions.
Instantiations Must Go!
| Speakers: | Matt Calabrese, Zachary Laine |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
In an effort to write a simple metafunction as part of a BoostCon09 session, the presenters tried to do something odd -- to write the metafunction without any template instantiations. After talking to experts much later, this turned out to be impossible. In the meantime, they discovered an interesting technique that makes somtimes-scary TMP code look a lot more like regular functional programming code, and removes the need to instantiate template definitions (though not declarations) for most metafunctions.
Is Boost Broken?
| Speaker: | Robert Ramey |
|---|---|
| Format: | lecture |
Good things about Boost.
- Credible "certification" of library quality and completness through formal review process
- Credible "certification" of implementation through formal testing, release process.
Boost isn't scaling well.
- Testing time takes longer and longer to complete..
- It's harder for testing to be comprehensive and include less well known compilers
- Current testing can't handle all the possible combinations of compiler settings (rtti on/off, debug/release, stl library, etc.
- installation becomes more onerous and fragile as more libraries are added.
- Hence, the "cost" or "overhead" of using boost increases with time even though new users will start using only one library. But there is no way to test/deploy just the libraries one is going to use.
Identity crisis - Is Boost
- A single (now large) library of core utilities? i) Tools test, release and deployment of boost is one operation. ii) The test, deployment and release of a subset of libraries has been considered necessary. ii) There is one release number for all libraries.
- Or a group (now large) of independent, decoupled libraries? i) Many or most libraries depend only on a subset of the total set of other boost libraries.
My argument is that it looks like boost started out as the former and is evolving towards the latter.
It's been a great 10 years for Boost. But to continue to be succeesful it's going to have to evolve. This presentation describes how I think boost has to change.
Logic Paradigm for C++
| Speaker: | Roshan Naik |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
The Logic paradigm (LP) is a powerful, Turing-complete programming paradigm that has seen little representation in mainstream languages as compared to the Object-Oriented, Imperative and Functional paradigms. LP is an important approach in Computer Science towards what is sometimes referred to as the Holy-Grail of programming "The user states the problem, the computer solves it". Origins of the theory underlying Logic dates back to about 300 B.C. when Aristotle founded Formal Logic to bring rigor to logical inferencing. The theory matured into Modern Logic more recently (early 1900s) when Russell & Whitehead showed that all of Mathematics could be reduced to Logic.
This talk centers around Castor, a new opensource C++ library which is intended to be proposed for inclusion into Boost. Besides extending Boost's abilities to support LP, this will allow Boost programmers to combine facilites from the functional paradigm with LP and enable integration of streams, algorithms and containers without need for iterators or ranges.
This talk will provide an introduction to the basics of LP in C++, followed by plenty of examples to get you thinking in terms of this paradigm. We will observe how it naturally blends with existing Boost and C++ concepts. Finally, we shall broaden the scope to see how powerful multiparadigm solutions emerge when programmers can freely mix and match paradigms. It will be evident from this talk, how a clean and deep integration of LP makes C++ a fountainhead for the many design patterns yet to be discovered.
Picnic'10
| Format: | social event |
|---|
A picnic on the Aspen Center for Physics campus.
Practical DSEL Design with Proto
| Speaker: | Eric Niebler |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
This presentation will focus on how to build useful DSELs rapidly with Boost.Proto. The session will step through the design and implementation of several real-world DSELs, starting with the simple (e.g., Boost.Assign's map_list_of()), moving on to the intermediate (e.g., Howard Hinnant's future groups), and finishing with the design for a simplified Phoenix library. The emphasis will be on practical solutions to real-world library design problems. Through the exploration of specific real-world problems, the value of DSELs in general will become apparent, as will the value of implementing them in C++ with Proto. Usability issues such as compile times and template error messages will also be discussed.
Production use of Boost.Test
| Speaker: | Gennadiy Rozental |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
This session will cover various usage scenarios of Boost.Test in production components. Specifically following subject are going to be covered:
- Usage of execution_monitor to guard function execution. Various configuration options. (New) Handling of floating point exceptions. (New) Trap site callbacks.
- Usage of program_execution_monitor for high level program execution guard.
- (New) Usage of Boost test tools in production components.
- In place unit testing: 2 approaches to built component unit test inside the implementation itself: a) using compile time switches, b) Using console test runner and implementation built as shared library.
RAD Spirit
| Speakers: | Joel de Guzman, Hartmut Kaiser |
|---|---|
| Format: | tutorial |
| Track: | Track II 2010 |
One allure of Boost Spirit Parser, compared to traditional parser generators, is its being embedded in C++. The user of the library specifies a parser's grammar directly in C++ code using expression templates. There are distinct advantages with this approach, but there are problems as well. The most glaring drawbacks are 1) long compile times and 2) difficult to understand error messages and 3) Difficulty in debugging and testing parsers. For small parsing tasks, these can be tolerated. Yet, after 8 years in active deployment, we've come to a point where Spirit is being used in increasingly more complex parsing tasks. 2 and 3 can somehow be alleviated by adding more "smarts" to the expression template engine (using Proto), but that would increase compile times further to the point where the libary will no longer be useful.
It would be interesting to have a tool (both stand-alone or library based) that accepts textual EBNF/PEG expressions and outputs either parsers that are immediately executable or C++ Boost Spirit code. The RAD tool can have all sorts of smarts to make writing parsers as painless as possible (e.g. debugging, error handling, analysis, etc). After the development of the parser is "set in stone", one can opt to have the tool emit C++ code that can then be included in an application. For more complex parsers, this will be a definite boon.
We would like to present the design and development of such a tool. Obviously, this "Dynamic Spirit" tool will be written using "static" Spirit. This would be a practical real world example using Spirit.
Reducing the Integration Complexity of Software Transactional Memory with TBoost.STM
| Speakers: | Vicente J. Botet Escriba, Justin Gottschlich, Dwight Y. Winkler |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
Transactional memory (TM) is a concurrency control paradigm that reduces the difficulty of writing parallel programs and supports the efficient execution of some concurrent workloads. While TM offers advantages over other abstractions, it can sometimes require complex hardware, programming language extensions, specific compiler support, or enforce impractical software design, making it unrealistic for early adopters.
In this paper, we explore recent advances in TBoost.STM, a software TM library, that support a wider array of C++’s control flow statements and simplify the integration of transactions into programs without transactions.
Revisiting Guidelines to Using Exceptions in C++
| Speaker: | Ken Joyner |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
It is fairly well known that writing exception-safe code is challenging. This leads many developers to conclude that the use of exceptions should be avoided at all cost. However, the problem with this conclusion is that developers are assuming it is easier to write error-safe code without the use of exceptions. I believe this assumption is incorrect. Instead, I believe that in practice many developers do not write error-safe code and exceptions make it more challenging to ignore the errors that occur (unhandled exceptions will cause your program to terminate so they must be handled).
Writing error-safe code is challenging with or without the use of exceptions. And not writing code that is error-safe leads to unpredictable and often unstable code.
This paper re-documents the levels of exception safety (with a few slight modifications), provides an exception safety recommendation that is more practical for most companies and developers, gives a comprehensive set of guidelines (many of them borrowed from other sources) that can be followed to achieve the level of safety a company or developer requires and provides a helper library (again many of the ideas are borrowed from other sources) along with specific recommendations for other libraries that will make writing error-safe code using exceptions significantly less challenging along with adding additional benefits to using exceptions.
Spirit History and Evolution
| Speakers: | Joel de Guzman, Hartmut Kaiser |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
This year, we celebrate Spirit's 10th anniversary from its early beginnings as an offshoot from a much larger GUI library in the 90s and debuted into Boost in May 2001 in the typical "Is there interest in this library?" fashion like all would be Boost libraries. From a humble 7 header file library, Spirit has grown to be one of the most sophisticated Boost libraries and along the way became the incubator of other Boost libraries such as Boost.Fusion, Boost.Phoenix, and Boost.Wave and played a significant role for Boost.Proto getting mature.
We would like to present Spirit (and the libraries it inspired) in a historical perspective. The presentation will aim to provide a lighter, more intimate perspective into the development of at least 4 libraries with almost a decade's worth of experience being Boost authors and bonafide crazy template metaprogrammers who abuse operators like Mad Scientists. Of course, we can't help it if we show off some C++ tricks here and there, but we'll try to keep it as light as we can.
Techniques in Flexible Header-Only C++ Network Library Implementations
| Speaker: | Dean Michael Berris |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
This paper highlights the various techniques used by the cpp-netlib project to deliver simple yet powerful header-only C++ networking libraries on top of Boost.Asio. Some of the techniques used are borrowed from other existing libraries while some arise from best practices following generic programming principles. The paper aims to highlight the organization of the different parts of the library as well as the idioms used to achieve highly modular and flexible implementations of a common message type, a type-safe URI parser and object representation, and a semantically consistent HTTP client. This paper serves as an introduction to the cpp-netlib project as well as a survey of the modern C++ techniques used throughout the implementation of the various modules of the library.
The Basics of Lock-free Programming
| Speaker: | Tony Van Eerd |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
Starting from the very basics, showing problems of accessing shared data, slowly expose the problems, and then lock-free solutions to the problems. Including: Explain atomicity. Explain the CAS instruction, and CAS-loops. Review the perils of the Double-Checked-Locking Pattern (DCLP), and how to avoid it (ie by using memory barriers). Review memory barriers by presenting an understandable model of how multiple CPUs work, based on the ideas of a read-request queue and a write-request queue. Present a lock free stack. Explain ABA and ways to avoid it. Touch upon some bleeding edge developments in lock-free programming (optimistic relaxed memory operations), etc. Touch upon Boost and C++0x and how they will affect lock-free programming moving forward.
The Meta State Machine Library V2
| Speaker: | Christophe Henry |
|---|---|
| Format: | tutorial |
| Track: | Track I 2010 |
My BoostCon09 article about MSM v1 was showing the main features of the library with the goal of facilitating a MDA (Model-Driven-Architecture), also called MDD (Model-Driven-Development) approach. Concretely, the talk was insisting on the descriptive and expressive nature of MSM. This paper will first sum up the main supported UML features and show their usage with the new front-ends provided by MSM v2. In the second part of this paper, we will see how MSM now moved further on the MDD way by providing more capabilities usable in a MDD context.
The Numerical Template Toolbox : BOOST'ed Generic Array Library for High Performance Computing
| Speakers: | Joel Falcou, Jean-Thierry Lapreste |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
Performing large, intensive or non-trivial computing on array like data structures is one of the most common task in scientific computing, video game development and other fields. This matter of fact is backed up by the large number of tools, languages and libraries to perform such tasks. If we restrict ourselves to C++ based solutions, more than a dozen such libraries exists from BLAS/LAPACK C++ binding to template meta-programming based Blitz++ or Eigen2. If all of these libraries provide good performance or good abstraction, none of them seems to fit the need of so many different user types.
In this talk, we present the Numeric Template Toolbox (NT2), which is a template meta-programming, array based scientific computing library which aims at providing a rock-solid implementation to enforce good performance with respect to architectural concerns like memory handling and automatic parallelism while providing an intuitive yet extensible user API and developer SDK. We also emphasize on the added value of using Boost.Components (MPl,Proto,Fusion,PP,Serialization among other) to the overall library design and performances.
Transactional Memory Today
| Speaker: | Maurice Herlihy |
|---|---|
| Format: | keynote |
Keynote
Type Erasure
| Speaker: | Nevin Liber |
|---|---|
| Format: | lecture |
| Track: | Track I 2010 |
Beginning with the definition found in C++ Template Metaprogramming, I'll talk about what is type erasure and how does it work, as well as its advantages and costs. I’ll start with an example taking an inheritance based interface and converting it to one using type erasure. I’ll cover the implementation of Boost.Any, as well as a simplified version of Boost.Function. I’ll touch upon the notion of regular types and classes that work (<http://stlab.adobe.com/wiki/index.php/Image:2008_06_26_classes_that_work.pdf>). I’ll compare using containers of Copyable/Assignable types with that of using containers of Boost.shared_ptr and Boost.Pointer Containers.
Using Spirit V2: Qi and Karma
| Speaker: | Michael Caisse |
|---|---|
| Format: | lecture |
| Track: | Track II 2010 |
Machinery, sensors, equipment, client/server communications, even file formats... Parsing and producing communication streams is everywhere you look. Often these tasks are simple or small enough to tempt ad-hoc solutions. The Spirit 2.1 library provides a model that is simple enough to tackle those "quick hacks" and easily scales for full-featured AST generation.
This session will explore real-life experiences with the parser and generator (Qi/Karma) portions of the Spirit library. As we look at various small and medium-sized parsers/generators employed in various products we will establish some "rules-of-thumb" and guidelines for tackling the parser/generator domain with Qi/Karma. The session will end with the implementation of a usable XML parser and a simplified XPath-like node extractor.
The session will include some lecture and a lot of tutorial. Attendees will walk away with the knowledge and tools to begin parsing and generating with Spirit Qi/Karma.