CppCon 2015 Program Highlights, 4 of N

The CppCon 2015 conference program has been posted for the upcoming September conference. We’ve received requests that the program continue to be posted in “bite-sized” posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.

 

The C++ possess another language inside it: the template language. It is useful for a lot of things, from writting less code to compile time computations or checks, but can lengthen compile time too. To master it is not easy.

The following interrelated CppCon 2015 talks tackle these issues and more (part 2).

In this post:

  • Compile-time tools supporting generic programming in C++
  • C++ metaprogramming: a paradigm shift
  • Pruning Error Messages From Your C++ Template Code
  • C++ Metaprogramming: Journey from simple to insanity and back
  • boo{stache} exposed : the inner-workings of a generic template engine

 

Compile-time tools supporting generic programming in C++

Generic programming is a programming paradigm which makes it possible to build highly extensible and efficient libraries. In C++ it can be implemented using templates, therefore developers and users of generic libraries need to understand how the compiler works with templates. The details are important when the code using a library instantiates different templates (or specialisations), or the same templates but with different arguments as expected. Fixing such bugs can lead to difficult debugging sessions. These are not bugs in the program's runtime behaviour. These are bugs in the program's compile-time behaviour and therefore different tools are needed to find them. Tools providing insight into what happens during the compilation process are needed.

Template metaprogrammers have been pushing the limits of what is possible using templates. The way they use templates is usually more complex than what generic libraries need. Recently a number of advanced tools supporting template metaprogrammers have been built. REPL shells, debuggers, profilers are available to make it possible to see what happens during compilation.

This talk presents how these tools can be used and be useful for the developers and users of generic libraries. Insight into what happens inside the compiler can be extremely useful to understand why the code compiles slowly, behaves the way it does or to debug errors in code using generic libraries.


C++ metaprogramming: a paradigm shift

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 Hana [1], a newly accepted Boost library using cutting edge features of the language in a creative way to solve the problem of metaprogramming for good.

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


Pruning Error Messages From Your C++ Template Code

Many template libraries are regarded with ambivalent feelings by developers: On the one hand, such libraries can offer wonderful functionality. On the other hand, they are dreaded for the sheer amount of error messages spilled out by the compiler when there is even a small bug in the developer's code. This talk will demonstrate several techniques to drastically reduce the amount of compiler output in case of errors (with real-life examples, of course).


C++ Metaprogramming: Journey from simple to insanity and back

Part I: Introduction to template metaprogramming. Template metaprogramming is a variant of generic programming, a technique that uses C++ template mechanism to perform computations at compilation time, usually to generate, from a single description, executable code that depends on the properties of the data types. It can be viewed as “programming with types”. In this example-driven class we start with the overview of the metaprogramming tools (everything you wanted to know about template specializations but were afraid to ask). We will apply these tools to simple examples, such as: how to sort a sequence in order of increasing values, unless it’s a sequence of pointers, in which case we want the values of what they point to. Part II: Advanced techniques and practical applications. Simple examples of metaprogramming are fun and useful, but once you master them you start chafing at the limitations. This is C++, where we don’t suffer limitations gladly. We therefore move on to the more advanced techniques, including SFINAE, and the appropriately more advanced examples. The journey takes us back to the beginning: after all, when sorting a sequence of values vs a sequence of pointers, you don’t really care whether the pointer is smart or dumb. What you really want to know is whether “*p” compiles or not. What you really need is an “if_compiles” metaprogramming function.


boo{stache} exposed : the inner-workings of a generic template engine

Template engines are commonly found generating web pages, customer reports, or even source code. They take a source template and data model as input and generate some desired output.

Boostache was started as the Library in a Week challenge from CppNow'14 with initial support for Mustache.

Today Boostache supports multiple template formats and adapts automagically at compile time to user defined data models. Many of the techniques utilized in Boostache are the same that Ciere has employed in custom IDL compilers, Domain Specific Language systems, compilers, and runtimes.

This talk will briefly introduce Boostache and then delve into the internal architecture and design of the library. We will explore some implementation details of the parser, compiler, virtual machine, and generic data model infrastructure with the goal to expose useful techniques and patterns from this C++11 code base that can be used in your own libraries and applications.

