Tony Antoun, Igor Zaika: “How Microsoft Uses C++ to Deliver Office (and More) Across iOS, Android, Windows, and Mac“

What does it take to target multiple major mobile devices (as well as traditional environments) with portable, efficient, single-source code? This talk demonstrates architectures, techniques, and lessons learned rooted in actual experience with using C++ to deliver several major cross-platform projects across iOS, Android, Windows, and Mac: Microsoft Office (Word, Excel, PowerPoint, OneNote) and the SQL Server PowerBI. Each presents a different case study: For example, Office already used C++, whereas PowerBI was originally written in Silverlight and then rewritten in C++; Office is a set of user-facing apps, whereas PowerBI is a system component. Although some of these are demanding first-tier “Cadillac” applications, we expect this experience to be a model for the future as more and more apps fall into this category and use C++ to target many popular platforms from (mostly) a single source base.

This talk covers the following key topics and tradeoffs: Rich vs. reach, including access to latest OS features (e.g., iOS 8 additions) and hardware features (e.g., vector units, GPUs). Consistency of functionality. Client code vs. server/service web code. Sharing vs. quality, including dialing appropriately between more shared code and high quality code. Drawing the line between the bulk of C++ code and interfacing with non-C++ for UX and PALs (platform adaptation/abstraction layers) for target-specific user interface and system services. Architecting PALs, including why “mini-PALs” rather than an “über-PAL.” Forcing “doing the right thing” and good architecture with composable components. How C++ enables things not feasible using other technologies. Velocity and enabling faster cross-platform development and deployment. Cost of maintenance, including time, size, and complexity (both breadth and depth). And, last but not least, developing in a single modern C++ source base built with different evolving C++ compilers, including VC++ and Clang/LLVM.

Speakers’ bio: Tony Antoun is Director of Development for APEX, focusing on delivering Office on all Apple platforms and form factors (iPhone, iPad, Mac), as well as aligning the Office experience on other major platforms (Win32, WinRT, Android). Before that, Dev Manager for SQL PowerBI – a cross-platform interactive client data visualization solution (iOS, WinRT, Web) connected to the SQL Reporting cloud service. Before that, Dev Manager for HD-DVD, cross-platform client solution for High Definition interactivity of media experiences (Win32, WinCE, Linux, Xbox).

Igor Zaika is the Development Manager for the Office Core Experience team at Microsoft, responsible for shared UX components and application framework used by Office applications. Before that, Igor worked in various areas related to Office client applications, ranging from building Word Object Model and integrating VBA (Visual Basic for Applications) with Office, to shipping first version of OneNote for the WinRT platform. Before joining Microsoft, Igor worked on 3D CAD application and contributed to the Kronos project.

We left a few slots in the CppCon 2014 program for what we call “invited talks”. They are used to fill in important but otherwise under-represented topics (such as game development, mobile and embedded systems, etc) or generally interesting and unusual uses of C++. Today we are ready to announce the first two invited talks which are on Facebook’s heavy use of C++ in their server infrastructure:

Marcelo Juchem: “Meta Techniques: Heterogeneous Polymorphism and Fast Prototyping at Facebook“

As data driven systems evolve there’s an ever growing demand for bringing new functionality into existing systems in an efficient, maintainable and least intrusive manner. When implementing features with different semantics or interfaces, virtual inheritance requires a compromise between design simplicity and performance. This implies a need for new techniques to achieve heterogeneous polymorphism efficiently. With C++11 and 14, type lists, type maps and variants can now be trivially implemented by the initiated. Facebook moves fast so we quickly adopted the new standards to further explore the capabilities of the type system. This talk demonstrates some meta-programming techniques like reflection and compile-time built structures to achieve heterogeneous polymorphism and fast prototyping.

Speaker’s bio: Marcelo Juchem is a Software Engineer at Facebook, working in stream processing and spam fighting systems. Fascinated by template meta-programming, he sees the C++ compiler as a powerful type juggler and programmable code generator. Such capabilities allow the combinatoric composition of types into efficient abstractions, reducing code duplication and enabling non-library writers to design logical components interaction and semantics rather than deal with low level details.

Drew Paroski: “C++@Facebook: How HHVM Uses Modern C++ for Fun and Profit (Both Literally)“

After an overview of HHVM’s architecture and history, this talk delves into what made C++ the language of choice when writing VMs and execution engines, including performance, benefits over assembly, and enabling C++ to call into JIT’d code. We cover the importance of control over ‘unsafe’ details: for memory layout, unions, casting, and bit-stealing. HHVM found important wins from being able to ensure that certain structures (Classes) are allocated in low-memory (i.e. addresses that fit within 32-bits) which allowed use of 32-bit immediates in machine code and 32-bit fields in objects. Also, being able to have fine control over memory allocation enabled having “huge pages”, a feature exposed in Linux (and other OSes) that allowed using fewer iTLB entries which gave a significant boost for Facebook’s PHP codebase. The talk will also mention some things that got in the way and how they were dealt with. Some were language features, such as virtual functions, member pointers. Before move constructors and rvalues were introduced in C++11, there were performance issues with returning smart pointers. While these were things that got in the way, it’s a testament to C++’s flexibility that there were always ways to work around these things in a stable fashion.

