Loading…
This event has ended. View the official site or create your own event → Check it out
This event has ended. Create your own
View analytic

Log in to bookmark your favorites and sync them to your phone or calendar.

Monday, May 15
 

4:00pm

Conference Registration and Reception
Please note the venue! This year registration is at the Meadows Resort.

Welcome! Let's get the paperwork out of the way and enjoy old and new friends.

Monday May 15, 2017 4:00pm - 6:00pm
Aspen Meadows Resort 845 Meadows Rd, Aspen, CO 81611

6:00pm

Dinner Break
Suggested Venue: Mezzaluna or Asie

Mention “Physics” and you’ll be seated together. Some will offer a free appetizer. They expect a group but you don’t have a reservation and if they can’t accommodate you, please see http://eataspen.com for more restaurant ideas and off-season specials. 

Monday May 15, 2017 6:00pm - 8:30pm
on your own

8:30pm

Social Event: Informal Gathering
Get acquainted with new friends and reacquainted with old friends. Bring your family and traveling companions.

Monday May 15, 2017 8:30pm - 10:00pm
Aspen Meadows Resort 845 Meadows Rd, Aspen, CO 81611
 
Tuesday, May 16
 

8:00am

General Conference Welcome
Welcome to Aspen! Orientation to the conference facilities and surroundings.

Speakers
avatar for Jon Kalb

Jon Kalb

Conference Chair, Boost Libraries
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!


Tuesday May 16, 2017 8:00am - 8:15am
Paepke Auditorium

8:15am

Library in a Week
Library in a week 2017

Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has... Read More →


Tuesday May 16, 2017 8:15am - 9:00am
Paepke Auditorium

9:00am

Rust: Hack Without Fear!
Through the concept of zero-cost abstractions, C++ has shown that it is possible to combine low-level control with high-level programming concepts. Rust is language that aims to offer the same sorts of zero-cost abstractions that C++ is capable of, while also enforcing memory safety and data-race freedom. The secret sauce is Rust's core notion of "ownership", which enables:

- Memory safety without garbage collection;
- Concurrency without data races,
- Abstraction without overhead.

In this talk, I'll explain ownership and show how Rust uses it to guarantee thread safety, amongst other things. I'll also talk about how Rust is designed to scale to large code-bases, sharing some of our experiences here at Mozilla from integrating Rust code into Firefox.

One final theme of the talk is that the benefits of ownership go beyond having fewer bugs: once you are freed from the need to prevent memory-safety violations, it becomes possible to write -- and **maintain** -- programs that aggressively pursue parallelization and other kinds of optimizations that would have been too risky or too difficult before.

Speakers
avatar for Niko Matsakis

Niko Matsakis

Senior Researcher, Mozilla
Nicholas Matsakis is a senior researcher at Mozilla research and a member of the Rust core team. He has been working on Rust for nearly six years and did much of the initial work on its type system and other core features. Prior to working on Rust, he did his undergraduate studie... Read More →


Tuesday May 16, 2017 9:00am - 10:30am
Paepke Auditorium

10:30am

Break
Join us on the patio at the ACP for light snacks, drinks, and gossip.

Tuesday May 16, 2017 10:30am - 11:00am
Aspen Center for Physics Patio

11:00am

C++11’s Quiet Little Gem: <system_error>
Amongst the loud fanfare of C++11 arrived this quiet little gem of <system_error>, with std::error_code and std::error_condition born from the heart of boost::asio. With Committee input they evolved for inclusion into the C++11 Standard, providing consistent and extensible ways for applications to expose platform-specific error-codes, platform-independent error-conditions, and rely upon an open-ended design that permits future extensibility for message reporting; and even internationalization of logs and user-facing events and conditions.

More than half a decade later, we most unhappily find that the motivation and intended use model for std::error_code and std::error_condition are still not well understood; even in circles eagerly embracing features and idioms encouraged by the latest C++ Standard revisions. This may be somewhat expected, as all things “error” tend to permeate system-wide design-decisions and influence the processing metaphor; how algorithms compose conditional success-or-failure branching; and create consistency challenges across APIs (both internally, and for interoperation with third-party libraries).

We discuss the features and design of <system_error> and its intended use; make recommendations regarding API design; and propose possible extension mechanisms for module-specific concerns, instance-specific messages (with embedded value-reporting), and internationalization.

Speakers
avatar for Charles Bay

Charles Bay

Senior Software Engineer, F5 Networks
Software developer with 25+ years experience in large-scale and distributed systems in performance-sensitive environments including real-time processing, performance visualization, embedded systems, time-sensitive processing of large data sets, hardware status-and-control, an... Read More →


Tuesday May 16, 2017 11:00am - 12:30pm
Bethe

11:00am

C++17 Features
The feature set for the C++17 release is set, and the release of the standard is just around the corner. In this session, we'll discuss all the new C++ features in C++17 and how they'll change the way we write C++ software. We'll explore the new standard in breadth, not width, covering a cornucopia of core language and library features and fixes, including:

* Major Language Changes: structured bindings, if constexpr, constexpr lambdas, inline variables, folding expressions, template <auto>, constructor template argument deduction, guaranteed copy elision, noexcept as part of the type system, if (init; cond) and switch (init; cond), nested namespace declarations, single-parameter static_assert, __has_include
* Major Library Changes: <filesystem>, <memory_resource>, string_view, optional<>, variant<>, any, parallel algorithms, aligned new, shared_mutex, math special functions, invoke/apply/is_callable<>, *_v* variable templates for type traits, conjunction<>/disjunction<>/negation<>.

Speakers
avatar for Bryce Lelbach

Bryce Lelbach

Lawrence Berkeley National Laboratory
Bryce Adelstein Lelbach is a researcher at Lawrence Berkeley National Laboratory (LBNL), a US Department of Energy research facility. Working alongside a team of hardware engineers, mathematicians and physicists, he develops and analyzes new parallel programming models for exasca... Read More →


Tuesday May 16, 2017 11:00am - 12:30pm
Flug Auditorium

11:00am

Rethinking Strings
At VMware `std::string` has served us well. We have built and shipped large
codebases around it. However, that experience has also taught us some of its
shortcomings. Now is a good time to take a step back and re-evaluate the string
design space. Why now? The context has changed dramatically since the dawn of
`basic_string`. The UTF family is the de facto encoding standard. 64bit
addressing will last much longer, in a much wider range of devices, than prior
addressing modes. We have `constexpr`, and soon will have ranges and
reflection. The library now includes `string_view`, all three major STL
implementations use the small string optimization, and Eric Neibler has given us
`folly::FixedString`. A `std::text_view` proposal is in flight. Even
`std::optional`, and smart pointers have some something to say about strings.

In this talk we will dissect strings along dimensions such as storage duration,
encoding, mutability, etc., and then see if we can knit it all back together
into a cohesive, modern, set of library and language features. I won't have all
the answers, so show up and speak up!

Speakers
avatar for Mark Zeren

Mark Zeren

Staff Engineer, VMware
Mark is a staff engineer at VMware where he works on C++ libraries, coding standards, and toolchains.



Tuesday May 16, 2017 11:00am - 12:30pm
Hudson Commons

12:30pm

Lunch Break
On your own.

The lunch truck will be available at 12:45.

Most attendees go into town.

Mention “Physics” and you’ll be seated together. Some will offer a free appetizer. They expect a group but you don’t have a reservation and if they can’t accommodate you, please see http://eataspen.com for more restaurant ideas and off-season specials. 

Tuesday May 16, 2017 12:30pm - 2:30pm
on your own

2:30pm

Expression Templates Everywhere with C++14 and Yap
Expression templates are very useful, but also come with a high implementation and maintenance cost, even when using a library like Boost.Proto. With the newer C++14 and later features, most notably generalized automatic return type deduction, it is now possible to make an expression template library with low compile times, high ease of use, and good object code generation.

Yap is an expression template library being proposed for Boost. It uses Hana, C++14, and C++17 (optionally) to make expression templates very easy to read, write, and use. This talk will be about using Yap, the process of creating Yap, and lessons learned using the new C++14 and C++17 features.

Speakers
avatar for Zach Laine

Zach Laine

Sr. Principal Engineer, Cadence
Zach Laine has been using C++ in industry for 15 years, focusing on data visualization, numeric computing, games, generic programming, and good library design. He finds the process of writing bio blurbs to be a little uncomfortable.


Tuesday May 16, 2017 2:30pm - 4:00pm
Flug Auditorium

2:30pm

Local (“Arena”) Memory Allocators
Are memory allocators worth the trouble? What situations merit their use? How are they applied effectively? What’s the performance impact? This practical talk by large-scale C++ expert John Lakos demonstrates that having local memory allocators in your tool box may lead to as much as order-of-magnitude speed improvements.

The runtime implications of the physical location of allocated memory are sometimes overlooked—even in the most performance-critical code. In this talk, we will examine how the performance of long-running systems can degrade when using just one global allocator (e.g., via new/delete). We will contrast the use of global allocators with various kinds of local allocators—allocators that allocate memory for a well-defined subset of objects in the system. We will also demonstrate how local allocators can reduce, if not entirely prevent, degradation seen in systems that rely solely on the global allocator. Six dimensions—fragmentability, allocation density, variation, utilization, locality, and contention—will be introduced to help characterize a given subsystem, assess the potential for accelerating its runtime performance, and—where appropriate—aid in determining the best local allocator to do so. Empirical evidence will be presented to demonstrate that introducing an appropriate local allocator can often result in substantial reductions in run times (compared with a similar system relying solely on just a single, global allocator).

