C++Now 2015

Suggested Venue: 

Battle.net is the online service that runs Blizzard's games. As such, it is a large scale distributed system with many interacting parts and dependencies on various services and data. While developing Battle.net servers, I needed a way to isolate and test functionality that I was working on.

In this talk I will cover my experience designing for testability of components in a distributed system, and practical ways to structure classes and data to facilitate testing. I will also present my solution to the problem of testing my code for correctness, performance and scalability without having to deploy a full-scale environment and spin up a million clients.

Slides 

C++14 has many ways of naming a type. In addition to using the type's name directly, we have auto, auto &, auto const &, auto &&, decltype(auto), and decltype(some-expression). In C++11, these methods of type deduction only applied to variable declarations, but C++14 adds return type deduction for normal functions.

When should we use this powerful feature, and when should we be more explicit with our types? What new types of libraries do these features allow, and what are the risks?

We will talk about how to design a modern C++ library that takes advantage of type deduction without harming readability.

Slides 

ODP File

I'm excited about constexpr. It's probably my favorite C++11 feature, and it has become even better with C++14. But when I talk to other developers about constexpr they seem puzzled. What sorts of useful computations can the compiler possibly do before runtime?

I'd like to take this session to explore some of the capabilities that constexpr brings to the table. We'll be looking at compile-time parsing, floating-point computations, containers, and maybe even explore what it would take to make a compile-time std::string. We'll also look at a possible way to work around one of constexpr's limitations.

Slides 

Suggested Venue: 

Hickory House or White House Tavern 

Boost’s original mission was to save C++ from extinction in the face of Java, C# et.al. by providing high quality enhancements to the C++ standard library. I argue that this mission has been accomplished, so that Boost needs a updated new mission. I will propose such a mission to motivate the continuing evolution of Boost and C++ over the next 10 years.  This will be to:

• Facilitate creation of quality C++ libraries by and for a wider audience
• Demonstrate standards and promote practices which result in quality code.

An evolution of mission will require changes Boost’s practices.  I will present specific proposals encompassing the following:

• Reviews and review management
• Library deployment and deprecation
• Testing
• Economic support for library development

By proposing specific mission and evolution of practices, I hope to provide a framework around which alternatives can be proposed and debated in the best of Boost tradition. Some other presentations at this conference touch on related themes.  I will invite presenters to refer to these topics in their own presentation and for other interested parties to make their own proposals in the “lightening talks” sessions later in the week. The goal is that by the last session - “The Future of Boost” we might have some consensus on where to take Boost in the coming decade.

Link to slides 

Designing your application to be portable, even if you never intend to go beyond one platform, will lead to cleaner more stable code. We will cover how considering portability will improve your code base; and address the practical considerations you should make to ensure portability if you need it in the future.

Slides 

Boost.Compute is a library for GPU/parallel-computing. It provides a high-level, STL-like API and is portable to a wide variety of parallel accelerators including GPUs, FPGAs, and multi-core CPUs. This talk will give an overview of the library and demonstrate how to write and execute high-performance C++ applications on modern GPU hardware.

Slides 

Have you heard about template metaprogramming? Have you seen how you can use it to calculate factorials at compile time? Have you thought to yourself that this sounds completely useless?

In this tutorial I present a small but real-world application of template metaprogramming. I show switchAny, a tool to dispatch to different code pieces based on the type contained in a Boost.Any holder. I demonstrate a number of TMP techniques used to develop this tool, including new techniques possible only in C++14 and C++1z.

Link to github repo 

At CppCon 2014 I gave a lightning talk trying to convince the audience that C++ needed a package manager. As it turned out, no convincing was necessary. I was also surprised by the number of people who told me after the presentation how desperately they needed this. In particular, it made me realize that this is not only a problem for a relatively few cross-platform library developers but also for organizations that struggle to manage their build configurations on a single platform using one C++ compiler.

Once you start thinking about a cross-platform C++ package manager, it won't be long before you realize that you also need a cross-platform build system to match. And when it comes to the existing tools, things don't look very promising. The more I thought about this the clearer it became that in order to create a C++ package manager we will first need to solve the build system problem.

So in this talk I would like to present the design of the new C++ build system I am working on and show lots of examples. As it is still work in progress, I am looking to get feedback and hear your ideas as much as to show what I have done so far. The discussion and choice of a build system can often have a religious aspect to it. But we are not going to hide from that. So if you don't think we need yet another build system, come and convince us why the whole thing is a bad idea.

Slides 

Suggested Venue: 

Mezzaluna or Campo de Fiori (both 25% off specials) 

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

Slides and Links:

MessagePack(msgpack): A Compact and Fast Serialization Library

Fun with with

Clang on SOC

Surviving and Thriving in a Multiplatform, Multilanguage, Multiproduct, Multisite Continuous Integration Environment

Sequences from Streams

Multimethod as dynamic C++ overloading.

Currying and other Functional Constructs in C++

General Relativity Applied to Coding Styles

When APIs Break, What Can You Do

Constexpr Include Joke

for_each_arg

make_unique and Restricted Constructors ||| Keynote File

Access Tuple by Runtime Index

 

