Home » Blog » Tags » intermediate

intermediate

CppCon 2015 C++: How I learned to stop worrying and love metaprogramming--Edouard Alligand

By Adrien Hamelin | Jul 25, 2016 01:55 PM | Tags: intermediate efficiency

Have you registered for CppCon 2016 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

C++: How I learned to stop worrying and love metaprogramming

by Edouard Alligand

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

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.

An update on the Meeting C++ Workshop Day

By Meeting C++ | Jul 25, 2016 08:09 AM | Tags: training intermediate experimental boost

I finally can announce that the workshops will end with talks by James McNellis and Michael Caisse:

An Update on the workshop day

by Jens Weller

From the article:

Michael Caisse - boost.fusion: power to the tuples

    Tuples provide heterogeneous, compile-time containers; however, they can be difficult to use at run-time. Boost.Fusion brings together compile-time and run-time semantics to produce the STL of the meta-programming world. It is the machinery behind several Boost libraries and is a common element in many of the solutions provided by Ciere Consulting.


James McNellis - Practical C++ Coroutines

    One of the most interesting new features being proposed for C++ standardization is coroutines, formerly known as “resumable functions”. C++ coroutines are designed to be highly scalable, highly efficient (no overhead), and highly extensible, while still interacting seamlessly with the rest of the C++ language.

Meeting C++ 2016: closing keynote & full schedule

By Meeting C++ | Jul 20, 2016 02:01 AM | Tags: intermediate experimental c++17 c++14 boost advanced

With the announcement of the closing keynote the full schedule for Meeting C++ 2016 stands!

Closing keynote & full schedule of Meeting C++ 2016

by Jens Weller

From the article:

Since mid of June the program of the 5th Meeting C++ conference was taking shape. With the selection of the talks it was also clear in which tracks they go, so that the schedule it self was almost ready, except a last detail: the closing keynote.

The closing keynote will be held by Louis Dionne on "C++ metaprogramming: evolution and future directions".

CppCon 2015 Functional Design Explained--David Sankel

By Adrien Hamelin | Jul 11, 2016 08:00 AM | Tags: intermediate efficiency

Have you registered for CppCon 2016 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Functional Design Explained

by David Sankel

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

An oft-cited benefit of learning a functional language is that it changes one's approach to solving problems for the better. The functional approach has such a strict emphasis on simplistic and highly composable solutions that an otherwise varied landscape of solution possibilities narrows down to only a few novel options.

This talk introduces functional design and showcases its application to several real-world problems. It will briefly cover denotational semantics and several math-based programming abstractions. Finally, the talk will conclude with a comparison of functional solutions to the results more traditional design methodologies.

No prior knowledge of functional programming or functional programming languages is required for this talk. All the examples make use of the C++ programming language.

CppCon 2015 Simple, Extensible Pattern Matching in C++14--John R. Bandela

By Adrien Hamelin | Jul 8, 2016 08:00 AM | Tags: intermediate efficiency c++14

Have you registered for CppCon 2016 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Simple, Extensible Pattern Matching in C++14

by John R. Bandela

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Recently, there has been in increased interest in applying functional programming techniques to C++. A very convenient construct that is used in functional programming languages is pattern matching. Due to the features introduced in C++11 and C++14 we can actually write a simple, easy to use, understandable, and extensible pattern matching library that is header only and uses no macros.

In this talks we will discuss the motivations for pattern matching, and see examples of use from other languages. We will then go on to design and implement a pattern matching library in C++. Particular attention will be payed to new C++14 features that greatly simplify the implementation such as integer_sequence, function return type deduction, and generic lambdas. The implementation will also serve a practical guide to using variadic templates and std::tuple.

We will show how the library can be easily extended and customized by working through some examples of customization such as working with user defined classes and structs, pointers, tuples, boost::optional, and boost::variant. At the end of the session, the audience will have an appreciation for pattern matching, as well as a sense that the C++11/14 features open new paradigms without sacrificing understandable code.

