CppCon Program Highlights, 4 of N: C++ and Modern Concurrency

By Blog Staff | Jul 16, 2014 04:51 AM | Tags: None

The CppCon 2014 conference program has been posted for the upcoming September conference. We've received requests that the program continue to be posted in "bite-sized" posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.

CppCon would be incomplete without strong coverage of concurrency-related techniques. But this year's material isn't about just any old concurrency techniques -- it's about stitching high-update-rate data structures and highly responsive algorithms into high performance scalable code. As always, these talks are by the right people -- Those Who Know and Those Who Do in some of the leading efforts in our industry, from *nix to Windows and from IBM to Microsoft to BlackBerry.

In this post:

• C++ Memory Model Meets High-Update-Rate Data Structures
• Lock-Free Programming (or, Juggling Razor Blades)
• Lock-Free by Example
• Async Sequences and Algorithms to Compose Them

C++ Memory Model Meets High-Update-Rate Data Structures

Highly performant and scalable techniques such as RCU and hazard pointers have been quite successful in read-mostly situations. However, there do come times when updates are necessary. It would be convenient if there was some general update-side counterpart to these techniques, but sadly there is not yet any such thing. Nevertheless, there are a number of specialized update-side techniques whose performance and scalability rival those of RCU and hazard pointers. This talk will discuss several of them, one of which is a solution to a challenge to the speaker at the 2014 Issaquah C++ standards committee meeting. This talk will also provide an outlook into the future of low-overhead scalable updates.

Speaker: Paul E. McKenney, Distinguished Engineer, IBM Linux Technology Center. Paul E. McKenney has been coding for almost four decades, more than half of that on parallel hardware, where his work has earned him a reputation among some as a flaming heretic. Over the past decade, Paul has been an IBM Distinguished Engineer at the IBM Linux Technology Center. Paul maintains the RCU implementation within the Linux kernel, where the variety of workloads present highly entertaining performance, scalability, real-time response, and energy-efficiency challenges. He is also the editor of "Is Parallel Programming Hard, And, If So, What Can You Do About It?" Prior to that, he worked on the DYNIX/ptx kernel at Sequent, and prior to that on packet-radio and Internet protocols (but long before it was polite to mention Internet at cocktail parties), system administration, business applications, and real-time systems. His hobbies include what passes for running at his age along with the usual house-wife-and-kids habit. Website: http://www.rdrop.com/users/paulmck

Lock-Free Programming (or, Juggling Razor Blades)

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.)

Speaker: Herb Sutter, Microsoft. Author, chair of the ISO C++ committee, software architect at Microsoft.

Lock-Free by Example

Dive into and follow along making a lock-free queue. In particular, a multi-producer, multi-consumer, growing, shrinking, mostly contiguous, lock-free circular queue. With this single (complicated!) example, we will come across, and attempt to solve, many of the typical problems found in lockfree programming, and delve into the pros and cons of various solutions to those problems.

Speaker: Tony Van Eerd, C++ Guy, BlackBerry. Tony Van Eerd has been coding for well over 25 years, and hopefully coding well for at least some of that. Most of that time has been in the graphics/video/film/broadcast industry (at Inscriber/Adobe), writing low level pixel++, high level UI, as well as threading and everything else in between. He now works at BlackBerry, watching over the BlackBerry APIs. He is also the company-wide "C++ guy" writing half of his code in emails and wiki pages.

Async Sequences and Algorithms to Compose Them

All have heard and some have wept over all the many ways to express sequences (eg. iterator, range, container) and the algorithms to compose them (eg. filter, transform, merge, zip) in C++. I will describe one more sequence that must have a representation and an algorithm library - A sequence of values that will arrive over time.

Speaker: Kirk Shoop, Developer, Microsoft Open Technologies, Inc. Hi! I have a family. I like food. I need sun (My need for sun must be why I live in Seattle). I like C++. I don't like threads (My aversion to using threads must be why I spend all my free time working on a library that composes sequences on many threads). I work at Microsoft Open Technologies, Inc.Website: http://kirkshoop.blogspot.com/Twitter handle: @kirkshoop

CppCon Bonus Talks: C++ at Facebook -- Boris Kolpackov

By Blog Staff | Jul 15, 2014 04:55 AM | Tags: None

In the CppCon spirit of talks "by the C++ community for the C++ community" given by Those Who Know and Those Who Do in some of the leading code bases in our industry, we're very pleased to relay this just announced on CppCon.org:

Bonus Talks: C++ at Facebook

by Boris Kolpackov

From the announcement:

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.

CppCon Program Highlights, 3 of N: C++ and the Modern Game