Messaging and signaling in C++

The 7th part of my series on writing applications in C++ using Qt and boost:

Messaging and Signaling in C++

by Jens Weller

From the article:

This time it is about how to notify one part of our application that something has happened somewhere else. I will start with Qt, as it brings with signals and slots a mechanism to do exactly that. But, as I have the goal not to use Qt mainly in the UI Layer, I will also look on how to notify other parts of the application, when things are changing.

CppCon 2015 hotels filling up

cppcon-031.PNGIf you're registered for CppCon (or going to be), make sure you book your hotel soon. If you leave booking till the week before the conference it's likely you'll have to stay someplace a few miles away because downtown Bellevue is a popular spot in September and all hotels within reasonable walking distance of CppCon are expected to be fully booked by the time of the event.

Last year's CppCon was well attended, and registration is stronger this year. Three of the four CppCon hotel room blocks are now sold out. The final CppCon negotiated room rate block expires on Monday at noon PST.

The announcement:

Hotel Room Shortage Predicted

Book Now!

Our contacts at the official conference hotels are predicting that, like last year, all hotel rooms in Bellevue will be booked.

Currently three of our four hotel blocks are full. The Marriott still has some rooms that we’ve reserved for attendees. Originally they had agreed to hold these rooms (at a conference discounted rate) until this Friday, but they’ve agree to extend the deadline to Monday (August 24th) at noon (west coast time).

We strongly encourage anyone planning to attend this year’s conference to book your room right away.

ะก++ Hints

Within the scope of this project, we publish 1 recommendation/tip on C and C++ programming every day, these tips containing concentrated information on techniques of using the C/C++ language in various situations, and including examples of incorrect and correct use from more than 200 open-source projects we have scanned.

C++ Hints

by PVS-Studio Team

From the hint:

Although the code is neat and easy-to-read, it didn't prevent the developers from overlooking the error. You can't stay focused when reading code like that because all you see is just similarly looking blocks and you can't help just quickly scanning through them. These similar blocks have most likely resulted from the programmer's desire to optimize the code as much as possible. He or she just "unrolled the loop" manually. I don't think it was a good idea in this case.

Object Oriented Programming without Inheritance - ECOOP 2015—Bjarne Stroustrup

Here is the last talk from Bjarne Stroustrup:

Object Oriented Programming without Inheritance

by Bjarne Stroustrup

Abstract:

Object-oriented programming is often characterized as encapsulation plus polymorphism plus inheritance. The original Simula67 demonstrated that we could do without encapsulation and Kristen Nygaard insisted that some OOP could be done without inheritance. I present generic programming as providing encapsulation plus polymorphism. In C++, this view is directly supported by language facilities, such as classes, templates and (only recently) concepts. I show a range of type-and-resource-safe techniques covering a wide range of applications including containers, algebraic concepts, and numerical and non-numerical algorithms.

CppCon 2015 Program Highlights, 3 of N

The CppCon 2015 conference program has been posted for the upcoming September conference. We’ve received requests that the program continue to be posted in “bite-sized” posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.

 

The C++ possess another language inside it: the template language. It is useful for a lot of things, from writting less code to compile time computations or checks, but can lengthen compile time too. To master it is not easy.

The following interrelated CppCon 2015 talks tackle these issues and more (part 1).

In this post:

  • Expression Templates - What, Why, When, Where
  • Visualizing Template Instantiations - Templator Demo
  • Variadic Templates - Guidelines, Examples and Compile-time computation
  • Variable Templates - C++14 compile-time computation
  • How I stopped worrying and love metaprogramming

 

Expression Templates - What, Why, When, Where - Part I, Part II, Part III

Expression Templates is one of this C++ idiom people learn to either love or hate. The main issues with ET is that everubody has its own conception about what they are, when they should be used, what benefits they give and what are their trade off. For a long time, Expression Tempaltes has been seen has a way to improve temporary heavy code. If the seminal implementation of ET by Todd Veldhuizen was actually about this, the landscape has changed since C++11 and C++14.

