Loading…
C++Now 2018 has ended
View analytic

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

Sunday, May 6
 

4:00pm

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

This year, the Registration Reception will be in Barksdale Lobby.

Sunday May 6, 2018 4:00pm - 6:00pm
Aspen Meadows Resort 845 Meadows Rd, Aspen, CO 81611

6:00pm

Dinner Break
Suggested Venue: Limelight Lounge or Hickory House

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.

The Hickory House offer for us is $5 off the regularly $23 full rack of ribs.

The Aspen Meadows Resort will have a limited-menu "popup" resturaunt during the dinner break in the Barksdale Lobby located in the Doerr Hosier Building.

Sunday May 6, 2018 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 to Barksdale Lobby.

The kitchen will be open for the room service menu until 11pm. The bar will also be open until 11pm.

Sunday May 6, 2018 8:30pm - 11:00pm
Aspen Meadows Resort 845 Meadows Rd, Aspen, CO 81611
 
Monday, May 7
 

8:00am

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

Speakers
avatar for Jon Kalb

Jon Kalb

Conference Chair, Jon Kalb, Consulting
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He is a director and the treasurer of the C++ Alliance.He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft... Read More →


Monday May 7, 2018 8:00am - 8:15am
Paepcke 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 written... Read More →


Monday May 7, 2018 8:15am - 8:55am
Paepcke Auditorium

9:00am

Opening Keynote: The Shape of a Program
When we talk about programs, we often use metaphors of space: we speak of connection and separation, of paths and boundaries, of areas and lengths. We clearly have some intuition that sees a program as a shape.

In this talk, I will take this intuition seriously, applying topology, the fundamental mathematics of space. I will show how a program can be mathematically described as a shape — a bitopological manifold — arranging actions and capabilities in a frame of time, space, causality, and possibility.

No previous knowledge of topology will be assumed.

Speakers
avatar for Lisa Lippincott

Lisa Lippincott

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.


Monday May 7, 2018 9:00am - 10:30am
Paepcke Auditorium

10:30am

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

Monday May 7, 2018 10:30am - 11:00am
Aspen Center for Physics Patio

11:00am

A Quantum Data Structure For Classical Computers
Classical computing fundamentally occurs through sequenced access to (mutable) state. In contrast, quantum computing relies upon the phenomenon of quantum interference, where computed results obscure the cause-and-effect reasoning that would otherwise be achieved through ordered operations. The implication is that quantum computing appears to “transcend-time”, and requires alternative software engineering strategies to govern dependencies and regulate state changes at scale.

Whereas functional programming manages complexity through “pure” computations without side-effect, quantum programming demands data structures that rely upon entanglement, and coherence. A quantum data structure within a classical machine represents “superpositioned state” where the inspected value varies based on (perhaps non-observable) context.

We describe the aspects of a quantum data structure; enumerate requirements necessary for implementation; compare with historical classical computing concerns; and present C++ code to illustrate quantum corollaries for classical computing idioms. A goal is to broaden computational options for existing software engineering challenges on today’s systems, as well as begin discussion for new types of design appropriate for emerging hardware increasingly reliant upon quantum effects.

Speakers
avatar for Charles Bay

Charles Bay

F5
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, and... Read More →


Monday May 7, 2018 11:00am - 12:30pm
Hudson Commons

11:00am

C++ Mixins: Customization Through Compile Time Composition
Working in the embedded domain where 'special cases' are the norm I often find myself fighting with customization capabilities and 'canned' (non-customizable) abstractions. std::string often has a small buffer for small string optimization, std::function has something similar, why can't I set the size of that buffer, or more radically why can't I just stick that same buffer in a std::vector for a 'small vector optimization'. While we're at it why can't I take .at() out of std::vectors public interface and call some user-defined function on out of memory, maybe I turned off exceptions but still want to handle errors properly. Maybe I want a std::deque interface but have a fixed sized ring buffer under the hood. Those following the SG14 will notice I am ticking off proposals, the problem with these proposals is that the mostly follow a common pattern: "I need X without Y" or "I need X to have Y" and there are many many combinations of X and Y. Why do I have to pay for atomic ref counting in a shared_pointer in a single threaded use case? We could go on all day. In this talk we will explore the feasibility of building classes from composable pieces, some concrete proof of concepts as well as the library infrastructure needed for this task.

Speakers
avatar for Odin Holmes

Odin Holmes

chaos monkey, Auto-Intern GmbH
Odin was allocated from a pool of hippies in the middle of the forest. He spent most of his career designing electronic circuits and programming micro controllers in assembler. One day after having shot himself in the foot particularly badly a friend introduced him to C++, a seriously... Read More →


Monday May 7, 2018 11:00am - 12:30pm
Flug Auditorium

11:00am

Fast Conversion From UTF-8 with C++, DFAs, and SSE Intrinsics
UTF-8 is taking on an increasingly important role in text processing. Many applications require the conversion of UTF-8 to UTF-16 or UTF-32, but typical conversion algorithms are sub-optimal. This talk will describe a fast, correct, DFA-based approach to UTF-8 conversion that requires only three simple lookup tables and a small amount of straightforward C++ code.

We'll begin with a quick review UTF-8 and its relation to UTF-16 and UTF-32, as well as the concept of code units and code points. Next, we'll look at the layout of bits within a UTF-8 byte sequence, and from that, show a simple algorithm for converting from UTF-8 to UTF-32. Along the way will be a definition of overlong and invalid byte sequences. Following that will be a discussion of how to construct a DFA to perform the same operations as the simple algorithm. We'll then look at code for the DFA traversal underlying the basic conversion algorithm, and how to gain an additional performance boost by using SSE intrinsics.

Finally, we'll compare the performance of this approach to several commonly-available implementations on Windows and Linux, and show how it's possible to do significantly faster conversions.

Speakers
avatar for Bob Steagall

Bob Steagall

CppCon Poster Chair, KEWB Computing
I've been working in C++ since discovering the second edition of The C++ Programming Language in a college bookstore in 1992. 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... Read More →


Monday May 7, 2018 11:00am - 12:30pm
Bethe

12:30pm

Lunch Break
On your own.

No lunch truck this year. See this alternative.

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. 

Monday May 7, 2018 12:30pm - 2:30pm
on your own

2:30pm

An Allocator is a Handle to a Heap
C++17 introduced the std::pmr framework. In this framework, a std::pmr::polymorphic_allocator<T> holds a pointer to a std::pmr::memory_resource. The memory resource is in charge of managing and organizing the heap itself, and the allocator object is just a thin "handle" pointing to the memory resource.

This is not just a convenient implementation strategy for std::pmr! Rather, this elucidates the true meaning of the Allocator concept which has existed, unchanged, since C++98. An Allocator *is* a handle to a MemoryResource. Even std::allocator can — and should — be viewed as a handle to a global singleton "heap", and not as a MemoryResource in its own right.

From this core insight we derive many corollaries, such as the need for allocator types to be lightweight and efficiently copyable, the fundamental impossibility of implementing an "in-place" std::vector via stupid allocator tricks, and the philosophical underpinnings of "rebinding."

We'll show at least two non-standard examples of types modeling Allocator that act as different kinds of handles to heaps: a `shmem_allocator` that holds a `shmem_ptr` to a memory resource, and a `shutdown_safe_allocator` that holds a `weak_ptr` to a memory resource.

Time permitting, we'll
- discuss what we can expect from a "moved-from" allocator object
- relate the notion of "handle" to neighboring notions such as "façade" and "adaptor"
- suggest similarities between "allocator/heap" and "executor/execution-context"

Speakers
avatar for Arthur O'Dwyer

Arthur O'Dwyer

Arthur O'Dwyer started his career writing pre-C++11 compilers for Green Hills Software; he currently writes C++14 for Akamai Technologies. Arthur is the author of "Colossal Cave: The Board Game," "Mastering the C++17 STL" (the book), and "The STL From Scratch" (the training course... Read More →


Monday May 7, 2018 2:30pm - 4:00pm
Flug Auditorium

2:30pm

Boost.Text: Fixing std::string, and Adding Unicode to Standard C++ (part 1 of 2)
std::string has serious design flaws: its fat interface; its uselessness for editing of very long sequences of characters; and its complete lack of support for text encoding. This talk presents a proposed library, Boost.Text, a library of interoperating types and algorithms.

Boost.Text tries to do two things. First, it seeks to address the deficiencies of std::string. Second, it adds an additional layer of full Unicode support for those users that need it (without encumbering users of strings that do not). Both of these are done in a consistent and modern way. This library is intended for eventual standardization.

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.


Monday May 7, 2018 2:30pm - 4:00pm
Bethe

2:30pm

Generalized Full Duplex Messaging
We've seen a lot in the realm of libraries for sockets and protocols for network communications, but what is there for bringing it all together?