CppCon 2015 Time Programming Fundamentals--Greg Miller

By Adrien Hamelin | Jul 6, 2016 08:00 AM | Tags: intermediate efficiency

Have you registered for CppCon 2016 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Time Programming Fundamentals

by Greg Miller

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

"Time zones are logical and easy to use." -- No one ever

Time programming is notoriously difficult and error prone. Attempts at handling daylight-saving time, for example, often yield baffling code, which of course is explained by a similarly misguided comment. Programmer confusion can spread virally throughout the codebase when these misconceptions find their way into library interfaces.

The problem is not that dates and times are fundamentally complicated (though they are). The problem is the lack of a simplified mental model with library support. This would give programmers the concepts and vocabulary necessary to reason about and discuss these concepts, and the ability to express this reasoning in simple C++ terms.

In this talk I will show how date and time programming evolved into what it is today. I will present a greatly simplified mental model that applies to all programming languages. I will show clear examples using an open source C++ library that implements these simplified concepts. And I will present practical tips for proper time hygiene that should be used by everyone immediately.

CppCon 2015 functional: What's New, And Proper Usage--Stephan T. Lavavej

By Adrien Hamelin | Jul 4, 2016 08:00 AM | Tags: intermediate experimental c++11

Have you registered for CppCon 2016 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

functional: What's New, And Proper Usage

by Stephan T. Lavavej

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

functional gained lots of machinery in C++11, with further changes in C++14 and C++17. This talk will cover what's new in 11/14/17, focusing on how to use it properly. For example, you've probably used std::function, but do you know the criteria for activating the Small Functor Optimization? (It's not just being small!) We'll also look at bind(), mem_fn(), C++17's invoke(), and more.

CppCon 2015 Using Spirit X3 to Write Parsers--Michael Caisse

By Adrien Hamelin | Jun 29, 2016 01:02 PM | Tags: intermediate community

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Using Spirit X3 to Write Parsers

by Michael Caisse

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Parsing is a common problem in many domains. The complexity of using a library often pushes developers to ad-hoc solutions utilizing std::string manipulations, regular expressions, or nested if/switch statements. Most “quick hack” implementations are unmaintainable.

Spirit provides a Domain Specific Embedded Language (DSEL) that allows grammars to be described in a natural and declarative manner just like writing PEG or EBNF directly in your C++ code. X3 is the third major release of the Spirit library and improves both compile and run times while simplifying the much of the library.

In this tutorial session you will be introduced to Spirit X3, attribute parsing, and variety of tips to writing efficient and maintainable parsers. We will build a JSON parser during the session to illustrate techniques and usage of the library. This session is applicable toward anyone needing to parse data.

Quick Q: Why doesn't std::queue::pop return value?

By Adrien Hamelin | Jun 27, 2016 01:52 PM | Tags: intermediate efficiency

Quick A: To guarantee exception safety and for performance.

Some time ago on SO:

Why doesn't std::queue::pop return value?

So, whats the difference, pop function could have done the same thing.

It could indeed have done the same thing. The reason it didn't, is because a pop that returned the popped element is unsafe in the presence of exceptions (having to return by value and thus creating a copy).

Consider this scenario (with a naive/made up pop implementation, to ilustrate my point):

template<class T>
class queue {
    T* elements;
    std::size_t top_position;
    // stuff here
    T pop()
    {
        auto x = elements[top_position];
        // TODO: call destructor for elements[top_position] here
        --top_position;  // alter queue state here
        return x;        // calls T(const T&) which may throw
    }

If the copy constructor of T throws on return, you have already altered the state of the queue (top_position in my naive implementation) and the element is removed from the queue (and not returned). For all intents and purposes (no matter how you catch the exception in client code) the element at the top of the queue is lost.

This implementation is also inefficient in the case when you do not need the popped value (i.e. it creates a copy of the element that nobody will use).

This can be implemented safely and efficiently, with two separate operations (void pop and const T& front()).