Speaker’s bio: Drew Paroski is a Software Engineer at Facebook and a co-creator of the HipHop Virtual Machine (HHVM) and the Hack programming language. Among other things, Drew is the primary designer and implementor of HHVM’s virtual instruction set architecture and Hack’s Collections framework, and he was a core contributor to HHVM’s JIT compiler in the early days of the project. Before Facebook, Drew worked at Microsoft helping improve the performance of Microsoft’s virtual machine for .NET languages (C#, VB.NET, F#, and more) known as the Common Language Runtime. Drew has been coding in C++ for over 10 years, and he enjoys designing and optimizing complex low-level systems.

Every time we post an update on CppCon 2014 someone asks if there will be a recording of the conference. From the beginning we ruled out going the C++Now way by having student volunteers record sessions using consumer camcoders. It is a huge headache for those organizing it just for C++Now’s 3 tracks. It simply won’t scale to CppCon’s 6. So the decision was made to either record professionally or not to record at all. And professional recording of a week-long conference with 6 tracks is not cheap. This is why we couldn’t give a concrete answer until we knew for sure. And now we know for sure: we found a sponsor (can’t yet announce who it is), the contract has been signed, and the entire 6 tracks will be professionally recorded!

Now if you think there is no longer a good reason to attend CppCon in person, let me give you several. There will be recording but no live streaming (live streaming is on a whole new level, expense-wise). Because of the number of sessions involved, we will only be able to publish them about a month later. There will also be no recording of the “unconference” material: lightning talks, hackathons, BoF sessions, extended Q&A, etc.

But the main difference between being there and watching things a month later is missing out on what happens after the talks. Organizers of C++Now like to joke that half of the conference happens between the presentations, in personal interactions.

From personal experience, I spent 1.5 hours after my C++Now presentation chatting to a bunch of attendees who were particularly interested in the topic of my talk. I am not kidding: it was the same length as my presentation! You can’t participate in stuff like this if you are not there.

The bottom line: yes, you will eventually be able to view all the sessions but you will miss out on a lot of fun, personal interactions, and insight that comes with that.

Video recording is also great news for those planning to come. Remember, you can only attend one talk out of every six. But now you will be able to catch up with the video recordings.

If you have never attended a C++ conference and you are not sure whether CppCon is worth it, I hope I managed to convey some of the atmosphere that you can expect. If C++Now is anything to go by, this will be a week where you will learn more about C++ than in the rest of the year all while having a lot of fun.

And remember, the Early Bird registration deadline is tomorrow.

The CppCon 2014 Program is now available with talk titles, abstracts, and speakers. The program contains over 100 one-hour sessions by over 70 speakers including plenary sessions by Scott Meyers and Herb Sutter, as well as the keynotes by C++ creator Bjarne Stroustrup on Keeping Simple Things Simple and Mark Maimone on using C++ on Mars: Incorporating C++ into Mars Rover Flight Software.

The detailed schedule including the exact day and time of each talk will be posted in the coming weeks. We have also extended the Early Bird deadline to July 9 so you have a week to study the program and still get the Early Bird rate.

Finally, we would like to thank the program committee, the speakers on the program, and the many more who proposed talks which we unfortunately just couldn’t squeeze in this year. Thank you for your hard work and enthusiastic support for this year’s program!

There are several developments in preparation for the conference: We’ve sent the acceptance notifications to authors who proposed talks. If you haven’t received the email, please contact the Program Committee. The Program Committee is now hard at work putting together and scheduling the program and we still aim to have it ready by the 27th of June. Note also that the early bird deadline is only 9 days away. Finally, we have the second keynote for CppCon 2014:

C++ on Mars: Incorporating C++ into Mars Rover Flight Software
by Dr. Mark Maimone

One of the more challenging aspects of developing flight software (FSW) for NASA’s Spirit and Opportunity Mars Exploration Rovers (MER) and Curiosity, the Mars Science Laboratory rover was how to enable them to drive themselves safely through unknown Martian terrain. When the MER mission was approved in the year 2000, JPL researchers had already demonstrated that capability on prototype rovers using software written primarily in C++ on a VxWorks realtime O/S platform with shared memory. So when asked to incorporate that capability into the MER vehicles which also relied on a similar VxWorks realtime O/S, the team concluded it would be safest and most expedient to incorporate the already field-tested C++ software. But that presented a challenge, since at that point all rover FSW development was mandated to be done mainly in the C programming language.

In this talk we present some of the challenges we faced and solutions we found in deploying C++ onto the Mars Rovers. For example, dynamic allocation was initially precluded, but development of a specialized memory allocator (using the C++ “placement new” operator) enabled us to incorporate it safely into the flight system. We will discuss what aspects of C++ were incorporated, what simulation environments aided development, describe some of the tools used to validate system behavior, and explain how our success using C++ for the implementation of autonomous navigation on MER has influenced future FSW efforts.

Speaker’s bio: Dr. Mark Maimone is a Navigation and Machine Vision researcher at JPL. Mark designed and developed the autonomous vision and navigation software that lets the MER and MSL Mars Rovers drive themselves safely, and wrote ground software that automated the analysis of Mobility and arm operations on MER. Mark is now a Rover Driver for Curiosity, and he continues to develop and enhance the onboard autonomous vision and navigation software for the rovers. Mark earned his Ph.D. in Computer Science at Carnegie Mellon University in 1996, and completed a postdoc there in 1997 as Navigation and Software Lead for the 1997 Atacama Desert Trek. At JPL since 1997, Mark has also worked on the Long Range Science Rover, Planetary Dexterous Manipulator, and Pioneer Vision System for Chornobyl Inspection projects, delivering 3D vision systems for autonomous robotic operations and mapping.

Stefanus Du Toit: “Hourglass Interfaces for C++ APIs”
Pedro Ramalhete, Andreia Correia: “How to Make Your Data Structures Wait-Free for Reads”
Gor Nishanov: “await 2.0: Stackless Resumable Functions”
Fedor Pikus: “Where did My Performance Go? (Scaling Visualization in Concurrent C++ Programs)”
Łukasz Mendakiewicz: “Viewing the World Through Array-Shaped Glasses”

Stefanus Du Toit: “Hourglass Interfaces for C++ APIs“

C++ provides a much richer set of abstractions than C. Classes, templates, overloading, and other core C++ features can be leveraged for more readable syntax, better compile time typechecking, more open ended genericity and improved modularity. On the flip side, C89 still boasts some advantages over C++, especially when viewed through a pragmatic lens. C ABIs on many platforms have been stable for decades, practically every language supports binding to C code through foreign function interfaces, and including nearly any C89 header has a negligible effect on compile time on modern computers. The Hourglass pattern provides the best of both worlds. It’s a way to structure libraries that retains the pragmatic benefits of C89 while still providing C++’s richness both at an interface and implementation level. It makes providing bindings from other languages to C++ libraries easier, and insulates from ABI issues such as incompatibilities between debug and release variants of runtimes. This talk provides an overview of the pattern, teaches practical techniques for its implementation using C++98 and C++11, and shares experience from using the pattern in real world projects.

Speaker’s bio: Stefanus Du Toit is a Software Lead at Thalmic Labs, where he enables amazing gestural experiences using the Myo armband. Stefanus previously worked as a Software Architect and Software Development Manager at Intel Corporation, and co-founded RapidMind (acquired by Intel), a startup that targeted GPUs and other processors using standard C++. Stefanus served on the C++ standards committee as Project Editor for C++14 and as Committee Secretary. He lives in Kitchener-Waterloo, Ontario, Canada and holds a BMath CS from the University of Waterloo.

Pedro Ramalhete, Andreia Correia: “How to Make Your Data Structures Wait-Free for Reads“

In this talk we will describe a new concurrency control algorithm with Blocking write operations and Wait-Free Population Oblivious read operations, which we named the Left-Right algorithm. We will show a new pattern where this algorithm is applied, which requires using two instances of a given resource, and can be used for any data structure, allowing concurrent access to it similarly to a Reader-Writer lock, but in a non-blocking manner for reads, including safe memory management without needing a GC.

Speaker’s bio: Pedro Ramalhete has a PhD in Particle Physics for research done at CERN. Most of the research itself required programming in C++, and he also had a major participation in the coding of the experiment’s data acquisition and decoding software in C and C++. Pedro is currently working at Cisco writing networking software, with emphasis on real-time concurrent synchronization techniques, and wait-free/lock-free data structures.

Gor Nishanov: “await 2.0: Stackless Resumable Functions“

When dealing with the task/future based asynchronous model, developers need to write lambda-heavy continuation code with potentially multiple nesting lambdas. This makes the code less readable and not very pleasant to write. Stackless resumable functions allow developers to use more natural imperative coding style and provide performance benefits that are not possible with library-only solutions.

Speaker’s bio: Gor Nishanov is a Principal Software Design Engineer on the Microsoft C++ team. He works on the ‘await’ feature. Prior to joining the C++ team, Gor was working on distributed systems in Windows Clustering team.

Fedor Pikus: “Where did My Performance Go? (Scaling Visualization in Concurrent C++ Programs)“

High performance is one of the main reasons programmers choose C++ for their applications. If you are writing in C++, odds are you need every bit of computing power your hardware can provide. Today, this means writing multi-threaded programs to effectively utilize the multiple CPU cores that the hardware manufacturers keep adding. Everyone knows that writing multi-threaded programs is hard. Writing correct multi-threaded programs is even harder. Only after spending countless hours debugging race conditions and weird intermittent bugs do many programmers learn that writing efficient multi-threaded programs is harder yet. Have you ever wanted to see what are all your threads doing when they should be busy computing? This talk will show you how. We begin by studying several techniques necessary for collecting large amounts of data from the running program very efficiently, with little overhead and minimal disruption to the program itself. We will cover efficient thread-safe memory management and efficient thread-safe disk I/O. Along the way we dabble in lock-free programming just enough to meet our needs, lest the subject will spiral into an hour-long talk of its own. With all these techniques put together, we can collect information about what each thread is doing, which threads are computing and what exactly, and which threads are slacking off waiting on locks, and do it at the time scale of tens of microseconds if necessary. Then we process the collected data and create a timeline that shows exactly what the program was doing at every moment in time.

Łukasz Mendakiewicz: “Viewing the World Through Array-Shaped Glasses“

It’s agreed among experts that the most performant data structure in C++ is an array. Or a vector. Or a dynarray. Indeed, until recently there was no standardized approach in C++ to view these types in a uniform manner. It was even murkier when the data had logically more than one dimension. This talk is an introduction to the new features proposed for C++17 in N3851 bringing all contiguous data into harmony and lifting it to higher dimensions: index, bounds, array_view and more. Attendees will also learn how indexable algorithms differ from the traditional elemental ones, and what does it mean for parallelism.

Speaker’s bio: Łukasz Mendakiewicz is a software engineer at Microsoft, where he focuses on the customer experience with parallel programming models for C++. He is especially interested in GPGPU acceleration, and puts this passion to work on C++ AMP. He holds an M.S. in Computer Science from AGH UST in Krakow, Poland.

Jeff Garland: “Rebuilding Boost Date-Time for C++11”
Kate Gregory and James McNellis: “Making C++ Code Beautiful”
Joel Falcou: “Costless Software Abstractions for Parallel Architectures”
Walter E. Brown: “Your Help Wanted: Language Proposals in Flight”
Jens Weller and Jon Kalb: “Founding C++ User Groups”

Jeff Garland: “Rebuilding Boost Date-Time for C++11“

Boost date_time is a widely used C++ library originally released in 2001 — including being the basis for elements of the chrono library in C++11. While the library interface has stayed stable for more than a decade, the world around it has changed with the standard library and language changing. It is time for the library to be rewritten to account for C++11. This lecture describes in detail the design decisions and changes to the library for C++11. More generally it describes elements of design for a small valuetype library. Many of these considerations involve new features of C++11 and how they should be used. This includes noexcept, move construction/assignment (R-values), constexpr, enum classes, and user defined literals. Attendees will learn about the design considerations and tradeoffs of using the new language features in their own work while getting a glimpse of boost date_time version 2.

Speaker’s bio: Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. He’s a long time participant in the Boost and C++ community including developing Boost date_time, serving as a moderator and Boost steering committee member, co-authoring papers for the C++11 chrono library, and running the annual Library in a Week workshop at C++Now. Mr. Garland holds a Master’s degree in Computer Science from Arizona State University and a Bachelor of Science in Systems Engineering from the University of Arizona. He is a co-author of “Large Scale Software Architecture: A Practical Guide Using UML.”

Kate Gregory and James McNellis: “Making C++ Code Beautiful“

Ask a non-C++ developer what they think of C++ and they’ll give the language plenty of compliments: powerful, fast, flexible, and “the language for smart people”. But along with that you are likely to hear ugly, complicated, hard to read, and “the language for smart people”. Is it possible to write beautiful C++? Not arcanely elegant or wickedly compact, but readable, clear, expressive – beautiful! We say it is, and we want to show you how. In this session, you’ll see how to turn pages of “comic book characters swearing” into code you’ll be proud to call your own. By making your code express your intent, using the power of new language and library functionality, and leaving hard-to-read constructs out of your vocabulary, you can give your code a makeover that will stand the test of time.

Speakers’ bio: Kate Gregory has been using C++ since before Microsoft had a C++ compiler. She writes, mentors, codes, and leads projects, in both C++ and .NET, especially for Windows 7 and 8. Kate is a Microsoft Regional Director, a Visual C++ MVP, and has written over a dozen books (the most recent on C++ AMP for Microsoft Press) and speaks at conferences and user groups around the world. Kate develops courses on C++, Visual Studio, and Windows programming for Pluralsight, founded the East of Toronto .NET Users group, and is a member of adjunct faculty at Trent University in Peterborough.

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.

Joel Falcou: “Costless Software Abstractions for Parallel Architectures“

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. Even 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 becomes unwieldy. This talk explores various software design techniques, like Generative Programming, Meta Programming and Generic Programming, and their application to the implementation of a parallel computing librariy in such a way that abstraction and expressiveness are maximized while 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.

Speaker’s bio: Joel Falcou is an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d’Informatique in Orsay, France. His research focuses on studying generative programming idioms and techniques to design tools for parallel software development. The two main parts of those works are: exploration of Embedded Domain Specific Language design for parallel computing on various architectures and the definition of a formal framework for reasoning about meta-programs and prove their compile-time correctness. Applications range from real-time image processing on embedded architectures to High Performance Computing on multi-core clusters. He is a NumScale SAS scientific advisor. NumScale mission is to assist businesses in the exploration and subsequently the mastery of high-performance computing systems.

Walter E. Brown: “Your Help Wanted: Language Proposals in Flight“

Want to collaborate in designing and implementing a new feature for C++17? Then this session is for you! After reviewing the process by which a new C++ feature enters the language, we will look at one or two of the speaker’s proposals that have received early favorable review from the standards committee, and that are awaiting sample implementation and/or formal wording. Attendee feedback will be solicited, and collaborators will be sought to help bring the proposal(s) to fruition.

Speaker’s bio: With broad experience in industry, academia, consulting, and research, Dr. Walter E. Brown has been a C++ programmer for over thirty years, joining the C++ standards effort in 2000. Among numerous other contributions, he is responsible for introducing such now-standard C++ library features as cbegin/cend and common_type as well as headers <random> and <ratio>, and has significantly impacted such core language features as alias templates, contextual conversions, and variable templates. He conceived and served as project editor for the International Standard on Special Mathematical Functions in C++. When not playing with his grandchildren, Dr. Brown is an Emeritus participant in the C++ standards process, with several more core and library proposals under consideration. He was recently appointed an associate project editor for the C++ standard itself.

Jens Weller and Jon Kalb: “Founding C++ User Groups“

In September “Meeting C++” will have existed for a little more than 2 years. Within those 2 years we went from a few C++ User Groups in Europe to many. We would like to talk about how to continue with founding even more C++ User Groups, but also sharing an overview of the already active User Groups in Europe and the US.

Speakers’ bio: Jens Weller has worked, since 2007, as a freelancer in C++, specialising in consulting, training and programming C++. He started with programming C++ back in 1998. He is an active member of the European C++ community and the founder of the Meeting C++ platform and conference. Jens is an active supporter of C++ user groups and blogs often about C++.

Jon has been programming in C++ for twenty years. He is currently doing this for Amazon’s A9.com. During the last two decades he has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, Yahoo! and a number of companies that you’ve never heard of. He taught C++ at the graduate school at Golden Gate University for a couple of years and is currently chair of C++ Now (aka BoostCon) and of the Boost Steering Committee. Jon’s current interest is coming up to speed with C++11/14.

Alisdair Meredith: “What’s New In The C++14 Library”
Hartmut Kaiser: “Asynchronous Computation in C++”
Eric Niebler: “Range-ifying the STL”
Michael Wong: “What did C++ do for Transactional Memory?”
John Lakos: “Defensive Programming Done Right”

Alisdair Meredith: “What’s New In The C++14 Library“

After the grand expansion of the C++11 library, the extensions in C++14 are more modest, often tweaking and cleaning up existing components. Alisdair Meredith, the Library Working Group chair, walks through all these changes and additions, and a little insight into features that did not make the cut, and are expected to arrive in other Technical Specification before the next standard ships.

Speaker’s bio: Alisdair Meredith is a software developer at BloombergLP in New York, and the C++ Standard Committee Library Working Group chair. He has been an active member of the C++ committee for just over a decade, and by a lucky co-incidence his first meeting was the kick-off meeting for the project that would become C++11, and also fixed the contents of the original library TR. He is currently working on the BDE project, BloombergLP’s open source libraries that offer a foundation for C++ development, including a standard library implementation supporting the polymorphic allocator model proposed for standardization.

Hartmut Kaiser: “Asynchronous Computation in C++“

With the adoption of the new C++11 Standard the community sees a revival of interest in the language. This interest is also driven by the demands that new computer architectures and technologies are exerting on application developers and domain scientists. Especially the need for highly runtime adaptive algorithms and applications puts a great strain on our ability to efficiently write code which performs well and which scales satisfactory, as multi-core and multi-threading is the new modality of computation. We argue that new programming models have to be developed if we are to gain continued scalability of computations as we increase the size of our systems. These are programming models which work equally well for inter-node as well for intra-node use. With the degree of complexity and size increasing in new hardware architectures, applications are more and more hindered by the main bottlenecks in computation, namely starvation, latency, overheads, and waiting for contention resolution. We present HPX, which is a general purpose parallel C++ runtime system implementing a new model of computation – ParalleX, that attempts to address those challenges. We show results from using HPX for leveraging and managing asynchrony, overlapping different phases of computation and communication, suggesting ways to seamlessly expose it to programmers in an easy to use way.

Speaker’s bio: Hartmut is a member of the faculty at the CS department at Louisiana State University (LSU) and a senior research scientist at LSU’s Center for Computation and Technology (CCT). He received his doctorate from the Technical University of Chemnitz (Germany) in 1988. He is probably best known through his involvement in open source software projects, mainly as the author of several C++ libraries he has contributed to Boost, which are in use by thousands of developers worldwide. His current research is focused on leading the STE||AR group at CCT working on the practical design and implementation of future execution models and programming methods. His research interests are focused on the complex interaction of compiler technologies, runtime systems, active libraries, and modern system’s architectures. His goal is to enable the creation of a new generation of scientific applications in powerful, though complex environments, such as high performance computing, distributed and grid computing, spatial information systems, and compiler technologies.

Eric Niebler: “Range-ifying the STL“

Range-based interfaces have many advantages over iterator-based ones. That explains why there are several range libraries to choose from. The standardization committee has been hard at work exploring the range library design space, and with luck we’ll have a best-of-breed solution ready for C++17. In this talk, I will present the work of several committee members, myself included, to put together a range library suitable for standardization. The work condenses the ideas from several popular range libraries, some new ideas, and much guidance from SG9, the Ranges Study Group. Come find out how we’re planning to make the STL easier to use, more powerful, and even more efficient than it already is, while keeping everything you already love.

Speaker’s bio: Eric Niebler is a true believer in the power of low-overhead abstraction and a shameless bit-twiddler, which explains his deep and abiding love of C++. Before setting out on his own as a freelancer, Eric worked as a consultant for BoostPro, a library developer for Visual C++, and a systems developer in Microsoft Research. He has authored 4 official Boost libraries, is on the Boost Steering Committee, and is a member of the C++ Standardization Committee. Eric lived for over 2 years years with no fixed address, slinging code from the coffee shops of the world. Buy him a beer and ask him about his life as a tech-nomad.

Michael Wong: “What did C++ do for Transactional Memory?“

SG5 is a Study Group within WG21 developing a promising new way to deal with mutable shared memory, that is expected to be more usable and scalable than current techniques based on atomics and mutexes. It promises to be as easy to use as coarse-grained locks, as scalable as fine-grained locks and yet remain composable. Find out where on the Gartner hype cycle lives Transactional Memory. Is it at the Peak of Inflated Expectations, Trough of Disillusionment, Slope of Enlightenment, or Plateau of Productivity? For that matter, just how soon will I be able to use it with the new Intel Haswell, and IBM Power Hardware, or is it one of those mirages where the closer you get to your hardware, the further it moves away. And is it true that one of the lead author of this TM proposal also wrote “Is it just a Research Toy?” This 60-90 minute advanced talk will cover the history of Transactional Memory, various lock elision and optimistic speculation techniques, the technical engine behind Transactional Memory, the recent research in its use cases, usability and performance data that supports its entry into the C++ Standard, and of course the latest details of the SG5 Technical Specification, including our effort at transactionalizing the C++ Standard Library.

Speaker’s bio: Michael Wong is the CEO of the OpenMP Corporation, a consortium of 26 member companies that hold the de-facto standard for parallel programming specification for C/C++ and FORTRAN. He is the IBM and Canadian Head of delegation to the C++ Standard, and Chair of the WG21 Transactional Memory group. He is the co-author of a number of C++/OpenMP/TM features and patents. He is the past C++ team lead to IBM´s XL C++ compiler, C compiler and has been designing C++ compilers for twenty years. Currently, he is leading the C++11 deployment as a senior technical lead for IBM. His current research interest is in the area of parallel programming, C++ benchmark performance, object model, generic programming and template metaprogramming. He is a frequent speaker at various technical conferences and serves on the Programming Committee of Boost, and IWOMP. He holds a B.Sc from University of Toronto, and a Masters in Mathematics from University of Waterloo.

John Lakos: “Defensive Programming Done Right“

In our component-based development methodology, each developer is responsible for ensuring that the software he or she creates is easy to understand and use, and not especially easy to misuse. One common form of misuse is to invoke a library function or method under circumstances where not all of its preconditions are satisfied, leading to undefined behavior. Contracts having undefined behavior are not necessarily undesirable, and (for many engineering reasons) are often optimal. Most would agree that a well-implemented library should do something other than silently continue when a pre-condition violation is detected, although these same folks might not agree on what specific action should be taken. Unfortunately, validating preconditions implies writing additional code that will execute at runtime. More code runs slower, and some would fairly argue that they should not be forced to pay for redundant runtime checks in the library software they use. Whether and to what extent library functions should validate their preconditions, and what should happen if a precondition violation is detected are questions that are best answered on an application by application basis – i.e., by the owner of main. “Defensive Programming Done Right” makes it all possible. In this talk, we begin by reviewing the basic concepts of Design-By-Contract (DbC), and what we mean by the term “Defensive Programming” (DP). We then explore our overall approach to institutionalizing defensive programming in robust reusable library software such that each application can conveniently specify both the runtime budget (e.g., none, some, lots) for defensive checking, and also the specific action to be taken (e.g., abort, throw, spin) should a precondition violation occur. Along the way, we touch on how modern compilers and linkers work, binary compatibility, and the consequences of possibly violating the one-definition rule in mixed-mode builds. We conclude the talk by describing and then demonstrating our “negative testing” strategy (and supporting test apparatus) for readily verifying, in our component-level test drivers, that our defensive checks detect and report out-of-contract client use as intended. Actual source for the supporting utility components will be presented throughout the talk and made available afterwards.

Speaker’s bio: John Lakos, author of “Large Scale C++ Software Design.”, serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide. He is also an active voting member of the C++ Standards Committee, Library Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications at Bear Stearns. For 12 years prior, Dr. Lakos developed large frameworks and advanced ICCAD applications at Mentor Graphics, for which he holds multiple software patents. His academic credentials include a Ph.D. in Computer Science (’97) and an Sc.D. in Electrical Engineering (’89) from Columbia University. Dr. Lakos received his undergraduate degrees from MIT in Mathematics (’82) and Computer Science (’81). His next book, entitled “Large-Scale C++, Volume I: Process and Architecture”, is anticipated in 2014.

Herb Sutter: “Standardization Update: C++14 and the Seven Dwarfs”
Stephan T. Lavavej: “STL Features And Implementation Techniques”
Jared Hoberock: “Parallelizing the Standard Algorithms Library”
Howard Hinnant: “Types Don’t Know #”
Lisa Lippincott: “How to call C libraries from C++”

Herb Sutter: “Standardization Update: C++14 and the Seven Dwarfs“

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, the chair of the ISO C++ committee will 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++.

Speaker’s bio: Herb Sutter is the author of several best-selling books about C++, chair of the ISO C++ standards committee, and a software architect at Microsoft.

Stephan T. Lavavej: “STL Features And Implementation Techniques“

This session will cover selected STL features from C++11/14, both explaining how to use them and delving into implementation techniques that could be useful outside the STL. I will avoid covering popular features you’re already using (e.g. make_shared, make_unique) and obscure features of limited use (e.g. forward_list). The focus will be on useful but underappreciated features like dual-range algorithms, minimal allocators, and heterogeneous associative lookup.

Speaker’s bio: Stephan T. Lavavej is a Senior Developer at Microsoft. Since 2007, he’s worked with Dinkumware to maintain Visual C++’s implementation of the C++ Standard Library. He also designed a couple of C++14 features: make_unique and the transparent operator functors. He likes his initials (which people can actually spell) and cats (although he doesn’t own any).

Jared Hoberock: “Parallelizing the Standard Algorithms Library“

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.

Speaker’s bio: Jared Hoberock is a research scientist at NVIDIA where he develops the Thrust parallel algorithms library and edits the Technical Specification on Extensions for Parallelism for C++.

Howard Hinnant: “Types Don’t Know #“

This presentation will be based on the C++ standards committee proposal of a new hashing infrastructure that completely decouples hashing algorithms from individual types that need to be hashed. This decoupling divides the hashing computation among 3 different programmers who need not coordinate with each other:

1. Authors of hashable types (keys of type K) write their hashing support just once, using no specific hashing algorithm. This code resembles (and is approximately the same amount of work as) operator== and swap for a type.
2. Authors of hashing algorithms write a functor (e.g. H) that operates on a contiguous chunk of generic memory, represented by a void const* and a number of bytes. This code has no concept of a specific key type, only of bytes to be hashed.
3. Clients who want to hash keys of type K using hashing algorithm H will form a functor of type std::uhash<H> to give to an unordered container: unordered_set<K, uhash<H>>

Speaker’s bio: Howard Hinnant is a lead author of several C++11 features including: move semantics, unique_ptr, <mutex>, <condition_variable> and <chrono>. Coming in C++14: <shared_mutex>. Howard is also a lead author on two open source projects: a std::lib implementationand an Itanium ABI implementation

Lisa Lippincott: “How to call C libraries from C++“

Many libraries used by C++ programs present C-like interfaces that are compatible with C++, but are not directly compatible with good C++ style. Using these libraries directly is error-prone in many of the ways C++ is designed to avoid. It is better to pass through an interface layer that presents good C++ style on the C++ side. But writing such an interface layer is daunting. Completing it may be an enormous task, as are documenting it and maintaining it as the underlying library evolves. To address this problem, I will present a style of writing such interfaces that can be used incrementally as needed, and that reduces documentation cost. I will also present a small library that supports the writing of interface layers in this style.

Speaker’s bio: Lisa Lippincott is a Chief Software Architect at Tanium, a bay-area startup. Her claim to fame is writing one phrase appearing in the C++ standard. In her spare time, she studies mathematical logic with a category-theoretic approach.

Continuing with the program preview, the next set of accepted talks is below (summary first, abstracts following):

Andrei Alexandrescu: “Mo’ Hustle Mo’ Problems”
Andrew Sutton: “Generic Programming with Concepts Lite”
Marshall Clow: “Hardening Your Code”
Nate Kohl: “cppreference.com: Documenting C++ One Edit at a Time”
Kate Gregory, James McNellis: “Modernizing Legacy C++ Code”

Andrei Alexandrescu: “Mo’ Hustle Mo’ Problems“

Reasonably-written C++ code will be naturally fast. This is due to C++’s excellent low-penalty abstractions and a memory model close to the machine. However, a large category of applications have no boundaries on desired speed, meaning there’s no point of diminishing returns in making code faster. Better speed means less power consumed for the same work, more workload with the same data center expense, better features for the end user, more features for machine learning, better analytics, and more. Optimizing has always been an art, and in particular optimizing C++ on contemporary hardware has become a task of formidable complexity. This is because modern hardware has a few peculiarities about it that are not sufficiently understood and explored. This talk discusses a few such effects, and guides the attendee on how to navigate design and implementation options in search for better performance.

Speaker’s bio: Andrei Alexandrescu is a researcher, software engineer, and author. He wrote three best-selling books on programming (Modern C++ Design, C++ Coding Standards, and The D Programming Language) and numerous articles and papers on wide-ranging topics from programming to language design to Machine Learning to Natural Language Processing. Andrei holds a PhD in Computer Science from the University of Washington and a BS in Electrical Engineering from University “Politehnica” Bucharest. He works as a Research Scientist for Facebook.

Andrew Sutton: “Generic Programming with Concepts Lite“

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.

Speaker’s bio: Andrew Sutton is an assistant professor at the University of Akron in Ohio where he teaches and conducts research at the intersection of Software Engineering and Programming Languages. Dr. Sutton helped design and implemented the Concepts Lite proposal for the C++ programming language. He is also the author of the Origin C++ Libraries, an experimental collection of generic libraries that supports ideas and research for generic programming. Dr. Sutton had previously worked as a postdoctoral researcher at Texas A&M University where he worked with Bjarne Stroustrup and Gabriel Dos Reis on the design and implementation of language support for generic programming (i.e., Concepts Lite). He is a member of the C++ Standards Committee and Project Editor for the Concepts Lite Technical Specification. He graduated with a PhD in computer science from Kent State University in Ohio in 2010.

Marshall Clow: “Hardening Your Code“

Ok, you’ve written some code, and it seems to work. How can you be sure that it works? It’s a busy, complicated, dangerous world out there, and software has to work in lots of different environments. How can you gain confidence about your code? How can you make your code more reliable? There are a lot of techniques available to developers today; I’ll talk about several of them: Unit tests, static analysis, runtime analysis, fuzzing, decoding compiler warnings and probably others.

Speaker’s bio: Marshall is a long-time Boost participant. He is one of the moderators of the Boost-Users mailing list, and helps keep the Trac system running. Marshall is a principal engineer at Qualcomm, Inc. in San Diego. He is the author of the Boost.Algorithm library, maintains Boost.Array and Boost.StringAlgo, and is the leader of the Boost Community Maintenance team.

Nate Kohl: “cppreference.com: Documenting C++ One Edit at a Time“

How do you convert hundreds of pages of C++ standardese into a resource that is accessible to software engineers around the world? This talk will describe the process of building a community-run website that documents all of the nooks and dark corners of the C++ programming language. I’ll look back at the history of how C++ was defined, cover the current state of documentation, examine the pros and cons of running a fairly high-profile publicly-editable wiki, and try to guess at what the future holds.

Speaker’s bio: Nate Kohl is a software engineer at Google who enjoys herding cats.

Kate Gregory, James McNellis: “Modernizing Legacy C++ Code“

C++ is a programming language with a long, storied history spanning over three decades–four if one includes its C ancestry. The C++ language has undergone many changes during that time, compiler technology has advanced substantially, and computers today are very different from the computers of decades past. But despite all of these advances, there’s an awful lot of C++ code in use today that looks like it was written in the 1980s. In C++ some cases, the code was written in the 1980s and it’s still in use; in other cases, it’s recently-written code that just doesn’t use modern style. In this talk, we’ll discuss some of the problems with legacy code, and review some practical techniques for applying principles of modern C++ to gradually improve the quality of legacy code and improve maintainability and debuggability. We’ll show how some very small changes to code can yield huge benefits.

Speakers’ bio: Kate Gregory has been using C++ since before Microsoft had a C++ compiler. She writes, mentors, codes, and leads projects, in both C++ and .NET, especially for Windows 7 and 8. Kate is a Microsoft Regional Director, a Visual C++ MVP, and has written over a dozen books (the most recent on C++ AMP for Microsoft Press) and speaks at conferences and user groups around the world. Kate develops courses on C++, Visual Studio, and Windows programming for Pluralsight, founded the East of Toronto .NET Users group, and is a member of adjunct faculty at Trent University in Peterborough.

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.