In this presentation, we will go through bringing together a combination of Boost.Asio, Boost.Hana, and the speaker's own Nbdl to demonstrate how to create a generic interface to a full duplex messaging system. We will look at how to create concrete implementations using different libraries providing anywhere from raw tcp to websockets. We will also touch on the complex task of managing object lifetimes with asynchronous operations.

Anyone interested in network programming, or making generic interfaces in their libraries will find this presentation useful.

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.


Monday May 7, 2018 2:30pm - 4:00pm
Hudson Commons

4:00pm

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

Monday May 7, 2018 4:00pm - 4:30pm
Aspen Center for Physics Patio

4:30pm

Beyond C++17
Presentation of features already voted into C++20 Standard Draft in Toronto, Albuquerque, and Jacksonville ISO C++ Committee Meetings as well as the overview of other really promising proposals that have high chances to arrive in C++20.

Speakers
avatar for Mateusz Pusz

Mateusz Pusz

Chief Software Engineer, Epam Systems
Software architect, chief developer, and security champion with more than 14 years of experience in designing, writing and maintaining C++ code for fun and living. C++ consultant, trainer, and evangelist focused on Modern C++. His main areas of interest and expertise are code performance... Read More →


Monday May 7, 2018 4:30pm - 6:00pm
Hudson Commons

4:30pm

Boost.Text: Fixing std::string, and Adding Unicode to Standard C++ (part 2 of 2)
std::string has serious design flaws: its fat interface; its uselessness for editing of very long sequences of characters; and its complete lack of support for text encoding. This talk presents a proposed library, Boost.Text, a library of interoperating types and algorithms.

Boost.Text tries to do two things. First, it seeks to address the deficiencies of std::string. Second, it adds an additional layer of full Unicode support for those users that need it (without encumbering users of strings that do not). Both of these are done in a consistent and modern way. This library is intended for eventual standardization.

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.


Monday May 7, 2018 4:30pm - 6:00pm
Bethe

4:30pm

C++17's std::pmr Comes With a Cost
Much has been said regarding the virtues of C++17's new polymorphic allocator
model (std::pmr), but these new facilities come with real costs that
should be considered before their adoption in large codebases. This talk
introduces the polymorphic allocator model and, through example, shows how they
interact with move semantics, unit testing, performance, developer
productivity, and reliability. Finally, concrete recommendations are provided
as to when and how to use 'std::pmr' in your large codebase.

If you're new to 'std::pmr' or allocators in general, this talk should serve as
a solid introduction to both the facility and the issues involved. Those
already familiar will gain deeper insight on the more subtle consequences of
polymorphic allocator use at scale.

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... Read More →


Monday May 7, 2018 4:30pm - 6:00pm
Flug Auditorium

6:00pm

Dinner Break
Suggested Venue: Limelight Lounge or Mezzaluna

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.

The Aspen Meadows Resort will have a limited-menu "popup" resturaunt during the dinner break in the Barksdale Lobby located in the Doerr Hosier Building.

Monday May 7, 2018 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 Consulting
Michael Caisse has been crafting code in C++ for 28-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 Project... Read More →

Monday May 7, 2018 8:30pm - 10:00pm
Flug Auditorium

10:00pm

Social Event: Informal Gathering
Join us in Barksdale Lobby for after session socializing.

The kitchen will be open for the room service menu until 11pm. The bar will be open until 1 am.

Monday May 7, 2018 10:00pm - Tuesday May 8, 2018 1:00am
Aspen Meadows Resort 845 Meadows Rd, Aspen, CO 81611
 
Tuesday, May 8
 

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 written... Read More →


Tuesday May 8, 2018 8:00am - 8:55am
Flug Auditorium

9:00am

Fancy Pointers for Fun and Profit
In modern C++ it is possible to implement user-defined types that closely mimic the behavior of ordinary pointers; these types are often referred to as fancy (or synthetic) pointers. With such types at one's disposal, it becomes feasible to build standard-conforming allocators that support relocatable memory in a way that is compatible with the standard containers. This, in turn, enables the use of the standard containers in applications like shared-memory databases, self-contained private heaps, and lightweight object persistence.

This talk will describe a small set of components that implement synthetic pointers. We'll begin by looking briefly at a couple of motivating problems, and then review how the standard defines "pointer-like types". We'll then discuss how closely a user-defined type can emulate ordinary pointers and sketch out a strategy for implementing such a type using the concepts of addressing model, storage model, and pointer interface.

We'll jump into the deep end by implementing two different addressing models, based 2D addressing and offset addressing, which act as policy types for a synthetic pointer class template. We'll then review simple storage models that support raw memory allocation for both addressing models before examining the synthetic pointer class in detail. We'll discuss how the synthetic pointer class interacts with the addressing models to implement pointer operations and emulate an ordinary pointer's interface. We'll also take a quick look at alternative implementations of the synthetic pointer type.

Finally, the talk will provide a couple examples of how these concepts can be applied - namely, containers in shared memory and self-contained private heaps.

Speakers
avatar for Bob Steagall

Bob Steagall

CppCon Poster Chair, KEWB Computing
I've been working in C++ since discovering the second edition of The C++ Programming Language in a college bookstore in 1992. 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... Read More →


Tuesday May 8, 2018 9:00am - 10:30am
Flug Auditorium

9:00am

The Best Type Traits that C++ Doesn't Have
I'll present three candidates for the best type trait that doesn't (yet!) exist in C++.

The first trait, is_trivially_relocatable_v<T>, tells whether objects of type T can be "atomically move-constructed-and-destroyed" by memcpy. The canonical use-cases for this operation are vector resizing and hash-table rehashing. We'll look at benchmarks for resizing vector<unique_ptr<T>> with and without this type trait, and consider the curious case of *swapping* two trivially relocatable objects.

The second trait, is_trivially_equality_comparable_v<T>, tells whether objects of type T can be compared by memcmp. The canonical use-case for this operation is compare-exchange on atomic<T>, which is already implemented in terms of memcmp but has undefined behavior for types that are not trivially comparable. (WG21 has begun to tackle this problem via papers N4130 and P0528.) With the introduction of "operator spaceship" in C++2a, the compiler now has enough information to determine the trivial comparability of every user-defined type; this could be exposed as a built-in type trait. We'll look at benchmarks for vector<unique_ptr<T>>::operator== with and without this type trait, and give a nod to is_trivially_less_than_comparable_v<T>.

The third trait is actually a traits class: tombstone_traits<T>. This part of the talk will build on Mark Zeren's C++Now 2017 session "Rethinking Strings." Most object types have invalid or "spare" representations, for example the all-bits-zero representation of a reference_wrapper<U> or the 0x02 representation of a bool. By opting into a specialization of tombstone_traits<T>, the programmer can make these "spare" representations available to tombstone-aware library classes such as optional<T> and cuckoo_hash<T>. We'll show how tombstone_traits<bool> exposes the spare representations, how tombstone_traits<optional<T>> propagates them appropriately, and how the tombstone representations can be used in practice by a Robin Hood hash table.

Speakers
avatar for Arthur O'Dwyer

Arthur O'Dwyer

Arthur O'Dwyer started his career writing pre-C++11 compilers for Green Hills Software; he currently writes C++14 for Akamai Technologies. Arthur is the author of "Colossal Cave: The Board Game," "Mastering the C++17 STL" (the book), and "The STL From Scratch" (the training course... Read More →


Tuesday May 8, 2018 9:00am - 10:30am
Hudson Commons

9:00am

The Continuing Saga of the Lock-free Queue: Part 3 of N
A continuation from previous talks on a multi-producer, multi-consumer, growing, shrinking, lock-free queue.
But previous knowledge is not required, as we will start by taking a quick look at the current state of the queue - including improvements as suggested from last year's audience.

We will then decide - as a group - which feature to tackle next (ie storing objects more than just ints? growing? and shrinking?) and tackle it together.
On the chalk-board.

This talk will help you learn how to think when doing lock-free programming, and to think twice before deciding that lock-free is really the solution you need.

Speakers
avatar for Tony Van Eerd

Tony Van Eerd

Senior C++ Guy, Christie Digital
Tony has been coding for well over 25 years, and coding well for hopefully some of that. He's worked at companies big (Adobe) and small (Inscriber) and currently writes software for projection mapping - making magic with light - at Christie Digital. He is a member of the C++ Standards... Read More →


Tuesday May 8, 2018 9:00am - 10:30am
Bethe

10:30am

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

Tuesday May 8, 2018 10:30am - 11:00am
Aspen Center for Physics Patio

11:00am

The Untapped Potential of Software Visualization
Software visualization is as old as software engineering, but it still only has limited day-to-day applications. The potential benefit of visualization stays largely untapped, while the software community is facing a big problem: Professional software developers spend most of their development time on reading and understanding existing source code, instead of actually writing new one. Thus, a lot of their productivity is lost.