Speakers
avatar for John Lakos

John Lakos

Software Infrastructure Manager, Bloomberg LP
John Lakos, author of Large-Scale C++ Software Design, serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide.  He is also an active voting member of the C++ Standards Committee’s Evolution Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications at Bear Stearns. For 12 years prior, Dr. Lakos developed large frameworks and advanced ICCAD applications at Mentor Graphics, for which he holds multiple software patents. His academic credentials include a Ph.D. in Computer Science ('97) and an Sc.D. in Electrical Engineering ('89) from Columbia University. Dr. Lakos received his undergraduate degrees from MIT in Mathematics ('82) and Computer Science ('81). His next book, entitled Large-Scale... Read More →


Tuesday May 16, 2017 2:30pm - 4:00pm
Bethe

2:30pm

Networking TS Workshop (part 1 of 2)
Networking is finally hitting the C++ standard. Are you ready for it?

In this workshop we will first explore what the Networking TS has to offer and how it compares to Boost.Asio. We will explore some of the patterns used when implementing both servers and clients. The second half of the session will be a hands-on workshop. A series of exercises will build on each other until we have implemented both clients and servers.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for over 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Pr... Read More →


Tuesday May 16, 2017 2:30pm - 4:00pm
Hudson Commons

4:00pm

Break
Join us on the patio at the ACP for light snacks, drinks, and gossip.

Tuesday May 16, 2017 4:00pm - 4:30pm
Aspen Center for Physics Patio

4:30pm

Containers & Strings: Why the Implementation Matters

We will provide a brief overview of an existing legacy container library and discuss some of the design and implementation decisions and how they affect maintainability and usage. Part of this discussion will involve talking about the pros and cons of using copy on write versus move semantics.

The pros and con of the various container APIs will be discussed and we will talk about why these are important to developers.

A brief overview including an explanation of unicode and how it allows the processing of non US languages will be presented. We will cover the pros and cons of various String formats including UTF-8, UTF-16, UCS-4, etc.

Following this discussion we will introduce our new BSD licensed CsString library.

Explain and show the new improvements in DoxyPress for parsing C++ which can now use libTooling.

No prior knowledge of CopperSpice or DoxyPress is required.

Speakers
avatar for Barbara Geller

Barbara Geller

Co-Founder, CopperSpice
I am an independent consultant with over twenty-five years of experience as a programmer and software developer. I have worked with numerous smaller companies developing in-house applications. I have also designed and developed Windows applications for several vertical markets in... Read More →
avatar for Ansel Sermersheim

Ansel Sermersheim

Co-Founder, CopperSpice
I have been working as a programmer for over fifteen years. My degree is in Computer Science from Cal Poly San Luis Obispo. | | Currently I work as a software engineer designing scalable, high performance, multi-threaded network daemons in C++. The daemons I have developed ar... Read More →


Tuesday May 16, 2017 4:30pm - 6:00pm
Bethe

4:30pm

Networking TS Workshop (part 2 of 2)
Networking is finally hitting the C++ standard. Are you ready for it?

This is the second half of the Networking TS session - the Workshop section. Materials (possibly some that are very physical) will be provided for this hands-on coding frenzy.

A series of exercises (challenges?) will build on each other until we have implemented both clients and servers to do our bidding.

Who knows ... perhaps there will even be a meta-game.


Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for over 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Pr... Read More →


Tuesday May 16, 2017 4:30pm - 6:00pm
Hudson Commons

4:30pm

constexpr ALL the things!
constexpr: in C++11, a curiosity; in C++14, viable for more uses; now with added power, in C++17 will it become an important tool in the programmer’s toolkit?

In this talk we will examine the possibilities and power of constexpr and explore what can (and what should) be done at compile-time with C++17. We’ll present techniques for building constexpr data structures and algorithms, and for effectively meshing compile-time and runtime computation with constexpr API constructs. We’ll also consider the opportunities for judicious use of user defined literals for expressive compile-time abstractions.

Compile-time computation offers perhaps the ultimate zero-cost abstraction, and this talk attempts to answer the question of how C++17 delivers on the promise.

Speakers
avatar for Ben Deane

Ben Deane

Principal Software Engineer, Blizzard Entertainment
Ben has been writing games for almost 20 years, and in C++ for most of that. He is currently a Principal Engineer at Blizzard Entertainment where he works on the Battle.net team. He's always looking for useful new techniques in C++, and he likes functional programming.
avatar for Jason Turner

Jason Turner

Developer, Trainer, Speaker
Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http... Read More →


Tuesday May 16, 2017 4:30pm - 6:00pm
Flug Auditorium

6:15pm

Social Event: Picnic
Bring your family and friends and your appetite!

The Aspen Center for Physics and the Aspen Meadows Resort are providing a us with cake and ice cream as a tenth anniversary gift to the conference.

Tuesday May 16, 2017 6:15pm - 8:30pm
Picnic Area
 
Wednesday, May 17
 

8:00am

Library in a Week
Library in a week 2017

Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has... Read More →


Wednesday May 17, 2017 8:00am - 9:00am
Paepke Auditorium

9:00am

Haskell taketh away: limiting side effects for parallel programming

In designing parallel programming abstractions, taking away user capabilities is as important as granting them.  In this talk, I'll explain the role of this idea in several different parallel programming libraries for Haskell, C++, and other languages--spanning from shared memory to big data.

The Haskell language is an experiment in making purely functional programming practical, and, as such, much of its design stems from limiting where and how the user can employ side effects.  Haskell is almost 30 years old, but is used more widely and changing more rapidly than ever before.  It's an exciting time for programming languages that use advanced type systems to accomplish formal software verification, and Haskell sits in midst of this revolution: at a juncture where it draws from the latest ideas in theorem proving languages, while at the same time remaining a practical programming language.

By clearing the canvas of unconstrained effects, Haskell and similar languages allow experimenting with specific combinations of effects that work well together: e.g., for transactional memory, deterministic parallelism, or accessing remote data sources.  Haskell enforces these restrictions at compile time, via the type system.  While C++ cannot limit a method's side effects directly through types, it is well suited to host embedded domain specific languages (EDSLs) that can incorporate the same ideas.

I will argue for a notion of purity that has little to do with whether memory is updated in place or not.  Rather, it has to with whether combinations of effects preserve determinism.

I'll show how entire applications can become deterministic functions of their inputs, including I/O.  Ultimately we can call entire C++ programs from inside a pure function in Haskell, without violating any rule of the type system or the language's runtime semantics. 

Finally, over the course of this talk I'll also describe some specific history where C++ has affected the evolution of Haskell, and where, conversely Haskell may have a few ideas to offer.  Haskell and C++ are both old languages that nevertheless keep changing regularly. There are even some surprising contemporary commonalities; for example, C++ and Haskell are two of the best languages available for data baking.


Speakers
avatar for Ryan Newton

Ryan Newton

Associate Professor, Indiana University
Ryan is a functional programmer of 25 years, and is a member of the Glasgow Haskell Compiler steering committee. Ryan Newton received his Ph.D. in computer science from MIT in 2009, advised by Arvind and Samuel Madden. His thesis introduced techniques for efficiently distributin... Read More →


Wednesday May 17, 2017 9:00am - 10:30am
Paepke Auditorium

10:30am

Break
Join us on the patio at the ACP for light snacks, drinks, and gossip.

Wednesday May 17, 2017 10:30am - 11:00am
Aspen Center for Physics Patio

11:00am

A vision for C++20, and std2 (part 1 of 3)
C++17 is about to ship, and one of the subtle additions is the reservation of a family of namespaces for a future standard library. As our attention turns to C++20 and beyond, Alisdair Meredith will explore how language evolution could (and should) affect the design of this future library, and just what kind of a new library do we want anyway?

This presentation breaks down into three parts. The first session lays down a vision of delivering all the language features likely to impact a library design in C++20. The obvious candidates are modules, concepts, and contracts, but what else? We will look at a variety of language features, assessing what they offer, or how they impact, a library designer. The second session looks into constraints and opportunities when designing a new C++ standard library. How compatible must we be with the old library? How ambitious should the new design be? What should our basic vocabulary types be? And how do we cope with language dependencies on 'std' types like 'type_info'?

The final session is a planned workshop, to gain feedback from the attendees of C++Now - an invaluable resource of world class library designers. Have I highlighted the correct questions? What should the priorities be? What is an appropriate schedule for developing and standardizing such a new library? How can those of us without access to committee meetings still help with the process? The results of this workshop will be written up in an informational paper for the next ISO mailing.

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

Bloomberg LP
Alisdair Meredith is a software developer at BloombergLP in New York, and 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... Read More →


Wednesday May 17, 2017 11:00am - 12:30pm
Hudson Commons

11:00am

Mocking C++ (full-length version)
When unit testing, many times you'll be re-testing already tested components, unnecessarily slowing down your code or pulling in dependencies and unreliabilities you'd like to avoid. There's a way to avoid that - use a mock component that pretends to do what you ask it to, but that instead just gives you the answers your test needs. It's a much easier way to get your tests for corner cases and bad return values written, and it makes them more reliable to boot.