This session provides best practices for building secure and robust applications with modern C++ language features and toolchains. The emphasis is on integration of new language features such as strong enums, static assert, type inferencing, error codes, ... along with significant improvements in the toolchains such as improved static analysis the run-time address, thread, and undefined behavior sanitizers. We also discuss best practices for compiling and linking to harden the resulting libraries and executables including stack and heap protection, read-only stack, and use of fortified variant of the standard libraries.

The goal is to bring together a range of best practices into a single session and show how they can be integrated. There are a number of interesting build issues for maximizing productivity while maintain high security and robustness.



gleaned from several years of building retail point of sale applications.

When designing a class, what do you make a member function, x.f(), and what do you make a free function, f(x)? When extending an already existing class, do you provide extra functionality with inheritance, composition, or adding new free functions? Do friend functions really violate encapsulation?

This presentation will cover techniques that not only allow safe and efficient interfaces, but also simplify your code. We will combine ideas from generic programming and object-oriented programming to achieve these goals. This talk will start with the basics of good engineering principles and build up from these to explain how to write scalable software. By taking a thoughtful approach to what should be a member function and what should be a free function, you can reduce code duplication and code size, thereby reducing the surface area for bugs.

Slides 

An "interesting" lock-free queue? Well, "multi-producer, multi-consumer, growing, shrinking, mostly contiguous, lock-free circular queue" was a bit long. Maybe "complicated" is a better word.

The "towards" is a hint that we won't complete the queue in 90 minutes. But we can make progress, and along the way encounter (and hopefully solve) many of the typical problems found in lock-free programming, and delve into the pros and cons of various solutions to those problems.

Slides 

Library in a week 2015 will attempt to build a C++ application configuration library.  The simplest of programs require options, but modern C++ applications often have tens if not hundreds of configuration options that users can specify.  These options can be specified in a myriad of ways - command line parameters, configuration files of various forms (xml, json, ini), environment settings, and other platform specific options. Each option setting needs string to c++ type conversion, default values, validation checked, error messages provided, and documented for users.  In addition, it's typical that options can be specified in multiple locations - command line and configuration files -- so options from multiple sources need to be prioritized and merged. 

What is seemingly a simple problem can suddenly spiral into a large amount of code - often poorly organized and only vaguely related to the application at hand.  And that code often provides one of the primary interfaces of the application to users. What we'd really like is a library that provides a succinct way for the programmer to define and organize options with a minimum amount of custom code. Ideally an all header library that supports modern C++ and modern configuration formats like JSON.

Of course for many years boost has had libraries to help. Program options being the primary library targeted at the domain.  
http://www.boost.org/doc/libs/1_58_0/doc/html/program_options.html

Another is property tree 
http://www.boost.org/doc/libs/1_58_0/doc/html/property_tree.html

Unfortunately neither library covers all the ground by itself.  So maybe all we need is to modernize and mashup property tree and program options? Or modernize and add to one or the other. Or maybe there's something more needed -- that's what the workshop will explore.

The workshop will work like this.  On day 1 I will provide motivation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library.  Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.

Collaboration Tools: 

Library in a week 2015 will use a git repository for collaboration and sharing
of information.

git clone https://github.com/JeffGarland/liaw2015.git

Also the group will use an email list for discussions beyond face to face meetings.
 
Level: Beginner to Expert 

Attendees should have a basic background in C++.

C++98 had the Rule of Three (or was it Four?). C++11 has the Rule of Five — or Six, if you count the default constructor — or Seven, if you count swap(). Should swap() be a member function? When is a default constructor absolutely mandatory? When is noexcept required for good performance? Should our classes support self-assignment and self-move? When is =default different from empty braces? We'll present reasonable answers to these questions and more.

Slides 

Most people think metaprogramming is hard. It isn't; we just didn't have the right tools for it. This talk will present a new way of metaprogramming using the same syntax as that of normal C++. It will show how the runtime and the compile-time boundaries can be crossed almost seamlessly. It will show how compilation times can be reduced without sacrificing expressiveness. It will introduce a new toolbox[1] for metaprogramming using cutting edge features of the language.

A paradigm shift that will fundamentally change C++ metaprogramming is about to begin. Be there!

[1]: http://github.com/ldionne/hana

Despite all of the recent interest, concurrency in standard C++ is still barely in its infancy. This talk uses the primitives supplied by C++14 to build a simple, reference, implementation of a task system. The goal is to learn to write software that doesn’t wait.

Link to Papers and Presentations by author

Experimental future
 

C++17 will bring most efficient, most scalable, most open/customizable coroutines of any programming language in existence. Stackless Resumable Functions are the proposed for standardization lightweight coroutines that scale to billions of concurrent coroutines, allow to consume existing any asynchronous OS APIs / libraries with zero-overhead adapters and allow library designers go wild, invent new coroutine types and plug them into Resumable Stackless Functions machinery.

We will look at examples of tasks, goroutines, generators running on top of resumable functions. We will explore implementation details of how they actually work and look at the customization machinery that allows library designers and ordinary users to extend coroutines as needed.

Slides 

Suggested Venue:

Little Annie’s or Little Ollie’s
 

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