This workshop will go over : - what are exactly Expression Templates and what kind of use case they can solve elegantly and efficiently - what are the benefits that one may reap by using expression tempalte in its library - what are the real cost of expressont empaltes both at runtime and compile-time - which tools to use to not reinvent the tempalte wheel everytime including an introduction to Boost.PROTO an Boost.HANA.

The main objective is to clarify why, even in C++1*, this idiom has a meaningful set of applciations and how to navigate around its pitfalls.


Visualizing Template Instantiations - Templator Demo

Many C++ beginners shy away from employing templates in their code, because of the myth of templates being hard. Even seasoned C++ developers can have problems manually interpreting template code correctly as Olve Maudal's C++ pub quiz demonstrates. Overloads and template specializations make it hard for programmers and also IDEs to show a developer what happens without compiling a program and even with a compile one might not get, what actually happens unless an unintelligible error message from your compiler appears.

My students tried to alleviate that problem by visualizing template instantiation and overload selection in a C++ IDE and allow to navigate through template code in instantiation context that a compiler would only create internally and that is otherwise not available for humans. While still in its nascent state I hope to show what is possible and if things go as planned at the time of the submission you should be able to solve the template pub quiz questions without running the programs.


Variadic Templates - Guidelines, Examples and Compile-time computation

Writing class templates and functions accepting a variable number of arguments has been a burden before C++11. With variadic templates, both class templates with a variable number of arguments as well as functions can be formulated much easier and more type safe way.

Nevertheless, the authoring of variadic templates can be challenging for the uninitiated. Even the interpretation of variadic template code can be a problem, as Olve Maudal's famous pub quiz shows.

This session will build up understanding and the ability to use and author variadic template functions and variadic template classes from easy examples up to more complicated applications such as employing std::forward correctly, std::integer_sequence and other upcoming language features such as a template UDL operator that bridges the gap between string literals and std::integer_sequence.

Understanding pack expansion, sizeof... and other hard to get on first sight issues are my goal. In the end you should have seen guidelines that help you avoid the template instantiation trap from the pub quiz and correct usage of std::forward in your variadic templates.


Variable Templates - C++14 compile-time computation

C++11 introduced Variadic Templates, constexpr Functions and Literal Types that ease and allow type-safe computations at compile time. For embedded development this is an important aspect, because it provides a means to create ROMable data in type-safe C++.

In combination with C++14 mechanism of Variable Templates, that actually defines constants, and the relaxed constexpr function rules there are unprecedented possibilities for compile-time computations.

This talk does not only show the mechanisms available but also demonstrates non-trivial examples, how they can be used to compute interesting data at compile time.


How I stopped worrying and love metaprogramming

Horrible software engineering technique conceived in the forge of Hell or the Only True Way of doing C++ in 2015, template metaprogramming and its cohort of companion techniques are sure to create animation in a group of programmers.

What if we were to tell you that an actual software product, actually sold to real customers and in production for now several years has been built on it? What if we were to tell you that a lot of advanced template techniques helped us to build a better software faster?

This talk is all about real life examples of template metaprogramming, why they are useful and when and how you could use them in your own projects.

Foreign Constructors—Gerard Meier

A nice technique to initialize complex objects simply with one constructor:

Foreign Constructors

by Gerard Meier

From the article:

Recently I found myself extending a game engine with font rendering support. Fonts have a lot of properties, so naturally I created a tidy structure to hold all parameters. Whenever drawing a piece of text: I'd simply pass this structure along.

A philosophy I follow, is one of programmer convenience. For example: I always specify default values; when you instantiate a class without any parameters, it is directly usable. Following from that, whenever you call an method or constructor - you should not have to specify not used parameters. This adds a practical issue: it requires all kinds of constructors...

 

New version of CLion, a cross-platform C and C++ IDE, is released

Summer brings the new release of CLion, a cross-platform C/C++ IDE from JetBrains.

Welcome CLion 1.1 with improved C++ parser, LLDB on OS X, and code style settings

by Anastasia Kazakova

