Performance and efficiency are always big themes at C++Now. This year is no exception - we have a number of talks about performance:
- Jason Turner - Practical Performance Practices
- David Stone - Exceptional Performance
- Sebastian Redl - Diet for your Templates - Reducing Code Bloat in Your Templated Library
We still have room for a few more people at this years’ conference! We have a couple registration slots left, and our group rate at Aspen Meadows, the conference hotel, is still available. Come join us in Aspen this May!
Some more information about these performance talks:
Jason Turner - Practical Performance Practices
In the past 6 years ChaiScript’s performance has been improved by nearly 100x. This was not accomplished by adding a virtual machine or performing dynamic recompilation. Instead, these increases have been accomplished by moving to more simple, cleaner, idiomatic C++ and by following some simple rules. We will outline these concepts with examples for how they both simplified code while improving performance.
About the Speaker: Jason Turner is an independent contractor with 15 years of development experience. For the past 5 years he’s been specializing in cross platform development, scripting of C++ libraries, automated testing and code quality analysis. Jason is the the co-creator and maintainer of the embedded scripting language for C++, ChaiScript, and the author and curator of the forkable coding standards document cppbestpractices.com.
David Stone - Exceptional Performance
When many of us choose C++, performance is one of the most important factors. It is so ingrained in the culture of C++ that the single most important tenant of C++ is probably “You don’t pay for what you don’t use”. This shows up in almost all components of modern C++: zero-cost abstractions backed by a powerful optimizing compiler. Yet there is one component of the language that appears to violate this rule: exceptions. The mere possibility of exceptions can force the compiler to generate different, slower, code than it otherwise would have. Throwing an exception is a slow operation, and exceptions can lead to an increase in code size. There is a lot of conflicting advice on what exactly the programmer can do to make sure that they only pay for what they use that runs the gamut from “Don’t worry about it” to “Pass this special flag to your compiler to turn off exceptions”. The situation is only made more complicated by the introduction of the noexcept keyword. In this presentation, we will discuss exactly what effect exceptions have on the performance of an application, backed up by numbers from both benchmarks and real world applications. We will go into the details of hardware architecture and memory hierarchy to try to understand exactly why code performs the way it does. Could it ever make sense to say that you using exceptions for performance reasons?
About the Speaker: David Stone has spoken at C++Now and Meeting C++. He is the author of the bounded::integer library and has a special interest in compile-time code generation and error checking, as well as machine learning. He works at Markit integrating real-time financial data. He has written an algorithm that solved the traveling salesman problem in polynomial time. He can square the circle and divide by zero. He can move his king into check. He once wrote an optimizing compiler that solved the halting problem, but doesn’t need to use it because his code is already optimized.
We developed a heavily templated-driven library, IoC++, in-house at our company. Using it, we discovered that it generated huge object files and libraries, leading to very long link times, large executables, and even linker crashes. In this session I present techniques we used to reduce the bloat in the library and got our link times down to acceptable values.
About the Speaker: Sebastian holds a BSc in Software Engineering from the Technical University of Vienna and is currently finishing an MSc. He is working at a small software company called Symena (part of Teoco), and recently spent a year’s sabbatical working at Google. He has contributed heavily to the Clang C++ compiler and maintains the Boost.PropertyTree library.
One of the major topics of this year’s program will be the C++17 standard which is nearing completion. Here’s a preview of a few of the sessions about C++17:
- David Sankel - Variants: Past, Present and Future
- Nathan Myers - Progress on Contract Support for C++17
- Alisdair Meredith - Implementing tuple in C++17
There’s still time if you’re thinking about joining us at C++Now. A few registration slots are still up for grabs, and our group rate at the conference hotel is still available. Hope to see you in Aspen this May!
Here’s some more details on those talks:
David Sankel - Variants: Past, Present and Future
What are variants, why are they important, and how I use them? Once available to a developer, variants become one of the most commonly used tools in everyday programming. This talk will explore the venerable Boost.Variant library, discuss the improvements made by the current ‘std::variant’ proposal (expected in C++17), and close with a discussion of the exciting new language-based variant and pattern matching papers (proposed for C++20). This talk aims to be of practical utility in variant library usage and informative as to where things are heading.
About the Speaker: David Sankel is a professional software developer/architect based in the USA. His prolific software developments have included CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at the C++Now! conferences and is especially well known for his advanced functional programming in C++ talks. David’s current research interests include dependently typed languages, semantic domains, EDSLs, and functional reactive programming. He currently works for the software firm, Stellar Science.
Nathan Myers - Progress on Contract Support for C++17
Contract Support in a language helps library authors and library users work together to make better programs, catching usage mistakes early and preventing spurious bug reports. Every library has incidental behaviors and interpretations of arguments that are not in the specification, and could easily be different in the next release. It is very easy to come to accidentally depend on these incidental details. When details can be spelled out directly in C++, and automatically verified during testing, there is much less room for misunderstandings. The process of getting contract support into C++ has been long and contentious, because the name actually refers to several nearly disjoint goals, with different champions, and conflicting priorities. Some are most interested in static, compile-time verification, others in runtime checking and controlled response to violations, or defense against security abuses, or even improved optimization opportunities. The annotations programmers would add could certainly be used for all of these things, but where to add them and what to say vary by the intended use. The factions have come together to present a common proposal meant to address all the disparate needs, with the minimum burden on programmers. This presentation explores the unified proposal and how it meets the needs of each group, and of programmers in general. Many surprises surfaced while merging the designs and simplifying.
About the Speaker: After using C++ in production since 1988, Nathan Myers joined the ISO Standard effort in 1993. He’s responsible for keyword “explicit” and he invented traits, empty-base optimization, and indexing type-erased containers by type. Nathan holds record for longest sentence using only C++ keywords, once each. He still thinks of the STL containers as only examples.
Alisdair Meredith - Implementing tuple in C++17
C++17 adds new language features that might affect the design and implementation of ‘std::tuple’, such as fold expressions for templates. Several other features still pending as this proposal is written, such as concepts and implicit comparison operators. In addition, the standard library itself pushes the interface of the ‘tuple’ template itself, while providing additional metaprogramming utilities that might help both the implementation, and users. This session will review the tuple interface, as specified for C++17, highlighting any changes since C++11 and C++14. It will then look into the design of several implementations of tuple, explored through several testing and benchmarking scenarios, before looking to draw conclusions. Note that the code shown in this session will require a recent version of a C++ compiler that implements an experimental C++17 mode. The latest Clang and gcc compilers should be capable, although the latest development compilers may be needed for new language features added in 2016.
About the Speaker: Alisdair Meredith is a software developer at BloombergLP in New York, and formerly the C++ Standard Committee Library Working Group chair. He has been an active member of the C++ committee for just over a decade, and by a lucky co-incidence his first meeting was the kick-off meeting for the project that would become C++11, and also fixed the contents of the original library TR. He is currently working on the BDE project, BloombergLP’s open source libraries that offer a foundation for C++ development, including a standard library implementation supporting the polymorphic allocator model proposed for standardization.
The C++Now 2016 program is now online.
This year’s Call for Submissions resulted in a record number of submissions, so it is no surprise that we’ve completely filled all three tracks for this year’s conference.
We have sessions from dozens of speakers. Many sessions feature popular returning speakers, including our keynote speaker, Sean Parent, but many sessions are from speakers presenting at C++Now for the first time.
As expected, the program features many sessions on C++14, performance, metaprogramming, and concurrency. In addition, we have sessions on open source, Boost, tools, portability, maintainability, refactoring, functional programming, coroutines, games, testing, documentation, reflection, and, of course, what to expect in C++17.
Our tenth annual conference is shaping up to be one of the strongest programs that we’ve ever offered. Join us in Aspen this May.
C++Now is a very forward-looking conference. It’s focused on cutting edge techniques that take advantage of the latest features of Standard C++ to see today what the libraries that we’ll all be using tomorrow will look like.
But with our tenth annual conference, we are also looking back at where it all began. In keeping with the forward-looking nature of the conference, our very first keynote was called “A Possible Future for Software Developement” and it was given by Sean Parent.
In that historic talk, Sean challenged the then-conventional wisdom about the OO paradigm and advanced the viewpoint that the design principles of Generic Programming offered a way toward quality, scalable software.
It is hard to imagine a better talk to characterize the direction that C++ library development has taken over the last decade. It isn’t possible to know if this was because of the influence that Sean has had on Boost and Boost has had on the C++ community or if Sean was just really good at predicting the future. In either case, it was a talk not to be missed.
Sean will be back this year to usher us into our second decade with another not-to-be-missed keynote called, simply, “Better Code.” Sean will give a concise defintion of “good code,” explore inevitable trade-offs, and discuss techniques for managing a large code base.
Sean is currently a principal scientist and software architect for Adobe’s digital imaging group and formerly managed Adobe’s Software Technology Lab.
It is my pleasure to announce the fourth year of the C++Now Student/Volunteer program! We are again inviting students with an interest in C++ to attend the May 9-14, 2016 conference in Aspen, CO as Student/Volunteers.
The Student/Volunteer program is an excellent way for students and young coders with an interest in C++ to learn about language and make lasting connections with the community.
“Attending has truly been one of the most inspirational moments of my life. I had the opportunity to learn, socialize and have a great time in general. I hope to attend this conference yearly now and make a lasting impact in the computer science community.” - Grant Mercer, 2013 Student/Volunteer - read more
Student/Volunteers will receive free registration and a travel stipend for their hotel and airfare.
Volunteers will handle various tasks during the conference, such as assisting presenters, setting up presentation rooms, running A/V equipment and helping with the conference picnic.
Students from all fields of study are welcome to apply. However, this conference covers advanced C++ topics, and applicants should have ample experience with the C++ programming language and be familiar with general computer science topics.
Applications will be accepted until March 16th, 2016. Application decisions will be sent out by March 21st, 2016.
You can apply and/or learn more about the program and some of the students who have participated here.
Bryce Adelstein-Lelbach email@example.com (Student/Volunteer Chair)
Registration for C++Now 2016 is open!
The Tenth annual C++Now Conference (formerly BoostCon) will be held at the Aspen Center for Physics in Aspen, Colorado, May 9th to 14th, 2016.
Photograph by Laurie Clow. Used with permission.
C++Now has sold out for the last three years and we expect to sell out again. Register immediately so you won’t miss out.
Register now at our registration page.
Note to submitters: If you have submitted a session for the 2016 conference, do not register at this time. You will be contacted with registration instructions.
Sponsorship opportunities for 2016 are available. For a copy of the conference Sponsorship Prospectus contact firstname.lastname@example.org.
C++Now is presented by Boost in-cooperation with ACM.
We invite you to submit session proposals to the 5th annual C++Now Conference (tenth annual BoostCon): C++Now 2016 (Aspen CO, USA, May 9 – 14, 2016).
Building upon the resounding success of previous BoostCon and C++Now conferences, C++Now 2016 will present leading speakers from the whole C++ community.
The C++Now Conference is dedicated to discussion and education about C++, an open and free language and standard. Our Conference will focus on discussion and education about open source software usage and developments in the C++ developer and user community. To reflect the breadth of the C++ and Boost communities, the conference includes sessions aimed at three constituencies: C++ and Boost end-users, hard-core library and tool developers, and researchers pushing the boundaries of computation. The program fosters interaction and engagement within and across those groups, with an emphasis on discussion.
As a multi-paradigm language, C++ is a melting pot with the most compelling ideas from other programming communities blending in powerful ways. Historically, some of the most popular sessions at C++Now have highlighted these concepts, from DSLs to functional programming to transactional memory and more. Bring your C#, Python, Ruby or Haskell influences to bear in an environment that will broaden their exposure.
At C++Now 2016 we would like to focus on the now established C++11 and C++14 standards and how those standards shape C++’s future. However, by no means is this intended to restrict the topics of proposals we hope to see. Any other topic related to C++, as described below, is suitable for submission.
Photograph by Zoetica Ebb. Used with permission.
|Proposal submissions due||January 29th (Note this date cannot and will not be extended.)|
|Proposal decisions sent||February 22nd|
|Program online||March 14th|
Best Presentation Awards
We know how much effort it takes to prepare talks for our conference. For this reason attendees vote on the best presentations of the conference. Each winner will receive a commemorative plaque and announcement on the C++Now website.
Topics of interest include, but are not restricted to, the following:
- C++11/14 and how it changes life for users and library writers
- New directions and proposal for upcoming C++ standards
- Concepts and generic programming
- Designing for testability
- Using specific Boost libraries in-depth
- Extending or enhancing existing Boost libraries
- Advanced implementation techniques used within Boost libraries
- The design and/or the development process
- Software development tools and their application to C++ and or Boost
- Boost infrastructure topics such as build tools, website, testing
- Any other topics likely to be of great interest to C++ developers
- Tools for better developer productivity
Interactive and collaborative sessions are encouraged, as this is the style of learning and participation that has proven most successful at such events. Sessions can be tutorial based, with an emphasis on interaction and participant involvement, or workshop based, whether hands-on programming or paper-based, discussion-driven collaborative work.
Lectures focus on a practitioner’s ideas and experience with anything relevant to the C++ community.
Panels feature three or four people presenting their ideas and experiences relating to C++’s relevant, controversial, emerging, or unresolved issues. Panels_ may be conducted in several ways, such as comparative, analytic, or historic.
Tutorials are sessions at which instructors teach conference participants specific skills or knowledge relevant to C++.
Workshops provide an active arena for advancements in C++-relevant topics. Workshops provide the opportunity for experienced practitioners to develop new ideas about a topic of common interest and experience.
Tool Vendor Presentations : We actively encourage tool vendors and ISP’s to submit proposals for a special Tool Vendors Session Track aimed at products related to Boost and C++ (compilers, libraries, tools, etc.).
Other formats may also be of interest. Don’t hold back a proposal just because it doesn’t fit into a pigeonhole.
Submitting a Proposal
All submissions should be made through our submission page: here.
Standard sessions are 90 minutes. You may submit a proposal for fractions or multiples of 90-minutes. Fractional proposals will be grouped into 90 minute sessions. Longer sessions, such as tutorials and classes, will be assigned 90 minute, three hour (i.e. half day), or six hour (i.e. full day) time slots.
One registration fee is waived for a standard session presentation. Shorter sessions are prorated.
All submissions will go through a peer review process.
Session materials will be posted to the C++Now website and will be available to conference attendees.
For general information on the C++Now 2016 paper submission process or the scope of technical papers solicited, please refer to the conference website at cppnow.org. For any other questions about the submission process or paper format, please contact the Program Committee email@example.com .
Note: Presenters must agree to grant a non-exclusive perpetual license to publish submitted materials, either electronically or in print, in any media related to C++Now.
C++Now is presented by Boost in-cooperation with ACM.
Hartmut Kaiser firstname.lastname@example.org (Program Committee Chair)
Joel Falcou email@example.com (Program Committee Chair)
Jon Kalb firstname.lastname@example.org (Conference Chair)
Photograph by Laurie Clow. Used with permission.
C++Now 2015 wrapped up with the announcement of C++Now 2016. The dates will be May 9, 2016 through May 14, 2016 and the location will be the Aspen Center for Physics in Aspen, Colorado.