News

CppCon Program Preview, 1 of N -- Boris Kolpackov

The countdown continues: Today we are exactly 100 days out from CppCon 2014.

This morning, the organizers announced that CppCon will have some 100 talks, which going by the size of the program likely makes this the biggest C++ event in... ever. Also, we now have the first set of accepted talks.

CppCon Program Preview, 1 of N

by Boris Kolpackov

From the announcement:

Good news: Due to the large number of submissions (we got over 140), the conference will have 6 tracks instead of the planned 5. This means there will be approximately 100 talks, and that’s not counting keynotes, plenary sessions, and lightning talks (more on those soon). As far as we know no other conference has ever had this number of C++-related presentations which will make CppCon 2014 the biggest event in the history of the language.

Understandably, many of you would like to see the conference program before registering. However, due to a greater than expected number of submissions, the final program is still some weeks away. So to help you make up your mind (or convince your boss) we are going to start publishing the talks as they are accepted. So here is the first chunk (summary first, abstracts following):

Scott Meyers: “Type Deduction and Why You Care”

John JT Thomas: “Embarcadero Case Study: Bringing CLANG/LLVM to Windows”

Rachel Cheng, Michael VanLoon: “Boost: A Bridge from C++98 to C++11; An Introduction to Using More Boost”

Titus Winters: “The Philosophy of Google’s C++ Code”

James McNellis: “Unicode in C++”

 

Scott Meyers: "Type Deduction and Why You Care"

C++98 had template type deduction, and it worked so intuitively, there was little need to understand what took place under the covers. C++11 extends type deduction to include universal references, applies it to auto variables and lambda expressions, then throws in a special auto-only deduction rule. C++14 pushes the boundary further, adding two forms of function return type deduction (auto and decltype(auto)) for arbitrary functions and offering auto parameters for lambdas. The result is that what could be treated as a black box in C++98 has become a topic that practicing C++ developers really need to understand. This talk will give you the information you need to do that.

Speaker’s bio: Scott Meyers is one of the world’s foremost experts on C++ software development. He wrote the best-selling Effective C++ series (Effective C++, More Effective C++, and Effective STL) and is also author of Overview of the New C++ (C++11/14) and Effective C++ in an Embedded Environment.

John JT Thomas: "Embarcadero Case Study: Bringing CLANG/LLVM to Windows"

CLANG/LLVM delivers a highly conforming C++ compiler and architecture for targeting multiple CPUs, and, as such, has seen success in iOS and other operating systems. Embarcadero has successfully delivered the first commercial compiler for Windows based on CLANG/LLVM. This session describes the benefits of CLANG/LLVM as well as the challenges in bringing it to the Windows operating system. Particular emphasis is placed on the managing the changes in CLANG as well as the additional features added to enable Windows development.

Speaker’s bio: John “JT” Thomas, Director of Product Management at Embarcadero Technologies, has more than 15 years of product management and product development experience including hands-on experience with the early versions of Delphi and C++Builder at Borland Software. While at Borland he was a delegate on the ANSI/ISO C++ standards committee. He earned his Computer Science degree from University of California, Santa Cruz and his MBA and MSE from San Jose State University.

Rachel Cheng and Michael VanLoon: "Boost: A Bridge from C++98 to C++11; An Introduction to Using More Boost"

Part one is for those who are stuck with a C++98/03 compiler, but are interested in using more advanced C++11-like strategies. We will discuss some of the differences between C++98 and C++11 while demonstrating how strategic use of Boost libraries can bridge the gap, allowing more modern programming paradigms in many cases.  Part two is a deeper dive into some interesting Boost libraries for those who may be new to Boost usage. We will explore how C++98 and C++11 can be enhanced and extended by the additional richness of Boost libraries. We will use as example some of the boost libraries used in the F5 Networks code base. If there is time leftover, we will discuss our experience upgrading GCC.

Speakers’ bio: Rachel Cheng is a recent graduate from The Evergreen State College is currently employed at F5 Networks. Michael VanLoon is a Senior Software Engineer at F5 Networks, is a member of the Northwest C++ Users group, and has attended ISO C++ Standards Committee meetings. He has benefited from time at Microsoft, Yahoo!, and VMware, among others, before joining F5. He is fascinated with crafting code and is dismayed at code that falls short of its potential.

