Announcing Visual C++ Build Tools 2015 – standalone C++ tools for build environments--Marian Luparu

By Adrien Hamelin | Nov 4, 2015 03:18 PM | Tags: experimental

You can now compile using Visual C++ without Visual Studio:

Announcing Visual C++ Build Tools 2015 – standalone C++ tools for build environments

by Marian Luparu

From the article:

Together with the availability of Visual Studio 2015 Update 1 RC, we’re also announcing a new way of acquiring the C++ tools: as a standalone installer that only lays down the tools required to build C++ projects without installing the Visual Studio IDE. This new installer is meant to streamline the delivery of the C++ build tools in your build environments and continuous-integration systems.

Integrating an HTML Editor into Qt using Javascript and QWebView

By Meeting C++ | Aug 26, 2015 01:58 AM | Tags: qt javascript intermediate experimental advanced

Part 8 of my series about writing applications in C++ using Qt and boost:

Integrating an HTML Editor into Qt using Javascript and QWebView

by Jens Weller

From the article:

This time its about integrating an HTML Editor into Qt using QWebView and Javascript! I'll start with text editors in general, and then continue to the integration, based on QWebkit and TinyMCE3. The end result is a little bit of hackery, but it is a working solution...

C++ concepts support merged into gcc trunk

By Adrien Hamelin | Aug 11, 2015 10:15 AM | Tags: experimental

An evolution of gcc occured:

C++ concepts support merged into gcc trunk

From the article:

I've been banging on the concepts branch for the past month after Andrew told me it was about ready to merge, fixing bugs and streamlining things there to get familiar with the code while I could still look at it as a whole rather than mixed in with the rest of the compiler. But I think I've reached diminishing returns and so I'm going to go ahead and merge it into the trunk...

CppCon 2014 Costless Software Abstractions for Parallel Architectures--Joel Falcou

By Adrien Hamelin | Jul 22, 2015 08:00 AM | Tags: experimental efficiency

Have you registered for CppCon 2015 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 2014 for you to enjoy. Here is today’s feature:

Costless Software Abstractions for Parallel Architectures

by Joel Falcou

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Performing large, intensive or non-trivial computing on array like data structures is one of the most common task in scientific computing, video game development and other fields. This matter of fact is backed up by the large number of tools, languages and libraries to perform such tasks. If we restrict ourselves to C++ based solutions, more than a dozen such libraries exists from BLAS/LAPACK C++ binding to template meta-programming based Blitz++ or Eigen. If all of these libraries provide good performance or good abstraction, none of them seems to fit the need of so many different user types.

Moreover, as parallel system complexity grows, the need to maintain all those components quickly become unwieldy. This talk explores various software design techniques - like Generative Programming, MetaProgramming and Generic Programming - and their application to the implementation of a parallel computing librariy in such a way that:

- abstraction and expressiveness are maximized - cost over efficiency is minimized

We'll skim over various applications and see how they can benefit from such tools. We will conclude by discussing what lessons were learnt from this kind of implementation and how those lessons can translate into new directions for the language itself.

CppCon 2014 Making Allocators Work, Part II—Alisdair Meredith

By Adrien Hamelin | Jul 15, 2015 12:08 AM | Tags: experimental efficiency c++11

Have you registered for CppCon 2015 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 2014 for you to enjoy. Here is today’s feature:

Making Allocators Work, Part II

by Alisdair Meredith

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Memory is an important property for every object, as whatever resources it manages, it must occupy some memory. THe ability to customize memory allocation is important for every C++ program that cares about performance, debug ability and support.

The original C++ standard supported an allocator parameter for every container, yet this feature was widely derided or ignored, as it was underspecified to the point it could not portably be used. C++11 makes significant changes to the allocator model, that simply its use while making it more powerful.

The Library Fundamentals TS goes further, allowing allocators’ type to be supplied at runtime, rather than compile type, using classic object oriented polymorphism - yet building on the infrastructure laid down in C++11.