The downside is that to implement it properly, you would need to have reflection. Java and C#, both with great mocking libraries use reflection to create their mock objects, and many times it's been posed that C++ just cannot do it without many macros, manual labor, unreliable scripts or duplicated code, because it lacks the ability. We show otherwise - unlike some C++ mocking libraries would have you believe, you can actually make mock objects without repeating - or implementing for the first time! - the classes you're testing with.

Speakers
avatar for Peter Bindels

Peter Bindels

Expert Software Engineer, TomTom NV
Original/first author of HippoMocks (github.com/dascandy/hippomocks), first author of cpp-dependencies (github.com/tomtom-international/cpp-dependencies), long-standing moderator at forum.osdev.org. Convinced of the ability of people to make things more complicated than they actu... Read More →


Wednesday May 17, 2017 11:00am - 12:30pm
Bethe

11:00am

(Ab)using C++17
C++17 is bringing with it many new small language features, and while it might not have the big features that some were hoping for, these new features can be combined and (ab)used in interesting ways. In this session we will discuss some of these new features, how they can be used and some ways they should probably not be used. We will cover fold expressions, template deduction guides, constexpr if, and returning multiple values from a function.

Speakers
avatar for Jason Turner

Jason Turner

Developer, Trainer, Speaker
Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http... Read More →


Wednesday May 17, 2017 11:00am - 12:30pm
Flug Auditorium

12:30pm

Boost Operations: C++Now Program Committee
This is an information/work session for the C++Now Program Committee.

We will discuss the review the Reviewers' Guide ways to impove our process and product:
https://docs.google.com/document/d/1Z1PXETemPj0FP_i_zqt1YFHK4KiFYAiGTvbpVa2kKE0/edit?usp=sharing

Note: Boost will cater this meeting for attendees that sign up by the end of Wednesday morning's break. 

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, Boost Libraries
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!

Wednesday May 17, 2017 12:30pm - 2:30pm
Bethe

12:30pm

Lunch Break
On your own.

The lunch truck will be available at 12:45.

The Boost Operations session is catered if you sign up by the end of morning break.

Most attendees go into town.

Mention “Physics” and you’ll be seated together. Some will offer a free appetizer. They expect a group but you don’t have a reservation and if they can’t accommodate you, please see http://eataspen.com for more restaurant ideas and off-season specials. 

Wednesday May 17, 2017 12:30pm - 2:30pm
on your own

2:30pm

Fun with Boost.Hana
Have you heard of metaprogramming? Have you heard it was an ugly beast that was difficult to tame and do anything useful with? Yeah, so have I.

In this session, we'll see how we can use Hana, a modern metaprogramming library, to solve problems with a high concentration of metaprogramming in a very elegant way. We'll do this by looking at real-world use cases like an event-triggering system and a type erasure library. For each use case, we'll dive deep into the implementation to really understand how it works under the hood. The result will be a deeper understanding of modern metaprogramming techniques, and a better understanding of how to leverage metaprogramming to define expressive interfaces, automate repetitive tasks and increase code maintainability.

This session is meant for people with some familiarity with the Boost.Hana library that would like to see it used in serious use cases and deepen their understanding of the library's interaction with the C++ type system.

Speakers
avatar for Louis Dionne

Louis Dionne

A9.com
Louis is a math and computer science enthusiast with interest in C++ (meta)programming, functional programming, domain specific languages and related subjects. He is an active member of the Boost community, and authored the Boost.Hana metaprogramming library.


Wednesday May 17, 2017 2:30pm - 4:00pm
Hudson Commons

2:30pm

The Mathematical Underpinnings of Promises in C++
What is the mathematical essence of a promise and how does it inform the
development of a promise library in C++? This talk explores the algebraic
foundation of promises and applies those concepts to the development of a
promise library. This talk serves as a case study of using functional design
to develop a practical library. The discussion will lead to general questions
such as "How do you discover the fundamental operations for a type?" and "Which
aspects of a mathematical design need modification to fit into a practical
language?".

We will be touching on purity, denotational semantics, monads, laziness, and
pragmatism. All abstract concepts will be adequately introduced and no
background in mathematics is required. Attendees should walk away with an
understanding of how functional design is put into practice and may even want
to give it a whirl in their next project.

Speakers
avatar for David Sankel

David Sankel

Bloomberg
David Sankel is a professional software developer/architect based in the USA and an active member of the C++ Standardization Committee. 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... Read More →


Wednesday May 17, 2017 2:30pm - 4:00pm
Bethe

2:30pm

Good FIFOs Make Good Thread Neighbors
Almost every program needs parallelism to scale performance. To have useful parallelism, threads must communicate in some way. There are a few predominant ways to do this, the most ubiquitous is the first-in first-out (FIFO) queue. Have you ever thought about the micro-architectural implications of the code in your FIFO? Do certain constructs behave better or worse? We’ll look at several open source FIFO implementations, and how they behave on a set of hardware. We’ll go step by step through the code, then assembly code, and look at what happens under the hood of your processor core. Never again will you wonder about how that FIFO impacts your performance, you’ll know exactly! Come see my talk to take a tour of the most common FIFOs as they wind the load-store pathways of some common architectures.

Speakers
avatar for Jonathan Beard

Jonathan Beard

Staff Research Engineer, ARM Inc.
Jonathan Beard received a BS (Biology) and BA (International Studies) in 2005 from the Louisiana State University, MS (Bioinformatics) in 2010 from The Johns Hopkins University, and a PhD in Computer Science from Washington University in St. Louis in 2015. Jonathan served as a U... Read More →


Wednesday May 17, 2017 2:30pm - 4:00pm
Flug Auditorium

4:00pm

Break
Join us on the patio at the ACP for light snacks, drinks, and gossip.

Wednesday May 17, 2017 4:00pm - 4:30pm
Aspen Center for Physics Patio

4:30pm

Composite Arithmetic Types Are > the + of Their Parts
Advances in fields such as heterogeneous computing and information security are testing C++'s arithmetic types to their limits. Fortunately, modern language features make it easier to upgrade the humble integer and prepare it for the challenges ahead.

This talk will explore what needs to be done to improve numeric types and how to go about it. I will demonstrate how I apply the compositional approach to the problem of building custom numeric types and how it produces a variety of low-cost abstractions to suit every need.

Using my fixed-point library as the jumping-off point, I will illustrate how modern language features such as type deduction, compile-time evaluation and user-defined literals can make arithmetic types that are faster, safer and easy to use.

Speakers
avatar for John McFarlane

John McFarlane

Programmer, A9.com
John McFarlane has used C++ for twenty years, specializing in simulation, AI and interactivity. He is a contributor to Study Groups 6 and 14 and is involved in standardizing fixed-point arithmetic.


Wednesday May 17, 2017 4:30pm - 5:15pm
Hudson Commons

4:30pm

Postmodern Immutable Data Structures
The C++ elites have been talking for years about value semantics, immutability and sharing by communicating. A better world without mutexes, races, observers, command patterns and so more lies ahead! When it gets to doing it practice, it is not so easy. One of the main problem lies in our data structures...

Immutable data structures don't change their values. They are manipulated by producing new values. The old values remain there, and can be read safely from multiple threads without locks. They provide structural sharing, because new and old values can share common data--they are fast to compare and can keep a compact undo-history. As such, they are great for concurrent and interactive systems: they simplify the architecture of desktop software and allow servers to scale better. They are the secret sauce behind the success of Clojure or Scala and even the JavaScript crowd is loving it via Facebook's Immutable.js.

We are presenting Immer, a C++ library implementing modern and efficient data immutable data structures.

In this session, we will talk about the architectural benefits of immutability and show how a very efficient yet powerful persistent vector type can be built using state of the art structures (Relaxed Radix Balanced Trees). We will also show an example application (a text-editor) built using the archectural style here proposed... not only is its code extremely simple, it outperforms most similar programs. Don't believe it? Come and see!

Links





Speakers
avatar for Juan Pedro Bolivar Puente

Juan Pedro Bolivar Puente

Freelance Consultant, Sinusoidal Engineering
I am Berlin based freelance software engineer, with a focus on interactive software, modern C++, functional programming and open source strategy. Before I worked for Ableton and I have been involved in various music technology projects. I have also developed for the GNU project a... Read More →


Wednesday May 17, 2017 4:30pm - 5:15pm
Flug Auditorium

4:30pm

Multithreading Using Lockless Lists and RCU
I will provide a brief review of multithreading terminology and an overview of the libGuarded library introduced at CppNow last year. I will provide a short explanation on why mutithreading is important and also complicated.

The main focus of this talk will be about the importance of lockless containers and RCU technology. The value of this approach will be explained and we will explore why it was added to the new version of libGuarded.

I will show how libGuarded 2.0 was used in the CsSignal library to prevent deadlocks.

Basic familiarity with multithreading is suggested.

Speakers
avatar for Ansel Sermersheim

Ansel Sermersheim

Co-Founder, CopperSpice
I have been working as a programmer for over fifteen years. My degree is in Computer Science from Cal Poly San Luis Obispo. | | Currently I work as a software engineer designing scalable, high performance, multi-threaded network daemons in C++. The daemons I have developed ar... Read More →