Titus Winters: "The Philosophy of Google’s C++ Code"

The Google C++ Style Guide is a fairly popular guide for C++ coding practices, both at Google and externally, but some of its recommendations often seem dated and have created controversy and perceived tension with more modern C++ In this talk we will focus on the core philosophies underlying that guide, ranging from the common (be consistent) to the unusual (leave an explicit trace for the reader), and debunk the idea that Google’s C++ is anything less than modern. We’ll discuss how these core ideas inform contentious rules like “No non-const references” and “Don’t use exceptions,” and how the application of those rules has worked for us in practice, both as developers and reliability engineers (SREs).

Speaker’s bio: Titus Winters has spent the past three years working on Google’s core C++ libraries. He’s particularly interested in issues of large scale software engineering and codebase maintenance: How do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? Along the way he has helped Google teams pioneer techniques to perform automated code transformations on a massive scale, and helps maintain the Google C++ Style Guide.

James McNellis: "Unicode in C++"

In some programming languages, text processing is easy. Unfortunately, C++ is not one of those languages. C++ lacks good, built-in support for Unicode, though the situation is starting to improve. This session will begin with a brief overview of text encodings, and an introduction to Unicode and the various Unicode encodings. We’ll look at the woeful state of Unicode support in C++98 (or, really, lack thereof), then take a look at the improvements that were made in C++11 and other improvements that have recently been proposed for standardization. We’ll finish up with a discussion of several libraries designed to make it easier to work with Unicode in C++, including the widely-used, open-source International Components for Unicode (ICU) library.

Speaker’s bio: James McNellis is a senior engineer on the Microsoft Visual C++ team, where he is responsible for the Visual C++ C Runtime (CRT) and C Standard Library implementation. He was previously a member of the Microsoft Expression Blend team, developing the XAML designer tools for Windows 8 apps. Prior to joining Microsoft in 2010, he spent several years working on real-time 3-D simulation and robotics projects in the defense industry. James is a prolific contributor on the Stack Overflow programming Q&A website and occasionally writes for the Visual C++ Team Blog.
 

Writing min function, part 1: The rise of Concepts -- Fernando Pelliccioni