This material should be of interest to both library authors and consumers, although clearly there are more details for the implementers to absorb. It also includes an interesting case study in C++11 compile time reflection, as required to implement the new ‘allocator_traits’ facility.

CppCon 2014 Making Allocators Work, Part I--Alisdair Meredith

By Adrien Hamelin | Jul 13, 2015 10:02 AM | Tags: experimental efficiency c++11

Have you registered for CppCon 2015 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 2014 for you to enjoy. Here is today’s feature:

Making Allocators Work, Part I

by Alisdair Meredith

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Memory is an important property for every object, as whatever resources it manages, it must occupy some memory. THe ability to customize memory allocation is important for every C++ program that cares about performance, debug ability and support.

The original C++ standard supported an allocator parameter for every container, yet this feature was widely derided or ignored, as it was underspecified to the point it could not portably be used. C++11 makes significant changes to the allocator model, that simply its use while making it more powerful.

The Library Fundamentals TS goes further, allowing allocators' type to be supplied at runtime, rather than compile type, using classic object oriented polymorphism - yet building on the infrastructure laid down in C++11.

This material should be of interest to both library authors and consumers, although clearly there are more details for the implementers to absorb. It also includes an interesting case study in C++11 compile time reflection, as required to implement the new 'allocator_traits' facility.

CppCon 2014 What the committee did next!--Alisdair Meredith

By Adrien Hamelin | Jun 26, 2015 08:00 AM | Tags: experimental community

Have you registered for CppCon 2015 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 2014 for you to enjoy. Here is today’s feature:

What the committee did next!

by Alisdair Meredith

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Now that C++14 is done, what is the standard committee working on next?

After inking 8 years to produce the C++11 standard (arguably 13) there was a feeling we should be able to produce new work faster, more incrementally. With the renewed interest in C++, we have more participation on the committee, and have looked to harness that enthusiasm in new ways. In the last 3 years we have spun up at least a dozen new study groups, and have 8 or mode Technical Specifications in various stages of development that we hope to ship over the next 12-24 months. So what are all these new groups and specifications about? Come to this session and get a vision of where C++ is headed in the immediate and short-term future.

CppCon 2014 Parallelizing the Standard Algorithms Library--Jared Hoberock

By Adrien Hamelin | Jun 24, 2015 08:00 AM | Tags: performance experimental

Have you registered for CppCon 2015 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 2014 for you to enjoy. Here is today’s feature:

Parallelizing the Standard Algorithms Library

by Jared Hoberock

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Until recently, C++ programmers building parallel programs found little support for parallelism in the standard toolbox. That's changing with the technical specification on Extensions for Parallelism in C++. This talk will explore how programmers can build portable parallel programs from high-level parallel algorithms which can execute on CPU threads, vector units, and even GPUs.

Folding Expressions -- Marco Alesiani

By Marco Arena | Jun 15, 2015 06:12 AM | Tags: experimental c++17

A new blog post containing runnable code from the Italian C++ Community:

Folding Expressions

by Marco Alesiani

From the article:

C++17, scheduled by 2017 at the time of writing, will introduce fold expressions into play and significantly broaden parameter packs scopes of use [...]

template<typename F, typename... T>
void for_each(F fun, T&&... args)
{
    (fun (std::forward<T>(args)), ...);
}

The sample above uses fold expressions together with the comma operator to create a simple function that calls the provided lambda per each one of the supplied arguments with perfect forwarding. [...]

HPX and C++ Dataflow(await) -- Hartmut Kaiser

By Mantosh Kumar | Jun 13, 2015 06:59 PM | Tags: intermediate experimental c++14

Uses/Implementation/Discussion about await feature in modern C++.

HPX and C++ Dataflow

by Hartmut Kaiser

From the article:

We have done some experiments with a preliminary implementation of await in Visual Studio 2015RC. We were able to integrate it well with the futures in HPX and the results are very promising. Unfortunately, the await keyword (and resumable functions) will only be available in all mainstream compilers years from today. So for now we will have to make do with our poor-man’s-await –dataflow.

In any case, if you want to try things out (including dataflow), please fork HPX from our Github site and tell us what you think.