HPX version 0.9.10 released -- STE||AR Group

By Hartmut Kaiser | Mar 24, 2015 11:04 AM | Tags: None

The STE||AR Group has released V0.9.10 of HPX -- A general purpose parallel C++ runtime system for applications of any scale.

HPX V0.9.10 Released

The newest version of HPX (V0.9.10) is now available for download! Please see here for the release notes.

HPX now exposes an API fully conforming to the concurrency related parts of the C++11 and C++14 standards, extended and applied to distributed computing.

From the announcement:

• The major focus of this release was to improve the reliability of large scale runs. We have shown to reliably run HPX applications on up to ~24k cores (~1k nodes).
• A very important improvement introduced with this release is the refactoring of the networking infrastructure which improves the overall performance.
• We continued our work towards a complete implementation of N4354 (Working Draft, Technical Specification for C++ Extensions for Parallelism).
• Move to C++11 variadics: all of the API now uses variadic templates.

CppCon 2014 Generic Programming with Concepts Lite, Part I--Andrew Sutton

By Adrien Hamelin | Mar 23, 2015 10:00 AM | Tags: experimental advanced

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

Generic Programming with Concepts Lite, Part I

by Andrew Sutton

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

In this talk, I will give an overview of the Concepts Lite language extension for C++ and present examples of its use in design and implementation of real-world generic libraries. Concepts Lite provides the ability for programmers to directly state constraints on template arguments as part of the template declaration. These constraints are predicates which determine whether or not a template argument can be used with that template. Constraints are checked by the compiler at the point of use, meaning that that effectively constrained generic libraries will not suffer from the usual problems of insane diagnostics. Libraries written using concepts will be far more readable and maintainable than the status quo. This talk will focus on generic programming, proposed language features, and their use in building real-world libraries.

Concepts Lite is a forthcoming ISO Technical Specification (TS) aimed at publication alongside C++14. Concepts Lite is implemented in a branch of GCC, which will be made available to the audience for experiments and experience.

N4394: PL22.16/WG21 draft agenda: 4-9 May 2015, Lenexa KS/US -- Clark Nelson

By Blog Staff | Mar 20, 2015 12:53 PM | Tags: None

New WG21 papers are available. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N4394

Date: 2015-03-12

PL22.16/WG21 draft agenda: 4-9 May 2015, Lenexa KS/US

by Clark Nelson

Excerpt:

At this meeting we will address ballot comments on the Transactional Memory PDTS (N4302), and discuss whatever comments are available on the Concepts PDTS (N4377). We also aim to bring several projects to their next ballot stage, potentially including the following:

• Library Fundamentals 2 (prospective WD N4336)
• Concurrency (proposal N4313)
• Networking (proposal N4370)

CppCon 2014 Metaprogramming with Boost.Hana: Unifying Boost.Fusion and Boost.MPL--Louis Dionne

By Adrien Hamelin | Mar 20, 2015 08:00 AM | Tags: performance efficiency c++14 boost

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

Metaprogramming with Boost.Hana: Unifying Boost.Fusion and Boost.MPL

by Louis Dionne

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Template metaprogramming sucks. No, seriously; you might like the imposed purely functional paradigm, but not the templates themselves. While C++11 has made our life easier, even simple metaprograms are often hard to write, impossible to maintain and slow to compile; we need better abstractions. In this talk, I will present Boost.Hana[1], an experimental C++14 library for heterogeneous computation. The library takes metaprogramming to a whole new level of expressiveness by unifying the well-known Boost.MPL and Boost.Fusion libraries under a single generic, purely functional interface. The library incorporates some of the most recent advances in C++ metaprogramming; I will give an overview of the most interesting implementation techniques used internally. Finally, I will show concrete ways to use the library so you, as a developer, can write less template black magic, increase your productivity and spend less time in coffee breaks waiting for the compiler (sorry).

CppCast Episode 4: Cmake, Git and Functional Programming with David Sankel -- Rob Irving

By robwirving | Mar 20, 2015 04:10 AM | Tags: None

Episode 4 of CppCast, the only podcast by C++ developers for C++ developers. In this episode David Sankel joins Rob Irving to talk about his upcoming C++Now! talk where he will be discussing the use of Cmake and Git in large C++ projects. We also touch on David's expertise with functional programming.