By Blog Staff | Jul 10, 2014 03:54 AM | Tags: None

The CppCon 2014 conference program has been posted for the upcoming September conference. We've received requests that the program continue to be posted in "bite-sized" posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.

No C++ conference (or 'Con) would be complete without covering a perennial stronghold for tight C++ code: games. What can be said that hasn't been said before? Some interesting answers will be found in the following talks, which cover the gamut from casual homebrew games to the world's top "AAA" titles... and a little bird tells us there may be some additional leading-edge game-related content still to be announced for CppCon. As always, these talks are by the right people -- Those Who Know and Those Who Do in some of the leading efforts in our industry.

In this post:

• How Ubisoft Montreal Develops Games for Multicore -- Before and After C++11
• C++ in Huge AAA Games
• Quick game development with C++11/C++14

How Ubisoft Montreal Develops Games for Multicore -- Before and After C++11

Multicore hit the video game industry in a big way. Every platform we develop for now comes in a multicore configuration, and we're always under pressure to exploit the hardware to its fullest. This talk will share our experience learning to develop C++ software for multicore processors over the last decade. It will also explore the new concurrency support in C++11, and examine the way C++11 has influenced the way we develop multicore software so far.

Speaker: Jeff Preshing, Technical Architect, Ubisoft. Jeff Preshing is a Technical Architect at Ubisoft Montreal, where he's worked on games such as Rainbow Six Vegas, Child of Light and Assassin's Creed Unity. He also maintains a blog where he writes frequently about lock-free programming and the C++11 atomic library.

C++ in Huge AAA Games

Video games like Assassin's Creed or Rainbow Six are among the biggest code bases with a single static linking. Iteration-time is critical to develop a great game and keeping a complete compilation-time of a few minutes is a constant challenge. This talk will explain the C++ usage reality at Ubisoft Montreal for huge projects. Ideas will be shared regarding performance, debugging and iteration time.

Speaker: Nicolas Fleury, Technical Architect, Ubisoft. Nicolas Fleury has been in video game industry for over 10 years, working as a Technical Architect on projects like Prince of Persia and currently on Rainbow Six: Siege. Before working in the game industry, he worked in computer assisted surgery, speech recognition and telecoms.

Finally, to underscore that C++ is not just for "big AAA" titles, CppCon is very pleased to include this fresh talk by a superb young up-and-coming open source gaming guru -- if you haven't heard his name yet, don't worry, you will:

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

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.

Speaker: Vittorio Romeo. Vittorio is an Italian 19 year old Computer Science student at the University of Messina. He started programming at a very young age and soon became an enthusiast of the C++ language. While following the evolution of the C++ standard and embracing the newest features, he worked on many open-source project, such as general-purpose libraries and free multiplatform independent games, which are still being maintained and expanded today. Vittorio also participated as a speaker at Messina's 2013 Linux Day event and he is currently creating an online game-development C++11 video tutorial series for beginners.

CppCon Program Highlights, 2 of N: C++ and the Modern Web

By Blog Staff | Jul 8, 2014 11:02 PM | Tags: None

The CppCon 2014 conference program has been posted for the upcoming September conference. We've received requests that the program continue to be posted in "bite-sized" posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.

Note: Early Bird registration ends in about 24 hours from the time of this post.

Some people seem to think that "web" and "C++" don't belong in the same sentence, but part of what you need to know about modern C++ is how essential it is for web services, how to use web services from C++ code, and the new tools available to compile C++ code to run in the browser -- any browser. In these talks, the CppCon program covers development in this exciting modern area, and we think you'll see that the speakers include the creators of the key technologies -- Those Who Know and Those Who Do in some of the leading efforts in our industry.

In this post:

• Emscripten and asm.js: C++'s Role in the Modern Web 
• Embind and Emscripten: Blending C++11, JavaScript, and the Web Browser
• Using C++ to Connect to Web Services

Emscripten and asm.js: C++'s Role in the Modern Web

All major web browsers are written in C++, but C++ is starting to fill an important role in web *content* as well: While JavaScript is the only standards-compliant language available to websites, compiling other languages to JavaScript has been shown to be practical and effective. This talk will explain how Emscripten, an LLVM-based open source compiler from C++ to JavaScript, lets you run a C++ codebase on the web at near-native speed. To achieve that level of performance, Emscripten emits asm.js, a strict subset of JavaScript that is easy for JavaScript engines to optimize, and was designed specifically as a compilation target for languages like C and C++. We'll also discuss some of the more challenging aspects of compiling C++ to JavaScript, stemming from the C++ language itself, libraries and toolchains, and some thoughts on possible solutions.

Speaker: Alon Zakai, Mozilla. Alan works on Emscripten, an LLVM-based compiler from C++ to JavaScript, as well as other projects related to porting existing content to the web. Twitter handle: @kripken

Embind and Emscripten: Blending C++11, JavaScript, and the Web Browser

Emscripten compiles C or C++ source code into JavaScript so it can run in a web browser. Emscripten is commonly used to port games to the web with no download or plugin required.

Embind is a C++11 binding library that makes it easy to expose libraries written in C++ to JavaScript. This allows JavaScript applications to take advantage of existing bodies of C++ code. In addition, C++ compiled into the asm.js subset of JavaScript is often faster than hand-written JavaScript, so Embind makes it convenient to accelerate JavaScript applications by writing high-performance functionality in C++.

With several motivating examples, this lecture will cover the design of embind, how variadic templates and constexpr facilitate interesting optimizations, and how embind minimizes its impact on the size of the generated JavaScript.

Speaker: Chad Austin, Technical Director, IMVU. Chad is a Senior Technical Director at IMVU, where he works on highly scalable backend systems, front-end web architectures, and optimizing the bits and bytes of 3D graphics pipelines. C++ was Chad's first love, and he once mowed "C++" into his back yard before a rainstorm, where it stayed for weeks. Website: http://chadaustin.me Twitter: @chadaustin

Using C++ to Connect to Web Services

Many languages have great support for connecting to web services. Trying to connect C++ applications to the cloud is difficult. The C++ standard library doesn't contain anything for networking (yet), and with the proliferation of devices, being able to do so in a cross platform manner is even more appealing. Often requiring use of multiple different styled, and potentially low level, libraries where asynchrony wasn't designed from the start. Or by building your own abstract layers over platform and operating system APIs, all of which distract from focusing on the core logic of your application.

The C++ REST SDK makes connecting to services easier by creating APIs focused on simplicity and asynchrony, built using tasks from the Parallel Patterns Library. This is done by putting together a series of cross platform libraries for working with HTTP, WebSockets, JSON, URIs, and OAuth. In many cases building on top of other popular open source libraries like Boost, OpenSSL, and WebSocket++. This talk will take a practical approach looking at what is involved in connecting to some of the common popular services from C++, using the C++ REST SDK and other libraries. Several tutorial style example and demos will be done using C++ code that runs on all the major platforms.

Speaker: Steve Gates, Microsoft. Steve Gates is a senior engineer on the Visual C++ team at Microsoft. Joining Microsoft in 2007, he's worked on various runtimes and libraries for parallel and asynchronous programming, including the Parallel Patterns Library. For the past couple of years he's been focusing on improving the experience in C++ for connecting to services. Specifically working on the C++ Rest SDK (Casablanca) open source project. Outside of work Steve's interests include growing vegetables, food preservation, and eating great food.

Introducing the CppCon House Band: Jim Basnight

By Blog Staff | Jul 8, 2014 12:30 PM | Tags: None

As already announced, CppCon is recording all sessions and panels, including on-mic Q&A. However, note that only the sessions will be recorded, not all of CppCon -- things that you can experience only by attending including lightning talks, BoFs, hackathons, extended Q&A with the 70+ speakers (when you follow them around after their mics turn off or enjoy extended ad-hoc hallway chats), live house band performances, other extra technical and social events in breaks and evening, and...

... wait. Did we say "live house band performances"?

We did indeed.

As part of presenting CppCon, the Foundation is proud to sponsor live music by a great local Seattle area act, The Jim Basnight Band. Jim and the boys  will be playing CppCon all five days and serving up all kinds of original music and covers, from rock and pop to funk and soul and a few surprises. Be sure to get to each day's plenary session early to rock out, and enjoy their Pacific Northwest musical vibe at other times throughout the week. The band has a deep song catalog, so get your requests ready.

We hope you'll join us in September to enjoy not only the deep technical breadth and depth of 2014's premier C++ conference program, but also the round-the-clock "unconference" and musical parts of the fun and refreshing spirit of CppCon.

Hundreds of attendees have already registered for C++'s "Woodstock 2014." Early Bird registration ends tomorrow.

(If you're reading this via a newsreader and don't get the embedded audio, visit this post on isocpp.org and enjoy.)

CppCon 2014 Video Recording -- Boris Kolpackov

By Blog Staff | Jul 8, 2014 06:47 AM | Tags: None

A very welcome announcement, hot off the press at cppcon.org:

CppCon 2014 Video Recording

by Boris Kolpackov

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.

CppCon Program Highlights, 1 of N

By Blog Staff | Jul 8, 2014 06:43 AM | Tags: None

The CppCon 2014 conference program has been posted for the upcoming September conference. We previously posted part of the CppCon program in six program preview blog posts, each containing a few session titles and abstracts. Several people have expressed that they prefer being able to absorb the program in this way as "bite-sized" blog posts, so we're going to continue posting a few additional sessions at a time this way, sometimes with commentary, until the entire conference program has been posted also via this blog series.

Note: Early Bird registration ends tomorrow.

Multi-device development across iOS, Android, Mac, Windows, and other platforms is increasingly in demand, and C++ is the only modern language supported on all of those platforms. We find many developers are still unaware of how C++ is being quietly adopted across major companies as the language of choice for sharing code to develop their cross-platform apps -- even in apps originally written in other platform-specific languages. In these talks, the CppCon program covers development in this exciting modern area, and we think you'll see that the speakers are Those Who Know and Those Who Do in some of the leading efforts in our industry.

In this post:

• Practical Cross-Platform Mobile C++ Development at Dropbox
• From the Dropbox Trenches: A Deep Dive into Two Cross-Platform Mobile Apps Written in C++
• UI Prototyping and Development for Multiple Devices in C++
• Multiplatform C++

​

Practical Cross-Platform Mobile C++ Development at Dropbox

The conventional wisdom of multi-platform mobile development comes down to two choices: write all your complex logic at least twice or settle for a slow, non-native experience for your users. Come learn how Dropbox has embraced a third option, where fast, cross-platform code in C++ is married to a smooth, native UI for the best of both worlds.

In Dropbox’s new generation of iOS and Android apps, we leverage the strengths of the platform frameworks while only writing and maintaining one version of complex logic like data syncing. We’ll explain the benefits and pitfalls of interfacing C++ to platform-specific code via Objective-C++ and JNI and how code generation has freed us from much of the effort involved. We’ll share the benefits we’ve gained from C++11/14, as well as the drawbacks, and how we’ve overcome each platform’s quirks. Finally, we’ll share tools that let you try this out yourselves.

Speakers:

• Alex Allain, Platforms and Libraries Lead, Dropbox. Alex has been writing about C++ since 1998, when he started Cprogramming.com. In 2012, he published Jumping into C++ to teach new programmers how to think like a professional C++ programmer. At Dropbox, Alex leads the Platforms and Libraries team, helping make the dream of cross-platform C++11 a reality. Prior to Dropbox, Alex led a team at Liquid Machines focused on injecting code into applications to perform binary hooking.
• Andrew Twyman, Software Engineer, Dropbox. Andrew Twyman has been developing products and libraries in C++ for almost 10 years. He loves building robust systems and solving tricky low-level problems. Starting in 2012, Andrew helped spearhead Dropbox’s new approach to cross-platform mobile development. Now on the Platforms and Libraries team, Andrew is helping bring cross-platform goodness to Dropbox’s new generation of mobile and desktop apps. Prior to Dropbox, Andrew was an architect at Liquid Machines, where shared libraries supported parallel development of more products than there were developers.

From the Dropbox Trenches: A Deep Dive into Two Cross-Platform Mobile Apps Written in C++

At Dropbox we’ve spent the last year and a half building two cross platform mobile apps: the email client, Mailbox, and the photo gallery, Carousel. We started with the goal of a native look and feel with seamless performance but also needed to leverage a small team to build these apps on multiple platforms. We ultimately accomplished this by using C++ to share significant amounts of code in each app.

We’ll cover what portions of our apps we built in C++ and why we left some portions in the platform languages of Java and Objective-C, deep diving into some of the most important components. We’ll also discuss some unexpected benefits, areas we faced technical and human challenges, and some tips and tricks that you can use to leverage C++ to build very high performance apps.

Speakers:

• Tony Grue, Engineering Manager, Dropbox. Tony has been building mobile applications, mostly in C++, for the last 8 years.  He worked on Dropbox for Android as it grew from a few million to more than 100 million installs. Now he leads the Carousel for Android and lib-carousel teams at Dropbox. Before Dropbox, Tony was at Microsoft where he contributed to the email, SMS, and visual search clients on Windows Phone.
• Steven Kabbes, Mobile Engineer, Dropbox. Steven was a member of the founding team of Mailbox and designed many of the core email sync algorithms that power it. Since then he has been working on cross platform mobile building the C++ layer of Mailbox which powers clients on iOS, Android and Mac. Steven is especially passionate about developer libraries, specifically ones that enable fast iteration on the next generation of products. https://avatars3.githubusercontent.com/u/592178

UI Prototyping and Development for Multiple Devices in C++

Using C++ for multi-device user interface and app development should be pretty straightforward. However, since the Standard C++ Language and Library specification does not specify a user interface library, it’s actually quite challenging given that the two leading mobile platforms provide non-C++ User Interface APIs. Even more challenging is the new world of mobile devices and the myriad form factors, layouts, resolutions, sensors, and services that an application developer has to deal with. Plus, the deployment model for remote devices makes testing UI changes slower due to the increased build and turnaround time. This session will describe how C++ can be used effectively for multi-device UI development and also deliver a rapid prototyping experience to minimize the deployment time to the device for testing.

Speaker: John "JT" Thomas, Director of Product Management at Embarcadero Technologies. JT 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. Previously, JT held product management positions at mobile Linux vendor MontaVista Software and at Research in Motion. He earned his Computer Science degree from University of California, Santa Cruz and his MBA and MSE from San Jose State University.Website: http://www.embarcadero.comTwitter handle: @FireMonkeyPM

Multiplatform C++

C++ is a multiplatform language, yet many difficulties arise when you want the same code to compile properly and function identically on different platforms. If you put aside the obvious system programming related obstacles, and the differences you might have between compilers (especially when it comes to supporting C++11 and C++14), you come to the surprising conclusion that what is truly hard is all the "little things" you didn't anticipate.

This talk will be about our experience with our own software, quasardb, that runs every day on three OS (FreeBSD, Linux and Windows), is built with three compilers (clang, gcc and msvc) and supports two architectures (IA32 and AMD64).

How to build natively the same software on Windows and Linux, provided that they have radically different tool chains? How to work around the subtle, but existing differences between Linux and FreeBSD? How do you solve cross-tools, cross-platform file editing problems? How to prevent your maintenance costs from increasing dramatically?

Speaker: Edouard Alligand, Chairman & CTO, Bureau 14. Edouard has more than thirteen years of professional experience in software engineering. After years hacking the kernel of various operating systems, Edouard founded Bureau 14, the home of the hyperscalable database quasardb. Combining an excellent knowledge of low level programming with a perverse love for template meta-programming, Edouard likes to come up with uncompromising solutions to seemingly impossible problems. He lives in Paris, France. Website: https://blogea.bureau14.fr/ http://twitter.com/edouarda14

CppCon 2014 Program Available -- Boris Kolpackov

By Blog Staff | Jul 2, 2014 06:00 AM | Tags: None

This is the day we've been waiting for: The CppCon 2014 Program is now available, with over 100 one-hour sessions by over 70 speakers.

Early Bird extended to July 9: Because there were many more good talk submissions than could fit into even a full-week six-track conference, the Program Committee needed an extra week to finalize the program selection. Early Bird registration was scheduled to end a week after the program was available to make sure that everyone could see the program in time for Early Bird, so the Early Bird registration has therefore also been extended to match, and will close on July 9. Register today for "the" C++ event of 2014.

Here's the announcement on cppcon.org:

CppCon 2014 Program Available

by Boris Kolpackov

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!

CppCon Status Update, Second Keynote -- Boris Kolpackov

By Blog Staff | Jun 24, 2014 08:57 AM | Tags: None

CppCon has announced a second keynote: C++ on Mars by Dr. Mark Maimone, JPL's lead architect for the C++ self-driving software in Mars Rover Curiosity and other rovers. He will be speaking on what it took to use C++ in this environment, and how this experience and lessons learned apply to other projects. This is a real treat you will not want to miss. More details below...

But first, a note: The full conference program is still coming soon, but its publication has been slightly delayed because the Program Committee had an unexpectedly high workload -- there were nearly twice as many talk proposals submitted as the conference has room for. Even though CppCon 2014 will have six full-week tracks with a total of 100 sessions, the PC had to make the difficult choice to reject many good talks that just didn't fit -- so many, in fact, that the good turned-down talks could fill another four-track full-week conference by themselves. (The silver lining is that the PC may have a head start on the program of CppCon 2015...)

If you haven't registered, register today -- Early Bird Registration ends in just over a week.

Status Update, Second Keynote

by Boris Kolpackov

From the announcement:

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.

CppCon Program Preview, 6 of N -- Boris Kolpackov

By Blog Staff | Jun 17, 2014 04:24 AM | Tags: None

More CppCon 2014 accepted talks have just been announced, below. For past announcements about the conference program, see also:

• CppCon Program Preview, 5 of N
• CppCon Program Preview, 4 of N
• CppCon Program Preview, 3 of N
• CppCon Program Preview, 2 of N
• CppCon Program Preview, 1 of N
• CppCon 2104: Initial Partial Topics and Speakers

Early Bird registration is available until June 30.

CppCon Program Preview, 6 of N

by Boris Kolpackov

From the announcement:

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.