Wednesday May 17, 2017 4:30pm - 6:00pm
Bethe

5:20pm

An easy to use RPC framework implemented in C++11/14
I want to introduce rest_rpc, a new approach to RPC libraries that shows off the power of modern C++.

The compelling value proposition of the rest_rpc framework is its focus on simplifying the calling code. Callers stay focused on business logic and spend no time on networking issues or data packing and unpacking.

We'll start with very short examples of simple, but complete client/server applications that communicate using rest_rpc on both client and server. We'll build on these to show more complicated examples that introduce more advanced, but still easy to use features.

I'll also discuss how I implemented some of the challenges I faced creating a library that is caller friendly, but type-safe at compile time and efficient at runtime. Among these challenges are:
*) How to register callback of any signature (using variadic templates and type erasure)
*) How to verify that RPC parameters are type correct at compile-time instead of just run-time.
*) How to support all types of callers (I use SFINAE, type_traits, variadic templates, and generic lambdas to create a bind that is stronger than Boost.Bind for smart pointers, raw pointers, and function objects)
*) How to hide the details of serialization and networking (utilizing meta data to avoid defining a protocol file)
*) How to route requests to the correct handler (using a metaprogramming trick to transform string arguments to real arguments)

The repository is here: https://github.com/topcpporg/rest_rpc

Speakers
avatar for Yu Qi

Yu Qi