CppCast Episode 4: Cmake, Git and Functional Programming with David Sankel

by Rob Irving

About the interviewee:

David Sankel is a professional software developer/architect based in the USA. His prolific software developments have included CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at the C++Now! conferences and is especially well known for his advanced functional programming in C++ talks.

David's current research interests include dependently typed languages, semantic domains, EDSLs, and functional reactive programming. He currently works for the software firm, Stellar Science.

Range comprehensions with C++ lazy generators -- Paolo Severini

By Marco Arena | Mar 19, 2015 04:11 AM | Tags: generators concurrency advanced

From a totally unnecessary blog (we beg to differ):

Range comprehensions with C++ lazy generators

by Paolo Severini

From the article:

Lazy evaluation is a powerful tool and a pillar of functional programming; it gives the ability to construct potentially infinite data structures, and increases the performance by avoiding needless calculations ...

... Functional languages like Haskell have the concept of list comprehensions ... In C#, of course, we have LINQ ... It would be nice to have something similar in an eager language like C++ ... now the lazy, resumable generators proposed by N4286 seem perfect for this purpose ... We can use the VS2015 CTP prototype to experiment with this idea ...

CppCon 2014 Quick Game Development with C++11 / C++14--Vittorio Romeo

By Adrien Hamelin | Mar 18, 2015 11:30 AM | Tags: intermediate efficiency c++14

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

Quick Game Development with C++11 / C++14

by Vittorio Romeo

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Modern C++ has made game development a much more pleasurable experience. Features such as smart pointers and variadic templates are invaluable in speeding up the development process and in making the code cleaner and more robust. New easy-to-use multimedia libraries such as SFML, SDL and Cinder make dealing with graphics, sounds and input very easy, and work well with modern code principles. This talk guides the audience through the creation of an Arkanoid/Breakout clone in under 200 lines of code, using C++11/C++14 features and idioms. Chronologically sequential code segments, compiled and executed one by one, will show the attendees how a game is created from scratch, slowly becoming a playable product, step by step. The end result will be a small game, completely written in modern C++ code. Topics covered will range from basic graphics programming to entity management and collision detection/response.

Lock-Free Data Structures. The Evolution of a Stack -- Max Khiszinsky

By Felix Petriconi | Mar 18, 2015 01:07 AM | Tags: intermediate concurrency

Max Khiszinsky describes in his recent blog article different approaches to develop concurrent containers.

Lock-Free Data Structures. The Evolution of a Stack

by Max Khiszinsky

From the article

Describing the known algorithms would be quite boring, as there would be a lot of [pseudo-]code, plenty of details that are important but quite specific. After all, you can always find them in the references I provide in articles. What I wanted was to tell you an interesting story about exciting things. I wanted to show the development of approaches to designing concurrent containers.

Quick Q: Why does ~shared_ptr amazingly know how to call the right destructor? -- StackOvervflow

By Blog Staff | Mar 17, 2015 05:10 PM | Tags: None

Quick A: Because shared_ptr is awesome and remembers the correct deleter to call.

Recently on SO:

Why does incomplete type of smart pointer data member and raw pointer data member have different behavior when their parent destruct?

In the following code:

smart pointer data member pImpl(class Impl) and raw pointer pc(class CAT) all are incomplete data type, there is no definition of these two classes in Widget.h ...

... For the raw pointer data member, its destuctor is not called when widget object is destructed.

While the shared_ptr data member, its destructor has been correctly called.

... Why do shared_ptr data member and raw data member have different behavior when the widget gets destructed?

Interview with Scott Meyers at Yandex -- Coder_CPP

By Blog Staff | Mar 17, 2015 04:53 PM | Tags: None

In case you missed the transcript a few days ago on Reddit:

Interview with Scott Meyers at Yandex

by Coder_CPP

From the interview:

... So I don’t think that in ten years everyone will be using managed languages. I think that C++ is going to remain an extremely important language for production use. Simply because if your goal is to get the maximum of performance out of the machine. If that is what is most important to you. I think that even these days the primary competitors are C and C++. Those are pretty much your choices. And C++ is just a much more expressive language. I have to say that I’m not a C programmer. I've never really been a C programmer. But I think that just a simple notion of destructors is so unbelievably powerful, that as a C programmer I would consider moving to C++ just so I could compile and get destructors. And, obviously, there is a lot more? to it than that...