[Ed: Note that this article series is not (yet) about C++ code, but it promises to go there and it has an interesting pedigree in its generic programming design analysis (Alex Stepanov) and reviewers (several ISO C++ participants including Andrzej Krzemienski and Dean Michael Berris.]

Writing min function, part 1: The rise of Concepts

by Fernando Pelliccioni

From the article:

This is the first in a series of articles in which I want to transmit what I learned (or what I think I learned) from the books, papers, lectures of Alexander Stepanov.

These are the lessons that Alex gives us, and I want to show them in this series:

  • Specify our algorithms correctly
  • Programming must be based on a solid mathematical foundation
  • Designing our API’s consistently
  • Not always the library implementations provided by the programming languages we use are correct, even though they are designed by “experts”.
  • The concept of Stability
  • Generic programming, of course!

Ref-qualified member functions -- Alexander Kulikov

kukuruku.PNGToday on Kukuruku:

Ref-qualified member functions

by Alexander Kulikov

From the article:

Today I’m going to tell you about a new and a little known (to my mind) C++ feature — reference-qualified member functions. I’ll tell about the rules of such functions overloading and, as an example of use, I’ll show you that with the help of ref-qualified you can try to improve the resource management scheme, which is implemented with the help of another C++ idiom — RAII.

How Dropbox Uses C++ for Cross-Platform iOS and Android Development -- Ole Begemann

dropbox.pngDid you know that C++ is a hot language for mobile development? This seems to be widely known among C++ developers, but surprisingly widely unknown in the non-C++ programming community at large. Two of the major reasons why C++ is currently experiencing this surge in mobile interest are:

  • C++'s efficiency and determinism help create power-sipping apps -- ones that not only use fewer CPU cycles, but use them in battery-friendly "bursty" ways that let the CPU sleep frequently, and deterministically let go of expensive resources like sensors immediately when they're not needed.
  • C++'s portability makes it the only cross-platform language that can target every major and minor mobile phone and tablet platform -- including iOS, Android, Windows and Windows Phone, and Blackberry -- never mind of course as usual also targeting every other platform and environment too, from desktops to servers to datacenters where it's already the language of choice in companies from Google to Facebook.

In that vein, here's a post from just before the U.S. long weekend about using C++ for cross-platform mobile development.

Expect to see more news like this. Also, expect to see talks on using C++ for modern cross-platform mobile development as one of the hot topics at CppCon this September.

How Dropbox Uses C++ for Cross-Platform iOS and Android Development

by Ole Begemann

From the article:

When work started on the Mailbox app for Android, the team made the choice to write a large portion of the non-UI code in C++ — rather than rewriting the entire app in Java — with the goal of sharing that common C++ layer between iOS and Android. The iOS app used Core Data at the time, so migrating it off of Core Data to the shared C++ library was also part of the process. C++ seemed like an obvious choice because it is available on every platform and team members preferred the language over Java.

The Carousel team made the same choice since launching simultaneously on iOS and Android was an important goal from the start.

Quick Q: Why can't a data member be in a lamba capture list -- StackOverflow

Quick A: Because you can only capture local (stack) objects, including function parameters, and to access a data member in a member function you capture the local variable this.

Today on SO:

Why can't a data member be in a lamba capture list

I have a class foo that has bar as a member variable.

In another member function of the class, I'm writing a lambda function:

[bar](void){}

But I can't include bar in the capture list. Why is that?

C++Now 2014 talk slides now available

Many of the slides from last week's sold-out C++Now event are now posted on GitHub at the link below, and more are still being added.

If you missed C++Now this year, head over to check out the new CppCon coming this September...

C++Now 2014 Presentations

Tuesday, May 13

Library in a Week - c++ templating engine

Keynote: Axiomatic Programming: From Euclidean Deductions to C++ Templates and Beyond

C++14: Through the Looking Glass

Coroutines, Fibers, and Threads, Oh My

The Canonical Class

ConceptClang: Theoretical Advances with Full C++ Concepts

Generic Programming of Generic Spaces: Compile-Time Geometric Algebra with C++11

Test-Driven Development With Boost.Test and Turtle Mock, Part I/II

Removing undefined behavior from integer operations: the bounded::integer library

Value Semantics and Range Algorithms - Composability and Efficiency

Preparing the C++11 Library AFIO for Boost Peer Review

Wednesday, May 14

MPL11: A New Metaprogramming Library for C++11

The Optimization of a Boost.Asio-Based Networking Server

Undefined Behavior in C++; what is it, and why should I care

Mach7: The Design and Evolution of a Pattern Matching Library for C++

Practical Type Erasure: A boost::any Based Configuration Framework

A Tutorial Introduction to C++11/14 Part I/II

C++11 in Space Plasma Model Development

C++11 Library Design

Goals for Better Code: Implement Complete Types

Multiplatform C++

Octopus: A Policy-Driven Framework for CFD Simulations

Thursday, May 15

Keynote: Beware of C++

Interactive Metaprogramming Shell Based on Clang

libcppa: Type-safe Messaging Systems in C++

Unicode in C++

CppComponents: A Modern Portable C++11 Component System

UI. Aesthetics. C++

Accelerator Programming with C++ AMP

Designing XML API for Modern C++

Modern C++ as Concurrent Assembly

Understanding &&

Boost Library Incubator | Zip Archive

Friday, May 16

Iterators May Stay | LibreOffice File

Value Semantics: It ain't about the syntax!

Create Your Own Refactoring Tool with Clang

How to Design C++ Implementations of Complex Combinatorial Algorithms

Intro to Functional Programming in C++

Managing Object Lifetimes

0xBADC0DE

Expected — An Exception-friendly Error Monad

Lifetime and Usage of Global, Thread-local, and Static Data

Functional Data Structures in C++

Asynchronous Programming Using Boost.MetaStateMachine and the Upcoming Asynchronous Library

Ownership of Memory in C++

Saturday, May 17

The Future of Accelerator Programming in C++

Functional Reactive Programming - Cleanly Abstracted Interactivity

Disambiguation: The Black Technology

My Thoughts on Large Code Base Change Ripple Management in C++

Future of Boost: Boostache

Future of Boost: Community Management Team

Vector of Objects vs Vector of Pointers Updated -- Bartlomiej Filipek

More in the "contiguous enables fast" department:

Vector of Objects vs Vector of Pointers Updated

by Bartlomiej Filipek

From the article:

For 1000 particles we need on the average 2000 cache line reads! This is 78% more cache line reads than the first case! Additionally Hardware Prefetcher cannot figure out the pattern -- it is random -- so there will be a lot of cache misses and stalls.

In our experiment the pointer code for 80k of particles was more 266% slower than the continuous case.

ACCU 2014 talk slides now available

[Ed: Here's a candidate for the most hilarious thing you'll probably see today: Kevlin Henney's slide deck, including a link to this @netbat tweet.]

The recent ACCU 2014 was another resounding success, and many of the talk slides have now been posted. You can find them here:

Slides, Photos, Blogs via #accu2014 (accu.org)

Some fun C++ highlights with slides available include:

  • Dietmar Kuhl · Performance Choices
  • Howard Hinnant · Everything You Ever Wanted To Know About Move Semantics (and then some)
  • Hubert Matthews · Where is C++ headed?
  • Jonathan Wakely · There Ain't No Such Thing As A Universal Reference
  • Jonathan Wakely · The C++14 Standard Library
  • Kevlin Henney · Immutabilty FTW!
  • Marshall Clow · C++ Undefined Behavior -- what is it, and why should I care?
  • Olve Maudal · C++ Pub Quiz
  • Pattabi Raman · Random number generation in C++ -- present and potential future
  • Peter Sommerlad · C++14 an overview on the new standard for C++(11) programmers
  • Steve Love · Range and Elevation -- C++ in a modern world
  • ... and more (see the page).

CppCon: My Proposed Talks (Part 2) -- Herb Sutter

cppcon-108.PNGFollowing up on Herb's three talk proposals posted yesterday, the other two titles and abstracts are now posted, this time of new talks (note: again, pending review and selection by the program committee, so this is not final -- they may or may not be selected if there is stronger material).

CppCon: My Proposed Talks (Part 2)

by Herb Sutter

From the post:

GC for C++, and C++ for GC: “Right” and “Wrong” Ways to Add Garbage Collection to C++ (1 to 2 hours)

"Garbage collection is essential to modern programming!" "Garbage collection is silly, who needs it!"

As is usual with extremes, both of these statements are wrong. Garbage collection (GC) is not needed for most C++ programs; we're very happy with determinism and smart pointers, and GC is absolutely penalizing when overused, especially as a default (or, shudder, only) memory allocator. However, the truth is that GC is also important to certain high-performance and highly-concurrent data structures, because it helps solve advanced lock-free problems like the ABA problem better than workarounds like hazard pointers.

This talk presents thoughts about how GC can be added well to C++, directly complementing (not competing with) C++'s existing strengths and demonstrating why, as Stroustrup says, "C++ is the best language for garbage collection."

 

Addressing C++’s #1 Problem: Defining a C++ ABI (1 hour)

"Why can't I share C++ libraries even between my own internal teams without using the identical compiler and switch settings?" "Why are operating system APIs written in unsafe C, instead of C++?" "Why can’t I use std::string in a public shared library interface; it's the C++ string, isn't it?!"

These and more perennial questions are caused by the same underlying problem: For various historical reasons, C++ does not have a standard binary interface, or ABI. Partial solutions exist, from the Itanium ABI which addresses only the language and only on some platforms, to COM and CORBA which do both less and far more than is needed.

It is deeply ironic that there actually is a way to write an API in C++ so that it has a de facto stable binary ABI on every platform: extern "C".

This session describes current work driven by the presenter to develop a standard C++ ABI. This does not mean having identical binaries on all platforms. It does mean tackling all of the above problems, including directly addressing the #1 valid reason to use C instead of C++, and removing a major obstacle to sharing binary C++ libraries in a modern way.

CppCon: My Proposed Talks (Part 1) -- Herb Sutter

cppcon-109.PNGWith the CppCon talk submission deadline upon us, we're starting to get glimpses of the potential CppCon conference program. In today's post, Herb Sutter mentions three of his five talk proposals (note: pending review and selection by the program committee, so this is not final -- they may or may not be selected if there is stronger material).

CppCon: My Proposed Talks (Part 1)

by Herb Sutter

From the post:

Lock-Free Programming – or, How to Juggle Razor Blades (~2 hours)

Example-driven talk on how to design and write lock-free algorithms and data structures using C++ atomic<> – something that can look deceptively simple, but contains very deep topics. (Important note: This is not the same as my "atomic<> Weapons" talk; that talk was about the "what they are and why" of the C++ memory model and atomics, and did not cover how to actually use atomics to implement highly concurrent algorithms and data structures.)

This talk is about the "how to use them successfully" part of atomics, including:

  • Best practices and style for using atomic<>s
  • Three or more examples, including lock-free mail slots and iterations of a lock-free linked list, all in portable Standard C++
  • Defining and applying the different levels of "lock-freedom" (wait-free, lock-free, obstruction-free) to develop highly concurrent algorithms and data structures
  • Explaining and applying key concepts including especially: linearizability; trading off concurrency vs. promptness; and trading off concurrency vs. throughput/utilization
  • Demonstrating and solving the ABA problem, with clean and simple code – that's right, did you know that in C++11 you can solve this without relying on esoterica like double-wide CAS (which isn’t always available) or hazard pointers (which are deeply complex) or garbage collection (which isn’t in the C++ standard... yet)?

Standardization Update: C++14 and the Seven Dwarfs (1 hour)

Standardization has accelerated: By the time we meet at CppCon, C++14 might already be ratified. But that's only one of eight (so far) work items now in flight. In this session, I'll give a brief summary of the new features coming in C++14 itself, and then a tour of the seven (7) near-term separate Technical Specifications already underway – think of these as the "C++14 wave" of deliverables.

The ISO C++ committee has transitioned to a "decoupled" model where updated versions of the standard are published more frequently, while at the same time major pieces of work can progress and be published independently from the Standard itself and delivered asynchronously in the form of Technical Specifications (TS’s) that are separate from the main Standard and can later be incorporated into the Standard. Come to this session to see how this is helping both the standard and C++ compiler implementations near you stay current with the latest in C++.

The topics covered will be:

  • C++14: What’s new in the new standard due this year
  • File System TS: Portable file system access
  • Library Fundamentals TS (small): string_view and optional<>
  • Array Extensions TS: Language and library dynamic arrays
  • Concepts Lite TS: Templates + constraints = ++usability and ++diagnostics
  • Concurrency TS: Nonblocking futures (.then, .when_*), executors, and (maybe) await
  • Parallelism TS: A whole new Parallel STL with both parallel and vector execution support
  • One of:
        – Networking TS (small): IP addresses, URIs, byte ordering
        – Transactional Memory TS: Language and library extensions for transactional memory instead of mutexes for many kinds of concurrency control

This session will present an overview of each set of features, what it looks like and how to use it, and why it’s important for the standard and for your own portable C++ code.

Modern C++ Style: Idioms of C++11/14 (1 to 3 hours)

This session will cover modern and current C++ style, focusing on C++14. It will demonstrate how major features and idioms from C++98 are now entirely replaced or subsumed and should be used no more; how other major features and idioms have been dramatically improved to the point where your code is cleaner and safer and you’ll even think in a different style; and how pervasive styles as common as variable declarations are changed forever, and not just for style but for serious technical safety and efficiency benefits. For one thing, you’ll never look at auto the same way again – and if hearing that makes you worry, worry not, just attend the session to dig deep into the good reasons for the new reality.

Why C++14? Two reasons: First, it really does "complete C++11" with small but important consistency features like generic lambdas and make_unique that let us teach modern C++ style with fewer “except for” footnotes. Second, C++14 “is” C++ for the next several years and it’s real; it is feature-complete and in the final stages of standardization, and more importantly we are already seeing near-complete conforming implementations becoming widely available around the same time C++14 is expected to be formally published.

C++14 is a small but important improvement on C++11 that really does complete the language. What this means is that we’re going to have a complete and simpler set of idioms and styles to learn and use.