From the post, there are the new features and improvements on board:

  • Massive C++ parser overhaul to handle tricky modern C++ cases.
  • LLDB integration for OS X users.
  • Predefined code styles (like for example Google, Qt, GNU, Stroustrup).
  • New code styles settings for CMake
  • And more

Find a demo from Dmitri Nesteruk at the end of the post.

CppCon 2015 Program Highlights, 2 of N

The CppCon 2015 conference program has been posted for the upcoming September conference. We’ve received requests that the program continue to be posted in “bite-sized” posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.

 

The standard template library (STL) is an important part of the C++ language. Knowing what there is inside and how to use it is an important part to create a program.

The following interrelated CppCon 2015 talks tackle these issues and more.

In this post:

  • STL Algorithms in Action
  • Enhancing STL containers
  • C++11/14/17 Atomics the Deep dive: the gory details, before the story consumes you!
  • Parallelizing the C++ Standard Library
  • Ranges and the Future of the STL

 

STL Algorithms in Action

This will be an entertaining trip through the STL algorithms, where we will view many of them in their natural habitats, going about their natural algorithm business. Then we will take some of them out of their native environments and make them do tricks that are entirely unexpected. In the end, you will gain a new appreciation for what the algorithms are and how pervasively they can be used throughout your code.

 

Enhancing STL containers

STL has a big history. Due to class paradigm of C++, many STL containers have a flat layout in memory, i.e. containers naturally store objects and address objects rather than their indexing entities such as smart pointers (which are, strictly speaking, objects too). This model has a benefit of lower memory fragmentation, that causes better CPU cache performance. However, many tasks in real life require reordering of objects, that requires compexity of O(n*q), where q is a size of an object and n is a compexity measured in operations. Thus, some imlementations of operations with reordering objects in some containers are much slower that they could be. This problem could sometimes be solved by storing “pointers” as index entities in containers instead of the objects by themselves, what improves performance by q times, but causes memory fragmentation and worse cache performance. Algorithmically, the solution with pointers is obviously better, but it is still not the most efficient one. In the presentation I will show myimplementations of containers using both approaches and having the best of two worlds. I will compare these methods with classical and modern approaches and draw some conclusion, encouraging everybody to use the power of algorithms with C++.

 

C++11/14/17 Atomics the Deep dive: the gory details, before the story consumes you!

In 2011, C++11 atomics offered three memory models but 6 settings. Most compilers have started implementing most of these (relaxed, seq_cst, acquire, release, acq_rel) but not consume (For that you will need to see Paul's talk which naturally follows this talk.) For this, I will deep dive into what each memory model setting means (especially for Games Development and low latency, a new SG14 in the C++ Standard) and how C++11 atomics are used to improve handling of mutable shared state. We have improved on it in C++14 and have more crazy things planned for C++17. I will also look at how C++ atomics are a natural precursor to SG5's Transactional Memory which was approved in Lenexa for publication.

 

Parallelizing the C++ Standard Library

As the era of frequency scaling comes to an end, multi-core parallelism has become an essential focal point in computational research. Mainstream languages, however, have not yet adapted to take full advantage of parallelism provided by the hardware. While new languages such as Rust and Swift are catching on and implementing multi-core algorithms in their libraries, C++ has only started to do so. A parallel Standard Library could bring with it many positive features that users can begin taking advantage of.

This talk will focus around two standards proposals, N4409 and N4406. N4409 outlines the details of a parallel Standard Library and features of these new parallel algorithms. The complementary N4406 outlines abstractions to take advantage of various mechanisms for parallel execution. We will cover the reasons why the new Standard Library would be beneficial to C++ users and our experience implementing these algorithms in HPX. The presentation will address what exactly the two proposals define, the challenges we faced, and the results we collected. In addition, we will discuss extensions made to these proposals and the C++11/14 standard in HPX to support these semantics in a distributed environment.

 

Ranges and the Future of the STL

Range-based interfaces are functional and composable, and lead to code that is correct by construction. With concepts and ranges coming to the STL, big changes are in store for the Standard Library and for the style of idiomatic C++. The effort to redefine the Standard Library is picking up pace. Come hear about one potential future of the STL from one of the key people driving the change.