C++Now 2018: Full Schedule

11:00am MDT

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

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 MDT
Flug Auditorium

presentation

Level Intermediate, Advanced, Expert
Tags generic programming, library design, metaprogramming, mixin

2:30pm MDT

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

Arthur O'Dwyer

C++ Trainer

Arthur O'Dwyer is the author of "Mastering the C++17 STL" (Packt 2017) and of professional training courses such as "Intro to C++," "Classic STL: Algorithms, Containers, Iterators," and "The STL From Scratch." (Ask me about training your new hires!) Arthur is occasionally active on... Read More →

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

presentation

Level Beginner, Intermediate, Advanced, Expert
Tags allocators, fancy pointers, philosophy, value semantics

4:30pm MDT

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

David Sankel

Principal Architect, Adobe

David Sankel is a Principal Scientist at Adobe and an active member of the C++ Standardization Committee. His experience spans microservice architectures, CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent... Read More →

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

presentation

Level Intermediate, Advanced, Expert
Tags allocators, large-scale development, pmr

8:30pm MDT

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

Michael Caisse

Ciere, Inc.

Michael Caisse started using C++ with embedded systems over 30 years ago. He continues to be passionate about combining his degree in Electrical Engineering with elegant software solutions and is always excited to share his discoveries with others.Michael works for Ciere Consulting... Read More →

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

lightning talks

Tags lightning talks

8:00am MDT

Library in a Week

Library in a week 2017

Speakers

Jeff Garland

CrystalClear Software

Jeff Garland has worked on many large-scale, distributed software projects over the past 30+ 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 MDT
Flug Auditorium

library in a Week

9:00am MDT

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

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 MDT
Flug Auditorium

presentation

Level Intermediate, Advanced, Expert
Tags allocators, containers, fancy pointers

11:00am MDT

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

Mateusz Pusz

Principal Engineer | C++ Trainer, Epam Systems | Train IT

A software architect, principal engineer, and security champion with over 20 years of experience designing, writing, and maintaining C++ code for fun and living. A trainer with over 10 years of C++ teaching experience, consultant, conference speaker, and evangelist. His main areas... Read More →

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

tutorial

Level Beginner, Intermediate, Advanced
Tags build systems, cmake, conan, installing, libraries, packaging

11:50am MDT

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

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 MDT
Flug Auditorium

tutorial

Level Beginner, Intermediate
Tags build system, cross compiling

2:30pm MDT

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

Vittorio Romeo

Software Engineer, Bloomberg

Vittorio Romeo (B.Sc. Computer Science) has been a Software Engineer at Bloomberg for more than 3 years, working on mission-critical company C++ infrastructure and providing Modern C++ training to hundreds of fellow employees.He began programming around the age of 8 and quickly became... Read More →

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

presentation

Level Advanced, Expert
Tags c++17, experimental, library development, metaprogramming, performance, template

4:30pm MDT

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

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 MDT
Flug Auditorium

tutorial

Level Beginner, Intermediate, Advanced, Expert
Tags containers, efficiency, emplace, move, optimization, performance, unions, variants

8:00am MDT

Library in a Week

Library in a week 2017

Speakers

Jeff Garland

CrystalClear Software

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

library in a Week

9:00am MDT

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

Bob Steagall

CppCon Poster Chair, KEWB Computing

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

presentation

Level Intermediate, Advanced
Tags allocators, containers, pointers

11:00am MDT

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

Jonathan Müller

Student, RWTH Aachen University

Jonathan is a Computer Science graduate currently studying Physics. In his spare time he works on various C++ open source libraries for memory allocation, cache-friendly containers or parsing. He also blogs about C++ and library development at foonathan.net.

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

presentation

Level Intermediate, Advanced, Expert
Tags guidelines, pointers, type safety

2:30pm MDT

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

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 MDT
Flug Auditorium

presentation

Level Intermediate, Advanced, Expert
Tags concepts, object model, polymorphism, type erasure

4:30pm MDT

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

John Lakos

Software Engineer, Bloomberg

John Lakos, author of Large-Scale C++ Software Design [Addison-Wesley, 1996], serves at Bloomberg LP in New York City as a senior architect and mentor for C++ software development worldwide. He is also an active voting member of the C++ Standards Committee’s Evolution Working... Read More →

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

presentation

Level Intermediate, Advanced, Expert
Tags architecture, compilation, features, language, optimization, standard

8:30pm MDT

Lightning Talks

Moderators

Michael Caisse

Ciere, Inc.

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

lightning talks

Tags lightning talks

8:00am MDT

Library in a Week

Library in a week 2017

Speakers

Jeff Garland

CrystalClear Software

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

library in a Week

9:00am MDT

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

Ben Deane

Quantlab

Ben was in the game industry for 23 years, at companies like EA and Blizzard. For the last couple of years he's been working in the finance industry at Quantlab. He's always looking for useful new techniques in C++, and he geeks out on algorithms, APIs, types and functional progr... Read More →

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

presentation

Level Beginner, Intermediate, Advanced, Expert
Tags Deane, declarative style, expressive code, interfaces

11:00am MDT

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

Peter Bindels

Software Engineer, TomTom

Peter is a dedicated software engineer that is eager to show the world how to use C++ and good design to write fast, efficient and reliable software.

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

presentation

Level Beginner, Intermediate, Advanced
Tags abstraction, lifetimes, ownership, parsing, python, range, view

11:50am MDT

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

Anastasia Kazakova

PMM, Marketing Lead, 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 worked as an intern in Microsoft Research, Networking department, outsourced in Telecom, and launched the 4G network. She has a passion for networking... Read More →

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

presentation

Level Intermediate, Advanced
Tags code comprehension, debugging, modern C++, tools

2:30pm MDT

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

Michael Caisse

Ciere, Inc.

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

presentation

Level Beginner, Intermediate, Advanced
Tags bare metal, embedded

4:30pm MDT

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

Titus Winters

C++ Library Lead, 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 MDT
Flug Auditorium

presentation

Level Intermediate, Advanced
Tags types

8:30pm MDT

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

Jon Kalb

Conference Chair, Jon Kalb, Consulting

Jon Kalb is using his decades of software engineering experience and knowledge about C++ to make other people better software engineers. He trains experienced software engineers to be better programmers. He presents at and helps run technical conferences and local user groups.He is... Read More →

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 MDT
Flug Auditorium

business

Tags business