Senior Software Engineer, FiberHome
Yu is a C++ programmer with 10 years experience who lives in Zhuhai, Guangdong province, China. He loves modern C++ and has founded an open source community ( http://www.purecpp.org/ ) to promote C++11/14 in China. His focus is distributed systems and he is the author of rest_rp... Read More →


Wednesday May 17, 2017 5:20pm - 6:05pm
Hudson Commons

5:20pm

Type Based Template Metaprogramming is Not Dead
Boost.Hana with its claim to the title "your standard library for metaprogramming" has opened this domain to many. For library implementers and experts however there is one thing Hana's new value based metaprogramming is lacking, compilation speed. In this talk I will present several new patterns which allow type based metaprograms to reach mammoth size at acceptable compilation speed. The separation of algorithm and data as well as the composition of operations allow us to save most of the intermediate types so that the compiler has far less work when calculating the same result.

Speakers
avatar for Odin Holmes

Odin Holmes

CEO/CTO, Auto-Intern GmbH
Odin Holmes has been programming bare metal embedded systems for 15+ years and as any honest nerd admits most of that time was spent debugging his stupid mistakes. With the advent of the 100x speed up of template metaprogramming provided by C++11 his current mission began: teach... Read More →


Wednesday May 17, 2017 5:20pm - 6:05pm
Flug Auditorium

6:00pm

Dinner Break
Suggested Venue: Limelight Lounge or White House Tavern

Mention “Physics” and you’ll be seated together. Some will offer a free appetizer. They expect a group but you don’t have a reservation and if they can’t accommodate you, please see http://eataspen.com for more restaurant ideas and off-season specials. 

Wednesday May 17, 2017 6:00pm - 8:30pm
on your own

8:30pm

Lightning Talks
Lightning talks are 5 minute talks on something of interest to C++ programmers. Presentation is open to any C++Now attendee, including Student/Volunteers.

Have a favorite technique or library to share? Employed some C++11/14 feature in a project with amazing/horrible results? Want to start a conversation on Boost 3.0? Submit your proposal for a 5 or 10-minute talk to Michael at lightning@cppnow.org. Be sure to include a title, 3-sentence abstract, and something about yourself.

Come to be amused, enlightened, outraged, or inspired!

Moderators
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for over 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Pr... Read More →

Wednesday May 17, 2017 8:30pm - 10:00pm
Flug Auditorium
 
Thursday, May 18
 

7:00am

'Meet the Volunteers' Breakfast
Limited Capacity seats available

Note: By Invitation Only

This opportunity to meet this year's Student/Volunteers is open to individuals that are Gold Level Boost Scholarship Sponsors (and some other VIPs). Students will introduce themselves and briefly discuss their studies and interest in C++.

If you would like to join us as an indvidual sponsor, please contact us at sponsorship@cppnow.org
 

Thursday May 18, 2017 7:00am - 8:30am
Aspen Meadows Resort 845 Meadows Rd, Aspen, CO 81611

8:00am

Library in a Week
Library in a week 2017

Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has... Read More →


Thursday May 18, 2017 8:00am - 9:00am
Flug Auditorium

9:00am

A look at C++ through the glasses of a language tool
With its history going back to the early days of programming, rich heritage, tons of legacy code mixed with modern language features and patterns, quickly evolving language standards, and a variety of tools in the environment, C++ can be tricky and easily enable hacks and inaccurate solutions if you don’t cook it right. Developing language tools (and IDEs in particular) is a good litmus test for such problems. When a tool gets confused by some code or fails to provide the full intelligence it’s supposed to possess, doesn’t that mean that developers should also pay more attention and be more careful in the same situations? This talk is dedicated to bringing such situations to light and sharing lessons learned.

We’ll cover core language trickiness and peculiarities, including preprocessor and context-dependent parsing, and how the modern language standards can be helpful. We’ll also look at some good practices that can help prevent shooting yourself in the leg with C++, and will reflect on C++ Code Guidelines.

We’ll analyze the tooling heritage as well, looking at the variety of build systems, compilers, debuggers, unit testing frameworks and package managers. Understanding the drawbacks of how they are integrated into language tools will give us insight into their limitations as well as into more accurate and error-free development in C++.

Speakers
avatar for Anastasia Kazakova

Anastasia Kazakova

Product Marketing Manager, JetBrains
C/C++ developer, *nix freak, JetBrains team member. | Being C/C++ fan I've been creating real-time *nix-based systems and pushing them to the production for 8 years. I have passion for networking algorithms and embedded programming and believe in good tooling.


Thursday May 18, 2017 9:00am - 9:45am
Hudson Commons

9:00am

Call: A Library that Will Change the Way You Think about Function Invocations (part 1 of 2)
Do you use tuples and variants? Do you practice the generic programming paradigm? Do you wish it were easier to deal with multimethods over a closed set of types? Are you interested in or involved with the C++ standard? Do you simply like having your mind blown? If you answered "yes" to any of these questions, then you should attend this presentation!

In this session, I introduce a library that allows users to invoke existing functions and function objects using an argument list whose types and arity may be dynamic both at compile-time and at run-time. Through a single algorithm and a couple of very simple concepts, this library offers a clean and unified generalization of C++17 facilities such as std::invoke, std::apply, std::visit, and more, and does so with an easy-to-write and easy-to-read syntax that the average C++ developer can understand. As with any generic library, the concepts that are presented may be modeled by users, leaving the door open for even more facilities than what is directly offered. Usefulness extends into the realm of higher-level libraries built off of the concepts that are described, and an example of such a library will be explored.

Though the title may be bold, I guarantee that many of you will have a different view of function calls after attending this talk. Consider it a challenge.

Speakers
avatar for Matt Calabrese

Matt Calabrese

Software Engineer, Google
Matt Calabrese is a software engineer working primarily in C++. He started his programming career in the game industry and is now working on libraries at Google. Matt has been involved with the Boost community for over a decade and is currently a member of the Boost Steering Comm... Read More →


Thursday May 18, 2017 9:00am - 10:30am
Flug Auditorium

9:00am

Sorting in less than O(n log n): Generalizing and optimizing radix sort
It is well known that sorting algorithms can be no faster than O(n log n). Except that for sorting integers, there is a sorting algorithm that can sort in O(n): Radix sort.

In this presentation I will explain how to generalize radix sort so that it can sort almost everything that std::sort can sort. I will also present an optimization to the inner loop of radix sort which makes this more than two times faster than std::sort for many inputs.

The interface for radix sort has to be slightly different than for comparison based sorting, so I will also go over how to make your old use case run with the new algorithm.

Speakers
avatar for Malte Skarupke

Malte Skarupke

Hi, I'm an AI programmer at Avalanche Studios in New York. We make video games written in C++. In my spare time I write libraries and blog on www.probablydance.com


Thursday May 18, 2017 9:00am - 10:30am
Bethe

9:50am

Boost vs Qt: What Could They Learn From Each Other?
Having a long history of using boost and Qt, plus visiting both communities for a long time, this talk reflects, on what the boost and Qt communities could learn from each other. As C++Now is more boost then Qt, the focus is more on what boost could learn though.

Speakers
avatar for Jens Weller

Jens Weller

C++ Evangelist, Meeting C++
Jens Weller is the organizer and founder of Meeting C++. Doing C++ since 1998, he is an active member of the C++ Community. From being a moderator at c-plusplus.de and organizer of his own C++ User Group since 2011 in Düsseldorf, his roots are in the C++ Community. Today his mai... Read More →


Thursday May 18, 2017 9:50am - 10:35am
Hudson Commons

10:30am

Break
Join us on the patio at the ACP for light snacks, drinks, and gossip.

Thursday May 18, 2017 10:30am - 11:00am
Aspen Center for Physics Patio

11:00am

A vision for C++20, and std2 (part 2 of 3)
C++17 is about to ship, and one of the subtle additions is the reservation of a family of namespaces for a future standard library. As our attention turns to C++20 and beyond, Alisdair Meredith will explore how language evolution could (and should) affect the design of this future library, and just what kind of a new library do we want anyway?

This presentation breaks down into three parts. The first session lays down a vision of delivering all the language features likely to impact a library design in C++20. The obvious candidates are modules, concepts, and contracts, but what else? We will look at a variety of language features, assessing what they offer, or how they impact, a library designer. The second session looks into constraints and opportunities when designing a new C++ standard library. How compatible must we be with the old library? How ambitious should the new design be? What should our basic vocabulary types be? And how do we cope with language dependencies on 'std' types like 'type_info'?

The final session is a planned workshop, to gain feedback from the attendees of C++Now - an invaluable resource of world class library designers. Have I highlighted the correct questions? What should the priorities be? What is an appropriate schedule for developing and standardizing such a new library? How can those of us without access to committee meetings still help with the process? The results of this workshop will be written up in an informational paper for the next ISO mailing.

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

Bloomberg LP
Alisdair Meredith is a software developer at BloombergLP in New York, and 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... Read More →


Thursday May 18, 2017 11:00am - 12:30pm
Hudson Commons

11:00am

Call: A Library that Will Change the Way You Think about Function Invocations (part 2 of 2)
Do you use tuples and variants? Do you practice the generic programming paradigm? Do you wish it were easier to deal with multimethods over a closed set of types? Are you interested in or involved with the C++ standard? Do you simply like having your mind blown? If you answered "yes" to any of these questions, then you should attend this presentation!

In this session, I introduce a library that allows users to invoke existing functions and function objects using an argument list whose types and arity may be dynamic both at compile-time and at run-time. Through a single algorithm and a couple of very simple concepts, this library offers a clean and unified generalization of C++17 facilities such as std::invoke, std::apply, std::visit, and more, and does so with an easy-to-write and easy-to-read syntax that the average C++ developer can understand. As with any generic library, the concepts that are presented may be modeled by users, leaving the door open for even more facilities than what is directly offered. Usefulness extends into the realm of higher-level libraries built off of the concepts that are described, and an example of such a library will be explored.

Though the title may be bold, I guarantee that many of you will have a different view of function calls after attending this talk. Consider it a challenge.

Speakers
avatar for Matt Calabrese

Matt Calabrese

Software Engineer, Google
Matt Calabrese is a software engineer working primarily in C++. He started his programming career in the game industry and is now working on libraries at Google. Matt has been involved with the Boost community for over a decade and is currently a member of the Boost Steering Comm... Read More →


Thursday May 18, 2017 11:00am - 12:30pm
Flug Auditorium

11:00am

Parallel Programming with RaftLib: streaming/data-flow concurrency via concise C++ iostream-like operators
Almost every commodity compute device from cell phone to server has a heterogeneous multicore processor inside it. To use these complex cores, we must write code that can execute in parallel. Effective use of multicore hardware with today’s tools requires that a programmer know a lot about the hardware. This was feasible with a single core, and two cores, but how about a hundred? What happens with cores that are of different types? How about multiple memory types? How about effectively programming these systems with differing link types for each of these processor-memory combinations? This hardware complexity is not well accommodated by current software models. RaftLib aims to abstract away this complexity to make authoring performant parallel applications in C++ as simple as possible, while giving the experienced programmer the control they desire without the boiler-plate code that often comes with lower-level APIs. It utilizes the familiar semantics of stream operators to link multiple parallel actors into a parallel, streaming application. RaftLib is built as a C++ template library, enabling programmers to utilize the robust C++ standard library along with RaftLib’s parallelization framework. RaftLib enables a programmer to write C++ code that will execute in multiple processes, multiple threads, user space threads, on distributed nodes, and with optional extensions, on accelerators without learning dozens of complex interfaces. This session covers the pitfalls of programming parallel hardware, offers RaftLib as a solution, and we'll walk programmers through how to use it effectively.

Speakers
avatar for Jonathan Beard

Jonathan Beard

Staff Research Engineer, ARM Inc.
Jonathan Beard received a BS (Biology) and BA (International Studies) in 2005 from the Louisiana State University, MS (Bioinformatics) in 2010 from The Johns Hopkins University, and a PhD in Computer Science from Washington University in St. Louis in 2015. Jonathan served as a U... Read More →


Thursday May 18, 2017 11:00am - 12:30pm
Bethe

12:30pm

Lunch Break
On your own.

The lunch truck will be available at 12:45.

The Boost Operations session is catered if you sign up by the end of morning break.

Most attendees go into town.

Mention “Physics” and you’ll be seated together. Some will offer a free appetizer. They expect a group but you don’t have a reservation and if they can’t accommodate you, please see http://eataspen.com for more restaurant ideas and off-season specials. 

Thursday May 18, 2017 12:30pm - 2:30pm
on your own

2:30pm

Postmodern C++
The term "Modern C++" can be traced back to Andrei Alexandrescu's "Modern C++ Design", published in February 2001. Much has changed since then. Alexandrescu is off *D*abbling in various things, Scott Meyers has retired; C++11 changed the landscape, and now we are at C++14 with C++17 just months away.

Surely we are now in the Postmodern C++ era!

So let's apply "postmodernism" to C++, and see what we get. Hopefully we get something interesting, enlightening, and entertaining.
For a sneak peak, follow me @tvaneerd and/or search for #PostModernCpp on twitter.

TL;DR: "How to code better, by Tony"

Speakers
avatar for Tony Van Eerd

Tony Van Eerd

Christie Digital
Tony Van Eerd has been coding for well over 25 years, and hopefully coding well for some of that. Mostly in graphics/video/film/broadcast (at Inscriber & Adobe), writing low level pixel++, high level UI, threading, and everything else. He now enables painting with light at Christ... Read More →


Thursday May 18, 2017 2:30pm - 4:00pm
Flug Auditorium

2:30pm

Practical (?) Applications of Reflection
What are the benefits of compiler support for static type introspection? What are the costs? This talk introduces the library-level solutions for reflection in C++ and gives a brief comparison to ther languages, then dives into an analysis of the recent reflection proposals to the C++ standard: P0194 (colloquially known as the "reflexpr" proposal) versus P0590R0 (the "operator $ proposal) and their reference implementations in Clang. Through several code examples, we will compare the power, expressiveness, and limitations of these proposals. If time permits, we'll explore how reflection fits into the future direction of C++ metaprogramming and how it could interact with other milestone features for C++20.

Speakers
avatar for Jackie Kay

Jackie Kay

Software Engineer, Marble Robotics
I write FOSS tools for the robotics community. Clang enthuasiast. Metaprogramming novice. Don't ask me about functors.


Thursday May 18, 2017 2:30pm - 4:00pm
Hudson Commons

2:30pm

Implementing `variant` visitation using lambdas
The addition of `std::variant` to the upcoming C++17 standard will introduce a "type-safe sum type" to the Standard Library.
Variants model a "choice between types" - they essentially are type-safe "tagged unions".

The interface they expose, however, is often more cumbersome to use than it needs to be: defining exhaustive visitors requires the user to create a class with several `operator()` overloads, or to create a chain of `if constexpr(...)` calls. Both solutions are not very elegant.

After a brief overview of `std::variant` and its usefulness, this talk will focus on the implementation of a "lambda-based in-place visitation" approach, where the user can visit a variant by simply providing a set of lambdas on the spot. This will require implementing a way of overloading arbitrary function objects.

Recursive variant types will then be covered and the "lambda-based" visitation techniques will be applied to them. This will require implementing the "Y combinator" higher-order function to achieve zero-runtime-overhead lambda recursion.

This talk is intended for developers familiar with C++11 and C++14 core language features (lambdas, variadic templates, `auto`, etc...). Prior knowledge of `std::variant` or sum types is not required.

Speakers
avatar for Vittorio Romeo

Vittorio Romeo

Software Engineer, Bloomberg LP
Vittorio Romeo is an Italian 22 year old Software Engineer at Bloomberg LP. He completed his Bachelor's degree in Computer Science at "Università degli Studi di Messina". | | He began programming at a very young age and is now a C++ enthusiast. While following the evolution... Read More →


Thursday May 18, 2017 2:30pm - 4:00pm
Bethe

4:00pm

Break
Join us on the patio at the ACP for light snacks, drinks, and gossip.

Thursday May 18, 2017 4:00pm - 4:30pm
Aspen Center for Physics Patio

4:30pm

Promises in C++: The Universal Glue for Asynchronous Programs
Promises, sometimes known as futures, can dramatically change the way we write
asynchronous applications for the better. All too often, however, the level of
abstraction provided in promise libraries is either overly complex or
utterly crippled. This unfortunate situation leads many to turn to inferior
approaches for developing asynchronous code.

In this talk, we will present a new promise library, dplp, which overcomes the
limitations of previous promise implementations and finally puts the power of
promises into the common developer's toolbox. We will show how this clever
little class with just one member function can become the universal vocabulary
type for connecting disparate networking libraries, wrapping complex
callback-based APIs, and orchestrating asynchronous operations.

This presentation will be a highly practical talk; we will build up intuition
on how to use promises by presenting increasingly complicated examples based on
real-world use cases at Bloomberg. At the end, an attendee will be equipped
with the knowledge of both when promises apply to a problem and how to apply
them. See the companion talk, "The Mathematical Underpinnings of Promises in
C++", for an in-depth discussion on the design of this library.

Speakers
avatar for David Sankel

David Sankel

Bloomberg
David Sankel is a professional software developer/architect based in the USA and an active member of the C++ Standardization Committee. 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... Read More →


Thursday May 18, 2017 4:30pm - 6:00pm
Flug Auditorium

4:30pm

Testing the Limits of Allocator Awareness
One of the lesser-known improvements in modern C++ is support for so-called "allocator-aware" containers in the standard library. With this support, it is now possible to create and use allocators that are stateful, as well as allocators that employ synthetic pointers to perform addressing operations. While most C++ programmers will never need such arcane constructs, there is a small class of problems where they can have a significant positive impact on performance and quality of implementation.

This talk will address two broad questions. First, how well do the standard libraries in recent versions of the most common C++ compilers (Clang/GCC/MSVC) conform to the requirements for allocator-aware containers? Second, what are the expected and measured performance implications of using stateful allocation strategies and synthetic pointers with the library implementations provided by these compilers?

To answer these questions, this talk will first review the old C++03 allocator requirements and the limitations they imposed on the design of custom allocators. We'll then examine the new allocator requirements in C++14 and their implications for library users, library implementors, and custom allocator implementors. Next, we'll discuss the design and goals of a suite of custom allocator components constructed to test the conformance and performance of library implementations. Following that, we'll dig into the important design and implementation details of those allocator components and how they are used as policy types for a high-level allocator class template. The talk will then describe the methodology for conformance and performance testing and summarize test cases for each. Finally, the test results will be presented and discussed.

Speakers
avatar for Bob Steagall

Bob Steagall

KEWB Computing
I've been working in C++ for the last 24 years. The majority of my career has been spent in medical imaging, where I led teams building applications for functional MRI and CT-based cardiac visualization. After a brief journey through the world of DNS, I'm now trying my hand at an... Read More →


Thursday May 18, 2017 4:30pm - 6:00pm
Bethe

4:30pm

Towards Painless Testing
In this tutorial we will be following the teachings of the Beyonce rule - "If you liked it then you should have put a test on it".
We will go above and beyond to make testing as painless as possible with modern C++. If you don't like writing Google Mocks
by hand then this tutorial is for you! As it will be shown how to eliminate this daunting task from your daily routine.
Additionally, it will be presented how to write a C++14 automatic mocks injector to make your testing life easier!
Its final focus will be on increasing your productivity with TDD (Test Driven Development) and BDD (Behavior Driven Development)
and to round it up, a vision of how testing may look like in C++20 and beyond will be discussed.

Speakers
avatar for Kris Jusiak

Kris Jusiak

Senior Software Engineer, Quantlab Financial
Kris is a Software Engineer focusing on modern C++ development where performance (including compilation times) and quality matters. He has been crafting modern C++ in telecommunications, games and recently finance industries. Kris is an author of [Boost].DI, [Boost].SML and GUnit... Read More →


Thursday May 18, 2017 4:30pm - 6:00pm
Hudson Commons

6:30pm

Dinner Break
Suggested Venue: Hickory House or Brunelleschi

Mention “Physics” and you’ll be seated together. Some will offer a free appetizer. They expect a group but you don’t have a reservation and if they can’t accommodate you, please see http://eataspen.com for more restaurant ideas and off-season specials. 

Thursday May 18, 2017 6:30pm - 8:30pm
on your own

8:30pm

Lightning Talks
Lightning talks are 5 minute talks on something of interest to C++ programmers. Presentation is open to any C++Now attendee, including Student/Volunteers.

Have a favorite technique or library to share? Employed some C++11/14 feature in a project with amazing/horrible results? Want to start a conversation on Boost 3.0? Submit your proposal for a 5 or 10-minute talk to Michael at lightning@cppnow.org. Be sure to include a title, 3-sentence abstract, and something about yourself.

Come to be amused, enlightened, outraged, or inspired!

Moderators
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for over 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Pr... Read More →

Thursday May 18, 2017 8:30pm - 10:00pm
Flug Auditorium
 
Friday, May 19
 

8:00am

Library in a Week
Library in a week 2017

Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has... Read More →


Friday May 19, 2017 8:00am - 9:00am
Paepke Auditorium

9:00am

Competitive Advantage with D

D is a systems programming language with C-like syntax and static typing. It combines efficiency, control, and modeling power with safety and programmer productivity.

Producing correct programs has notoriously been expensive in systems programming. Depending on the language used, programmers face a combination of labor and time intensive issues including struggling with language peculiarities, writing boilerplate code, code generation with difficulty or with external tools, manual resource management, and having to abide by long lists of coding guidelines. Correct programs further require prototyping sometimes with auxiliary languages and unit testing with external frameworks. It is not uncommon that readability and maintainability are sacrificed in the process.

D has minimal historical baggage, outstanding compile-time capabilities, useful exceptions, compiler-guaranteed memory safety, internal unit testing, and optional garbage collector as parts of an extensive feature set. Its features spanning from the lowest to the highest levels of programming paradigms generally obviate auxiliary languages in production.

This talk will give a general introduction of D, focusing mainly on its compile-time features like reflection, templates, code generation, conditional compilation, and user defined attributes; and present D as a time-saving software engineering tool suited for business requirements.

Because C++ is such a powerful language and because C++Now attendees are master users of it, it will be hard to argue for a single feature of D that would make one prefer D over C++. We know that one can achieve almost any programming task in C++, D, or most other languages. The killer feature of D is that the whole package it delivers makes it easier to achieve those tasks. That is the competitive advantage that it brings to D users.


Speakers
avatar for Ali Çehreli

Ali Çehreli

Senior Software Engineer, Octarine Labs, Inc.
Ali has been working with C, C++, and D at various networking companies in Silicon Valley since 1996. His experience includes a fun stint at WekaIO, a high performance storage company that bases its technology entirely on D. Ali is the author of the book Programming in D, the secretary and board member of... Read More →


Friday May 19, 2017 9:00am - 10:30am
Paepke Auditorium

10:30am

Break
Join us on the patio at the ACP for light snacks, drinks, and gossip.

Friday May 19, 2017 10:30am - 11:00am
Aspen Center for Physics Patio

11:00am

A vision for C++20, and std2 (part 3 of 3)
C++17 is about to ship, and one of the subtle additions is the reservation of a family of namespaces for a future standard library. As our attention turns to C++20 and beyond, Alisdair Meredith will explore how language evolution could (and should) affect the design of this future library, and just what kind of a new library do we want anyway?

This presentation breaks down into three parts. The first session lays down a vision of delivering all the language features likely to impact a library design in C++20. The obvious candidates are modules, concepts, and contracts, but what else? We will look at a variety of language features, assessing what they offer, or how they impact, a library designer. The second session looks into constraints and opportunities when designing a new C++ standard library. How compatible must we be with the old library? How ambitious should the new design be? What should our basic vocabulary types be? And how do we cope with language dependencies on 'std' types like 'type_info'?

The final session is a planned workshop, to gain feedback from the attendees of C++Now - an invaluable resource of world class library designers. Have I highlighted the correct questions? What should the priorities be? What is an appropriate schedule for developing and standardizing such a new library? How can those of us without access to committee meetings still help with the process? The results of this workshop will be written up in an informational paper for the next ISO mailing.

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

Bloomberg LP
Alisdair Meredith is a software developer at BloombergLP in New York, and 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... Read More →


Friday May 19, 2017 11:00am - 12:30pm
Bethe

11:00am

Effective CMake
While CMake has become the de-facto standard buildsystem for C++, it's siblings
CTest and CPack are less well known. This talk gives a lightspeed introduction
into these three tools and then focuses on best practices on building, testing,
and packaging. We will learn how to manage dependencies and export our
libraries in such a way that they can be easily used by our clients. We will
crosscompile for different platforms and run our tests in an emulator.
We will analyze code coverage and perform static and dynamic code analysis.

Speakers
avatar for Daniel Pfeifer

Daniel Pfeifer

Daniel is an Electrical Engineer turned into a Computer Scientist. He works as C++ developer, system architect, trainer and guru for C++ and CMake. Daniel is the founder of the C++ user group in Munich. He is also an active contributor to CMake and knows some undocumented interna... Read More →


Friday May 19, 2017 11:00am - 12:30pm
Flug Auditorium

11:00am

Restoring Your Sanity: An Approach to Dealing with Reference Types in the Generic Programming Paradigm
When specifying datastructures using the generic programming paradigm, we explicitly require or assume certain properties of our input types. For instance, in order for a standard container to make sense, you should give it a type that is at least some non-conflicting subset of the Regular concept. Your value type should be movable, and if it is copyable and copy-assignable as well, the semantics of those operations should be consistent in meaning with those of a Regular type. Violating these requirements results in code that will either not compile at all, or will have semantics that may be both useless and totally inconsistent with other instantiations. In brief, don't attempt to create a vector of a reference type or a vector of a proxy type such as vector<bool>::reference.

And yet despite that totally reasonable restriction, we sometimes encounter real-world, higher-level generic code that *seems* to need or want to be able to use generic datastructures with reference types or proxy types. Is this higher-level code simply in error and in conflict with generic programming principles, or are the details a bit more subtle? In this session, we will examine such cases and deduce what the expected semantics in such code actually is. We will further explore how it is that we can develop our datastructures of the future in a way that works not just with Regular objects, but with reference types and proxy types as well, and without making the existing semantics of our generic datatructures weaker or parametric.

Audience participation is encouraged and should lead to discussions. This session is expected to be controversial, but constructive for all library developers.

Speakers
avatar for Matt Calabrese

Matt Calabrese

Software Engineer, Google
Matt Calabrese is a software engineer working primarily in C++. He started his programming career in the game industry and is now working on libraries at Google. Matt has been involved with the Boost community for over a decade and is currently a member of the Boost Steering Comm... Read More →


Friday May 19, 2017 11:00am - 12:30pm
Hudson Commons

12:30pm

Lunch Break
On your own.

The lunch truck will be available at 12:45.

The Boost Operations session is catered if you sign up by the end of morning break.

Most attendees go into town.

Mention “Physics” and you’ll be seated together. Some will offer a free appetizer. They expect a group but you don’t have a reservation and if they can’t accommodate you, please see http://eataspen.com for more restaurant ideas and off-season specials. 

Friday May 19, 2017 12:30pm - 2:30pm
on your own

2:30pm

Locally Atomic Capabilities and How to Count Them
When we write a program, we imagine that each function should only exercise certain local capabilities — for example, that it should only examine or alter certain objects, and that other objects are reserved to other parts of the program.

But when we execute a program, these restrictions are largely unenforced. If any part of a program may exercise a capability, all parts may, and the accidental (or malicious) use of a non-local capability is at the heart of many bugs.

In this talk, I will examine the nature of capabilities; show how a notation for function interfaces can express the flow of capabilities between functions; define correct usage of capabilities; and present a way to instrument a function’s neighborhood or an individual translation unit to test the correct local usage of capabilities.

This talk continues the examination of program correctness in “How we reason about procedural programs” (C++Now 2015) and “What is the basic interface?” (C++Now 2016, CppCon 2016), but is intended to be accessible to people unfamiliar with that material.

Speakers
avatar for Lisa Lippincott

Lisa Lippincott

Chief Software Architect, Tanium
Lisa Lippincott is Chief Software Architect at Tanium, a bay-area startup. She's also a language nerd, and has contributed to arcane parts of the C++ standard. In her spare time, she studies mathematical logic with a category-theoretic approach.


Friday May 19, 2017 2:30pm - 4:00pm
Hudson Commons

2:30pm

No raw std::thread! - Live Tweet Analysis in C++
No raw loops is the clarion call for applying the existing std algorithms to values-distributed in space.
No raw std::thread is the same call to apply algorithms to values-distributed-in-space.
The live tweet analysis app, explored here, provides a working example of how complex interactions between; a live stream of tweets, REST api calls, and the main rendering loop can be expressed by applying concurrent algorithms instead of raw std::thread and std::mutex.
The app will request the twitter stream, parse out each tweet, call a Machine Learning REST API to return the sentiment of each tweet (positive or negative) display the tweets with search, display a word cloud and eventually attach the sentiment back to the correct tweet when the REST API completes.
The app uses algorithms for values distributed in time to batch values in space, distribute values to different threads and coordinate values through time. When the values are distributed in space then the range-v3 algorithms library is used to process the batch of values.

Speakers
avatar for Kirk Shoop

Kirk Shoop

Principal Software Engineer, Microsoft
Rx Cpp, Asynchronous Algorithms, catching code errors at compile time.


Friday May 19, 2017 2:30pm - 4:00pm
Bethe

2:30pm

The 'Detection idiom:' A Better Way to SFINAE
Hidden in the Library fundamentals Technical Specification, there is a section called "Detection idiom". The specification doesn't really say what it is for, and it has not received a lot of notice.

That's a shame. This is an amazingly powerful method for distinguishing between kinds of types. Writing SFINAE constraints is tedious and confusing, and this makes it much easier to do.

This session will introduce the detection idiom, walk through how it works, and then give examples on how to use it.

Speakers
MC

Marshall Clow

Marshall has been programming professionally for 35 yearsHe is the author of Boost.Algorithm, and has been a contributor to Boost for more than 15 years. He is the chairman of the Library working group of the C++ standard committee. He is the lead developer for libc++, the C++ st... Read More →


Friday May 19, 2017 2:30pm - 4:00pm
Flug Auditorium

4:00pm

Break
Join us on the patio at the ACP for light snacks, drinks, and gossip.

Friday May 19, 2017 4:00pm - 4:30pm
Aspen Center for Physics Patio

4:30pm

C++ Core Guidelines - Modernize your C++ Code Base
Leading C++ experts propose the C++ Core Guidelines to foster better coding practices for C++ developers. The Core Guidelines build around safe coding practices without losing C++'s efficiency, such as using const deliberately or minimize the use of raw pointers. Many of the guidelines provide hints for enforcing the guideline and some even require or imply effective static analysis tooling to make them useful.

IFS (Institute for Software) has a long history of providing static analysis within an IDE and also suggesting transformation for improving code, such as, applying C++11’s initializers, instead of uninitialized or old-fashioned initialized variable declarations. While already addressing some areas covered by the Core Guidelines, we recently targeted many more of those explicitly and provide corresponding static analysis and quick-fix refactoring support to adjust existing C++ code toward following the core guidelines.

This talk will introduce the C++ Core Guidelines and demonstrate how you can modernize your code and improve its quality without losing performance through automated tooling built into Cevelop.


Speakers
avatar for Peter Sommerlad

Peter Sommerlad

Director IFS, HSR Rapperswil
Prof. Peter Sommerlad is director of IFS Institute for Software at FHO HSR Rapperswil where he inspired the C++ IDE Cevelop. Peter is co-author of the books POSA Vol.1 and Security Patterns. His goal is to make software simpler by Decremental Development: Refactoring software dow... Read More →


Friday May 19, 2017 4:30pm - 6:00pm
Flug Auditorium

4:30pm

Customization Points That Suck Less
Flexible customization points are a hard thing to provide in C++. Some - and this includes the standard library - go the way of template specializations, but everyone who ever needed to create a customization point of this kind for a type (and a template) somewhere several namespaces deep knows how much pain this involves.

Others go the way of free functions, relying on ADL to select the proper overload - but ADL isn't the most user-friendly mechanism that exists in C++.

In this talk I'll attempt to enumerate the various means of providing customization points for library (and core language!) features, including several case studies of how this is done in different libraries, and will propose one that I haven't seen in the wilds before (but am sure that it exists somewhere), and show how to integrate it with type erasure. I'll also talk about how this relates to Concepts TS - and a thing called "virtual concepts", which is an attempt at marrying Concepts with type erasure.

Speakers
avatar for Michał Dominiak

Michał Dominiak

Software Engineer, Nokia Networks
Bachelor of Engineering in Computer Science from Wrocław University of Technology. Professional and enthusiast programmer. Interested in the foundational problems of computing, from the lowest levels of CPU architectures, through operating systems and programming language design... Read More →


Friday May 19, 2017 4:30pm - 6:00pm
Bethe

4:30pm

The Holy Grail - A Hash Array Mapped Trie for C++
C++ has a handful of associative containers. We started with set and map, both based on node-based red-black trees. These are fine but are not the most efficient and, in particular, suffer from more cache misses than we’d like. If we want to build persistent versions of them it’s achievable but aggravates the problems even more and adds considerable extra complexity (I know - I’ve done it!)

C++11 brought the hash-map based unordered_set and unordered_map, which are generally much faster, with better cache locality - but can be less memory efficient and also don’t translate so easily into persistent versions.

But there exists another general purpose data structure that combines many of the characteristics of trees and hash tables into something that in many important ways is superior to both, and with minimal downside (they are close but not quite as fast as pure hash tables). Hash Array Mapped Tries are more memory efficient than hash tables and, as a bonus, are trivially made persistent - with big implications for concurrency, functional programming, and other applications that benefit from being able to treat them immutably (as well as share large amounts of common state in memory at once).

This talk will describe how this data structure works from the ground up and look at a reference implementation I am writing with the intention of proposing as a boost library - and possibly later for standardisation. We’ll also look at how it can be used in practice, and some of the performance characteristics.

Speakers
avatar for Phil Nash

Phil Nash

Developer Advocate, JetBrains
I'm the author of the test framework, Catch, and also have feet in the Swift and F# worlds. | As Developer Advocate at JetBrains I'm involved with CLion, AppCode and ReSharper C++.


Friday May 19, 2017 4:30pm - 6:00pm
Hudson Commons

6:00pm

Dinner Break
On your own.

Mention “Physics” and you’ll be seated together. Some will offer a free appetizer. They expect a group but you don’t have a reservation and if they can’t accommodate you, please see http://eataspen.com for more restaurant ideas and off-season specials. 

Friday May 19, 2017 6:00pm - 8:30pm
on your own

8:30pm

C++Now 2018 Planning Session
The planning committee for next year's conference gets started early. Join us if you'd like provide suggestions or otherwise pitch in.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, Boost Libraries
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!

Friday May 19, 2017 8:30pm - 10:00pm
Flug Auditorium
 
Saturday, May 20
 

8:00am

Library in a Week
Library in a week 2017

Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has... Read More →


Saturday May 20, 2017 8:00am - 8:45am
Flug Auditorium

8:45am

CHAP:A memory analyzer for un-instrumented cores
Traditionally, memory usage analysis and memory leak analysis for C and C++ programs involve instrumenting either source code or binary code before running it through a series of tests. Such an approach, depending on how aggressively the code is instrumented, can result in false leak reports, if the code is not sufficiently instrumented to completely understand whether allocations are still in use, or can distort the timing so much that it is not practical to run on a regular basis. What is worse, if the memory usage of interest happened using code that was not instrumented, it may not be practical to reproduce the problem, for example due to dependence on some obscure code path or on some test that is expensive to run.  One other limitation of instrumentation is that it often changes the algorithm itself, and in doing so makes cases where the memory growth is due to allocator-specific behavior less clear to analyze.

At VMware I have developed a tool, now called CHAP but until very recently called ah64, that avoids these issues by analyzing un-instrumented core files, either live cores or cores from crashes, for leaks and memory usage and corruption. It does not report any false leaks and is sufficiently reliable that we run it in an automated way to catch leaks before they are checked in to our code base. We also use it regularly to understand memory growth issues and cases of memory corruption. In this talk I will discuss how the tool works and how to use it to address the use cases described earlier in this paragraph.

VMware has now made this available as open source at http://github.com/vmware/chap. At present it is working only for Linux ELF cores generated with programs that use glibc malloc.  There was prototyped support for at least one other allocator, but that prototype cannot be made available as open source without permission from the owners of that allocator. Some expected areas of enhancement for CHAP are likely to include support for other open source allocators, such as tcmalloc and jemalloc, support for other dump formats, better scripting, and use of DWARF information to make usage analysis more precise.

Speakers
avatar for Tim Boddy

Tim Boddy

Staff Engineer, VMware
I have been working with C since 1984 or so and with C++ since 2005. My current focus at VMware is writing debugging tools including memory analyzers, deadlock analyzers and python extensions to gdb, and sometimes using these tools or offering advice on how to do so. | | On... Read More →


Saturday May 20, 2017 8:45am - 10:15am
Bethe

8:45am

clang-useful: Building useful tools with LLVM and clang for fun and profit
The talk will consist of two parts. The first will be a general overview of the LLVM and clang library infrastructure available for creating custom tools such as static analyzers or source-to-source transformation tools. I will explain the ecosystem of the LLVM and clang tooling environment and outline options, tradeoffs and examples of the different ways of creating a tool (e.g. the difference between creating a plugin vs. a LibTooling executable). I will then go further in depth about how clang represents C++ source code by means of an AST and ways of traversing the AST to look for certain points of interest, e.g. old-style for loops that could be converted to range-based loops, or braces that are indented in Allman instead of One-True-Brace-Style, which could be useful for any company with a style guide it wants to enforce at compile-time rather than on paper or in code-reviews.

For the second part, I will then branch out into the two common tasks one might want to perform with a custom-built tool: emitting warnings or errors (for static analysis), and transforming and emitting new code (source-to-source transformations, such as clang-tidy). For each use-case, I will walk through real code that shows how one might approach a simple task in each category.

At the end of the talk, I expect listeners to have a basic understanding of the LLVM/clang tooling environment and AST representation. However, most importantly, I expect people to take away knowledge they can take home or to their office and immediately build tools in no time at all that *genuinely* improve their workflow and productivity. This is not a "give a man a fish" talk. This is a "teach a man to fish" talk.

Speakers
avatar for Peter Goldsborough

Peter Goldsborough

Intern, Facebook
I'm Peter and technically a second year CS student at TU Munich. Practically, I'm a first year student who decided to do a gap year and join the workforce. Since last August I've been doing engineering internships: first Google, then Bloomberg, now Facebook. I currently physicall... Read More →


Saturday May 20, 2017 8:45am - 10:15am
Flug Auditorium

8:45am

Type-safe Programming
C++ provides a really advanced type system. A prime example of its application is std::chrono: It uses the type system to create different types for different units and prevent programmer errors.

But the same principle can be applied to your everyday code - this talk is going to show you how. I'll present simple techniques to leverage the C++ type system to detect and prevent possible bugs at compile-time. We'll start with the bare minimum - minimize implicit conversions, and then quickly go to more advanced things like using types to express preconditions or general guidelines about type-safe class design.

This talk is in part based on ideas and concepts implemented in my type_safe library (http://type_safe.foonathan.net/).

Speakers
avatar for Jonathan Müller

Jonathan Müller

Student, RWTH Aachen University
Jonathan is a CS student passionate about C++. In his spare time he writes libraries like foonathan/memory which provides memory allocator implementations. He is also working on standardese which is a documentation generator specifically designed for C++. Jonathan tweets at @foon... Read More →


Saturday May 20, 2017 8:45am - 10:15am
Hudson Commons

10:15am

Break
Join us on the patio at the ACP for light snacks, drinks, and gossip.

Saturday May 20, 2017 10:15am - 10:45am
Aspen Center for Physics Patio

10:45am

Nbdl: Generic Library for Managing State Seamlessly Across Network
Nbdl: Network Based Data Layer is an experimental generic library for managing the state of an application. In this session we will go through its design, concepts, internals, and server/client integrations. We will see how it leverages metaprogramming with Boost.Hana to reduce run-time conditions, remove boiler-plate code, and create safer interfaces along with a few best practices for compile-time performance. We will see demos for a few integrations including an AppleTV app and a Web Application. We will also see how Docker can be used to manage dependencies and deployment.

Speakers
avatar for Jason Rice

Jason Rice

Jason is a web applications programmer with an appetite for C++ metaprogramming having made small contributions to Boost.Hana. He is actively working on the library Nbdl, waiting for the day when C++ takes over the web.


Saturday May 20, 2017 10:45am - 11:30am
Bethe

10:45am

Performance analysis and optimization of C++ standard libraries
We will present the performance analysis work on libcxx and libstdc++ and the changes we did to the libraries and to the LLVM compiler to optimize the code using the C++ standard libraries. This includes the improvements on standard library algorithms like string::find, libc++::basic_streambuf::xsgetn, libc++::stringstream. These algorithms were suboptimal and we improved those algorithms, particularly std::string which improved by more than 10x as a result of our work. Similarly, we enabled the inlining of constructor and destructor of libc++::std::string. We will present a systematic analysis of function attributes in libc++ and the places where we added missing attributes. We will present comparative analysis of libc++ vs. libstdc++ on commonly used algorithms, and show cases where std::sort of libstdc++ performs much better than that of libc++.

We will talk about std-benchmark (https://github.com/hiraditya/std-benchmark) that we started developing to help analyze performance across standard C++ libraries.

We will discuss the performance issues we are currently working on:
- Suboptimal parsing of numbers in libc++::stringstream
- Suboptimal libc++::std::sort
- Range checked access, for vectors (vector::at), is not properly optimized by the compiler
- Missing function attributes like __attribute__(noreturn)

For each of the performance issues that we have found, we will suggest possible solutions we are working on like improving the implementation or improved compiler optimizations (inlining extern templates, loop idiom recognition, loop rotation etc.)

If time permits, we will also present the lessons learnt as a result of analyzing C++ standard libraries like things to look out for while using standard C++ libraries, for example:
- Instead of std::rotate for std::list we can just exchange few pointers.
- Issue with the destructor of std::string
- Performance issues while using most commonly used containers such as std::vector, std::string

Speakers
avatar for Aditya Kumar

Aditya Kumar

Senior Compiler Engineer, Samsung Austin R&D Center
I've been working on LLVM since 2012. I've contributed to GVNHoist, Hexagon specific optimizations, clang static analyzer, libcxx, libstdc++, and graphite framework of gcc.
avatar for Sebastian Pop

Sebastian Pop

Samsung Austin R&D Center
Loop optimizations, testing, benchmarks, performance tracking.


Saturday May 20, 2017 10:45am - 11:30am
Flug Auditorium

10:45am

The Lesser-Known Multicore Synchronization Primitives
Despite more than 20 years of active research and development, more advanced synchronization mechanisms remain inaccessible to many students, engineers and open-source projects. This is especially true in the context of an unmanaged language such as C++ despite its popularity in highly complex concurrent systems. Even in light of attractive performance properties, small to medium-sized corporations are extremely hesitant to adoption due to the technology lock-down associated with the various interfaces of existing concurrency libraries. To top it off, when introducing engineers to this area, many are overwhelmed by the literature and the sparsity of performance data.

This talk will provide a guided tour of lesser-known synchronization mechanisms and their performance properties, and the challenges faced for the practitioner making use of them. The talk will use examples from the Concurrency Kit project which is used in billions of transactions on mission-critical systems every day.

Speakers
avatar for Samy Bahra

Samy Bahra

CTO / Co-Founder, Backtrace
Samy Al Bahra is the cofounder of Backtrace, where he is helping build a modern debugging platform for today’s complex applications. Prior to Backtrace, Samy was a principal engineer at AppNexus, where he played a lead role in the architecture and development of many mission-cr... Read More →


Saturday May 20, 2017 10:45am - 11:30am
Hudson Commons

11:45am

Future of Boost
The people who bring you Boost and C++ Now! talk and answer questions about what they see coming.


Saturday May 20, 2017 11:45am - 1:00pm
Flug Auditorium