Home » Blog » Categories »

Object Oriented Programming without Inheritance - ECOOP 2015--Bjarne Stroustrup

By Adrien Hamelin | Aug 19, 2015 11:46 PM | Tags: intermediate

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

By Adrien Hamelin | Aug 19, 2015 09:00 AM | Tags: None

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

By Adrien Hamelin | Aug 18, 2015 12:46 PM | Tags: intermediate c++11

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

By Anastasia Kazakova | Aug 18, 2015 09:34 AM | Tags: tools

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

By Adrien Hamelin | Aug 18, 2015 09:00 AM | Tags: None

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.

Videos from 2015 ACCU Conference

By Adrien Hamelin | Aug 14, 2015 09:37 AM | Tags: community

If you missed the last ACCU conference, you can see some sessions here:

Videos from 2015 ACCU Conference

From the page:

The following videos from the ACCU 2015 Conference are currently available:

  • Axel Naumann · Large-Scale Scientific C++ For Casual Coders: Why You (Should) Care
  • Pete Goodliffe · Becoming a Better Programmer
  • Chris Oldwood · In the Toolbox - Live!
  • Hubert Matthews · The Dos and Don'ts of Multithreading

Bitesize Modern C++: std::initializer_list--Glennan Carnie

By Adrien Hamelin | Aug 14, 2015 09:31 AM | Tags: c++11 basics

Do you know how to use initializer lists?

Bitesize Modern C++: std::initializer_list

by Glennan Carnie

From the article:

An aggregate type in C++ is a type that can be initialised with a brace-enclosed list of initialisers. C++ contains three basic aggregate types, inherited from C:

  • arrays
  • structures
  • unions

Since one of the design goals of C++ was to emulate the behaviour of built-in types it seems reasonable that you should be able to initialise user-defined aggregate types (containers, etc.) in the same way...