Visualization leverages research on human visual perception. Its use allows us to process and understand information much quicker than information provided solely in textual form. We will see how these laws are used by different software visualization fields to improve comprehension of certain aspects of a software system. Applying the introduced design principles we will develop a simple visual notation that helps to accelerate understanding source code. Sourcetrail, a cross-platform source explorer built on top of the LLVM/Clang LibTooling library, will be used to demonstrate how such a visual notation simplifies getting to know a large code base in practice.

Speakers
avatar for Eberhard Gräther

Eberhard Gräther

Software Engineer | UX Designer | Managing Director, Coati Software KG


Tuesday May 8, 2018 11:00am - 11:45am
Hudson Commons

11:00am

Git, CMake, Conan: How to Ship and Reuse our C++ Projects
The purpose of that presentation is to solve the problems of build system and packaging that we have with large, multi-platform, C++ projects with many open source dependencies. Git and CMake are already established standards in our community. However, it is not clear how to use them in an efficient way. As a result, many C++ projects have problems with either importing other dependencies or making themselves easy to import by others. The talk will describe how Conan package manager - a new contender on the market may address those use cases.

Speakers
avatar for Mateusz Pusz

Mateusz Pusz

Chief Software Engineer, Epam Systems
Software architect, chief developer, and security champion with more than 14 years of experience in designing, writing and maintaining C++ code for fun and living. C++ consultant, trainer, and evangelist focused on Modern C++. His main areas of interest and expertise are code performance... Read More →


Tuesday May 8, 2018 11:00am - 11:45am
Flug Auditorium

11:00am

Boost.TMP: Your DSL for Metaprogramming
In last years talk I presented new ways to write algorithms in template metaprogramming with the library kvasir::mpl and ended with a small taste of the libraries composition and modeling power. In this talk, I would like to pick up where we left off and show how far the rabbit hole of 'metaprogramming through composition' can go. Not only can we express whole programs as tacit style compositions of basic building blocks but the resulting metaprogramms are blazingly fast and quite readable.
We will also explore other strategies of SFINAE use, more efficient use of type_traits as well as a forward-looking teaser of my vision of what fusion style metaprogramming should look like.

Speakers
avatar for Odin Holmes

Odin Holmes

chaos monkey, Auto-Intern GmbH
Odin was allocated from a pool of hippies in the middle of the forest. He spent most of his career designing electronic circuits and programming micro controllers in assembler. One day after having shot himself in the foot particularly badly a friend introduced him to C++, a seriously... Read More →


Tuesday May 8, 2018 11:00am - 12:30pm
Bethe

11:50am

Fortransformers: A Field Study
It's 2018 - there is a new programming language almost every other week - and still we have to bother with Fortran. The language of course has its advantages but from the perspective of a C++ developer, it lacks features like function overloading, templates and generic containers, to name just a few.
When my team decided to translate two of our main Fortran-libraries to C++ we set out the following conditions: maintain the runtime performance and, even more important, do not upset the Fortran-developers, by modifying the sources as little as possible. Especially syntax and semantics of arrays should not change, i.e. one-based, multi-dimensional, whole-array-operations. Since existing Fortran to C/C++ translators like f2c and fable only support Fortran 77, we had to develop our own tool. Furthermore, we needed a C++ expression template array-library that satisfied the requirements.
This talk will bring some light into the dark corners of Fortran translation tools and also show the benefits of expression template pioneer Blitz++.
It will cover the evaluation of translation tools and expression template libraries, culminating in an almost-automatic version of f2c and a modernized version of Blitz++ as DSEL for Fortran-like array-operation. We will review code examples before and after the translation process and analyse the performance of the C++ libraries versus their Fortran-versions.
So, open your Fortran storages and trunks and let in a fresh cool breeze of modern C++.

Speakers
avatar for Tobias Loew

Tobias Loew

Software Architect, steag energy services
C++ developer for now almost 20 years with PhD in mathematics and a background in functional languages and their mathematical models


Tuesday May 8, 2018 11:50am - 12:35pm
Hudson Commons

11:50am

Docker Based C++ Dependency and Build Management
If you are looking to bootstrap a new C++ project, or want an easier way to contribute to your favorite op
en source library all with elaborate library and system dependencies, then this talk is for you!

In this presentation, we will get up to speed with Docker and how its multi-stage build process can be used to build C++ programs. Starting with a fresh system, we will compile our compiler toolchains, install build tools, and resolve library dependencies to get a tutorial project up and running, targeting multiple platforms as well as using documentation and testing resources.

We will also look at CppDock, a tool to help manage dependencies and hide much of the tedious Docker command-line for common cases such as creating build environment containers and installing target files to the host environment.

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.


Tuesday May 8, 2018 11:50am - 12:35pm
Flug Auditorium

12:30pm

Lunch Break
On your own.

No lunch truck this year. See this alternative.

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 8, 2018 12:30pm - 2:30pm
on your own

1:00pm

Open Discussion about Software Freedom Conservancy, Boost's Non-Profit Home
The Boost project became a member of Software Freedom Conservancy (a charitable home for Open Source and Free Software projects) in 2007. Conservancy has worked with the Boost project and its Steering Committee since then on many activities, including coordination and funding of GSoC participation and other student programs, back-office support for the organization of BoostCon and C++Now, and covering travel expenses for countless Boost developers.

Bradley is excited to finally attend BoostCon/C++Now for the very first time and welcomes an open discussion and questions from everyone in the C++ community about how Conservancy works, what it does for Boost and its other projects, and to brainstorm about what more Conservancy can do to support Open Source C++ work.

Moderators
avatar for Bradley Kuhn

Bradley Kuhn

Distinguished Technologist, Software Freedom Conservancy
Bradley M. Kuhn is the Distinguished Technologist at Software Freedom Conservancy, on the Board of Directors of the Free Software Foundation (FSF), and editor-in-chief of copyleft.org. Kuhn began his work in the software freedom movement as a volunteer in 1992, as an early adopter... Read More →

Tuesday May 8, 2018 1:00pm - 2:00pm
Bethe

2:30pm

Futures Without Type Erasure
The most popular implementations of futures, including `std::future`, use dynamic allocation and type erasure in order to allow composition of futures into fork/join asynchronous computation graphs. While this overhead is unavoidable when the control flow of the asynchronous graph depends on run-time conditions, it is unnecessary when the "shape" of the computation graph is known at compile-time.

* Is it possible to implement composable futures without dynamic allocation and type erasure?
* Is it worth it?

After a brief overview of the upcoming `std::experimental::future` additions focused on composability, this talk answers these questions showing the train of thought behind the design and implementation of an experimental future library, step-by-step. The library will revolve around the following idea: embed the asynchronous computation graph into types. Template metaprogramming and compile-time transformations will be heavily used to implement zero allocation & zero type erasure futures.
Running time, compilation time, and generated assembly benchmarks/comparisons will be provided and analyzed.

The code covered in the talk will make use of C++17 language and library features, that will be explained throughout the presentation. The intended audience for the talk should be familiar with most C++11/14 language features and with `std::future` (or `boost::future`). Knowledge of C++17 features is recommended but not required.

Speakers
avatar for Vittorio Romeo

Vittorio Romeo

Software Engineer, Bloomberg
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 →


Tuesday May 8, 2018 2:30pm - 4:00pm
Flug Auditorium

2:30pm

Smart Output Iterators
Smart output iterators are an approach to perform operations on collections in C++. In this session, you'll see what they are and how they complement the STL algorithms and the range library.

Indeed, range-v3's adaptors put some operations inside of the iterators of an *input* collection. What if we put some logic inside the *output* iterators? What are the advantages to do so?

In this session, we'll see various kinds of smart output iterators, such as iterators that help a smooth integration into data structures, and iterators that relieve some of the complexity of the algorithms.

We'll discuss when it makes sense to stick with the STL algorithms, to prefer ranges adaptors, or to go for smart output iterators.,You'll also see a comparison of performance of those designs.

I've used smart output iterators in my code and presented them at the C++ meetup in Paris. I'd like to show them to you to hear your opinion and debate about their interest and about the optimal strategy to manipulate collections in C++.

Speakers
avatar for Jonathan Boccara

Jonathan Boccara

Murex
Jonathan Boccara is a Principal Engineering Lead at Murex where he works on large codebases in C++. | His primary focus is searching how to make code more expressive. He has dedicated his blog, Fluent C++, to writing expressive code in C++. | He also gives internal trainings on C... Read More →


Tuesday May 8, 2018 2:30pm - 4:00pm
Bethe

2:30pm

The Julia Language and C++: The Perfect Marriage?
The objective of this session is to introduce [the Julia language](https://julialang.org) and its interfaces to C++. Julia is a high-level programming language with a focus on scientific computing. Julia leverages LLVM to achieve levels of performance comparable to C++. It is a strongly typed, but dynamic language with a strong focus on generics. Similarly to C++, function overloading is supported, resulting in a "multiple dispatch" system that chooses the correct function to call based on the types of the arguments, compiling specialized versions of the function as needed. However, unlike C++, the dispatch decision is delayed until runtime, eliminating the difference between compile time and runtime types. Julia is an excellent high-level companion to a C++ library (compared to e.g. Python). Its combination of high performance and almost zero-overhead FFI to C++ allow interfacing at any level of abstraction, even in inner loops (e.g. the inner loop of matrix multiply) without a significant performance penalty.

There are currently two methods of using C++ libraries within Julia: [Cxx.jl](https://github.com/Keno/Cxx.jl) to write the interfacing code as part of a Julia program, or [CxxWrap.jl](https://github.com/JuliaInterop/CxxWrap.jl) to write the interface in C++. Cxx.jl leverages Clang and LLVM to JIT compile inline C++ code and execute it on the julia execution engine, while CxxWrap.jl uses the existing Julia-C interface from C++. Cxx.jl allows tight integration between Julia and C++ code, interspersing both in the same source file, with arbitrarily nested control flow between the two languages. It also provides a C++ REPL and interactive use of C++ code, similar to Cling. Furthermore, it allows instantiating C++ templates on julia values. In CxxWrap.jl on the other hand, all glue code is in C++ and compiled into a shared library, akin to Boost.Python for Python. This is less flexible with regard to template parameters, but reduces the stress on the JIT-compiler. CxxWrap.jl also offers a few higher-level C++ constructs to facilitate calling into Julia from C++.

In our tutorial, we will start with some examples to introduce the basic Julia concepts, followed by interactive tutorials introducing the usage of both Cxx.jl and CxxWrap.jl. We will finish with a number of examples and benchmarks. By the end of the session, we hope you will agree that Julia is a fast, high-level language that offers excellent mechanisms to use existing C++ libraries without much effort.

Additional material for this talk can be found here: https://github.com/barche/cppnow2018-julia

Speakers
avatar for Keno Fischer

Keno Fischer

CTO, Julia Computing Inc
avatar for Bart Janssens

Bart Janssens

Major, Royal Military Academy
I am an associate professor at the mechanics department of the Royal Military Academy. For my Ph.D., I worked on Coolfluid, a C++ framework for computational fluid dynamics with a domain specific language. My interest in Julia is sparked by its powerful metaprogramming functionality... Read More →


Tuesday May 8, 2018 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 8, 2018 4:00pm - 4:30pm
Aspen Center for Physics Patio

4:30pm

Generative Programming in Action: Emulating the 3DS
Console emulation needs to stem the difficult balance between optimizing code for stable frame rates and maintaining the complex logic required to emulate the given hardware - any subtle bug in this system easily manifests in a user-visible glitch. How can modern C++ help?

Using the toolbox of generative programming, we take a look at the interprocess communication subsystem of the 3DS and see how far variadic templates, function reflection, and some metaprogramming will get us in terms of bridging the gap between performance, maintainability, and correctness.

Based on this example I will introduce the general idea of generators and declarative interfaces, and how we can use them in serialization-like problems to provide reusable and customizable functionality with a uniform API that minimizes boilerplate code.


Speakers
avatar for Tony Wasserka

Tony Wasserka

Freelance Software Developer
Low-level anything: Tony is a freelancer and long-term C++ enthusiast who has worked on the console emulator projects Dolphin (GameCube/Wii), PPSSPP (PSP), and Citra (3DS) since 2010. More recently, he has worked on Vulkan graphics drivers for PowerVR graphics processors. His main... Read More →


Tuesday May 8, 2018 4:30pm - 6:00pm
Hudson Commons

4:30pm

What Else Has My Compiler Done For Me Lately?
We've given Matt four day's notice (a scheduled speaker had to cancel) to tell us what his compiler has done for him since  his CppCon Keynote.

Come and see the latest.


Speakers
avatar for Matt Godbolt

Matt Godbolt

Senior Software Engineer, Coinbase
Matt Godbolt is the creator of the Compiler Explorer website. He is passionate about writing efficient code. He has previously worked at a trading firm, on mobile apps at Google, run his own C++ tools company and spent more than a decade making console games. When he's not hacking... Read More →


Tuesday May 8, 2018 4:30pm - 6:00pm
Bethe

4:30pm

Moving Faster: Everyday Efficiency in Modern C++
There seems to be a widely held belief among programmers today that efficiency no longer matters in most situations because processors are so fast and numerous and memory is so large. But from a user’s perspective computers are often slower today than they were 30 years ago despite the enormous increase in measured performance of the hardware. How can this be? If this is true, what are we doing wrong and what can we do about it? Is efficiency an everyday concern for working programmers, or is it only needed for special cases written by specialists?

In this talk we will explore these questions and consider the proposition that, contrary to popular belief, performance almost always matters and pervasive attention to efficiency is essential to ensure good performance. We will examine the efficiency tools modern C++ has to offer and discuss techniques for writing efficient code in an elegant, expressive and natural way. Topics will include tuning vs. optimizing, value semantics vs. reference semantics, unions and variants, move semantics, forwarding, container choice, in-place construction, and container node handling.

Speakers
avatar for Alan Talbot

Alan Talbot

Manager - Software Engineering, LTK Engineering Services
Alan Talbot started programming in 1972, in BASIC on a DEC PDP-8. He began his professional programming career in 1979 and started using C++ in 1989. For 20 years he was a pioneer in music typography software, then spent 8 years writing digital mapping software, and has spent the... Read More →


Tuesday May 8, 2018 4:30pm - 6:00pm
Flug Auditorium

6:15pm

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

Tuesday May 8, 2018 6:15pm - 8:30pm
Picnic Area

9:00pm

Social Event: Informal Gathering
Join us in Barksdale Lobby for after picnic socializing.

The kitchen will be open for the room service menu until 11pm. The bar will be open until 1am.

Tuesday May 8, 2018 9:00pm - Wednesday May 9, 2018 1:00am
Aspen Meadows Resort 845 Meadows Rd, Aspen, CO 81611
 
Wednesday, May 9
 

7:00am

'Meet the Volunteers' Breakfast

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
 

Wednesday May 9, 2018 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 written... Read More →


Wednesday May 9, 2018 8:00am - 8:55am
Flug Auditorium

9:00am

Game Engine API Design
Recent C++ standards have given us amazing tools for building easy to use and intuitive APIs. Despite this, C++ is still considered to be "too difficult" and "too complex." While that's a fairly subjective matter, the results are clear: new developers are reaching for technology perceived as easier to use/learn. In the world of game development we've seen a sharp rise in usage of software considered more approachable. Those approachable tools have contributed immensely to creating the thriving indie game development scene that exists today. With all the new tools C++ programmers have, it should be possible to build a game engine as approachable as the ones using other languages. This talk seeks to explore that space.

A game engine's API can be very insightful into how it works. We will examine some design choices made by major players in the game engine space to understand how they work and where the industry is heading. From there we will look at how those interfaces can be built in C++, as well as how the features added in recent standards can be used to create even better interfaces.

Speakers
avatar for Allan Deutsch

Allan Deutsch

Program Manager, Microsoft
Allan Deutsch is a Program Manager at Microsoft working in the Advanced Technology Group. He is a BSCS graduate from DigiPen Institute of Technology, where he focused on game development and gained an interest in game engine design.


Wednesday May 9, 2018 9:00am - 10:30am
Bethe

9:00am

If I Had My 'Druthers: A Proposal for Improving the Containers in C++2x
Although the existing standard containers have served us well for the last two decades, they are starting to show their age. Recent reports of positive experiences with the PMR-based containers provide one example of how seemingly small improvements in the containers can have a big payoff. With the creation and reservation of the std2 namespace comes the exciting prospect of refactoring the standard containers for C++2x, a possibility rasied and briefly discussed at last year's conference.

This talk will first review weaknesses in the current container library and discuss corresponding opportunities for improvement. We'll then list some tentative requirements, distinguishing between the needs of ordinary users and power users. We'll cover the need for meaningful names, and emphasize the distinction between low-level concrete containers, such as linked lists, and high-level adaptor containers, such as stacks. We'll then present a proposed high-level design for the container library and an idiom for container implementation that fulfills those requirements. We'll also cover changes to allocators and memory management facilities needed to support the proposed design. Along the way we'll look at example code for implementation and usage, and discuss ways to improve the containers' public APIs.

Speakers
avatar for Bob Steagall

Bob Steagall

CppCon Poster Chair, KEWB Computing
I've been working in C++ since discovering the second edition of The C++ Programming Language in a college bookstore in 1992. 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... Read More →


Wednesday May 9, 2018 9:00am - 10:30am
Flug Auditorium

9:00am

Words of Wisdom
Collected words of wisdom on coding - not mine (I'm not wise enough), but those of others, such as Yoda, Shakespeare, Bruce Lee, and Sean Parent.

This talk will touch on Value Semantics, Strong Types, API design, and more.

Speakers
avatar for Tony Van Eerd

Tony Van Eerd

Senior C++ Guy, Christie Digital
Tony has been coding for well over 25 years, and coding well for hopefully some of that. He's worked at companies big (Adobe) and small (Inscriber) and currently writes software for projection mapping - making magic with light - at Christie Digital. He is a member of the C++ Standards... Read More →


Wednesday May 9, 2018 9:00am - 10:30am
Hudson Commons

10:30am

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

Wednesday May 9, 2018 10:30am - 11:00am
Aspen Center for Physics Patio

11:00am

Design And Implementation Of DBMS Asynchronous Client Library with C++17, Boost.Hana and Boost.Asio
How to communicate with a database and use a connection efficiently, make queries and get results in a type-safe manner? What is the design for a library which provides a convenient and efficient interface to interact with DBMS? What are customization points? Where are extensions required and what could they be? But don't forget about performance.

We'll talk about data transmissions, and the techniques providing typed requests and responses. How to implement queries with strongly typed arguments and no boilerplate. How to extend the library type system with custom types using convenient introspection mechanisms of Boost.Hana and Boost.Fusion and without code generation at all. What C++17 allows us to provide flexibility and strong type guarantee. Where are the limits of constexpr in this field. How to implement the library in an efficient asynchronous manner using Boost.Asio and Networking TS. We'll try to consider various asynchronous programming techniques and the ways to support them in a single interface. Finally, we will talk about the library design. How the concepts help us to provide an efficient mechanism with wide customization. Eventually, we'll look at how to test all of it by GUnit.

All of this is implemented in PostgreSQL client library named ozo. Ozo is production ready and supports the binary protocol, retries, transactions, streaming.

Speakers
avatar for Roman Siromakha

Roman Siromakha

Software Developer, Yandex
Roman graduated from Bauman Moscow Technical University as M.S. in Software Engineering. | He is a Software Developer at Yandex, making backend for web mail interface dealing with C++. | His hobby is to learn about AI by studying and participating in the Russian AI Cup competition... Read More →


Wednesday May 9, 2018 11:00am - 12:30pm
Hudson Commons

11:00am

Rethinking Pointers
"Do not use owning raw pointers, use a smart pointer instead." — And yet it is common to use them when writing a linked list, for example.

"Use a reference when a pointer is non-null." — But the standard library interfaces themselves don't follow this advice all the time.

We're at a point where a simple question "I need to point to some other object" requires a complicated lecture about raw vs. smart pointers, references and the danger of putting references inside angle brackets. Clearly we can do better.

Let's take a step back, and look at the bigger picture:
What are the common pointer-like types?
Which properties do they have in common, which are unique?
What are the possible situations that require pointer-like types?
Which properties do those situations require?

This talk will answer those questions and so provide the definitive guide to choosing the correct pointer types.
We'll be discussing whether or not `optional<T&>` or `std::observer_ptr` are necessary, talk about the difference in applications for `T&`, `gsl::non_null<T>` and `std::reference_wrapper<T>`, and look how the type system can help us catch lifetime issues.

Speakers
avatar for Jonathan Müller

Jonathan Müller

Student, RWTH Aachen University
Jonathan is a second-year Computer Science passionate about C++. In his spare time he works on various C++ open source projects, like foonathan/memory, an allocoator library, or standardese, a C++ documentation generator. He also blogs about C++ and library development at foonathan.net... Read More →


Wednesday May 9, 2018 11:00am - 12:30pm
Flug Auditorium

11:00am

You Can Do Better than std::unordered_map: New and Recent Improvements to Hash Table Performance
The hash table is probably the most important data structure. Because of that importance, there is a large zoo of possible implementations with design trade-offs. The standard hash table, std::unordered_map, traded off performance in order to get backwards compatibility with std::map. Which was probably a good choice, but it does leave us with a lot of hash tables that are slower than necessary, while also using more memory than necessary.

This talk is about replacements for std::unordered_map. How they work, why they are faster, and when you should choose which. Topics include linear probing with Robin Hood Hashing, Google's new trick of using SIMD instructions to look at 16 elements at a time, and optimizations for node based containers, because they can actually be really fast.

I will also talk about recent improvements to hash table performance. Little tricks that shave nanoseconds from table lookup times. In an environment that's already had decades worth of micro-optimizations, it's fascinating to watch as people come up with inventive new ways to keep pushing performance.

Speakers
avatar for Malte Skarupke

Malte Skarupke

Malte is an AI programmer at Avalanche Studios in New York. In his free time he likes to optimize algorithms. He blogs at www.probablydance.com


Wednesday May 9, 2018 11:00am - 12:30pm
Bethe

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 Tuesday morning's break. 

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, Jon Kalb, Consulting
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He is a director and the treasurer of the C++ Alliance.He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft... Read More →
avatar for Bryce Adelstein Lelbach

Bryce Adelstein Lelbach

NVIDIA
Bryce Adelstein Lelbach is a software engineer on the CUDA driver team at NVIDIA. Bryce is passionate about parallel programming. He maintains Thrust, the CUDA C++ core library. He is also one of the initial developers of the HPX C++ runtime system. He spent five years working on... Read More →

Wednesday May 9, 2018 12:30pm - 2:30pm
Bethe

12:30pm

Lunch Break
On your own.

No lunch truck this year. See this alternative.

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 9, 2018 12:30pm - 2:30pm
on your own

2:30pm

How Compilers Reason About Exceptions
The performance impact of exceptions in C++ has been a hotly debated topic for at least as long as I've been involved in C++. This talk will cover how modern compilers implement exceptions and focus on their effects on the optimizer. Attendees will leave with a greater understanding of the true cost of exceptions and why those costs exist.

Speakers
avatar for Michael Spencer

Michael Spencer

Compiler Engineer, Sony Interactive Entertainment
Michael Spencer is a Compiler Engineer at Sony Interactive Entertainment where he has spent 6 years works on PlayStation's C++ toolchain. He is an active member of the LLVM community focusing on object files and linkers. He also serves as Sony's representative to the ISO C++ standard... Read More →


Wednesday May 9, 2018 2:30pm - 4:00pm
Hudson Commons

2:30pm

Runtime Polymorphism: Back to the Basics
C++ solves the problem of runtime polymorphism in a very specific way. It does so through inheritance, by having all classes that will be used polymorphically inherit from the same base class, and then using a table of function pointers (the virtual table) to perform dynamic dispatch when a method is called. Polymorphic objects are then accessed through pointers to their base class, which encourages storing objects on the heap and accessing them via pointers. This is both inconvenient and inefficient when compared to traditional value semantics. As Sean Parent said: Inheritance is the base class of evil.

It turns out that this is only one of many possible designs, each of which has different tradeoffs and characteristics. This talk will explore the design space for runtime polymorphism in C++, and in particular will introduce a policy-based approach to solving the problem. We will see how this approach enables runtime polymorphism with stack-allocated storage, heap-allocated storage, shared storage, no storage at all (reference semantics), and more. We will also see how we can get fine-grained control over the dispatch mechanism to beat the performance of classic virtual tables in some cases. The examples will be based on a real implementation in the Dyno library [1], but the principles are independent from the library.

At the end of the talk, the audience will walk out with a clear understanding of the different ways of implementing runtime polymorphism, their tradeoffs, and with guidelines on when to use one implementation or another.

[1]: https://github.com/ldionne/dyno

Speakers
avatar for Louis Dionne

Louis Dionne

C++ Standard Library Engineer, Apple
Louis is a math and computer science enthusiast who got swallowed by the C++ monster when he was a naive, unsuspecting student. He now works for Apple, where he is responsible for libc++, the Standard Library shipped with LLVM/Clang. He is a member of the C++ Standards Committee and... Read More →


Wednesday May 9, 2018 2:30pm - 4:00pm
Flug Auditorium

2:30pm

Initializer Lists Are Broken, Let's Fix Them
C++11's initializer_list objects are flawed in ways that prevent them from being used in some contexts and used efficiently in other contexts. They allow you to create dangling references that most compilers and static analysis tools are unable to track. Specific examples, benchmarks, and quotes from the standard will illustrate these problems and how they are mandated. Will it be possible to address these issues with library changes or do we need to make a change to the standard? We will attempt to come to a consensus as a group.

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://cppbestpractices.com... Read More →


Wednesday May 9, 2018 2:30pm - 4:00pm
Bethe

4:00pm

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

Wednesday May 9, 2018 4:00pm - 4:30pm
Aspen Center for Physics Patio

4:30pm

Argot: Simplifying Variants, Tuples, and Futures
If you have worked with tuples, variants, and futures in C++, you may frequently find yourself frustrated with how complicated it can be to get seemingly simple things done, especially if coming from a language with more direct support for algebraic datatypes. Expanding tuples in anything but trivial ways requires being something of a language expert. Visiting variants can often be even worse. Forming chains of ".then" continuations (if you even have a ".then") can be a drag. These are supposed to be powerful, useful abstractions, yet they are often too complicated for most programmers.

The Argot library aims to solve some of these problems by acting as something like an <algorithm> or <utility> but for dealing with TupleLike, VariantLike, and now FutureLike concepts and the expansions of their underlying values into function arguments. Easily perform what would otherwise be complicated variant visitation. Expand tuples in more powerful ways than with std::apply. Form continuations with futures without explicitly writing complicated .then() chains. Do things that you may not have thought were possible.

This talk is on an updated and re-named version of a library from the C++ Standard proposal "A Single Generalization of std::invoke, std::apply, and std::visit" ( http://wg21.link/p0376 ). The library is planned to be added to the boost review queue sometime later this year.

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 Committee... Read More →


Wednesday May 9, 2018 4:30pm - 6:00pm
Hudson Commons

4:30pm

Option(al) Is Not a Failure
Error code returns were bad so we invented exceptions. Much better we said.
Then we realised exceptions had their problems - with whole domains outlawing their use altogether. We've been trying to patch them up how we can (with noexcept, for example) - but most of the problems are systemic.

So there's a return to error codes. But now we have new features in the language (arithmetic data types, including variant and optional) - and the promise of more coming (expected, outcome?) - that bring us closer to the best of both worlds, with almost none of the downsides. While the vocabulary types are important, we don't need to wait for them - and the more experience we gain with these approaches the better - especially as std::expected gets locked down, Boost.Outcome goes through final reviews.

But there's more. Where do error_code and error_condition fit in? What's all this about monadic binding? What about pattern matching? Do/ try syntax with a keyword? What do other languages that are further down this road do and what can we learn from them?

This talk will be a tour of the past, present, and possible future of C++ error handling, the trade-offs and rationale for each piece and a discussion of where to go next and what we can do as a community to get there.

Note that, while technical, this is Big Picture - with lots of jumping off points for other talks and materials that are deep dives on individual components and techniques.

Speakers
avatar for Phil Nash

Phil Nash

Developer Advocate, JetBrains
Phil is the author of the test frameworks, Catch - for C++ and Objective-C, and Swordfish for Swift. As Developer Advocate at JetBrains he's involved with CLion, AppCode and ReSharper C++. More generally he's an advocate for good testing practices, TDD and using the type system and... Read More →


Wednesday May 9, 2018 4:30pm - 6:00pm
Bethe

4:30pm

The Current State of Modules in C++
This talk will cover one of the Standard Committee's most anticipated new features: modules.

We'll start with the problems that modules is designed to address and the goals for the new feature and then cover the current status of the proposal.

In addition to efficiency and fast build times, the feature must address the architectural needs of very large codebases such as those found at companies like Bloomberg, Google, Facebook, A9, and Microsoft.

We'll discuss both the efficiency and architecture requirements in detail as well as providing insights into how the feature can meet these objectives and well as provide a migration path for existing code bases of every scale.

Speakers
avatar for John Lakos

John Lakos

Software Engineer, 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... Read More →


Wednesday May 9, 2018 4:30pm - 6:00pm
Flug Auditorium

6:30pm

Dinner Break
Suggested venues: L’Hosteria or Mi Chola or Hickory House

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.

The Hickory House offer for us is $5 off the regularly $23 full rack of ribs.

The Aspen Meadows Resort will have a limited-menu "popup" resturaunt during the dinner break in the Barksdale Lobby located in the Doerr Hosier Building.

Wednesday May 9, 2018 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 Consulting
Michael Caisse has been crafting code in C++ for 28-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 Project... Read More →

Wednesday May 9, 2018 8:30pm - 10:00pm
Flug Auditorium

10:00pm

Social Event: Informal Gathering
Join us in Barksdale Lobby for after session socializing.

The kitchen will be open for the room service menu until 11pm. The bar will be open until 1 am.

Wednesday May 9, 2018 10:00pm - Thursday May 10, 2018 1:00am
Aspen Meadows Resort 845 Meadows Rd, Aspen, CO 81611
 
Thursday, May 10
 

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 written... Read More →


Thursday May 10, 2018 8:00am - 8:55am
Flug Auditorium

9:00am

Easy to Use, Hard to Misuse: Declarative Style in C++
We say that interfaces should be easy to use and hard to misuse. But how do we
get there? In this talk I will demonstrate how using declarative techniques in
APIs, functions, and plain old "regular" code can help.

We'll look at what is meant by "declarative style" in C++; explore why
declarative interfaces are desirable and how to construct them; and take an
in-depth look at which features of C++ help us write in a declarative style.

I want to deconstruct C++ a bit, examine what we're doing and what makes the
good parts good, and from that reconstruct some best practices. Many of us are
already writing code following piecemeal modern advice such as "no raw loops",
or "almost always auto", or C++ core guideline recommendations. In many cases,
this advice translates to writing more declarative code; being deliberate about
exploring and using declarative techniques gives us insight we can apply more
widely.

Speakers
avatar for Ben Deane

Ben Deane

Ben was in the game industry for 23 years, at companies like EA and Blizzard. He's always looking for useful new techniques in C++, and he | geeks out on algorithms, APIs, types and functional programming.


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

9:00am

The Problem with "Cutting Edge C++"
Boost and its gathering in Aspen has always been the place for getting the newest and best C++. Or the tricks and cheats to make our ideas and dreams compile, so that programming C++ got a little easier. For the last 20 years, that has been the essence of boost, and it has been loved and hated for it. Lets also talk about the down sites of embracing the language like this.

Between '98 - '11, boost could innovate a lot in C++, it was what kept C++ interesting for many of us, keeping true to its spirit, while C++ the Standard was seemingly taking a break. Then with C++11 and its following standards it was the opposite: the good parts of boost became the standard, while hacks stayed behind in boost. As boost was and is build on some of these, once clever hacks. The hacks enabled boost to do things like variadic templates, before there was such a thing in the language. While these hacks were cutting edge in their days, now they've become the rusted blades.

So lets reflect on what it means to be cutting edge in C++, and how to make sure, that the cutting edge of today is not the rusted blade that cuts you tomorrow.

Speakers
avatar for Jens Weller

Jens Weller

CEO, Meetingcpp GmbH
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 main... Read More →


Thursday May 10, 2018 9:00am - 10:30am
Bethe

9:00am

yomm2: Fast, Orthogonal, Open Methods in a Library
Have you ever felt your life would be simpler if you could just add virtual functions to a class hierarchy whenever you needed to (e.g., to persist an object or render it in JSON), but refrained because you did not own the classes and it would violate the principle of separation of concerns? Have you toiled on a Visitor class once again? Did you struggle to get double dispatch right because you needed to implement binary operations for polymorphic classes?

Open methods solve all these problems, while requiring you to write much less code -- and they deliver superior performance.

Open methods are virtual functions that are defined outside of a class. Given a method declaration and a set of specializations, the most specific version is selected depending on the dynamic type of one or more arguments. Open methods make it possible to add polymorphic behavior to existing hierarchies of classes, without needing to modify them. They provide a superior alternative to the Visitor pattern and a solution to the problem of cross-cutting concerns. Since more than one argument can participate in the selection of the specialization, open methods also solve the binary (or multiple) dispatch problem.

yomm2 implements open methods in a library. Unlike its predecessor yomm11, it does not require instrumentation of the classes involved in method dispatch, yet calling a method with one virtual argument is almost as fast as calling the equivalent virtual member function.

yomm2 is available on GitHub (https://github.com/jll63/yomm2)

Speakers
avatar for Jean-Louis Leroy

Jean-Louis Leroy

Senior Software Engineer, Bloomberg LP
I am the author of yomm2, a library that implements open multi-methods. See https://github.com/jll63/yomm2


Thursday May 10, 2018 9:00am - 10:30am
Hudson Commons

10:30am

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

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

11:00am

-Os Matters
At VMware we include binary size deltas in code reviews for large, C++,
user-space, applications. You might be thinking "that's the most pointy haired
thing I've every heard of!". Come to this talk and learn how this simple
metric provides surprisingly strong counter pressure to complexity.

Speakers
avatar for Mark Zeren

Mark Zeren

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


Thursday May 10, 2018 11:00am - 11:45am
Hudson Commons

11:00am

A View to a View
C++17 brings views to C++, a new lifetime concept that comes with its own brand new pitfalls and headaches. When more views are introduced the complexity behind them seems to go out of control. In well-designed software however, views are the fundamental building block that enables new levels of performance, cleaner abstractions and more readable code. This talk will inspect and answer the complications arising when designing, implementing and using views; both those that are in the standard library and user-specific views.

Speakers
avatar for Peter Bindels

Peter Bindels

Principal Software Engineer, TomTom
Peter is a C++ developer known for writing HippoMocks and cpp-dependencies, and less well known for encouraging C++ both for beginners and for uncommon target areas (OS development, embedded, server-side). He likes to rethink the basics of what we take for granted to see if new ideas... Read More →


Thursday May 10, 2018 11:00am - 11:45am
Flug Auditorium

11:00am

From Parsing to sema: Making Sense of Syntax Trees
So you are writing a compiler, or an interpreter, or something else that uses a language that has to be analyzed, and you've managed to write a correct parser for your syntax, whichever way you chose to do that. Now what? When I've previously stumbled upon this question, when writing such code myself, I didn't really know the answer. I just started poking around the problem until I got something that worked. I've tried some ways that I hated, and I tried some ways that I ended up going with. This talk will take you on a journey that follows the approaches I tried, including some failures and some success stories, and while they aren't very numerous, I believe that looking at the challenges through the eyes of somebody else will help you when you're faced with similar design decisions yourself.

This talk is by no means meant to be a comprehensive guide to writing analyzers; it's meant to explain how I approached the challenge of making sense of a syntax tree, it's meant to be fun, and I also hope to learn from your experience in this field.

Speakers
avatar for Michał Dominiak

Michał Dominiak

System Software Engineer, Nvidia
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 →


Thursday May 10, 2018 11:00am - 12:30pm
Bethe

11:50am

Debug C++ Without Running
Macros, templates, compile-time evaluation and code generation, reflection and metaclasses – C++ tends to hide the final code passed to the compiler under the tons of various names and aliases. Add here the preprocessor that shadows the actual running curve of your program with dozens of alternatives mixed in a non-trivial way. While this allows to avoid boilerplate code and reduce copy-paste and other errors, such an approach demands better tooling support to make the debugging process easier.

To find an error in such a code, one has to continuously read-fix-run it and compare the results with some etalon, or to debug in order to find actual substitutions. But should you really wait until your code is run or even compiled to debug it? Or how to deal with the situations when the code can’t be run on the local machine? A text editor with code completion won’t help, while a smart IDE that “gets” your code can do a better job.

In this talk we’ll see interesting approaches to solving cases like macro and typedef ‘debug’, understanding types when auto/decltype hide them, dealing with different code branches depending on the preprocessor’s pass-through, and other ideas. Some suggestions are already implemented as ready-to-use features in CLion and ReSharper C++, tools for C++ from JetBrains (that means I can show it in action), others are planned for the future. The aim of this talk is to share the workflows supported by the tools that can help C++ developers create better modern C++ code.

Speakers
avatar for Anastasiia Kazakova

Anastasiia Kazakova

PMM, JetBrains
As a C and C++ software developer, Anastasia Kazakova created real-time *nix-based systems and pushed them to production for 8 years. She has a passion for networking algorithms and embedded programming and believes in good tooling. With all her love for C++, she is now the Product... Read More →


Thursday May 10, 2018 11:50am - 12:35pm
Flug Auditorium

11:50am

Making Your Library More Reliable with Fuzzing
Fuzzing is a technique to find bugs in your library by using it in ways that you have not imagined.
Originally, fuzzing was limited to throwing random input at your library's entry points, and looking for crashes, but today's fuzzers are much more sophisticated.

After a brief description of what fuzzing is and is not, I will talk about various fuzzing options and tools, and then finish with results of fuzzing both libc++ and Boost.Algorithm.

Speakers
avatar for Marshall Clow

Marshall Clow

Marshall has been programming professionally for 35 years. He 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++ standard... Read More →


Thursday May 10, 2018 11:50am - 12:35pm
Hudson Commons

12:30pm

Lunch Break
On your own.

No lunch truck this year. See this alternative.

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 10, 2018 12:30pm - 2:30pm
on your own

2:30pm

Modern C++ in Embedded Systems
For nearly 35 years I have been working with small processors and there has always been deep divides between practitioners of languages. When writing assembly we ridiculed those using C and when I spent years microcoding we scoffed at everyone. However, nearly all groups continue to wag their heads at the shameful C++ programmers attempting to twist their tools toward the small.

Recent language developments have made C++ the obvious choice for many embedded projects; nevertheless, the toxic environment extends past reddit roasts into poor vendor support of tools and nearly obstructionist chip manufacturers.

This session will use a bare-metal project started in 2018 for a Ciere client as a case study while we work through the decision process for using C++, the acrobatics required to support the language, recent language features that enable goals of size, speed, and expressiveness, and useful libraries.

While the examples will be based on a concrete project, the extracted lessons-learned should be applicable to many embedded projects (bare-metal and small-OS). Attendees will walk away with motivations to use C++ in embedded projects, hints and tips to making tools work, and a sampling of language features and idioms that improve the quality of a final product.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere Consulting
Michael Caisse has been crafting code in C++ for 28-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 Project... Read More →


Thursday May 10, 2018 2:30pm - 4:00pm
Flug Auditorium

2:30pm

My Little *this Deduction: Friendship is ... Uniform?
This is a talk about a will-have-been-proposed-by-c++now new feature. Here's your standardese buzzword-bingo board (not all cells are covered by this talk, make sure to keep track!):

[uniform call syntax] [recursive lambdas] [const-ref-volatile method templates]
[simplifies language] [move from lambda] [no new keywords]
[executors] [curiously recurring template pattern] [call-by-value methods]

OK, so, here goes:

This lecture is about a small idea by Ben Deane at CppCon 2017. The idea was to make lambdas' call operator aware of whether it was an rvalue or lvalue. The simplest solution was suuuuuper simple (no spoilers though). However, as is customary with anything Ben & Jason touch, it solved ALL THE THINGS! Well, almost. Bear with me.

All this time, Ben Deane, Berry Revzin, Simon Brand, and Gašper Ažman have been working diligently to bring you the following:

- Ever wanted to write a recursive lambda? It's obvious how to, now. Still converts to function pointer. No new keywords.
- Have you ever been peeved about writing a const, &, and a && value accessor? Now it's one template. Same syntax as above.
- Did you ever want to return the derived type from a method, as opposed to the base class type? It's the same template. boost::operator without CRTP!
- Did you ever wonder whether it's size(thing) or thing.size()? No more. Uniform Call Syntax is opt in, works, and ABI compatible. And with no breakage! And no new keywords!
- [captured=std::move(foo)] {
return std::move(captured); /* can I move? Should I copy? Am *I* an rvalue? Now you can know! */
}
- Oh, and this feature makes the language more uniform, not less. We're getting rid of the specialness of methods. You still can't define them elsewhere though. Unless *maybe*! If you care, come to the talk! (Or to a committee meeting, I guess.)
- And Uniform Call Syntax can bind to the *second* (or third...) parameter, if called as method: foo.find(in) or find(in, foo) can be the same function!
- Why Uniform Call Syntax failed before, and why it won't (ok, has a lesser chance to) fail now.
- How about methods that take *this by value?
- And, of course, the Magic of Friendship!

This talk is about how the development of the feature went, what was thrown out, what was defended, where it is now, and about how it will be - hopefully with audience participation. It's all our language, after all!

Speakers
avatar for Gašper Ažman

Gašper Ažman

SDE R&D, Citadel Securities


Thursday May 10, 2018 2:30pm - 4:00pm
Hudson Commons

2:30pm

Secure Coding Best Practices: Your First Line Is The Last Line Of Defense
Computer systems are under siege 24 hours a day, day in and day out. The critical security infrastructure designed to protect those systems, won't:

* Perimeter security won't protect you.
* Network analytics won't protect you.
* Virus scanners won't protect you.
* Even the users who should know better than to click on that too-good-to-be-true offer won't protect you.

The other side has the best security hardware and software systems other people's money can buy and they have all the time in the world to find creative ways to defeat them. Meltdown and Spectre are prime examples security vulnerabilities that have lurked dormant for decades. Or have they? If your systems are in any way connected to the outside world, the other side will get inside the wire on you. Know that going in.

Whether you write applications, libraries or work in kernel code, the line of code you write today may very well be the vulnerability someone else finds tomorrow. By nature every code base contains hundreds of attack surfaces and it only takes one serious vulnerability to compromise your system.

But what exactly is an attack surface?

While Modern C++ is designed to be secure, the ways we use it often aren't. And with each vulnerability comes new questions:

* Is it serious?
* If I fix it, do I take a performance hit?
* How do I write efficient, scalable code that's also secure?
* How do I know which vulnerabilities will compromise my system and which ones are a low enough risk?

Yes, there are trade-offs. We make them every day and security is no different. In this talk, we'll look at the ways our software often fails. We'll walk through code samples to uncover their silent vulnerabilities and show how to correct them. And we'll discuss what trade-offs we can make to balance security vs. performance. Finally, we'll look at ways to deal with those threats starting at design time, baking security directly into the code from the very first line.

The critical security infrastructure designed to protect your systems is largely out of your control. The one thing you can control is the next line of code you write. This talk is for anyone that uses C++ or Modern C++ for kernel, applications or libraries that run in the real-world and that face real-world attacks.

In today's world, that's all of us.

Speakers
avatar for Matthew Butler

Matthew Butler

Matthew Butler has spent the last three decades as a systems architect and software engineer developing systems for network security, law enforcement and the military. He primarily works in signals intelligence using C, C++ and Modern C++ to build systems running on hardware platforms... Read More →


Thursday May 10, 2018 2:30pm - 4:00pm
Bethe

4:00pm

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

Thursday May 10, 2018 4:00pm - 4:30pm
Aspen Center for Physics Patio

4:30pm

C++ Development with Visual Studio Code
Free, open-source and runs everywhere.

If you’re looking for a fast and lightweight code editor, Visual Studio Code has you covered. Come get an overview of Visual Studio Code along with the C++ extension that enables editing, building, and debugging your C++ code across Windows, Mac, and Linux.

Speakers
avatar for Rong Lu

Rong Lu

Principal Program Manager, Microsoft
Rong Lu is a Program Manager in the Visual C++ team at Microsoft. She has been working on the Visual Studio team for the past 10 years since she graduated with her master degree in computer science. She is currently working on Visual Studio tools for game development, Visual C++ tools... Read More →


Thursday May 10, 2018 4:30pm - 6:00pm
Bethe

4:30pm

Compile Fast, Run Faster, Scale Forever: A Look into the sol2 Lua Library
Using another language inside your C++ program never comes easily, even if its a scripting language. Specifically, the Lua language's C API is very explicit and fast but stack management and API quirks often make scaling up a problem without significant man-hours, and often result in suboptimal wrappers written to serve the current needs and deadlines without thought to clean interface or later optimization.

sol2 is a new approach to wrapping the Lua C API. We consider first how to create a pleasant experience similar to the Lua language itself, creating airtight abstractions around core concepts to maximize initial intuitive understanding of our wrapper. We then introduce library-specific concepts with tutorials and documentation to allow the user to make progress quickly. Finally, we provide several facilities for overriding the default wrapper behavior to allow for custom handling, letting the user scale the wrapper alongside their needs.

In this session, we will discuss API extension points, C API wrapping techniques, Lua C API (ab)use, runtime performance characteristics, and compile-time reduction strategies. Friendly discussion throughout the demo and presentation is encouraged!

Speakers
avatar for JeanHeyd Meneide

JeanHeyd Meneide

Student, Columbia Unviersity
JeanHeyd "ThePhD" is a student at Columbia University in New York. Most of his programming is for fun and as a hobby, even if his largest open-source contribution -- sol2 -- is used across many industries. He is currently working towards earning his own nickname, climbing the academic... Read More →


Thursday May 10, 2018 4:30pm - 6:00pm
Hudson Commons

4:30pm

Modern C++ API Design: From Rvalue-References to Type Design
The old rules for C++API design are due for an update - we made ad hoc changes to design principles in the standard library, but haven’t really written down the new ideas. Parameter passing and API design for free functions/member functions is due for a general update, particularly as a result of rvalue-references and reference qualification. How do we express “maybe move” APIs? When do we want reference-qualified overload sets? What does an rvalue-reference qualified non-overloaded method mean? How do we express call once semantics?

For types, our consistency in producing Regular types has weakened in recent C++ releases with types like unique_ptr (move-only) and string_view (reference semantics). These classes of design that have shown themselves to be valuable, but certainly surprising at first. As we should not continue to extend the set of type designs arbitrarily, this is a good time to look at type design in the modern C++ era and narrow down the set of designs that are generally favored. This talk will focus on modern C++ design from small (choice of passing by value or reference) to large (Regular types, reference types, move-only types, etc). We will also introduce a taxonomy of type properties as a means to discuss known-good type design families.

Speakers
avatar for Titus Winters

Titus Winters

C++ Codebase Cultivator, Google
Titus Winters has spent the past 6 years working on Google's core C++ libraries. He's particularly interested in issues of large scale software engineer and codebase maintenance: how do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? Along... Read More →


Thursday May 10, 2018 4:30pm - 6:00pm
Flug Auditorium
  • Level Intermediate, Advanced
  • Tags types

6:00pm

Dinner Break
Suggested venues: L’Hosteria or Mi Chola or Hickory House

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.

The Hickory House offer for us is $5 off the regularly $23 full rack of ribs.

The Aspen Meadows Resort will have a limited-menu "popup" resturaunt during the dinner break in the Barksdale Lobby located in the Doerr Hosier Building.

Thursday May 10, 2018 6:00pm - 8:30pm
on your own

8:30pm

C++Now 2019 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, Jon Kalb, Consulting
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He is a director and the treasurer of the C++ Alliance.He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft... Read More →
avatar for Bryce Adelstein Lelbach

Bryce Adelstein Lelbach

NVIDIA
Bryce Adelstein Lelbach is a software engineer on the CUDA driver team at NVIDIA. Bryce is passionate about parallel programming. He maintains Thrust, the CUDA C++ core library. He is also one of the initial developers of the HPX C++ runtime system. He spent five years working on... Read More →

Thursday May 10, 2018 8:30pm - 10:00pm
Flug Auditorium

10:00pm

Social Event: Informal Gathering
Join us in Barksdale Lobby for after session socializing.

The kitchen will be open for the room service menu until 11pm. The bar will be open until 1 am.

Thursday May 10, 2018 10:00pm - Friday May 11, 2018 1:00am
Aspen Meadows Resort 845 Meadows Rd, Aspen, CO 81611
 
Friday, May 11
 

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 written... Read More →


Friday May 11, 2018 8:00am - 8:55am
Paepcke Auditorium

9:00am

Closing Keynote: Undefined Behavior and Compiler Optimizations
This talk is about the inner lives of compiler optimizations. First, I'll explain how undefined behavior (UB) is alive and well in compiler intermediate representations, where it can be exploited to give the optimizer the freedom to perform desirable transformations. Perhaps surprisingly, UB at this level doesn't have that much to do with UB in the original source code.

Second -- and closely related -- I'll talk about sequential memory models. C++ occupies a tricky design point: on one hand, it wants to be able to assume that a pointer originating in one block of memory cannot be used to refer to another block, but on the other hand any pointer can be turned into an integer, manipulated arbitrarily, and then turned back into a pointer. These conflicting demands have interesting implications for a compiler's optimization rules and some of the implications are still being figured out.

Finally, I'll speculate about the future of compiler optimizations: many optimizations will be formally verified and some will also be generated automatically. The result will be compilers that are less buggy and more effective at optimizing.

Speakers
avatar for John Regehr

John Regehr

Professor, University of Utah
John Regehr is a professor of computer science at the University of Utah, USA. His research group creates tools for making software more efficient and correct. For example, one of his projects, Csmith, generates random C programs that have been used to find more than 500 previously unknown bugs in production-quality C compilers. | | Outside of work John likes to explore the mountains and deserts of Utah with his family... Read More →


Friday May 11, 2018 9:00am - 10:30am
Paepcke Auditorium

10:30am

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

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

11:00am

Closing Panel: What Belongs in the C++ Standard Library
TBA

Moderators
avatar for Bryce Adelstein Lelbach

Bryce Adelstein Lelbach

NVIDIA
Bryce Adelstein Lelbach is a software engineer on the CUDA driver team at NVIDIA. Bryce is passionate about parallel programming. He maintains Thrust, the CUDA C++ core library. He is also one of the initial developers of the HPX C++ runtime system. He spent five years working on... Read More →

Friday May 11, 2018 11:00am - 12:00pm
Paepcke Auditorium

12:00pm

Lunch Break
On your own.

No lunch truck this year. See this alternative.

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 11, 2018 12:00pm - 1:45pm
on your own

1:45pm

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

Speakers
avatar for Steering Committee and C++Now Committee Chairs

Steering Committee and C++Now Committee Chairs

The Boost Steering Committee is currently comprised of:Boris KolpackovDavid SankelHartmut KaiserJon Kalb, chairLisa LippincottLouis DionneMatt CalabreseMichael CaissePeter DimovSebastian RedlThe Boost Steering Committee Home Page... Read More →
avatar for Jon Kalb

Jon Kalb

Conference Chair, Jon Kalb, Consulting
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He is a director and the treasurer of the C++ Alliance.He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft... Read More →


Friday May 11, 2018 1:45pm - 2:45pm
Paepcke Auditorium