Loading…
This event has ended. View the official site or create your own event → Check it out
This event has ended. Create your own
View analytic

Log in to bookmark your favorites and sync them to your phone or calendar.

Saturday, September 19
 

9:00am

Modernizing Your C++: Part I
You need this ticket from Eventbrite to sign up: Tuition: Modernizing Your C++.
"Modernizing Your C++" is a two day training course taught by Michael Caisse of Ciere Consulting. This course is for students that are comfortable with classic C++, but want to come up to speed with C++11/14. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 19th & 20th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/?p=613

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com


Saturday September 19, 2015 9:00am - 5:00pm
Kwolek (402) Meydenbauer Center
 
Sunday, September 20
 

9:00am

Modernizing Your C++: Part II
You need this ticket from Eventbrite to sign up: Tuition: Modernizing Your C++.
"Modernizing Your C++" is a two day training course taught by Michael Caisse of Ciere Consulting. This course is for students that are comfortable with classic C++, but want to come up to speed with C++11/14. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 19th & 20th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/?p=613

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com


Sunday September 20, 2015 9:00am - 5:00pm
Kwolek (402) Meydenbauer Center

4:00pm

Registration
Welcome! Let's get the paperwork out of the way.

Sunday September 20, 2015 4:00pm - 6:00pm
Hamilton (403) Meydenbauer Center

8:00pm

Reception
Get acquainted with new friends and reacquainted with old friends.

Sunday September 20, 2015 8:00pm - 10:00pm
Hamilton (403) Meydenbauer Center
 
Monday, September 21
 

8:00am

Registration
Welcome! Let's get the paperwork out of the way.

Monday September 21, 2015 8:00am - 9:00am
Montessori Hall Meydenbauer Center

9:00am

Keynote: Writing Good C++14
How do we use C++14 to make our code better, rather than just different? How do we do so on a grand scale, rather than just for exceptional programmers? We need guidelines to help us progress from older styles, such as “C with Classes”, C, “pure OO”, etc. We need articulated rules to save us from each having to discover them for ourselves. Ideally, they should be machine-checkable, yet adjustable to serve specific needs.

In this talk, I describe a style of guidelines that can be deployed to help most C++ programmers. There could not be a single complete set of rules for everybody, but we are developing a set of rules for most C++ use. This core can be augmented with rules for specific application domains such as embedded systems and systems with stringent security requirements. The rules are prescriptive rather than merely sets of prohibitions, and about much more than code layout. I describe what the rules currently cover (e.g., interfaces, functions, resource management, and pointers). I describe tools and a few simple classes that can be used to support the guidelines.

The core guidelines and a guideline support library reference implementation will be open source projects freely available on all major platforms (initially, GCC, Clang, and Microsoft).

Use, comment, and contribute!

Speakers
avatar for Bjarne Stroustrup

Bjarne Stroustrup

MD, Morgan Stanley
C++: history, design, use, standardization, future; performance, reliability; software developer education; | distributed systems


Monday September 21, 2015 9:00am - 10:45am
Montessori Hall Meydenbauer Center

11:00am

Beyond Sanitizers
At CppCon’2014 we presented the Sanitizers, a family of dynamic testing tools for C++. These tools allow you to find many stability and security bugs in C++ code, but they are only as good as your tests are. In this talk we will show how to improve your tests with guided fuzzing and how to protect your applications in production even if some bugs were not found. Fuzzing, or fuzz testing, is a surprisingly effective technique that allows you to discover new interesting test inputs. Coverage-guided fuzzing uses coverage-like code instrumentation to make fuzzing orders of magnitude more efficient. Taint-guided fuzzing goes even further by using taint tracking techniques. The next line of defense may be incorporated directly into production: the Control Flow Integrity instrumentation allows you to protect your program from corrupted function pointers (including pointers to virtual tables) and separating stack variables from the call stack protects from corrupted return addresses -- both with near-zero overhead. We will concentrate on particular tools implemented in the opensource LLVM toolchain (libFuzzer, DataFlowSanitizer, -fsanitize=cfi,safe_stack), but will also discuss several alternatives.

Speakers
avatar for Kostya Serebryany

Kostya Serebryany

Software Engineer, Google
Konstantin (Kostya) Serebryany is a Software Engineer at Google. His team develops and deploys dynamic testing tools, such as AddressSanitizer and ThreadSanitizer. Prior to joining Google in 2007, Konstantin spent 4 years at Elbrus/MCST working for Sun compiler lab and then 3 years at Intel Compiler Lab. Konstantin holds a PhD from mesi.ru and a Master from msu.ru.Twitter handle: @kayseesee


Monday September 21, 2015 11:00am - 12:00pm
McClintock (404) Meydenbauer Center

11:00am

Executors for C++ - A Long Story
Executors will be a base building block in C++ for asynchronous, concurrent and parallel work. The job of an executor is simple: run the tasks that are posted. So the first proposals for executors in C++ had a very simple interface. However, being a building block, the executor should provide an interface that's useful for all kind of higher level abstractions and needs to work together with different types of concurrency, like co-operative multi-tasking or GPU like hardware. This presentation will look at the evolution of the executor proposals for C++ and what they'll provide for normal application programmers.

Speakers

Monday September 21, 2015 11:00am - 12:00pm
Hamilton (403) Meydenbauer Center

11:00am

Qt: modern user interfaces for C++
The C++ language evolved significantly in the recent past, and so did many frameworks and libraries in the big ecosystem surrounding it.

For twenty years now, Qt is being used on a multitude of platforms to create native looking, compelling graphical user interfaces.

It offers C++ libraries and tools for building desktop, mobile and embedded applications. Qt gives engineers APIs for developing using two dimensional controls, integrating 3D using OpenGL, embedding web content, as well as a new declarative domain-specific language called QML, which is extensible using C++. Qt is also much more than a UI toolkit and provides a multitude of helper libraries for various use-cases, such as localization, database access, XML and JSON parsing and much more.

During this talk, I will give an introduction to Qt and present its capabilities in how it can be utilized to write modern UIs using C++, both in 2D as well as 3D. Additionally, I will show how some of its features, like the integrated web engine or QML, can be leveraged to go beyond C++. While at it, I hope to clear up some outdated misconceptions about Qt and its relationship to standard C++ and the STL as well as Boost and other libraries.

Finally, I will present the KDE Frameworks, an open source collection of high quality, cross platform Qt libraries that are being used by the KDE Software Collection. KDE frameworks are to Qt as Boost is to the STL. Recent development makes it simpler than ever to use these libraries in external applications.

Speakers
avatar for Milian Wolff

Milian Wolff

Software Engineer, KDAB (Deutschland) GmbH&Co KG
Milian Wolff works as a Software Engineer at KDAB, an expert Qt, C++ and | OpenGL consultancy. | He contributes to Qt and KDE for several years now. Besides that, improving | tooling around C++ development | is of huge interest to him: As the co-maintainer of the KDevelop IDE, he is | currently integrating Clang there | to replace the handwritten C++ parser and semantic analyzer. Performance of | C++ code is very important... Read More →


Monday September 21, 2015 11:00am - 12:00pm
Franklin (407) Meydenbauer Center

11:00am

Reactive Stream Processing in Industrial IoT using DDS and Rx.cpp
50 billion devices will be connected to the Internet by 2020. Many of them will belong to national critical infrastructure (smart power grids, smart roads, smart hospitals, smart cities) – forming the Industrial Internet of Things (IIoT). These devices will generate data streams that will need to be correlated, merged, filtered, and analyzed in real-time.  This talk will explore an elegant solution to this problem that is productive, composable, concurrency-friendly, and scales well. We utilize OMG’s Data Distribution Service for Real-Time Systems (DDS) standard for connectivity, and Reactive Extensions (Rx) for functional-style composable asynchronous data processing in modern C++.

Rx is a generalization of futures and can be thought of as the async equivalent of C++ ranges.  It helps create asynchronous data processing pipelines by chaining reusable higher-order functions (map, filter, flatmap, zip etc.) that rely on a common abstraction called an Observable (a continuation monad). RxCpp makes wonderful use of functional programming features in modern C++ including generic lambdas, type inference, variadic templates, and more.

Conceptually, Rx is a generalization of futures. It lets programmers create asynchronous data processing pipelines (dataflow) from a number of reusable higher-order functions (map, filter, flatmap etc.) that share a common abstraction called an Observable. In many ways, Rx is an “async equivalent of C++ ranges”. Rx is one of the best libraries that truly highlights the power of functional design principles applied in object-oriented programming languages. 

DDS and Rx work great together because they are both reactive, use the publish-subscribe paradigm, and facilitate loose coupling between components. This presentation will discuss Rx4DDS [link=http://bit.ly/cppcon-rx4dds], which is a research library that integrates Rx with RTI Connext DDS. Rx4DDS enables a clean, distributed, asynchronous dataflow architecture for stream processing and is available in C#, C++, and JavaScript.


References:

[1] Rx4DDS [link=http://bit.ly/cppcon-rx4dds]

[2] Reactive Programming with DDS and Rx [slides: see above] [video=https://vimeo.com/125712582] 

Speakers
avatar for Sumant Tambe

Sumant Tambe

Principal Research Engineer, Real-Time Innovations
Sumant Tambe is Principal Research Engineer at Real-Time Innovations (RTI)—the leading communications platform provider for the Industrial Internet of Things. At RTI, Sumant uses cutting-edge technologies to improve RTI’s software product-line through government-funded research projects. He develops and maintains a number of standards related to Data Distribution Service (DDS), which is a data-centric publish-subscribe middleware for... Read More →


Monday September 21, 2015 11:00am - 12:00pm
Noether (408) Meydenbauer Center

11:00am

Variadic Templates - Guidelines, Examples and Compile-time computation
Writing class templates and functions accepting a variable number of arguments has been a burden before C++11. With variadic templates, both class templates with a variable number of arguments as well as functions can be formulated much easier and more type safe way.

Nevertheless, the authoring of variadic templates can be challenging for the uninitiated. Even the interpretation of variadic template code can be a problem, as Olve Maudal's famous pub quiz shows.

This session will build up understanding and the ability to use and author variadic template functions and variadic template classes from easy examples up to more complicated applications such as employing std::forward correctly, std::integer_sequence and other upcoming language features such as a template UDL operator that bridges the gap between string literals and std::integer_sequence.

Understanding pack expansion, sizeof... and other hard to get on first sight issues are my goal. In the end you should have seen guidelines that help you avoid the template instantiation trap from the pub quiz and correct usage of std::forward in your variadic templates.

Speakers
avatar for Peter Sommerlad

Peter Sommerlad

Director IFS, HSR Rapperswil
Prof. Peter Sommerlad is director of IFS Institute for Software at FHO HSR Rapperswil where he inspired the C++ IDE Cevelop. Peter is co-author of the books POSA Vol.1 and Security Patterns. His goal is to make software simpler by Decremental Development: Refactoring software down to 10% its size with better architecture, testability and quality and functionality. Peter is a member of the C++ standardization committee, ACCU, ACM, IEEE Computer... Read More →


Monday September 21, 2015 11:00am - 12:00pm
Hopper Theater Meydenbauer Center

11:00am

Implementation of a component-based entity system in modern C++14
An alternative to deep inheritance trees for game and application architecture design is "composition". Separating data (in independent components) from logic (in independent systems) allows the code to be more reusable and more efficient, alongside additional benefits. Using modern C++11 and C++14 features, it is possible to design an efficient and user-friendly component-based entity system library, with intuitive syntax and convenient cost-free abstractions.

Speakers
avatar for Vittorio Romeo

Vittorio Romeo

Software Engineer, Bloomberg LP
Vittorio Romeo is an Italian 21 year old Computer Science student at "Università degli Studi di Messina". He began programming at a very young age and is now a C++ enthusiast. While following the evolution of the C++ standard and embracing the newest features, he worked on several open-source projects, including modern general-purpose libraries and free cross-platform indie games. Vittorio is an active member of the C++ community: he... Read More →


Monday September 21, 2015 11:00am - 12:00pm
Six (406) Meydenbauer Center

12:30pm

C++ Today: The Beast is Back
This talk will cover why engineers looking for performance choose C++. 

Jon will present an historical perspective of C++ focusing on what’s going on in the C++ community right now and where the language and its user base is heading.

With a renewed interest in performance for both data centers and mobile devices, and the success of open source software libraries, C++ is back and it is hot. This talk will explain why C++ is most software engineers’ go-to language for performance.

You will receive a rough historical sketch that puts C++ in perspective and covers its popularity ups and downs.

This talk is based, in part, on the book "C++ Today: The Beast is Back" published by O'Reilly. 

Speakers
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!


Monday September 21, 2015 12:30pm - 1:30pm
Hopper Theater Meydenbauer Center

2:00pm

Advanced Unit Testing in C++
This session goes in-depth into advanced techniques to isolate and unit test C++ classes, especially those in legacy code that isn't easy to change. This builds on the Pragmatic Unit Testing in C++ talk from last year, with live code examples of safe refactorings, injecting mock objects, and potential pitfalls across different platforms and toolchains.

Speakers
MH

Matt Hargett

Matt's first programming was on a TI 99/4a with his mother, and his first reverse engineering was on an 8086 to make shareware games easier to finish. Matt co-authored Pragmatic Unit Testing in C#, and has spoken at conferences around the world on network security, reverse engineering, unit testing, and static analysis. His hobbies include world travel, playing video games, and writing/publishing indie pop songs under the moniker "the making of... Read More →


Monday September 21, 2015 2:00pm - 3:00pm
McClintock (404) Meydenbauer Center

2:00pm

CLANG + C2 - Engineering/Futures/Measurements
The talk will cover the CLANG + c2.dll compiler for the Microsoft platform. It will contain parts of the talk given at //Build 2015 that can be found on line: "Compiling Objective-C Using the Visual Studio 2015 C++ Code Generation that Builds Windows, SQL, .Net, and Office". The focus this time will be on C++.

The talk will disclose the architecture of how we tied the CLANG open source front end with the Microsoft optimizing backends (several configurations are needed) and how far we are from providing a CTP for public consumption targeting 4 different architectures. Included in this section will be a disclosure of data on compile time, memory consumption, conformance and correctness.

In addition the talk will cover the nuts and bolts of several key innovative compiler and runtime technologies we will be delivering in the Visual Studio 2015 updates (Fall, Winter and Spring). New investments in the compiler and runtime space include: Improved optimization and auto-vectorization, more secure code generation, incremental whole program compilation, and new asynchronous C++ code generation.

Speakers
JR

James Radigan

Dev. Manager - Code Gen Technologies, Microsoft


Monday September 21, 2015 2:00pm - 3:00pm
Six (406) Meydenbauer Center

2:00pm

The current memory and C++ debugging tools used at Electronic Arts
Scott Wardle a senior software engineer Electronic Arts will talk about the current memory and C++ debugging setup and tools used in games.

PS4 and Xbox One have virtual memory and 64 bit address spaces, GPU and CPU are getting closer in the ability to work virtual memory. So our tools are getting better and better and closer to PCs. Most of a games memory goes towards art and level data like bitmap textures and polygon meshes. So artist and designer need to understand how much their data takes up. Giving them call stacks of memory allocations does not help. They want to know how big is a group of building is. Why is this group of building bigger than this one? Maybe this one has some animation data or one of the textures is too big. But there are 10,000s of objects built by 100s of people all around the world.

Speakers
avatar for Scott Wardle

Scott Wardle

Senior Software Engineer, Electronic Arts
Hey Everyone, I am Scott Wardle, I have been in games over 20 years. Much of that in EA Canada Vancouver (though I started my career in EA Japan.). I like to solve hard problems. I love good data visualization and metric systems and using them to fix hard bugs. Also, I like to find good interfaces that use both tech and people together to flip throw hard problems such that they become easy and solve them selves.



Monday September 21, 2015 2:00pm - 3:00pm
Hopper Theater Meydenbauer Center

2:00pm

Generic Lambdas from Scratch
Lambdas (even those mysterious generic lambdas) are just syntactic sugar atop constructs that are perfectly understandable when approached from the right direction.

We'll start with the implementation of C-style functions, then move to overloading, function templates, non-static member functions, C++11 lambdas, and then demystify C++14 generic ("auto") lambdas. Finally, we'll detour into the implementations of std::function and std::bind to show how they're different from lambdas.

Speakers
avatar for Arthur O'Dwyer

Arthur O'Dwyer

Software Engineer, Mixpanel
Arthur O'Dwyer worked for many years at Green Hills Software, making the world's most optimizing C and C++ compilers. Now he works at Mixpanel in San Francisco, where he organizes a monthly C++ meetup.


Monday September 21, 2015 2:00pm - 3:00pm
Franklin (407) Meydenbauer Center

2:00pm

Expression Templates - What, Why, When, Where, Part I
Expression Templates is one of this C++ idiom people learn to either love or hate. The main issues with ET is that everubody has its own conception about what they are, when they should be used, what benefits they give and what are their trade off. For a long time, Expression Tempaltes has been seen has a way to improve temporary heavy code. If the seminal implementation of ET by Todd Veldhuizen was actually about this, the landscape has changed since C++11 and C++14.

This workshop will go over : - what are exactly Expression Templates and what kind of use case they can solve elegantly and efficiently - what are the benefits that one may reap by using expression tempalte in its library - what are the real cost of expressont empaltes both at runtime and compile-time - which tools to use to not reinvent the tempalte wheel everytime including an introduction to Boost.PROTO an Boost.HANA.

The main objective is to clarify why, even in C++1*, this idiom has a meaningful set of applciations and how to navigate around its pitfalls.

Speakers
avatar for Joel Falcou

Joel Falcou

CTO, NUMSCALE
Joel Falcou is NumScale CTO. NumScale mission is to assist businesses in the exploration and subsequently the mastery of high-performance computing systems. | | He is also an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d’Informatique in Orsay, France.


Monday September 21, 2015 2:00pm - 3:00pm
Hamilton (403) Meydenbauer Center

3:15pm

C++ in the Audio Industry
Sound is an essential medium for human-computer interaction and vital for applications such as games and music production software. In the audio industry, C++ is the dominating programming language. This talk provides an insight into the patterns and tools that C++ developers in the audio industry rely on. There are interesting lessons to be learned from this domain that can be useful to every C++ developer.

Handling audio in real time presents interesting technical challenges. Techniques also used in other C++ domains have to be combined: real-time multithreading, lock-free programming, efficient DSP, SIMD, and low-latency hardware communication. C++ is the language of choice to tie all these requirements together. Clever leveraging of advanced C++ techniques, template metaprogramming, and the new C++11/14 standard makes these tasks more exciting than ever.

Speakers
avatar for Timur Doumler

Timur Doumler

JUCE Senior Software Engineer, ROLI Ltd.
Timur Doumler is Senior Software Developer at London-based technology company ROLI. He is currently working on JUCE, the leading cross-platform framework for creating audio applications used by hundreds of companies in the audio industry. After five years of writing high-performance code in Fortran, C, and C++ for numerical simulations of the cosmic structure formation, Timur became committed to audio and music production software. Before joining... Read More →


Monday September 21, 2015 3:15pm - 4:15pm
Six (406) Meydenbauer Center

3:15pm

Haskell's Design Patterns for genericity and asynchronous behavior
The paper explores some of Haskell's support for genericity through type classes, Functors, Monads, and Continuations and their impact on lanugages such as C++, Scala, and Rust. We explore these language features and consider alternatives that have been proposed to existing language features, including Object Algebras, GADTs, Open data types, open pattern matching, and extensions to Haskell's type system that impact the type inference algorithm and decidability. We use a number of case studies to demonstrate what proposed solutions look like in the target languages, considering how easy they are to use and how well the solutions integrate with existing linguistic features.

Speakers
avatar for Sheryl Shulman

Sheryl Shulman

Faculty, The Evergreen State College
Sherri Shulman is a member of the faculty in Computer Science at The Evergreen State College | | I have been teaching at Evergreen for 23 years. My primary interests include language design, the role of types in programming, comparative programming languages, and higher order programming and its impact on software reuse. I regularly teach introduction to programming using Haskell and then transition to C and C++. I particularly like... Read More →


Monday September 21, 2015 3:15pm - 4:15pm
Franklin (407) Meydenbauer Center

3:15pm

Live lock-free or deadlock (practical Lock-free programming), Part I
Part I: Introduction to lock-free programming. We will cover the fundamentals of lock-free vs lock-based programming, explore the reasons to write lock-free programs as well as the reasons not to. We will learn, or be reminded, of the basic tools of lock-free programming and consider few simple examples. To make sure you stay on for part II, we will try something beyond the simple examples, for example, a lock-free list, just to see how insanely complex the problems can get. Part II: having been burned on the complexities of generic lock-free algorithms in part I, we take a more practical approach: assuming we are not all writing STL, what limitations can we really live with? Turns out that there are some inherent limitations imposed by the nature of the concurrent problem: is here really such a thing as “concurrent queue” (yes, sort of) and we can take advantages of these limitations (what an idea, concurrency actually makes something easier!) Then there are practical limitations that most application programmers can accept: is there really such a thing as a “lock-free queue” (may be, and you don’t need it). We will explore practical examples of (mostly) lock-free data structures, with actual implementations and performance measurements. Even if the specific limitations and simplifying assumptions used in this talk do not apply to your problem, the main idea to take away is how to find such assumptions and take advantage of them, because, chances are, you can use lock-free techniques and write code that works for you and is much simpler than what you learned before.

Speakers
avatar for Fedor Pikus

Fedor Pikus

Chief Engineering Scientist, Mentor Graphics
Fedor G Pikus is a Chief Engineering Scientist in the Design to Silicon division of Mentor Graphics Corp. His earlier positions included a Senior Software Engineer at Google and a Chief Software Architect for Calibre PERC, LVS, DFM at Mentor Graphics. He joined Mentor Graphics in 1998 when he made a switch from academic research in computational physics to software industry. His responsibilities as a Chief Scientist include planning long-term... Read More →


Monday September 21, 2015 3:15pm - 4:15pm
Hopper Theater Meydenbauer Center

3:15pm

constexpr: Introduction
I'm excited about constexpr. It's probably my favorite C++11 feature and it's gotten even better with C++14. This talk will introduce constexpr to the uninitiated. We'll start with C++11 and continue into the improvements introduced with C++14. We'll look into useful ways to think about constexpr code. We'll also cover some tips and tricks with writing constexpr code.

Speakers
avatar for Scott Schurr

Scott Schurr

Senior Software Engineer, Ripple
If you ask his children, they will tell you that Scott has been writing software since dinosaurs roamed the earth. In 1996 Scott learned C++ by working through the exercises in Stroustrup's TC++PL 2nd edition and he has never looked back. Scott is currently working at Ripple Labs developing open source crypto-financial software. When he's not writing code Scott plays the Chapman Stick, sings rock and roll, and spends time with his lovely... Read More →


Monday September 21, 2015 3:15pm - 4:15pm
McClintock (404) Meydenbauer Center

3:15pm

Expression Templates - What, Why, When, Where, Part II
Expression Templates is one of this C++ idiom people learn to either love or hate. The main issues with ET is that everubody has its own conception about what they are, when they should be used, what benefits they give and what are their trade off. For a long time, Expression Tempaltes has been seen has a way to improve temporary heavy code. If the seminal implementation of ET by Todd Veldhuizen was actually about this, the landscape has changed since C++11 and C++14.

This workshop will go over : - what are exactly Expression Templates and what kind of use case they can solve elegantly and efficiently - what are the benefits that one may reap by using expression tempalte in its library - what are the real cost of expressont empaltes both at runtime and compile-time - which tools to use to not reinvent the tempalte wheel everytime including an introduction to Boost.PROTO an Boost.HANA.

The main objective is to clarify why, even in C++1*, this idiom has a meaningful set of applciations and how to navigate around its pitfalls.

Speakers
avatar for Joel Falcou

Joel Falcou

CTO, NUMSCALE
Joel Falcou is NumScale CTO. NumScale mission is to assist businesses in the exploration and subsequently the mastery of high-performance computing systems. | | He is also an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d’Informatique in Orsay, France.


Monday September 21, 2015 3:15pm - 4:15pm
Hamilton (403) Meydenbauer Center

4:45pm

C++ for cross-platform VR development
This talk is an overview of how C++ can be used to quickly create cross-platform virtual reality experiences while sharing one codebase.

To support all major vendors, a VR experience has to span not only across operating systems, but also device types, hardware specs, manufacturers, and SDKs -- and so pitfalls and learnings from shipping on Oculus mobile and desktop, Google Cardboard, and soon Sony's Morpheus will be discussed.

We'll cover networking, graphics, SDK wrappers, and even abstracting language oddities (Android's Java layer for Oculus mobile).

Speakers
avatar for Nicolas Lazareff

Nicolas Lazareff

VP of Software Development, OTOY
Nick is a VR/AR engineer who is passionate about bridging the interface between computers and humans. Currently he's VP of Software Development at OTOY focusing on VR and AR ("mixed/digital reality"). He was a cofounder of everyAir, a pioneering P2P game streaming application which was later acquired. Before that he worked at Microsoft on Office 2010 and 2013. | | Feel free to talk to me about any rendering, real-time graphics, computer... Read More →


Monday September 21, 2015 4:45pm - 5:45pm
Franklin (407) Meydenbauer Center

4:45pm

Doxygen to DoxyPress : A Journey from C++98 to C++11
This presentation will discuss the benefits of using a documentation generator for creating internal code documentation or end user documentation.  DoxyPress can be used to document your source code, generate API documentation, show class hierarchies, collaboration diagrams, and much more. DoxyPress supports several output formats including html, chm, latex, and man pages. 

As part of our talk we will cover the process of redesigning source code originally designed for C++98 and how to migrate it to C++11. We will talk about the advantages and drawbacks of moving to C++11 and show how the code changed in DoxyPress.

We will show a small demonstration of DoxyPressApp, which is a a GUI program used to set up your project file which is then used by DoxyPress to generate documentation.

DoxyPress is a fork of the Doxygen documentation tool. A very basic understanding of C++ will be helpful. No prior knowledge of DoxyPress or Doxygen is required.

Speakers
avatar for Barbara Geller

Barbara Geller

Co-Founder, CopperSpice
I am an independent consultant with over twenty-five years of experience as a programmer and software developer. I have worked with numerous smaller companies developing in-house applications. I have also designed and developed Windows applications for several vertical markets including medical billing, transportation, and construction. | | My degree is in Electrical Engineering from Cal Poly Pomona with additional studies in Computer... Read More →
avatar for Ansel Sermersheim

Ansel Sermersheim

Co-Founder, CopperSpice
I have been working as a programmer for over fifteen years. My degree is in Computer Science from Cal Poly San Luis Obispo. | | Currently I work as a software engineer designing scalable, high performance, multi-threaded network daemons in C++. The daemons I have developed are used at a Tier 1 carrier serving static and live content to customers around the world. I am a Co-founder of CopperSpice, a C++ library derived from the existing Qt... Read More →


Monday September 21, 2015 4:45pm - 5:45pm
Noether (408) Meydenbauer Center

4:45pm

Functional Design Explained
An oft-cited benefit of learning a functional language is that it changes one's approach to solving problems for the better. The functional approach has such a strict emphasis on simplistic and highly composable solutions that an otherwise varied landscape of solution possibilities narrows down to only a few novel options.

This talk introduces functional design and showcases its application to several real-world problems. It will briefly cover denotational semantics and several math-based programming abstractions. Finally, the talk will conclude with a comparison of functional solutions to the results more traditional design methodologies.

No prior knowledge of functional programming or functional programming languages is required for this talk. All the examples make use of the C++ programming language.

Speakers
avatar for David Sankel

David Sankel

Bloomberg
David Sankel is a professional software developer/architect based in the USA and an active member of the C++ Standardization Committee. His prolific software developments have included CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at the C++Now conferences and is especially well known for his advanced functional programming in C++ talks. David’s... Read More →


Monday September 21, 2015 4:45pm - 5:45pm
McClintock (404) Meydenbauer Center

4:45pm

Live lock-free or deadlock (practical Lock-free programming), Part II
Part I: Introduction to lock-free programming. We will cover the fundamentals of lock-free vs lock-based programming, explore the reasons to write lock-free programs as well as the reasons not to. We will learn, or be reminded, of the basic tools of lock-free programming and consider few simple examples. To make sure you stay on for part II, we will try something beyond the simple examples, for example, a lock-free list, just to see how insanely complex the problems can get. Part II: having been burned on the complexities of generic lock-free algorithms in part I, we take a more practical approach: assuming we are not all writing STL, what limitations can we really live with? Turns out that there are some inherent limitations imposed by the nature of the concurrent problem: is here really such a thing as “concurrent queue” (yes, sort of) and we can take advantages of these limitations (what an idea, concurrency actually makes something easier!) Then there are practical limitations that most application programmers can accept: is there really such a thing as a “lock-free queue” (may be, and you don’t need it). We will explore practical examples of (mostly) lock-free data structures, with actual implementations and performance measurements. Even if the specific limitations and simplifying assumptions used in this talk do not apply to your problem, the main idea to take away is how to find such assumptions and take advantage of them, because, chances are, you can use lock-free techniques and write code that works for you and is much simpler than what you learned before.

Speakers
avatar for Fedor Pikus

Fedor Pikus

Chief Engineering Scientist, Mentor Graphics
Fedor G Pikus is a Chief Engineering Scientist in the Design to Silicon division of Mentor Graphics Corp. His earlier positions included a Senior Software Engineer at Google and a Chief Software Architect for Calibre PERC, LVS, DFM at Mentor Graphics. He joined Mentor Graphics in 1998 when he made a switch from academic research in computational physics to software industry. His responsibilities as a Chief Scientist include planning long-term... Read More →


Monday September 21, 2015 4:45pm - 5:45pm
Hopper Theater Meydenbauer Center

4:45pm

Using Spirit X3 to Write Parsers
Parsing is a common problem in many domains. The complexity of using a library often pushes developers to ad-hoc solutions utilizing std::string manipulations, regular expressions, or nested if/switch statements. Most “quick hack” implementations are unmaintainable.

Spirit provides a Domain Specific Embedded Language (DSEL) that allows grammars to be described in a natural and declarative manner just like writing PEG or EBNF directly in your C++ code. X3 is the third major release of the Spirit library and improves both compile and run times while simplifying the much of the library.

In this tutorial session you will be introduced to Spirit X3, attribute parsing, and variety of tips to writing efficient and maintainable parsers. We will build a JSON parser during the session to illustrate techniques and usage of the library. This session is applicable toward anyone needing to parse data.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com


Monday September 21, 2015 4:45pm - 5:45pm
Six (406) Meydenbauer Center

4:45pm

Expression Templates - What, Why, When, Where, Part III
Expression Templates is one of this C++ idiom people learn to either love or hate. The main issues with ET is that everubody has its own conception about what they are, when they should be used, what benefits they give and what are their trade off. For a long time, Expression Tempaltes has been seen has a way to improve temporary heavy code. If the seminal implementation of ET by Todd Veldhuizen was actually about this, the landscape has changed since C++11 and C++14.

This workshop will go over : - what are exactly Expression Templates and what kind of use case they can solve elegantly and efficiently - what are the benefits that one may reap by using expression tempalte in its library - what are the real cost of expressont empaltes both at runtime and compile-time - which tools to use to not reinvent the tempalte wheel everytime including an introduction to Boost.PROTO an Boost.HANA.

The main objective is to clarify why, even in C++1*, this idiom has a meaningful set of applciations and how to navigate around its pitfalls.

Speakers
avatar for Joel Falcou

Joel Falcou

CTO, NUMSCALE
Joel Falcou is NumScale CTO. NumScale mission is to assist businesses in the exploration and subsequently the mastery of high-performance computing systems. | | He is also an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d’Informatique in Orsay, France.


Monday September 21, 2015 4:45pm - 5:45pm
Hamilton (403) Meydenbauer Center

8:30pm

Grill the Committee
What would you like to know about how the C++ Standard happens?

The panel is made up of members of the C++ Standards Committee and the audience asks the questions.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!

Speakers
avatar for Chandler Carruth

Chandler Carruth

C++ Lead, Google
Chandler Carruth leads the Clang team at Google, building better diagnostics, tools, and more. Previously, he worked on several pieces of Google’s distributed build system. He makes guest appearances helping to maintain a few core C++ libraries across Google’s codebase, and is active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all... Read More →
avatar for Marshall Clow

Marshall Clow

Principal Engineer, Qualcomm
Marshall is a long-time LLVM and Boost participant. He is a principal engineer at Qualcomm, Inc. in San Diego, and the code owner for libc++, the LLVM standard library implementation. He is the author of the Boost.Algorithm library and maintains several other Boost libraries.
avatar for Lawrence Crowl

Lawrence Crowl

Dr. Lawrence Crowl has expertise in programming languages, compilers, and parallel programming. He has been mixing threads with C++ for twenty-five years and is a major contributor to C++11. His goal is to achieve both high quality and high performance programs.
avatar for Gabriel Dos Reis

Gabriel Dos Reis

Gabriel Dos Reis is a Principal Software Development Engineer at Microsoft. He is also a researcher and a longtime member of the C++ community.  His research interests include programming tools for dependable software. Prior to joining Microsoft, he was Assistant Professor at Texas A&M University.  Dr. Dos Reis was a recipient of the 2012 National Science Foundation CAREER award for his research in compilers for dependable... Read More →
RS

Richard Smith

Clang hacker, Google
Richard is the code owner of the Clang C++ frontend, to which he has been contributing for over five years. He implemented most of the C++11, C++14, and C++17 features that Clang supports, and brought Clang's modules support up to production quality. | Richard is also the Project Editor of the ISO C++ committee, in which he is an active participant. He proposed or contributed to more than half of the language features added in C++14 and C++17.
avatar for Bjarne Stroustrup

Bjarne Stroustrup

MD, Morgan Stanley
C++: history, design, use, standardization, future; performance, reliability; software developer education; | distributed systems
avatar for Herb Sutter

Herb Sutter

Software architect, Microsoft
Author, chair of the ISO C++ committee, software architect at Microsoft.
avatar for Ville Voutilainen

Ville Voutilainen

Principal Technologist, Symbio
Ville Voutilainen is the Chair of the Evolution Working Group, and also a gcc/libstdc++ developer. He's the Finnish representative in the C++ committee, and has contributed to numerous C++11 and C++14 facilities, including override/final, lambda init-captures, aggregate NSDMIs, and more.
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


Monday September 21, 2015 8:30pm - 10:00pm
Hopper Theater Meydenbauer Center
 
Tuesday, September 22
 

8:00am

C++ Community Building Birds of a Feather
Are you a C++ community leader? Would you like to be?

If you are or would like to be working to build a C++ community, either on-line or in meat space, we'd like to hear from you about your challenges and your successes.

We'll hear from sucessful community leaders, answer questions, and share resources and ideas.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!

Tuesday September 22, 2015 8:00am - 8:45am
Franklin (407) Meydenbauer Center

8:15am

SG14 meeting Wednesday:Towards better support in C++ for Games and Finance
Two significant areas where C++ violates "don't pay for what you don't use" are RTTI and exception handling. So much so that some groups turn it off for performance reasons.

Two industries that do so but still use C++ heavily are Games and Financial/Trading. They are among the highest employer of C++ programmers. So have you wondered how C++ can be improved for low-latency applications like Games and Financial/Trading. The emphasis is performance in low-latency, soft-real-time, simulation, graphics, simulation applications.

ISO C++ decided to start a Study Group 14 to officially analyze proposals to improve C++ in these important domains and it will occur on Wednesday as an official C++ Standard meeting. If you are in these domains and are interested in analyzing proposals, or just want to see how a C++ Standard meeting is run, please come to this Open Content talk to find out more about Wednesday's SG14 meeting.

Speakers
avatar for Nicolas Guillemot

Nicolas Guillemot

Graphics Software Engineer, Intel
I do C++, game programming, and graphics programming. Currently doing gaming graphics stuff at Intel. Was previously at Electronic Arts, and am studying at the University of Victoria.
avatar for Sean Middleditch

Sean Middleditch

Lead Software Engineer, Wargaming Seattle
I make games.
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


Tuesday September 22, 2015 8:15am - 8:45am
Six (406) Meydenbauer Center

9:00am

Visualizing Template Instantiations - Templator Demo
Many C++ beginners shy away from employing templates in their code, because of the myth of templates being hard. Even seasoned C++ developers can have problems manually interpreting template code correctly as Olve Maudal's C++ pub quiz demonstrates. Overloads and template specializations make it hard for programmers and also IDEs to show a developer what happens without compiling a program and even with a compile one might not get, what actually happens unless an unintelligible error message from your compiler appears.

My students tried to alleviate that problem by visualizing template instantiation and overload selection in a C++ IDE and allow to navigate through template code in instantiation context that a compiler would only create internally and that is otherwise not available for humans. While still in its nascent state I hope to show what is possible and if things go as planned at the time of the submission you should be able to solve the template pub quiz questions without running the programs.

Speakers
avatar for Peter Sommerlad

Peter Sommerlad

Director IFS, HSR Rapperswil
Prof. Peter Sommerlad is director of IFS Institute for Software at FHO HSR Rapperswil where he inspired the C++ IDE Cevelop. Peter is co-author of the books POSA Vol.1 and Security Patterns. His goal is to make software simpler by Decremental Development: Refactoring software down to 10% its size with better architecture, testability and quality and functionality. Peter is a member of the C++ standardization committee, ACCU, ACM, IEEE Computer... Read More →


Tuesday September 22, 2015 9:00am - 9:30am
Noether (408) Meydenbauer Center

9:00am

Organizational Leadership with Modern C++
With the "C++ Renaissance" it is imperative that the technical leadership prove their mettle to lead a large organization into adopting modern practices and idioms.

In this talk, John and Kevin will discuss various techniques that they have employed to help drive their large development organization (~ 75 software engineers) towards a culture of modernization - some techniques that have worked well, and some that have not.

This will not be a discussion on specifics and nuances of the language. This is more a "fuzzy" discussion on what it means to be both at the forefront of the language and a leader / champion for your peers.

Speakers
avatar for John Wyman

John Wyman

Lead Programmer, Thomson Reuters
I has been working at Thomson Reuters (then Creative Solutions) since 1999. There I develop a US Tax application that contains modules for most conceivable forms of US Tax. US Tax makes for a dynamic code base and a strong desire for efficiency, making C++ our tool of choice.


Tuesday September 22, 2015 9:00am - 9:30am
McClintock (404) Meydenbauer Center

9:00am

<functional>: What's New, And Proper Usage
<functional> gained lots of machinery in C++11, with further changes in C++14 and C++17. This talk will cover what's new in 11/14/17, focusing on how to use it properly. For example, you've probably used std::function, but do you know the criteria for activating the Small Functor Optimization? (It's not just being small!) We'll also look at bind(), mem_fn(), C++17's invoke(), and more.

Speakers
avatar for Stephan T. Lavavej

Stephan T. Lavavej

Principal Software Engineer, Microsoft
Stephan T. Lavavej is a Principal Software Engineer at Microsoft, maintaining Visual C++'s implementation of the C++ Standard Library since 2007. 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).


Tuesday September 22, 2015 9:00am - 10:00am
Hopper Theater Meydenbauer Center

9:00am

Single Threaded Functional to Massively Parellel Stochastic with AMP
Come with us as we take a legacy MFC financial modelling application that is largely function in design and transform it to something new. We will take a portion of this large financial simulation application and change its single threaded ways into parallel processing stochastic model. Transforming single class’s with a hodge-podge of functions into an object oriented parallel design using c++ amp and implementing Stochastic modelling methodology. Aside from focusing on the key portions of converting functional single threaded code to a parallel design we will also touch on some of the details of financial modeling for interest rate risk.

Speakers
avatar for Kevin Carpenter

Kevin Carpenter

Developer, c. myers corporation
I started writing software before I finished grade school and have spent my life in technology since then. I currently write primarily Windows based financial applications in C++. My passion is in producing not only quality code, but software that works for businesses. As much as I love trying to find the most elegant solution to a problem, I realize the client needs the solution that keeps them in business just as much. I enjoy trying to... Read More →


Tuesday September 22, 2015 9:00am - 10:00am
Franklin (407) Meydenbauer Center

9:00am

Time Programming Fundamentals
"Time zones are logical and easy to use." -- No one ever

Time programming is notoriously difficult and error prone. Attempts at handling daylight-saving time, for example, often yield baffling code, which of course is explained by a similarly misguided comment. Programmer confusion can spread virally throughout the codebase when these misconceptions find their way into library interfaces.

The problem is not that dates and times are fundamentally complicated (though they are). The problem is the lack of a simplified mental model with library support. This would give programmers the concepts and vocabulary necessary to reason about and discuss these concepts, and the ability to express this reasoning in simple C++ terms.

In this talk I will show how date and time programming evolved into what it is today. I will present a greatly simplified mental model that applies to all programming languages. I will show clear examples using an open source C++ library that implements these simplified concepts. And I will present practical tips for proper time hygiene that should be used by everyone immediately.

Speakers
avatar for Greg Miller

Greg Miller

Software engineer, Google
I design and implement C++ core libraries at Google. I work on Google's core strings libraries, as well as a Google's Time and Time Zone libraries.
avatar for Bradley White

Bradley White

Software Engineer, Google, Inc.
Co-author of the open-source CCTZ library (github.com/google/cctz). Co-author of two proposals that are trying to push the concepts from CCTZ into the C++ standard.


Tuesday September 22, 2015 9:00am - 10:00am
Six (406) Meydenbauer Center

9:00am

Test Driven C++ With Catch
C++ has been notorious for being a second class citizen when it comes to test frameworks. There are plenty of them but they tend to be fiddly to set-up and ceremonious to use. Many of them attempt to follow the xUnit template without respect for the language environment they are written for. Catch is an attempt to cut through all of that. It is simple to get and simple to use - being distributed in a single header file - yet is powerful and flexible. Catch includes a number of innovations that make testing in C++ more natural - and fun - than ever before. This presentation introduces you to the unique approach that Catch brings to unit and integration testing - and how to use Catch to drive your design with TDD or BDD.

Speakers
avatar for Phil Nash

Phil Nash

Thing doer, Two Blue Cubes Ltd
Long time C++ developer but also dabbles with F#, Objective-C, Swift, C#, Python, D, Rust and others. | Open source author and contributor - particularly Catch - a C++ test framework in a single header file. | Interested in all forms of bettering oneself!


Tuesday September 22, 2015 9:00am - 10:00am
Hamilton (403) Meydenbauer Center

9:30am

High-performance, async-only and monadic future
std::future provides us a mechanism for asynchronous communication between a provider and receiver. However, the C++14 standard does not allow for actual asynchronous programming, as the only ways to interact with an std::future are blocking calls. The proposed then helps, but the interface is awkward and can be extremely slow when handling exceptions. Here, I will talk about completion a high-performance, async-only and monadic alternative to std::future and how it is used at SolidFire.

Speakers
avatar for Travis Gockel

Travis Gockel

Founder, CurrentDB
Travis is a bit of a programming language nerd and is a big fan of where Rust is going (eventually). If you find Travis during the day without coffee or during the night without whiskey, there is a problem.


Tuesday September 22, 2015 9:30am - 10:00am
McClintock (404) Meydenbauer Center

9:30am

3D Face Tracking and Reconstruction using Modern C++
In this talk, I will present my work in computer vision, namely landmark detection and 3D face tracking, and the two C++ libraries that were developed in the process. The first part of the talk will give an introduction to detecting facial landmark points and work through a hello-world code example that presents and uses the superviseddescent library, a cross-platform library for cascaded regression that can be used to solve problems like landmark detection or pose estimation. The second part of the talk will present an approach that uses the found landmarks from the first part to use a 3D face model to track a person's face. With the library presented in the process, we hope to make 3D models easier to use and more widespread in the community. Both libraries are designed to be lightweight and simple to use, and try to follow modern C++11/14 programming paradigms. The talk concludes with my views on code sustainability in academia and a wish list of standard library features for computer vision.

Speakers
avatar for Patrik Huber

Patrik Huber

PhD student in computer vision, University of Surrey
I'm a PhD student in computer vision at the Centre for Vision, Speech and Signal Processing of the University of Surrey, UK. My research is about using 3D face models to reconstruct a 3D face from a single 2D image, object tracking and facial landmark detection. My interest in C++ emerged in 2013 when I discovered the power of modern C++ programming, and I have since then open-sourced much of my research software.


Tuesday September 22, 2015 9:30am - 10:00am
Noether (408) Meydenbauer Center

10:30am

Writing Good C++14 By Default
Modern C++ is clean, safe, and fast. It continues to deliver better and simpler features than were previously available. How can we help most C++ programmers get the improved features by default, so that our code is better by upgrading to take full advantage of modern C++?

This talk continues from Bjarne Stroustrup’s Monday keynote to describe how the open C++ core guidelines project is the cornerstone of a broader effort to promote modern C++. Using the same cross-platform effort Stroustrup described, this talk shows how to enable programmers write production-quality C++ code that is, among other benefits, type-safe and memory-safe by default –  free of most classes of type errors, bounds errors, and leak/dangling errors – and still exemplary, efficient, and fully modern C++.

Background reading: Bjarne Stroustrup’s 2005 “SELL” paper, “A rationale for semantically enhanced library languages," is important background for this talk.

Speakers
avatar for Herb Sutter

Herb Sutter

Software architect, Microsoft
Author, chair of the ISO C++ committee, software architect at Microsoft.


Tuesday September 22, 2015 10:30am - 12:00pm
Montessori Hall Meydenbauer Center

12:30pm

Writing my own Content Management System in C++
In the past weeks I have started to work on my own CMS in C++, which is still a work in Progress. I'd like to share with you the problems and solutions I found using Standard C++, boost and Qt.

Speakers
avatar for Jens Weller

Jens Weller

Meeting C++, Meeting C++
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++.


Tuesday September 22, 2015 12:30pm - 1:30pm
Hamilton (403) Meydenbauer Center

12:30pm

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
KG

Kate Gregory

Partner, Gregory Consulting
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... Read More →

Tuesday September 22, 2015 12:30pm - 1:30pm
Hopper Theater Meydenbauer Center

12:30pm

Kiss-Templates
You want to present some content as HTML, TEX or other text file using C++?

Kiss-Templates offer an elegant, lean and mean, statically checked, readable and super easy way of doing so.

Lets talk about how they work and how to use them in a tutorial / Q&A session, optionally with coding.

See https://github.com/rbock/kiss-templates

Speakers
avatar for Roland Bock

Roland Bock

Principal Software Engineer, PPRO Financial Ltd
From my days at the university, I hold a PHD in physics (although that was in the previous century and seems like a different life by now). Ever since then I have been developing software and/or managing engineering teams. In 2008, I started to learn C++ because I could not believe that it was as difficult as some people claimed. Turns out they were totally wrong and totally right at the same time. | | Today, I am still learning and I hope... Read More →


Tuesday September 22, 2015 12:30pm - 1:30pm
Six (406) Meydenbauer Center

12:30pm

Effective C++ Implementation of Class Properties
This session will be a brainstorm, so, possibly, we will invent something even more interesting, and make the result available for the whole C++ society. Join me to work on this important problem.

"Property" is a special sort of class member between field and method. https://en.wikipedia.org/wiki/Property_(programming). Properties are extremely useful while working with a poorly organized legacy codebase, e.g. as a mean to transparently implement setters and getters in initially public classes.

In reality there is no a part in C++ standard for implementation of properties, though there are many ways to implement them using syntax of the language. We will overview these general ways with its pros and cons.

A good implementation is an implementation with a little both memory and performance overhead. At the moment I have a developed solution with memory overhead of one pointer and one indirection for performance, per property; It is better than all the implementations I could find publicly available.We will try to find an implementation as ideal as possible. 



Moderators
avatar for Viktor Korsun

Viktor Korsun

Head of client-side development, Zeptolab
Viktor graduated from Moscow Technical University and Yandex Data Analysis School. | In 2006 - 2008 Viktor worked for Galaktika corpotation, participated in the creation of a 4'th generation OO-programming language. | In 2008 - 2010 Viktor worked for Alta-Soft LLC as a technical architect of a distributed customs database. | Since 2012 Viktor has been working for Zeptolab LLC, creating modern mobile games. At the moment the company is... Read More →

Tuesday September 22, 2015 12:30pm - 1:30pm
McClintock (404) Meydenbauer Center

2:00pm

C++11/14/17 Atomics the Deep dive: the gory details, before the story consumes you!
In 2011, C++11 atomics offered three memory models but 6 settings. Most compilers have started implementing most of these (relaxed, seq_cst, acquire, release, acq_rel) but not consume (For that you will need to see Paul's talk which naturally follows this talk.) For this, I will deep dive into what each memory model setting means (especially for Games Development and low latency, a new SG14 in the C++ Standard) and how C++11 atomics are used to improve handling of mutable shared state. We have improved on it in C++14 and have more crazy things planned for C++17. I will also look at how C++ atomics are a natural precursor to SG5's Transactional Memory which was approved in Lenexa for publication.

Speakers
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


Tuesday September 22, 2015 2:00pm - 3:00pm
Hopper Theater Meydenbauer Center

2:00pm

Large Scale C++ With Modules: What You Should Know

“Modules” are a frequently requested and long-awaited feature by C++ programmers.  In a nutshell, the idea is to have a direct language support for (a) expressing the boundaries and dependencies of a program component; (b) isolating source codes from macro vagaries; (c) scaling compile time, especially for large projects, given the ubiquity of “headers-only” template libraries; (d) spur innovation and deployment of semantics-aware developer tools.

This presentation will focus on three major points: (1) the design of the module proposal currently being considered by the C++ standards committee (design goals, properties, constraints); (2) implementations currently under way; and (3) early user experience and migration.

Modules directly address a problem (scalability) listed as one of the three major areas where C++17 is expected to significantly improve daily experience of the working C++ programmer.  Naturally, this feature is  also on the top ten list of C++17 functionalities Bjarne Stroustrup put forward in his “Thought on C++17.” 

Speakers
avatar for Gabriel Dos Reis

Gabriel Dos Reis

Gabriel Dos Reis is a Principal Software Development Engineer at Microsoft. He is also a researcher and a longtime member of the C++ community.  His research interests include programming tools for dependable software. Prior to joining Microsoft, he was Assistant Professor at Texas A&M University.  Dr. Dos Reis was a recipient of the 2012 National Science Foundation CAREER award for his research in compilers for dependable... Read More →


Tuesday September 22, 2015 2:00pm - 3:00pm
McClintock (404) Meydenbauer Center

2:00pm

Parallelizing the C++ Standard Library
As the era of frequency scaling comes to an end, multi-core parallelism has become an essential focal point in computational research. Mainstream languages, however, have not yet adapted to take full advantage of parallelism provided by the hardware. While new languages such as Rust and Swift are catching on and implementing multi-core algorithms in their libraries, C++ has only started to do so. A parallel Standard Library could bring with it many positive features that users can begin taking advantage of.

This talk will focus around two standards proposals, N4409 and N4406. N4409 outlines the details of a parallel Standard Library and features of these new parallel algorithms. The complementary N4406 outlines abstractions to take advantage of various mechanisms for parallel execution. We will cover the reasons why the new Standard Library would be beneficial to C++ users and our experience implementing these algorithms in HPX. The presentation will address what exactly the two proposals define, the challenges we faced, and the results we collected. In addition, we will discuss extensions made to these proposals and the C++11/14 standard in HPX to support these semantics in a distributed environment.

Speakers
avatar for Daniel Bourgeois

Daniel Bourgeois

Student, Louisiana State University
I'm a student at LSU and have been working at the SET||AR research group helping implement parallel algorithms inside of HPX. Feel free to talk to me about new C++ features, parallel computing or anything else.


Tuesday September 22, 2015 2:00pm - 3:00pm
Hamilton (403) Meydenbauer Center

2:00pm

Simple, Extensible Pattern Matching with C++14
Recently, there has been in increased interest in applying functional programming techniques to C++. A very convenient construct that is used in functional programming languages is pattern matching. Due to the features introduced in C++11 and C++14 we can actually write a simple, easy to use, understandable, and extensible pattern matching library that is header only and uses no macros.

In this talks we will discuss the motivations for pattern matching, and see examples of use from other languages. We will then go on to design and implement a pattern matching library in C++. Particular attention will be payed to new C++14 features that greatly simplify the implementation such as integer_sequence, function return type deduction, and generic lambdas. The implementation will also serve a practical guide to using variadic templates and std::tuple.

We will show how the library can be easily extended and customized by working through some examples of customization such as working with user defined classes and structs, pointers, tuples, boost::optional, and boost::variant. At the end of the session, the audience will have an appreciation for pattern matching, as well as a sense that the C++11/14 features open new paradigms without sacrificing understandable code.

Speakers
avatar for John Bandela

John Bandela

I first started programming in C++ at age 14 in 1994 when I cajoled my parents into buying me Visual C++ 1.0 for my birthday. It took a while, but as I learned the language, I decided I really liked C++. I attended the University of Florida and obtained my undergraduate degree in Computer and Information Science. During my undergraduate time, I created and submitted Boost.Tokenizer. I went on to medical school and neurosurgery residency, but... Read More →


Tuesday September 22, 2015 2:00pm - 3:00pm
Six (406) Meydenbauer Center

2:00pm

Integrating generators EDSL's for Boost.Spirit X3
Based on the presentation I made on C++Now 2015 for Developing EDSL's for Boost.Spirit V2, present the development of generators for Boost.Spirit X3 (next version of boost spirit) and how that can be used for higher abstraction EDSL's while, through template metaprogramming, create parsers and generators automatically from the same grammar, using CORBA format as an example, while dealing with endianness, alignment and asymmetric grammars. This work is based on the library mORBid (https://github.com/expertisesolutions/mORBid) and (https://github.com/expertisesolutions/giop).

Speakers
FM

Felipe Magno de Almeida

Owner, Expertise Solutions


Tuesday September 22, 2015 2:00pm - 3:00pm
Noether (408) Meydenbauer Center

3:15pm

C++ Atomics: The Sad Story of memory_order_consume: A Happy Ending at Last?
One of the big advantages of C++ atomics is that developers can now let the compiler know about the intent behind their multi-threaded synchronization mechanisms. At least they can tell the compiler as long as the synchronization mechanism in question is not RCU. You see, all production compilers promote RCU's memory_order_consume to memory_order_acquire. Although this promotion does ensure correctness, it also ensures the additional overhead of memory-barrier instructions on weakly ordered systems and of needlessly suppressed compiler optimizations on all systems.

All previous attempts to resolve this issue have foundered on either standard-committee reluctance to eviscerate the standard for a special case, compiler-writer reluctance to eviscerate their compilers for a special case, and kernel-developers reluctance to eviscerate their source base for late-to-the-party compiler support.

But now there is a glimmer of hope in the guise of a small set of small patches to the Linux kernel that eliminate the most challenging use cases. Will this hope be realized? Come to this talk to here the story, which by September will hopefully have a happy ending!

Speakers
avatar for Paul E. McKenney

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... Read More →



Tuesday September 22, 2015 3:15pm - 3:45pm
Hopper Theater Meydenbauer Center

3:15pm

Cross-Platform Mobile App Development with Visual C++ 2015
Visual C++ 2015 supports the development of apps for the Windows platform as well as for Android and iOS. A single code base, possibly with a thin platform-specific UI layer, can be compiled to run on Windows, Android, and iOS. The resulting binary can be published to a device and debugged, all from within Visual C++ 2015. This presentation introduces you to such cross-platform mobile app development, including debugging and emulation, and includes a number of demos.

Speakers
avatar for Marc Gregoire

Marc Gregoire

Software Architect, Nikon Metrology
Marc Gregoire has worked as a software engineer consultant for 6 years for Siemens and Nokia Siemens Networks on critical 2G and 3G software running on Solaris for telecom operators. This required working in international teams stretching from South America and USA to EMEA and Asia. Now, Marc is working for Nikon Metrology on 3D scanning software. His main expertise is C/C++, and specifically Microsoft VC++ and the MFC framework. Next to C/C... Read More →


Tuesday September 22, 2015 3:15pm - 4:15pm
Franklin (407) Meydenbauer Center

3:15pm

How I stopped worrying and love metaprogramming
Horrible software engineering technique conceived in the forge of Hell or the Only True Way of doing C++ in 2015, template metaprogramming and its cohort of companion techniques are sure to create animation in a group of programmers.

What if we were to tell you that an actual software product, actually sold to real customers and in production for now several years has been built on it? What if we were to tell you that a lot of advanced template techniques helped us to build a better software faster?

This talk is all about real life examples of template metaprogramming, why they are useful and when and how you could use them in your own projects.

Speakers
avatar for Edouard Alligand

Edouard Alligand

CEO, quasardb
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... Read More →


Tuesday September 22, 2015 3:15pm - 4:15pm
Hamilton (403) Meydenbauer Center

3:15pm

Writing Great Libraries in 89 Easy Steps
Writing code that does what you want it to do, correctly and efficiently, is hard. Doing so when you don't even know yet what you want the code to do yet is quite a bit harder. Yet this is the job of a library writer -- the users of a library may have a very different use case from that of the original author.

How do library writers develop correct and efficient APIs that are also:

- easy to use correctly - hard to use incorrectly - highly reusable - gracefully interoperable with other code

This talk gives lots of practical advice and techniques for accomplishing those goals and more.

Speakers
ZL

Zach Laine

Sr. Programmer, Nvidia
Zach Laine has been using C++ in industry for 12 years, focusing on data visualization, numeric computing, games, generic programming, and good library design. He finds the process of writing bio blurbs to be a little uncomfortable.


Tuesday September 22, 2015 3:15pm - 4:15pm
McClintock (404) Meydenbauer Center

3:15pm

constexpr: Applications
I'm excited about constexpr. It's probably my favorite C++11 feature and it's gotten even better with C++14. But when I talk to other developers about constexpr they seem puzzled. What sorts of useful computations can the compiler possibly do before runtime?

I'd like to take this session to explore some of the capabilities that constexpr brings to the table. We'll look at compile-time parsing, floating-point computations, and containers. We'll also talk about motivations for computing these at compile time.

This session builds on the "constexpr: Introduction" talk.

Speakers
avatar for Scott Schurr

Scott Schurr

Senior Software Engineer, Ripple
If you ask his children, they will tell you that Scott has been writing software since dinosaurs roamed the earth. In 1996 Scott learned C++ by working through the exercises in Stroustrup's TC++PL 2nd edition and he has never looked back. Scott is currently working at Ripple Labs developing open source crypto-financial software. When he's not writing code Scott plays the Chapman Stick, sings rock and roll, and spends time with his lovely... Read More →


Tuesday September 22, 2015 3:15pm - 4:15pm
Six (406) Meydenbauer Center

3:45pm

Concurrency TS: The Editor's Report
In this presentation we will talk about the new C++ concurrency features that have been included in the Concurrency Technical Specification.

The TS should be of interest to anyone writing concurrent code in C++. The proposal includes improved futures for wait-free composition of asynchronous operations (including their relationship with C++ 'await'), new synchronization constructs as well as atomic smart pointers.

Speakers
avatar for Artur Laksberg

Artur Laksberg

Software Engineer, Microsoft
Artur Laksberg is a software design engineer at Microsoft. His interests include concurrency, programming language and library design, and modern C++. Artur is a regular participant in the work of the Concurrency Study Group in the ISO C++ Committee, serving as the editor of the Concurrency Technical Specification. He is one of the co-authors of the proposal to improve std::future (currently part of the Concurrency TS) and also a contributor to... Read More →


Tuesday September 22, 2015 3:45pm - 4:15pm
Hopper Theater Meydenbauer Center

4:45pm

C++ on the Web: ponies for developers without pwn’ing users
Is it possible to write apps in C++ that run in the browser with native code speed? Yes. Can you do this without the security problems associated with running native code downloaded from the net? Yes and yes. Come to this session to learn how.

We'll showcase some resource-intensive applications that have been compiled to run in the browser. These applications run as fast as native code with access to cornerstone native programming APIs—modern C++ STL, OpenGL, files and processes with full access to C++’s concurrency and parallelism—all in an architecture- and OS-agnostic packaging. Then, we'll describe how we deliver native code on the web securely, so developers get their C++ ponies and users don’t get pwn’d. We’ll also touch on the fuzzing, code randomization, and sandboxing that keep the billions of web users safe.

Speakers
avatar for JF Bastien

JF Bastien

Jest-in-Time Compiler, template
JF Bastien is a compiler engineer, currently focusing on performance and security to bring portable, fast and secure code to the Web. JF is a member of the C++ standards committee, where his mechanical engineering degree serves little purpose. He’s worked on startup incubators, business jets, flight simulators, CPUs, dynamic binary translation, systems, and compilers.


Tuesday September 22, 2015 4:45pm - 5:45pm
Franklin (407) Meydenbauer Center

4:45pm

Parallel Program Execution using Work Stealing
If you've used a C++ parallel-programming system in the last decade, you've probably run across the term "work stealing." Work stealing is a scheduling strategy that automatically balances a parallel workload among available CPUs in a multi-core computer, using computation resources with theoretical utilization that is nearly optimal. Modern C++ parallel template libraries such as Intel(R)'s TBB or Microsoft*'s PPL and language extensions such as Intel(R) Cilk(tm) Plus or OpenMP tasks are implemented using work-stealing runtime libraries.

Most C++ programmers pride themselves on understanding how their programs execute on the underlying machine. Yet, when it comes to parallel programming, many programmers mistakenly believe that if you understand threads, then you understand parallel runtime libraries. In this talk, we'll investigate how work-stealing applies to the semantics of a parallel C++ program. We'll look at the theoretical underpinnings of work-stealing, now it achieves near optimal machine utilization, and a bit about how it's implemented. In the process, we'll discover some pit-falls and how to avoid them. You should leave this talk with a deeper appreciation of how parallel software runs on real systems.

Previous experience with parallel programming is helpful but not required. A medium level of expertise in C++ is assumed.

Speakers
avatar for Pablo Halpern

Pablo Halpern

Software Engineer, Intel Corp.
Pablo Halpern has been programming in C++ since 1989 and has been a member of the C++ Standards Committee since 2007. He is currently an enginneer at Intel Corp., where he works on high-performance computing. As the former chairman of the Parallel Programming Models Working Group at Intel, he coordinated the efforts of teams working on Cilk Plus, TBB, OpenMP, and other parallelism languages, frameworks, and tools targeted to C++, C, and Fortran... Read More →


Tuesday September 22, 2015 4:45pm - 5:45pm
Hamilton (403) Meydenbauer Center

4:45pm

Reflection techniques in C++
Reflection is a very powerful and useful feature used in many languages to achieve things like serialization, object-relationship mapping, and general data-driven development. C++ doesn't support reflection natively in the language yet. There are proposals to add compile-time reflection to the language, but C++ has survived all this time without direct support for reflection.

This talk will discuss the various techniques the can be used to achieve reflection including boost fusion, the visitor patter, and do-it-yourself with some macros and metaprogramming. This talk will discuss how these techniques can be used to implement serialization or object-relational mapping.

Speakers
avatar for Paul Fultz II

Paul Fultz II

Software Engineer, AMD


Tuesday September 22, 2015 4:45pm - 5:45pm
McClintock (404) Meydenbauer Center

4:45pm

STL Algorithms in Action
This will be an entertaining trip through the STL algorithms, where we will view many of them in their natural habitats, going about their natural algorithm business. Then we will take some of them out of their native environments and make them do tricks that are entirely unexpected. In the end, you will gain a new appreciation for what the algorithms are and how pervasively they can be used throughout your code.

Speakers
avatar for Michael VanLoon

Michael VanLoon

Principal Software Engineer, F5 Networks
I have been developing software for over 30 years. Yes, I started before I was born. I have been doing C++ for over 20 years, not very well at first, and slightly better now. | | I work at F5 Networks, and have worked at Disney, VMware, Yahoo!, and Microsoft, among many others. I have benefited from a wide range of experience and personalities. | | I have a personal grudge against code that does not strive to reach a high... Read More →


Tuesday September 22, 2015 4:45pm - 5:45pm
Six (406) Meydenbauer Center

4:45pm

Your Tests Are Terrible: Tales from the Trenches
Thousands of Google engineers have collectively written about 100,000 separate C++ test binaries in the last 15 years. Not all of those was a perfect test. In this talk we’ll focus on how to write good tests and adopt a good testing philosophy, with lots of examples of what not to do (and why).

Speakers
avatar for Titus Winters

Titus Winters

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

Hyrum Wright

Software Engineer, Google
Hyrum Wright hates C++ less than the rest of the programming languages he's worked with, and works on C++ library infrastructure at Google. He writes programs to rewrite other programs, and will eventually put himself out of a job. In a former life, he was an author of Apache Subversion, and still retains membership in the Apache Software Foundation. Hyrum enjoys cycling, but didn't bring a bike to Seattle. Twitter handle: @hyrumwright


Tuesday September 22, 2015 4:45pm - 5:45pm
Hopper Theater Meydenbauer Center

4:45pm

Boost Units Library for Correct Code
I will give a presentation on the Boost Units library.

This library implements a zero runtime facility for performing dimensional analysis checking and automatic units conversion on C++ expressions. I have found this indispensable for coding scientific programs involving a variety of complex physical units. The documentation of the Boost Units library is totally complete and accurate, but totally inpenetrable. I had to spend way too much time figuring out how to use this. By attending this meeting, you're going to avoid this pain and just get the benefit of simpler programs that contain fewer bugs.

Speakers
avatar for Robert Ramey

Robert Ramey

Proprietor, Robert Ramey Software Development
Robert Ramey is a freelance Software Developer living in Santa Barbara, California. (See www.rrsd.com.)  His long and varied career spans various aspects of software development including business data processing, product, embedded systems, custom software, and C++ library development. Lately, he has been mostly interested in C++ library design and implementation related to Boost.  He is the author and maintainer of the Boost... Read More →


Tuesday September 22, 2015 4:45pm - 5:45pm
Noether (408) Meydenbauer Center

8:30pm

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
KG

Kate Gregory

Partner, Gregory Consulting
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... Read More →

Tuesday September 22, 2015 8:30pm - 10:00pm
Hopper Theater Meydenbauer Center
 
Wednesday, September 23
 

8:00am

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
KG

Kate Gregory

Partner, Gregory Consulting
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... Read More →

Wednesday September 23, 2015 8:00am - 8:45am
Hopper Theater Meydenbauer Center

8:30am

ISO SG14 Working Meeting

You need this ticket from Eventbrite to sign up: ISO SG14 Meeting 2015-09-23.
ISO Study Group 14 “Game Development and Low Latency” working session. Conference attendance is not required to participate in the SG14 meeting, but a separate ticket is. For more information https://groups.google.com/a/isocpp.org/forum/#!topic/sg14/SOcxeUNSzQw
You need this ticket from Eventbrite to sign up: ISO SG14 Meeting 2015-09-23

Moderators
avatar for Herb Sutter

Herb Sutter

Software architect, Microsoft
Author, chair of the ISO C++ committee, software architect at Microsoft.
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →

Wednesday September 23, 2015 8:30am - 5:30pm
Joliot-Curie (409) Meydenbauer Center

9:00am

The Current State of (free) Static Analysis
We will discuss the currently available free static analysis software available for C++. What kinds of errors can these tools catch? What kind do they miss? Why static analysis should be a part of your normal build process.

Speakers
avatar for Jason Turner

Jason Turner

Developer, Trainer, Speaker
Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http://cppbestpractices.com. | | I'm available for contracting and onsite training.



Wednesday September 23, 2015 9:00am - 9:30am
McClintock (404) Meydenbauer Center

9:00am

C++ in Open Source Robotics
The robotics community is thriving in part due to flexible, powerful, accessible open source tools. The Open Source Robotics Foundation is a non-profit organization dedicated to the development, distribution, and adoption of open source software in robotics. We enable academics to focus on high-level research by re-using code, robotics startups to keep their development costs lean, and novice users to engage with powerful, complex robotics technology.

The first half of this talk centers around the future of ROS, the most widely used open source framework for robotics. After an overview of ROS transport, tools, capabilities, and the diverse ecosystem of ROS-compatible libraries, we will motivate the development of ROS 2: a major API change that targets new use cases for ROS, including embedded hardware, multi-robot systems, and real-time performance. Starting with an overview of the ROS 2 architecture, which includes a modern C++11 client library built on top of a generic DDS middleware interface, we will then focus on two core user code examples: publish/subscribe over a topic, and client request/service response. After this half of the presentation, attendees will understand C++ is a dominant language choice for robotics and why C++11 makes it easy to build a flexible, modular, Boost-free framework for communication and synchronization.

The second half of the talk focuses on Gazebo, a simulator for robotics that features support for multiple rigid body dynamics physics engines, high quality graphics, and a flexible C++ API. Simulation software like Gazebo is of utmost importance for developing controller algorithms, prototyping robot designs, and regression testing in challenging environments. It has been used in high­-stakes competitions such as the DARPA Robotics Challenge. This talk will delve into how different components of the simulator interact, from calculating the physical interactions between objects to rendering graphics with OGRE. We will also discuss upcoming features in Gazebo and the process of tailoring our development to our community. 

Speakers
avatar for Jackie Kay

Jackie Kay

Software Engineer, Open Source Robotics Foundation
avatar for Louise Poubel

Louise Poubel

Software Engineer, Open Source Robotics Foundation
Louise Poubel is a software engineer at the Open Source Robotics Foundation, working on GUI tools and user experience for the multi-robot simulator Gazebo. She first got involved with OSRF in the end of 2013 through GNOME's Outreach Program For Women. Louise grew up in Brazil and went to college in Japan, where she received her BS in Electromechanical Engineering from Chiba University. After that she got a joint MEng in Advanced Robotics from... Read More →



Wednesday September 23, 2015 9:00am - 10:00am
Franklin (407) Meydenbauer Center

9:00am

On C++, Javascript and WebSockets
Session presents Open Service Platform (OSP) - an application server engine inspired by OSGi, consisting of C++ and JavaScript runtime environments; OSP is based on the POCO C++ Libraries, with embedded Google V8 JavaScript engine.

A brief overview of the application server and underlying technologies will be given, followed by dissection of the most interesting implementation details - C++-to-JavaScript bridging mechanism and WebSocket-based messaging mechanism for transparent intra- and inter-process scalable communications. The language bridging mechanism exposes the C++ classes to JavaScript code without a need for manually written glue code or separate IDL constructs for interfaces. The messaging mechanism provides a unified, event-based interface for the in-process entities as well as those reachable over the network - be it TCP/HTTP server or a web browser.

Key design aspects, advantages, as well as trade-offs will be examined; a live example demonstrating key technologies in action will be presented.

Speakers
avatar for Alex Fabijanic

Alex Fabijanic

Alex is the POCO (C++ POrtable COmponents, http://pocoproject.org) Project Lead and ISO/IEEE Computer Society Certified Software Development Professional. Alex has been a professional programmer since 1992, using C and C++ since 1998. He earned a master's degree in Mechanical Engineering from Faculty of Engineering (University of Rijeka, Croatia) and a master's degree in Software Engineering from Citadel Graduate College in Charleston, South... Read More →


Wednesday September 23, 2015 9:00am - 10:00am
Noether (408) Meydenbauer Center

9:00am

C++ Coroutines - a negative overhead abstraction
C++ coroutines are one of the few major features that may land in C++17. We will look at the current standardization status, available experimental implementations and develop a small coroutine adapter over raw C networking APIs that will beat hand-crafted state machine in performance.

Speakers
avatar for Gor Nishanov

Gor Nishanov

Principal Software Engineer, Microsoft
Gor Nishanov is a Principal Software Design Engineer on the Microsoft C++ team. He works on design and standardization of C++ Coroutines, and on asynchronous programming models. Prior to joining C++ team, Gor was working on distributed systems in Windows Clustering team.


Wednesday September 23, 2015 9:00am - 10:00am
Hopper Theater Meydenbauer Center

9:00am

The unexceptional exceptions
The main goal of this class is not to teach how to use exceptions - it's not that hard, and we will go over the basics at the start of the class. The main goal is to teach to not be afraid to use exceptions, and also not to be awed by them. We will spend few minutes on the basic syntax and semantics of exceptions, as well as their interaction with other parts of the language. Then we get to the real issue: the error handling. It is important to understand that errors, or exceptional cases, do not need to be handled by exceptions. Exceptions are just a tool that provides one way of coding the error handling, and it’s not even a very good one: overly focusing on exception handling, as opposed to error handling, often leads to code that is both buggy and hard to read and maintain. My goal is to show that the best approach to error handling involves very light explicit use of exceptions. The emphasis is put on maintaining program invariants and avoiding the undefined behavior, something all programs need to do at all times, with or without errors. Thus, a well-written program should have very little error handling code, and only a part of that explicitly deals with exceptions. This understanding is particularly important for programmers who have to deal with the “we don’t use exceptions here” mindset, or want to use exceptions for handling errors in their part of the larger legacy system. Once you understand (small) the role exceptions play in the real problem of error handling, it becomes quite obvious how to start using exceptions in a small part of a larger system without disturbing the rest of it, or even how to write very “exception-like” code without actually using exceptions. Most importantly, the exceptions are completely demystified.

Speakers
avatar for Fedor Pikus

Fedor Pikus

Chief Engineering Scientist, Mentor Graphics
Fedor G Pikus is a Chief Engineering Scientist in the Design to Silicon division of Mentor Graphics Corp. His earlier positions included a Senior Software Engineer at Google and a Chief Software Architect for Calibre PERC, LVS, DFM at Mentor Graphics. He joined Mentor Graphics in 1998 when he made a switch from academic research in computational physics to software industry. His responsibilities as a Chief Scientist include planning long-term... Read More →


Wednesday September 23, 2015 9:00am - 10:00am
Six (406) Meydenbauer Center

9:00am

Variable Templates - C++14 compile-time computation
C++11 introduced Variadic Templates, constexpr Functions and Literal Types that ease and allow type-safe computations at compile time. For embedded development this is an important aspect, because it provides a means to create ROMable data in type-safe C++.

In combination with C++14 mechanism of Variable Templates, that actually defines constants, and the relaxed constexpr function rules there are unprecedented possibilities for compile-time computations.

This talk does not only show the mechanisms available but also demonstrates non-trivial examples, how they can be used to compute interesting data at compile time.

Speakers
avatar for Peter Sommerlad

Peter Sommerlad

Director IFS, HSR Rapperswil
Prof. Peter Sommerlad is director of IFS Institute for Software at FHO HSR Rapperswil where he inspired the C++ IDE Cevelop. Peter is co-author of the books POSA Vol.1 and Security Patterns. His goal is to make software simpler by Decremental Development: Refactoring software down to 10% its size with better architecture, testability and quality and functionality. Peter is a member of the C++ standardization committee, ACCU, ACM, IEEE Computer... Read More →


Wednesday September 23, 2015 9:00am - 10:00am
Hamilton (403) Meydenbauer Center

9:30am

Mantid, A C++ framework for the reduction and analysis of neutron scattering data
Today one of the most important barriers between performing an experiment and publishing the results is the complex and time-consuming effort that individual researchers apply to data reduction and analysis. In a neutron experiment one must relate measured counts to a physically meaningful four-dimensional scattering function. While the first neutron scatters had to manually setup their instrument and record neutron counts – in handwriting – one single point at a time, users at a modern time of flight spectrometer rapidly collect hundreds of gigabytes of data in less than one day. High performance software is now a necessity. Rapid reduction, analysis and visualization provide feedback for users, helping them make optimal use of limited beam time. Software must also be accessible to and customized by users with a wide range of abilities and interests in programming. In this talk, I will discuss Mantid-(the Manipulation and Analysis Toolkit for Instrument Data), which is the framework designed for the reduction and analysis of data acquired at muon and neutron sources. It is a partnership between multiple user facilities including Rutherford Appleton Laboratory, Oxfordshire, UK, Oak Ridge National Laboratory, Tennessee, USA and the European Spallation Source, Scandinavia. The core of the Mantid Framework is written in C++ with the user interacting via a GUI or python bindings. I will describe real-world cross-platform situations we have encountered while supporting Mantid on Linux, OS X and Windows. This plus a climate that values stability over the latest operating systems and compilers creates challenges to utilizing new language and library features available in C++11/14. To better exploit parallelism on all of the supported platforms, we are wrapping parallel loops so that different implementations can be chosen at compile time. Considerable portions of Mantid provide domain-specific user interfaces to cross-platform libraries. One example is 3D visualization of the large multidimensional datasets generated in Mantid. Our approach utilizes the application widgets and rendering libraries from ParaView. Mantid provides plugins specifically designed for the Mantid data structures. A custom interface for visualization can be started within Mantid, creating a seamless environment for novice users not comfortable with the ParaView workflow.

This research at ORNL’s High Flux Isotope Reactor and Spallation Neutron Source was sponsored by the Scientific User Facilities Division, Office of Basic Energy Sciences, US Department of Energy.

Speakers
avatar for Steven Hahn

Steven Hahn

Data Analysis Software Engineer, Oak Ridge National Laboratory
Steven Hahn is currently a data analysis software engineer in the Neutron Data Analysis and Visualization Division at the Oak Ridge National Laboratory. He is one of the developers contributing to the MANTID Project, a framework for manipulating and analyzing neutron scattering and muon spectroscopy data. Previously he was a Postdoc in the Quantum Condensed Matter Division at ORNL where he wrote a C++ library to simplify carrying out... Read More →


Wednesday September 23, 2015 9:30am - 10:00am
McClintock (404) Meydenbauer Center

10:30am

Keynote: Better Code: Data Structures
The standard library containers are often both misused and underused. 
Instead of creating new containers, applications are often structured with 
incidental data structures composed of objects referencing other object. 
This talk looks at some of the ways the standard containers can be better 
utilized and how creating (or using non-standard library) containers can 
greatly simplify code. The goal is no incidental data structures. 

Speakers
avatar for Sean Parent

Sean Parent

Principal Scientist, Adobe
Sean Parent is a principal scientist and software architect for Adobe’s mobile digital imaging group. Sean has been at Adobe since 1993 when he joined as a senior engineer working on Photoshop and later managed Adobe’s Software Technology Lab. In 2009 Sean spent a year at Google working on Chrome OS before returning to Adobe. From 1988 through 1993 Sean worked at Apple, where he was part of the system software team that developed... Read More →


Wednesday September 23, 2015 10:30am - 12:00pm
Montessori Hall Meydenbauer Center

12:30pm

Easy compilation from TouchDevelop to ARM Cortex-M0 using C++11

The BBC micro:bit is a small micro-computer that will be handed out to a million kids in the UK to teach them programming. The students program the device using TouchDevelop, a web-based programming portal, featuring TouchDevelop-the-language, a statically-typed, JavaScript-inspired scripting language. The blessed toolchain for ARM Cortex-M0s, however, is C++. This talk will describe how we compile TouchDevelop to C++; more specifically, how we use C++11's features to make sure we do as little work as possible and let the C++ compiler handle most of it!


Speakers
avatar for Jonathan Protzenko

Jonathan Protzenko

Post-doc Researcher, Microsoft
Jonathan Protzenko is a post-doc researcher at Microsoft Research in Redmond. He graduated from INRIA in 2014. His areas of focus include programming language design, more specifically, the intersection of type systems and verification. Recently, he joined the TouchDevelop team to deliver the programming environment for the BBC micro:bit.


Wednesday September 23, 2015 12:30pm - 1:00pm
Hamilton (403) Meydenbauer Center

12:30pm

Become a GDB Power User
If you’re writing C++ for anything other than Windows, chances are that you occasionally break out GDB. This session presents some of the lesser known features of GDB that can change the way you debug. GDB has come a long way in the last few years and does so much more than break, print, step and continue. Reversible debugging; Non-Stop Mode; Multi-process Debugging; and Dynamic Printf are but some of its best features, and its built-in Python scripting is particularly powerful.

Join Undo Software co-founder and CEO, Greg Law, as he takes you through a series of demos to show some amazing tricks with GDB, and powerful new (and not-so-new) features that you may not have heard of. Note: this talk builds on - but is much more extensive than - the Lightning Talk, “Give me fifteen minutes and I’ll change your view of GDB”.

Speakers
avatar for Greg Law

Greg Law

CEO, Undo Ltd
Greg is a software geek at heart, but likes to keep one foot in the software world and one foot in the business world. He finds it particularly rewarding to turn innovative software technology into “real” business development. Greg has over 20 years of experience in both academia and innovative start-up software companies. In 2005 he co-founded Undo Software, which he now runs.


Wednesday September 23, 2015 12:30pm - 1:30pm
McClintock (404) Meydenbauer Center

12:30pm

Welcome to Boost
Boost provides free peer-reviewed portable C++ source libraries and has been the source of most additions to the standard library since 1998.
Come to the session to learn about the history of Boost, what we do, how we do it, how you benefit from it, and how you can participate. We’ll have brief talks for Boost leaders and authors followed by question from attendees.

Speakers
RC

Rachel Cheng

Software Engineer, F5 Networks
avatar for Marshall Clow

Marshall Clow

Principal Engineer, Qualcomm
Marshall is a long-time LLVM and Boost participant. He is a principal engineer at Qualcomm, Inc. in San Diego, and the code owner for libc++, the LLVM standard library implementation. He is the author of the Boost.Algorithm library and maintains several other Boost libraries.
avatar for Beman Dawes

Beman Dawes

Beman Dawes is a software developer from Virginia in the United States and the founder of boost.org. He is the author of the StreetQuick geographic atlas library used by digital map publishers to help people get really, really, lost. He wrote his first computer program 40 years ago, and does not mourn the passing of bi-quinary arithmetic. Beman has been a voting member of the ANSI/ISO C++ Standards Committee since 1992, and chaired the Library... Read More →
avatar for Niall Douglas

Niall Douglas

Consultant, ned Productions Ltd
Niall Douglas is a lead author of WiP Boost.AFIO v2, Boost.Outcome, Boost.KernelTest and Boost-lite. He has been the lead Google Summer of Code administrator for Boost since 2014. He is an Affiliate Researcher with the Waterloo Research Institute for Complexity and Innovation at the University of Waterloo, Canada, and holds postgraduate qualifications in Business Information Systems and Educational and Social Research as well as a second... Read More →
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!
avatar for Bryce Adelstein Lelbach

Bryce Adelstein Lelbach

Lawrence Berkeley National Laboratory
Bryce Adelstein Lelbach is a researcher at Lawrence Berkeley National Laboratory (LBNL), a US Department of Energy research facility. Working alongside a team of hardware engineers and scientists, he develops and analyzes new parallel programming models for exascale and post-Moore architectures. Bryce is one of the developers of the HPX C++ runtime system. He spent five years working on HPX while he was at Louisiana State University's Center... Read More →
avatar for Robert Ramey

Robert Ramey

Proprietor, Robert Ramey Software Development
Robert Ramey is a freelance Software Developer living in Santa Barbara, California. (See www.rrsd.com.)  His long and varied career spans various aspects of software development including business data processing, product, embedded systems, custom software, and C++ library development. Lately, he has been mostly interested in C++ library design and implementation related to Boost.  He is the author and maintainer of the Boost... Read More →


Wednesday September 23, 2015 12:30pm - 1:30pm
Hopper Theater Meydenbauer Center

2:00pm

boo{stache} exposed : the inner-workings of a generic template engine
Template engines are commonly found generating web pages, customer reports, or even source code. They take a source template and data model as input and generate some desired output.

Boostache was started as the Library in a Week challenge from CppNow'14 with initial support for Mustache.

Today Boostache supports multiple template formats and adapts automagically at compile time to user defined data models. Many of the techniques utilized in Boostache are the same that Ciere has employed in custom IDL compilers, Domain Specific Language systems, compilers, and runtimes.

This talk will briefly introduce Boostache and then delve into the internal architecture and design of the library. We will explore some implementation details of the parser, compiler, virtual machine, and generic data model infrastructure with the goal to expose useful techniques and patterns from this C++11 code base that can be used in your own libraries and applications.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com


Wednesday September 23, 2015 2:00pm - 3:00pm
Franklin (407) Meydenbauer Center

2:00pm

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 Garbage Collector.

Speakers
avatar for Pedro Ramalhete

Pedro Ramalhete

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


Wednesday September 23, 2015 2:00pm - 3:00pm
Hopper Theater Meydenbauer Center

2:00pm

More than lint: modern static analysis for C++
Static analysis tools have the potential to significantly improve programmer productivity as well as the safety, reliability and efficiency of the code they write. Modern static analysis has moved well beyond the mental model people often have based on “lint”: just finding simple “typos” or “thinkos”. Static analysis can find subtle, complex bugs early, identify opportunities to improve performance, encourage consistent style and appropriate usage of libraries and APIs.

This talk will look at the different purposes static analysis tools can be used to meet all these different goals. It will present specific examples from our experience working with sophisticated analysis tools on large, commercial codebases. The talk will also present a specific implementation of a modern static analysis toolkit for C++. This toolkit is being used in a number of different contexts: to provide tool-based enforcement of new coding guidelines and rules, to migrate people to modern C++ coding idioms and to find important security and reliability defects. One notable example of its use is to implement the checker for enforcement of a core set of coding guidelines that are presented in Bjarne Stroustrup’s keynote address.

Some of the tools described in the talk will be available for download in a future Community Technology Preview .

Speakers
avatar for Neil MacIntosh

Neil MacIntosh

Principal Software Engineer, Microsoft
Neil is the lead for the C++ static analysis frameworks used widely within Microsoft, including PREfix, PREfast, and EspXtension, as well as the /analyze feature of the Microsoft C++ compiler. He is currently focused on making all these tools work better with portable C++14 code rather than nonstandard annotations. He also maintains Microsoft's implementation of the Guideline Support Library (GSL).


Wednesday September 23, 2015 2:00pm - 3:00pm
McClintock (404) Meydenbauer Center

2:00pm

Transducers: generalized, composable and functional transformations of sequential inputs, from Clojure to C++

Transducers allow to express transformations on sequential inputs (like std::transform, std::filter, most of boost::range::adators [4] and more) in a way that is independent of the input source. They are simple high order functions agnostic of the notion of iterator or collection and can be combined by simple function composition. They can later be applied eagerly or lazily over iterators, but most interestingly, also to other kinds of "reactive" sources, like networked streams, inter-process channels or reactive observables (e.g. RxCpp [3]). Not only they provide an elegant decoupling between the "what" and the "how" and higher level of reuse, their implementation is often simpler and and more performant than similar boost::range adaptors.

Transducers were introduced in Clojure by Rich Hickey [2]. At Ableton we implemented them in C++ and released them as part of our Open Source modern C++ toolkit: Atria [1]. Our implementation introduces innovations of its own, like implementing state-full transducers without mutation, enabling further safety and reusability. We also use Eric Niebler's technique [5] to describe and check its concepts in standard compliant C++11.

In this session we will introduce the concept of transducers and how they can be implemented in modern C++. We will also cover some of the most interesting use-cases.

[1] https://github.com/AbletonAG/atria
[2] http://clojure.org/transducers
[3] https://github.com/Reactive-Extensions/RxCpp
[4] http://www.boost.org/doc/libs/1_58_0/libs/range/doc/html/range/reference/adaptors.html
[5] http://ericniebler.com/2013/11/23/concept-checking-in-c11/


Speakers
avatar for Juan Pedro Bolívar Puente

Juan Pedro Bolívar Puente

Software Engineer, Ableton
Juanpe is a Spanish software engineer currently based in Berlin, Germany. Since 2011 he works for Ableton, where he has helped building novel musical platforms like Push and Live and where he coordinates the "Open Source Guild" helping the adoption and contribution to FLOSS. He is most experienced in C++ and Python and likes tinkering with languages like Haskell or Clojure. He is an advocate for "modern C++" and pushes for adoption of... Read More →


Wednesday September 23, 2015 2:00pm - 3:00pm
Six (406) Meydenbauer Center

2:00pm

An Overview on Encryption in C++
Encryption has become a very important topic for C++ developers and this session will serve as an introduction and overview this topic. I will present an overview on the popular encryption libraries cryptopp, botan and libsodium, and give you an update on the popular encryption algorithms of AES and RSA, plus why cryptoboxes can be a great help.

Speakers
avatar for Jens Weller

Jens Weller

Meeting C++, Meeting C++
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++.


Wednesday September 23, 2015 2:00pm - 3:00pm
Hamilton (403) Meydenbauer Center

3:15pm

A few good types: Evolving array_view and string_view for safe C++ code
The Library Fundamentals TS already contains a string_view type, and possibly soon an array_view type. These are important and should be used pervasively as function parameters, especially instead of (pointer, length) pairs which are generally unsafe. They offer additional benefits in the form of decoupling: allowing functions to be specified in terms of high-level views rather than references to specific, concrete string and container types which bind both caller and callee to a specific implementation detail. As a specific example, using string_view in function signatures allows them to be called with any of the endless proliferation of string types that exist in codebases today (std::string, CStringT, char*, BSTR, HSTRING, MyString etc).

We can and should evolve these types further as a key part of achieving memory safety for C++ code.

This example-driven talk shares our experience with preventing defects in large-scale commercial C++ codebases by applying modestly evolved versions of the proposed array_view and string_view types, plus a small number of related types such as not_null. Adopting these types enables simpler and safer code that eliminates important classes of defects by construction. The types are carefully designed to have usually exactly zero space and time overhead over the current unsafe idioms they replace, so as to leave no valid performance reason against adopting them. Using these types enables high-quality static analysis, and is allowing Microsoft to fully replace non-standard and non-portable annotation systems for type and memory safety in our own code bases.

We believe this approach is generally applicable to code at all levels, from application code down to the most performance-sensitive systems code. An open source reference implementation of the types that supports all major compilers and platforms will be available on GitHub.

Speakers
avatar for Neil MacIntosh

Neil MacIntosh

Principal Software Engineer, Microsoft
Neil is the lead for the C++ static analysis frameworks used widely within Microsoft, including PREfix, PREfast, and EspXtension, as well as the /analyze feature of the Microsoft C++ compiler. He is currently focused on making all these tools work better with portable C++14 code rather than nonstandard annotations. He also maintains Microsoft's implementation of the Guideline Support Library (GSL).


Wednesday September 23, 2015 3:15pm - 4:15pm
Six (406) Meydenbauer Center

3:15pm

Benchmarking C++ Code
With the ending of Moore's Law and the rise of multicore systems, programmers from across the industry are increasing forced to develop and maintain highly performance sensitive software. For C++, a language frequently used for performance sensitive projects, benchmarking and performance analysis is especially important. Developing good benchmarks can be tricky; gathering and analyzing data from benchmarks can be an even greater challenge.

This talk will discuss techniques and best practices for writing C++ benchmarks using facilities from the standard library and Boost. We'll also cover the development of performance unit/regression tests. We'll discuss the statistical best practices for gathering data, as well as techniques for benchmarking a variety of different metrics - time, memory, algorithmic complexity, etc.

The main topics which will be covered:

* Statistical Best Practices (dealing with uncertainty, achieving statistical confidence, how to sample)
* Time-Based Benchmarking (best practices for timing, derived time-based metrics)
* Non-Time-Based Benchmarking (memory, algorithmic complexity in time and space, etc)
* Techniques for C++-specific Performance Metrics (counting copies/moves, allocator tricks)
* Converting Benchmarks into Tests

Speakers
avatar for Bryce Adelstein Lelbach

Bryce Adelstein Lelbach

Lawrence Berkeley National Laboratory
Bryce Adelstein Lelbach is a researcher at Lawrence Berkeley National Laboratory (LBNL), a US Department of Energy research facility. Working alongside a team of hardware engineers and scientists, he develops and analyzes new parallel programming models for exascale and post-Moore architectures. Bryce is one of the developers of the HPX C++ runtime system. He spent five years working on HPX while he was at Louisiana State University's Center... Read More →


Wednesday September 23, 2015 3:15pm - 4:15pm
Hopper Theater Meydenbauer Center

3:15pm

Bridging Languages Cross-Platform: Djinni Implementation Techniques
Dropbox has been using C++ for cross-platform development on mobile platforms since 2012. In 2014 we open-sourced Djinni, our code generator that bridges C++ to other languages. In this talk we'll dive deep into some implementation techniques we use to bridge languages, easily, flexibly, and efficiently. We'll use the recent addition of Python-to-C++ bridging as an example of the challenges and decisions which come up when building a bridge between two very different languages, as well as talking about some interesting challenges we faced in Java and Objective-C.  Topics include marshaling data-types, cross-language object ownership and identity, template-generated cached proxy objects, and translation of exceptions. What you learn should arm you to bridge languages for your own needs, or use/extend Djinni for your own programs. No prior knowledge of Djinni or mobile development required, but intermediate C++ will be assumed, and a bit of Python will be useful.

Speakers
avatar for Jacob Potter

Jacob Potter

Software Engineer, Dropbox
Jacob Potter is a recovering embedded systems engineer who is now driving Dropbox’s use of modern C++ for cross-platform mobile development. He's also the primary maintainer of Djinni, the tool Dropbox uses for generating cross-language bindings.
avatar for Andrew Twyman

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... Read More →


Wednesday September 23, 2015 3:15pm - 4:15pm
Noether (408) Meydenbauer Center

3:15pm

Enhancing STL containers
STL has a big history. Due to class paradigm of C++, many STL containers have a flat layout in memory, i.e. containers naturally store objects and address objects rather than their indexing entities such as smart pointers (which are, strictly speaking, objects too). This model has a benefit of lower memory fragmentation, that causes better CPU cache performance. However, many tasks in real life require reordering of objects, that requires compexity of O(n*q), where q is a size of an object and n is a compexity measured in operations. Thus, some imlementations of operations with reordering objects in some containers are much slower that they could be. This problem could sometimes be solved by storing “pointers” as index entities in containers instead of the objects by themselves, what improves performance by q times, but causes memory fragmentation and worse cache performance. Algorithmically, the solution with pointers is obviously better, but it is still not the most efficient one. In the presentation I will show myimplementations of containers using both approaches and having the best of two worlds. I will compare these methods with classical and modern approaches and draw some conclusion, encouraging everybody to use the power of algorithms with C++.

Speakers
avatar for Viktor Korsun

Viktor Korsun

Head of client-side development, Zeptolab
Viktor graduated from Moscow Technical University and Yandex Data Analysis School. | In 2006 - 2008 Viktor worked for Galaktika corpotation, participated in the creation of a 4'th generation OO-programming language. | In 2008 - 2010 Viktor worked for Alta-Soft LLC as a technical architect of a distributed customs database. | Since 2012 Viktor has been working for Zeptolab LLC, creating modern mobile games. At the moment the company is... Read More →


Wednesday September 23, 2015 3:15pm - 4:15pm
Franklin (407) Meydenbauer Center

3:15pm

Transactional Memory in Practice
Transactional memory has been held up as a panacea for concurrent programming in some quarters. The C++ standardization committee is even looking at including it in the standard. But is it really a panacea? Has anyone used it in a shipping piece of software? There are scattered examples, mostly from the high-performance and super-computing realms. On the other end of the spectrum, at Wyatt Technology we've been using transactional memory in a desktop application that does data acquisition and analysis for the light-scattering instruments we build. That application is called Dynamics and we've been using a software transactional memory system in it for four years now. This talk will detail how our system works, how well it worked, and what pitfalls we've run into. Prior experience with transactional memory will not be assumed, though it would help if you have experience programming threads with locks and an open mind about alternatives and why we're looking for them.

Speakers
avatar for Brett Hall

Brett Hall

Principal Software Engineer, Wyatt Technology
Brett is the lead developer on Dynamics, a data collection and analysis package developed at Wyatt Technology(http://www.wyatt.com/) for use with their light scattering instruments. He holds a PhD in Physics from the University of California, Santa Barbara. Previous to joining Wyatt, Brett worked in the game industry, remote sensing, and web development. He also blogs about C++, among other things, at backwardsincompatibilities.wordpress.com.


Wednesday September 23, 2015 3:15pm - 4:15pm
Hamilton (403) Meydenbauer Center

3:15pm

Type Traits - what are they and why should I use them?
In this talk, I will answer the questions, "What are type traits?" and "Why are type traits useful?", along with some examples of why when when they should be used.


Speakers
avatar for Marshall Clow

Marshall Clow

Principal Engineer, Qualcomm
Marshall is a long-time LLVM and Boost participant. He is a principal engineer at Qualcomm, Inc. in San Diego, and the code owner for libc++, the LLVM standard library implementation. He is the author of the Boost.Algorithm library and maintains several other Boost libraries.


Wednesday September 23, 2015 3:15pm - 4:15pm
McClintock (404) Meydenbauer Center

4:45pm

Applying functional programming in code design
At first glance C++ doesn't seem to be a language that lets you do much functional programming, not to mention actually focusing the structure of your application around that. But that is changing, together with the general approach to program in the language. We do care about const-correctness; when writing code meant to run concurrently, we want to avoid locks, so we do our best not to share mutable state (I'm here to argue that uniquely owned mutable state is perfectly fine). With that mindset, we can try to design our applications in a functional way.

This talk will focus not only on things typically associated with functional programming, but also on the following in the context of C++: * Making functions pure (as long as it makes sense). * Using functional data structures. * Designing control flows that don't lead to shared state. * Composability and benefiting from laziness. * Striving for generic code. * Noticing patterns and turning them into abstractions. * Functors and monads as "patterns". * An example application built around those principles.

Speakers
avatar for Michał Dominiak

Michał Dominiak

Software Engineer, Nokia Networks
Bachelor of Engineering in Computer Science, studied at Faculty of Electronics at Wrocław University of Technology. Loves metaprogramming and doing as much as possible during compile time, instead of wasting precious cycles at runtime.


Wednesday September 23, 2015 4:45pm - 5:45pm
McClintock (404) Meydenbauer Center

4:45pm

Contracts for Dependable C++

One of the three major areas that C++17 is expected to address is “improving support for large-scale dependable software.” A general understanding of ‘dependable software’ is the notion that the product should reliably perform the task it was designed for, and when given erroneous inputs the program should not be allowed to blindly continue execution, thereby possibly causing serious harms. In another words, an abrupt program termination is preferable to an exploited program vulnerability.

“Contracts” are a language feature being considered by the ISO C++ standards committee for C++17. They offer a basic mitigation measure, and early containment mechanism, by allowing a C++ programmer express more formally (instead of just comments) in code the requirements of a function interface. They offer a complement to conventional static type checking, and move comments closer to mechanized scrutiny. This presentation will explore the design space, previous efforts, the importance of analysis tools (both static and dynamic), and how contracts provide greater integration and support.


Speakers
avatar for Gabriel Dos Reis

Gabriel Dos Reis

Gabriel Dos Reis is a Principal Software Development Engineer at Microsoft. He is also a researcher and a longtime member of the C++ community.  His research interests include programming tools for dependable software. Prior to joining Microsoft, he was Assistant Professor at Texas A&M University.  Dr. Dos Reis was a recipient of the 2012 National Science Foundation CAREER award for his research in compilers for dependable... Read More →


Wednesday September 23, 2015 4:45pm - 5:45pm
Hamilton (403) Meydenbauer Center

4:45pm

Declarative Control Flow
Getting exception handling right is a perennial problem in C++ that has eluded systematization. Not for much longer. New language and library developments make it possible to handle exceptions in a declarative manner, leading to drastic code simplification.

This talk discusses an alternative approach to handling exceptional flow that eliminates the need for small ancillary RAII classes, try/catch statements that rethrow, and other cleanup mechanisms. The popular Scope Guard idiom gets a spectacular generalization. Statements specify in a declarative manner actions to be taken if the current scope is left normally or via an exception. The resulting code is simpler, smaller, and easier to maintain.

Speakers
avatar for Andrei Alexandrescu

Andrei Alexandrescu

Founder, D Language Foundation
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 BSc in Electrical Engineering from... Read More →


Wednesday September 23, 2015 4:45pm - 5:45pm
Hopper Theater Meydenbauer Center

4:45pm

Intro to the C++ Object Model
Introduction to the C++ object model.

This talk is to help you learn about how objects are represented in C++. I find it very helpful to have a mental model of how objects exist in the program memory space to understand how my code operates within program execution.

Speakers
avatar for Richard Powell

Richard Powell

Audio Software Engineer, Apple, Inc
I started using C++ 10 years ago to write a psychoacoustic audio encoder/decoder and have continued to explore how to make software that unlocks the potential of hardware to bring amazing applications to life. I graduated from UC Berkeley with a BS in Electrical Engineering and Computer Science, and worked throughout the Bay Area for the past 15 years. I enjoy teaching and learning about C++ and programming.


Wednesday September 23, 2015 4:45pm - 5:45pm
Six (406) Meydenbauer Center

4:45pm

What is Open Source, and Why Should You Care?
In this session, Kevin will present a condensed history of open source software: its origins, motivations and effect on the world of software development. He'll then talk about open source *beyond* software, and various ways that students can get involved in open source projects to develop useful (and marketable) skills. These are skills which are not taught in most degree programs, but are very valuable for jobs in scientific and engineering disciplines.

Speakers
avatar for Kevin P. Fleming

Kevin P. Fleming

Member of the CTO Office, Bloomberg LP
I manage community development and evangelism at Bloomberg, spanning our activities in the open source, open standards and academic communities. Ask me about open source software, open source licensing, and C++!


Wednesday September 23, 2015 4:45pm - 5:45pm
Franklin (407) Meydenbauer Center

6:00pm

NW C++ User Dinner
The NorthWest C++ Users Group is having a pizza dinner sponsored by Collabera before their Ask the Expert panel at the Meydenbauer.

Moderators
avatar for Brett Searles

Brett Searles

Principal Architect, Attobotics
Work in hardware, embedded, graphics and web-based software space. Currently working on a Holographic Surgical Center to allow surgeons to perform simulated surgeries on real patient data. Also working with a major electronics distributor on a SAAS tool for their customers to easily interchange embedded environments.

Wednesday September 23, 2015 6:00pm - 6:45pm
Zeeks Pizza 10201 NE 10th Street, Bellevue, WA 98004

7:00pm

Ask the Expert : SG14 and Security
Have you had a question about a certain aspect of the C++ programming language related to security? How about questions on how C++ is developing better support for low latency and graphics programming? Well, now you have the chance to ask experts in both the security and game programming/low latency fields. Please bring your curiosity and even your experiences and listen to what the ISO C++ Standards Committee is doing to address your concerns about low latency programming and to experts who deal with security-based issues. You will have a number of resources to get in depth knowledge and tips to make enhancements to the performance of your applications.

Moderators
avatar for Brett Searles

Brett Searles

Principal Architect, Attobotics
Work in hardware, embedded, graphics and web-based software space. Currently working on a Holographic Surgical Center to allow surgeons to perform simulated surgeries on real patient data. Also working with a major electronics distributor on a SAAS tool for their customers to easily interchange embedded environments.

Speakers
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


Wednesday September 23, 2015 7:00pm - 8:00pm
Hopper Theater Meydenbauer Center

7:00pm

Informal C++ Audio Meetup
Everyone interested in C++ audio is welcome to attend.

Moderators
JS

Julian Storer

Director, Raw Material Software Ltd
Working with C++ in the multimedia industries for 20 years, I'm the creator of the JUCE cross-platform framework, which is used by hundreds of audio and media companies around the world. I also created the Tracktion DAW, which has been helping people create music for over a decade!

Wednesday September 23, 2015 7:00pm - 8:00pm
Lot 3 460 106th Ave NE, Bellevue, WA 98004

8:30pm

Boost Working Session
This work session is for individuals interested in working on Boost infrastructure projects.

Moderators
avatar for Robert Ramey

Robert Ramey

Proprietor, Robert Ramey Software Development
Robert Ramey is a freelance Software Developer living in Santa Barbara, California. (See www.rrsd.com.)  His long and varied career spans various aspects of software development including business data processing, product, embedded systems, custom software, and C++ library development. Lately, he has been mostly interested in C++ library design and implementation related to Boost.  He is the author and maintainer of the Boost... Read More →

Wednesday September 23, 2015 8:30pm - 9:15pm
Franklin (407) Meydenbauer Center

8:30pm

Functional programming: functors and monads
Following the 'Applying functional programming in code design' session from Wednesday, I'd like to conduct a 'crash course' on functors and monads, and why they are important - and useful - regardless of the language you are writing code in.

Speakers
avatar for Michał Dominiak

Michał Dominiak

Software Engineer, Nokia Networks
Bachelor of Engineering in Computer Science, studied at Faculty of Electronics at Wrocław University of Technology. Loves metaprogramming and doing as much as possible during compile time, instead of wasting precious cycles at runtime.


Wednesday September 23, 2015 8:30pm - 10:00pm
McClintock (404) Meydenbauer Center

8:30pm

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
KG

Kate Gregory

Partner, Gregory Consulting
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... Read More →

Wednesday September 23, 2015 8:30pm - 10:00pm
Hopper Theater Meydenbauer Center

8:30pm

A Crash Course in Open Source Licensing
Open source software licenses are intended to provide a way for software authors to protect their own rights, and the rights of the users of their software, but many developers are unaware of how they work, why they are important, and how to apply them to their projects.

It may never have occurred to you, but software licenses are much like programs: they are developed to meet requirements, they live in a world of external influences and constraints, and they use documented techniques to solve problems.

In this session, the attendees will participate in a fun, interactive process to choose the components of a software license through real-world examples, with the goal of every attendee leaving with a basic understanding of the more important aspects of software licenses. Along the way they will learn the basics of copyrights and how they apply to software; what 'derivative work' and 'distribution' mean in these contexts; and many other useful concepts, including the most important differences between common licenses like the GNU General Public License family and the Apache 2 license.

Speakers
avatar for Kevin P. Fleming

Kevin P. Fleming

Member of the CTO Office, Bloomberg LP
I manage community development and evangelism at Bloomberg, spanning our activities in the open source, open standards and academic communities. Ask me about open source software, open source licensing, and C++!


Wednesday September 23, 2015 8:30pm - 10:00pm
Hamilton (403) Meydenbauer Center
 
Thursday, September 24
 

8:00am

A Project-Based Learning Approach to Teaching C++
Most people learn best by doing, and that applies to learning C++. Come join a discussion on how Project-Based Learning techniques have helped an intermediate C++ course deliver better student results at Utah Valley University, and bring your own ideas on how best to teach and learn C++.

Speakers
avatar for Chuck Allison

Chuck Allison

Professor, Utah Valley University
Chuck Allison is professor and chair of Computer Science at Utah Valley University. Before that he spent 20 years as a software engineer at various large corporations in the western U.S. He was an active contributor to the C++98 standard, having designed and provided the reference implementation for std::bitset and std::vector<bool>/boost::dynamic_bitset. He was an editor and columnist at the C/C++ Users Journal from 1992–2001 and its... Read More →


Thursday September 24, 2015 8:00am - 8:45am
Hamilton (403) Meydenbauer Center

8:00am

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
KG

Kate Gregory

Partner, Gregory Consulting
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... Read More →

Thursday September 24, 2015 8:00am - 8:45am
Hopper Theater Meydenbauer Center

8:00am

Crazy Easy C++ Scripting With ChaiScript
Join us for a hands-on session as the co-creator of ChaiScript, a clean and easy way to add scripting to C++, takes you through its major features. Bidirectional sharing of functions, data, futures, and exceptions between script and C++ will be explored. This is your chance to for in-depth Q&A and feedback.

Speakers
avatar for Jason Turner

Jason Turner

Developer, Trainer, Speaker
Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http://cppbestpractices.com. | | I'm available for contracting and onsite training.


Thursday September 24, 2015 8:00am - 8:45am
McClintock (404) Meydenbauer Center

9:00am

Faster Complex Numbers
Complex numbers are an important tool from mathematics enabling many problems to be written in a more generic form. The C++ standard library comes with an implementation to work with complex numbers in a natural way.

Motivated by useful real world examples from theoretical physics and audio dsp I will discuss benchmarks of std::complex and demonstrate how alternative implementations, naïve or advanced ones based on expression templates, outperform std::complex and can compete with hand-crafted C code (depending on compiler and std lib). A quick introduction to expression templates will be provided.

Speakers
avatar for André Bergner

André Bergner

Team Leader Software Development, Native Instruments GmbH
André leads the Traktor software development team at Native Instruments. There he is taking an active role in modernizing the C++ coding standards by organizing tech talks and introducing new techniques and libraries. Some of his main interests are functional and generic programming and solving meta-programming puzzles. Besides that he is lecturer at the Beuth Hochschule in Berlin where he teaches C++ and is one of the organizers of the local... Read More →


Thursday September 24, 2015 9:00am - 9:30am
Franklin (407) Meydenbauer Center

9:00am

C++ metaprogramming: a paradigm shift
Most people think metaprogramming is hard. It isn't; we just didn't have the right tools for it. This talk will present a new way of metaprogramming using the same syntax as that of normal C++. It will show how the runtime and the compile-time boundaries can be crossed almost seamlessly. It will show how compilation times can be reduced without sacrificing expressiveness. It will introduce Hana [1], a newly accepted Boost library using cutting edge features of the language in a creative way to solve the problem of metaprogramming for good.

[1]: http://github.com/ldionne/hana

Speakers
avatar for Louis Dionne

Louis Dionne

Louis is a math and computer science enthusiast with interest in C++ (meta)programming, functional programming, domain specific languages and related subjects. He is an active member of the Boost community, and recently wrote the Boost.Hana metaprogramming library.


Thursday September 24, 2015 9:00am - 10:00am
McClintock (404) Meydenbauer Center

9:00am

Lessons in Sustainability: How to Maintain a C++ Codebase for Decades
Google maintains (we believe) the largest monolithic C++ codebase in the world with over 100M lines of C++ code. Early commits to this repository date back to the late 1990s. About 4000 engineers submit at least one change in C++ every week. We’ve learned a few things about what it takes to maintain a codebase at this scale.

In this talk I’ll present some of the lessons we’ve learned over the years with respect to policies, technology, education, design, and maintenance of a long-lived monolithic codebase.

Speakers
avatar for Titus Winters

Titus Winters

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


Thursday September 24, 2015 9:00am - 10:00am
Hopper Theater Meydenbauer Center

9:00am

Rcpp: Seamless R and C++ Integration
R is an open-source statistical language designed with a focus on data analysis. While its historical roots are in statistical applications, it is currently experiencing a rapid growth in popularity in all fields where data matters: from data science, through bioinformatics and finance, to machine learning. Key strengths contributing to this growth include its rich libraries ecosystem (over 6 thousands packages at the moment of writing) – often authored by the leading researchers in the field, providing early access to the latest techniques; beautiful, high-quality visualizations – supporting seamless exploratory data analysis and producing stunning presentations; all of this available in an interactive environment resulting in high productivity through fast iteration times.

At the same time, there are no free lunches in programming: the dynamic, interactive nature of R does have its costs, including a significant impact on run-time performance. In an era of growing data sizes and increasingly realistic models this concern is only becoming more important.

In this talk we provide an introduction to Rcpp – a library allowing smooth integration of R with C++, combining the productivity benefits of R for data science together with the performance of C++. First released in 2005, today it’s the most popular language extension for R -- used by over 400 packages. We'll also discuss challenges (as well as possible solutions) involved in integrating modern C++ code, and demonstrate the usage of popular C++ libraries in practice. We’ll conclude the talk with the RInside package allowing to embed R in C++.

Speakers
avatar for Matt P. Dziubinski

Matt P. Dziubinski

Research & Development, Aalborg University
Matt P. Dziubinski is affiliated with the Department of Mathematical Sciences, Aalborg University, Denmark and a Junior Fellow at Center for Research in Econometric Analysis of Time Series (CREATES). His fascination with computers started in the late 1980s with an 8-bit Atari. His current research interests include Quantitative Finance and High Performance Scientific Computing, with a focus on applied cross-platform parallel computing... Read More →



Thursday September 24, 2015 9:00am - 10:00am
Six (406) Meydenbauer Center

9:00am

What's New in Visual C++ 2015 and Future Directions
In this talk, we'll discuss new features, optimizations, and scenarios in Visual Studio 2015. We'll cover new backend optimizations, improved build throughput, new productivity and diagnostics features, and give a detailed update on our conformance progress, as well as talk about cool new c++1y features that we are shipping from await to modules.

Visual Studio isn't just for Microsoft platform developers. We'll also demonstrate our latest cross platform C++ development features for Android and iOS. We'll also give a sneak peak at our work on combining the Clang frontend with our existing backend to bring Clang support for Windows to Visual Studio.

Speakers
SC

Steve Carroll

Visual C++ Dev Manager, Microsoft
AS

Ayman Shoukry

Group Program Manager, Microsoft
Ayman Shoukry has been with the Microsoft Developer Division product groups for close to 15 years. He is currently the Group Program Manager for the Visual C++ team at Microsoft. Ayman’s team is responsible for delivering the compilers, libraries, runtimes and IDE that enable developers to create great native applications using visual Studio. Prior to joining Microsoft, Ayman spent a year & half in Newcastle, Australia where he earned... Read More →


Thursday September 24, 2015 9:00am - 10:00am
Hamilton (403) Meydenbauer Center

9:30am

C++ Multi-dimensional Arrays for Computational Physics and Applied Mathematics
The language feature of passing a multi-dimensional array to a function without specifying all its dimensions at compile time is crucial for computational physics and applied mathematics. For example a matrix is a two dimensional array and a matrix inversion function which needs to know the size of the matrix at compile time would be of limited use. Major general purpose languages such as C, Java and C# support this feature. Of course, scientific programming languages like Fortran, Matlab and R also support this feature.

C++ is perhaps the only major programming language which does not allow passing a multi-dimensional array to a function unless the size of all the dimensions except the first one is known at compile time. Due to this limitation of C++, various libraries have been developed for using multi-dimensional arrays in C++. Some of these libraries are Blitz++, Armadillo, Eigen and boost.multi_array. These libraries are very large and complex. While they do provide a wide variety of features, they have a learning curve which may be difficult to justify for something as basic as passing multi-dimensional arrays to functions. Also the computational physics or applied mathematics code becomes dependent on a large non-standard library. Hence its usage will be limited to only those scientists who are willing to install these non-standard libraries.

The reference feature of C++ allows us to develop a multi-dimensional array class. The class has a small number of lines of code and hence the code can be included with the scientific application code. We use this class to write programs for various areas of computational physics and show that the class is easy to use and it leads to readable programs.

Speakers
PG

Pramod Gupta

Research Scientist, University of Washington
Pramod Gupta is a research scientist at the Department of Astronomy at | the University of Washington. He works on computational astrophysics using C++ and other languages. He is interested in parallel computing and he has used both the established techniques such as MPI and OpenMP and the newer techniques such as Hadoop and CUDA/GPU. He has taught a graduate course on astrophysics. He holds several United States patents. He has presented... Read More →


Thursday September 24, 2015 9:30am - 10:00am
Franklin (407) Meydenbauer Center

10:30am

Tuning C++: Benchmarks, and Compilers, and CPUs! Oh My!
A primary use case for C++ is low latency, low overhead, high performance code. But C++ does not give you these things for free, it gives you the tools to control these things and achieve them where needed. How do you realize this potential of the language? How do you tune your C++ code and achieve the necessary performance metrics?

This talk will walk through the process of tuning C++ code from benchmarking to performance analysis. It will focus on small scale performance problems ranging from loop kernels to data structures and algorithms. It will show you how to write benchmarks that effectively measure different aspects of performance even in the face of advanced compiler optimizations and bedeviling modern CPUs. It will also show how to analyze the performance of your benchmark, understand its behavior as well as the CPUs behavior, and use a wide array of tools available to isolate and pinpoint performance problems. The tools and some processor details will be Linux and x86 specific, but the techniques and concepts should be broadly applicable.

Speakers
avatar for Chandler Carruth

Chandler Carruth

C++ Lead, Google
Chandler Carruth leads the Clang team at Google, building better diagnostics, tools, and more. Previously, he worked on several pieces of Google’s distributed build system. He makes guest appearances helping to maintain a few core C++ libraries across Google’s codebase, and is active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all... Read More →


Thursday September 24, 2015 10:30am - 12:00pm
Montessori Hall Meydenbauer Center

12:30pm

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
KG

Kate Gregory

Partner, Gregory Consulting
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... Read More →

Thursday September 24, 2015 12:30pm - 1:30pm
Hopper Theater Meydenbauer Center

12:30pm

cppreference.com: the community wiki
Did you know cppreference.com documents more than C++? Did you know you can choose which standard revision to see? Have you noticed something wrong but couldn't figure out how to edit the wiki?

This talk will highlight some of the new and exciting things that appeared on cppreference.com since last September, as well as some of the things that are currently in the pipeline. We will take a look at the lesser-known sections, features, knobs, and gadgets. Finally, we will present a few pointers on contributing to cppreference, including how to work your way through some of the more common standard and custom templates used on the site.

Speakers
avatar for Sergey Zubkov

Sergey Zubkov

Morgan Stanley
Sergey is a former biochemistry researcher and OS developer, who now works in finance and spends his free time editing cppreference.com


Thursday September 24, 2015 12:30pm - 1:30pm
McClintock (404) Meydenbauer Center

2:00pm

`for_each_argument` explained and expanded
During January 2015, Sean Parent posted a very interesting short piece of code on Twitter. The code iteratively iterates at compile-time over any number of function arguments, forwarding them one by one to a callable object.

How does this code work? What are the possible use cases? Can we make it even more generic and useful?

My talk answers all of the questions above, using independently compiled chronologically sequential code segments that show the audience the analysis and improvement process of `for_each_argument`.

Speakers
avatar for Vittorio Romeo

Vittorio Romeo

Software Engineer, Bloomberg LP
Vittorio Romeo is an Italian 21 year old Computer Science student at "Università degli Studi di Messina". He began programming at a very young age and is now a C++ enthusiast. While following the evolution of the C++ standard and embracing the newest features, he worked on several open-source projects, including modern general-purpose libraries and free cross-platform indie games. Vittorio is an active member of the C++ community: he... Read More →


Thursday September 24, 2015 2:00pm - 2:30pm
Franklin (407) Meydenbauer Center

2:00pm

std::allocator Is to Allocation what std::vector Is to Vexation
std::allocator has an inglorious past, murky present, and cheerless future. STL introduced allocators as a stop gap for the now antiquated segmented memory models of the 1990s. Their design was limited and in many ways wasn't even aiming at helping allocation that much. Because allocators were there, they simply continued being there, up to the point they became impossible to either uproot or make work, in spite of valiant effort spent by the community.

But this talk aims at spending less time on poking criticism at std::allocator and more on actually defining allocator APIs that work.

Scalable, high-performance memory allocation is a topic of increasing importance in today's demanding applications. For such, std::allocator simply doesn't work. This talk discusses the full design of a memory allocator created from first principles. It is generic, componentized, and composable for supporting application-specific allocation patterns.

Speakers
avatar for Andrei Alexandrescu

Andrei Alexandrescu

Founder, D Language Foundation
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 BSc in Electrical Engineering from... Read More →


Thursday September 24, 2015 2:00pm - 3:00pm
Hopper Theater Meydenbauer Center

2:00pm

Shared_Future from Scratch
The contents of header are probably still a bit mysterious to most people. Sure, we know that setting the value of a promise causes the corresponding future to resolve; but how does that happen behind the scenes in a way that allows us to move futures around? How are we going to implement the new features in the Concurrency TS, such as .then() and .when_all()? How (if at all) do futures interact with std::thread, std::async, and "executors"?

We'll present an extremely simplified implementation of futures and shared_futures, without the template metaprogramming that comes along with future and future and so on, but showing all the pointers and synchronization primitives.

Speakers
avatar for Arthur O'Dwyer

Arthur O'Dwyer

Software Engineer, Mixpanel
Arthur O'Dwyer worked for many years at Green Hills Software, making the world's most optimizing C and C++ compilers. Now he works at Mixpanel in San Francisco, where he organizes a monthly C++ meetup.


Thursday September 24, 2015 2:00pm - 3:00pm
Hamilton (403) Meydenbauer Center

2:00pm

The Importance of Being const
The Importance of Being const

Why do we use const? It helps the compiler enforce program invariants, find trivial bugs, and generally makes code better. But with C++11 has an extended meaning, specifically in regards to multi-threaded code.

This talk will be an intro to the const keyword and what it means to declare objects, pointers and member functions as const. We will also explore some subtle issues encountered with const, mutable, and multithreaded code.

Speakers
avatar for Richard Powell

Richard Powell

Audio Software Engineer, Apple, Inc
I started using C++ 10 years ago to write a psychoacoustic audio encoder/decoder and have continued to explore how to make software that unlocks the potential of hardware to bring amazing applications to life. I graduated from UC Berkeley with a BS in Electrical Engineering and Computer Science, and worked throughout the Bay Area for the past 15 years. I enjoy teaching and learning about C++ and programming.


Thursday September 24, 2015 2:00pm - 3:00pm
McClintock (404) Meydenbauer Center

2:00pm

Racing the file system
Almost every programmer knows about and fears race conditions on memory where one strand of execution may concurrently update data in use by another strand of execution, leading to an inconsistent and usually dangerous inconsistent read of program state. Almost every programmer therefore is aware of mutexes, memory ordering, semaphores and the other techniques used to serialise access to memory.

Interestingly, most programmers are but vaguely aware of potential race conditions on the filing system, and as a result write code which assumes that the filing system does not suddenly change out from underneath you when you are working on it. This assumption of a static filing system introduces many potential security bugs never mind ways of crashing your program, and of course creating data loss and corruption.

This workshop will cover some of the ways in which filing system races can confound, and what portable idioms and patterns you should employ to prevent misoperation, even across networked Samba shares. Finally, an introduction of the proposed Boost library AFIO will be made which can help application developers writing filing system race free code portably.

Speakers
avatar for Niall Douglas

Niall Douglas

Consultant, ned Productions Ltd
Niall Douglas is a lead author of WiP Boost.AFIO v2, Boost.Outcome, Boost.KernelTest and Boost-lite. He has been the lead Google Summer of Code administrator for Boost since 2014. He is an Affiliate Researcher with the Waterloo Research Institute for Complexity and Innovation at the University of Waterloo, Canada, and holds postgraduate qualifications in Business Information Systems and Educational and Social Research as well as a second... Read More →


Thursday September 24, 2015 2:00pm - 3:00pm
Six (406) Meydenbauer Center

2:30pm

Null pointers shouldn't compile: how Dropbox uses the type system to enforce contracts
Tony Hoare called null pointers a “billion-dollar mistake”, but nearly every language in wide use today has them. There have been many efforts to reduce the risk of nulls creeping in where they shouldn't be, but most involve attributes or annotations rather than being part of the type system itself. Can we do better? C++'s customizable value types make it possible to solve this sort of problem.

In this talk, I’ll present a non-nullable pointer wrapper, `nn`, that’s found wide use in Dropbox’s C++ code. This helper lets us use the type system to track pointers that can't be null, and express and enforce contracts at compile time. I’ll go into some depth on the template trickery needed to make things “just work”, the toolchain bugs we found along the way, and how this tool has helped us improve our code.

Speakers
avatar for Jacob Potter

Jacob Potter

Software Engineer, Dropbox
Jacob Potter is a recovering embedded systems engineer who is now driving Dropbox’s use of modern C++ for cross-platform mobile development. He's also the primary maintainer of Djinni, the tool Dropbox uses for generating cross-language bindings.


Thursday September 24, 2015 2:30pm - 3:00pm
Franklin (407) Meydenbauer Center

3:15pm

Compile-time tools supporting generic programming in C++
Generic programming is a programming paradigm which makes it possible to build highly extensible and efficient libraries. In C++ it can be implemented using templates, therefore developers and users of generic libraries need to understand how the compiler works with templates. The details are important when the code using a library instantiates different templates (or specialisations), or the same templates but with different arguments as expected. Fixing such bugs can lead to difficult debugging sessions. These are not bugs in the program's runtime behaviour. These are bugs in the program's compile-time behaviour and therefore different tools are needed to find them. Tools providing insight into what happens during the compilation process are needed.

Template metaprogrammers have been pushing the limits of what is possible using templates. The way they use templates is usually more complex than what generic libraries need. Recently a number of advanced tools supporting template metaprogrammers have been built. REPL shells, debuggers, profilers are available to make it possible to see what happens during compilation.

This talk presents how these tools can be used and be useful for the developers and users of generic libraries. Insight into what happens inside the compiler can be extremely useful to understand why the code compiles slowly, behaves the way it does or to debug errors in code using generic libraries.

Speakers
avatar for Ábel Sinkovics

Ábel Sinkovics

Morgan Stanley
Ábel Sinkovics is a software developer and has defended his PhD in January at Eötvös Loránd University, Budapest, Hungary. His research is about C++ template metaprogramming, functional programming and domain-specific languages. He has been building libraries supporting domain-specific language embedding based on template metaprogramming and libraries supporting template metaprogrammers. He has also been working on tools... Read More →


Thursday September 24, 2015 3:15pm - 4:15pm
Franklin (407) Meydenbauer Center

3:15pm

Demystifying Floating Point Numbers
Every day we develop software that relies on math while we often overlook the importance of understanding the implications of using our IEEE floats. From the often cited “floating point error” to unstable algorithms, this talk will explain the importance of floats, understanding their storage, the impact of the IEEE floats on math, and designing algorithms better. Finally, the talk will conclude with a quick case study of storing time for games and simulations.

Speakers
avatar for John Farrier

John Farrier

Sr. Lead Technologist, Booz Allen Hamilton
John Farrier is a software engineer, researcher, and musician. He designs software architectures for military modeling and simulation activities. His projects support efforts across the U.S. Department of Defense ranging from lab-based experimental software to fielded software on live fire test ranges.


Thursday September 24, 2015 3:15pm - 4:15pm
McClintock (404) Meydenbauer Center

3:15pm

Programming with less effort in C++
The C++ language and libraries propose different ways to implement codes. For example, using explicit loops or STL algorithms to traverse containers and process data. C++11&14 bring also new features to the C++ language aimed at simplifying the writing of codes. But what is the gain we can expect in term of development effort when using these different possibilities and features ? or, as a developer may ask himself: Is it viable for me to spend some time learning new C++ libraries or standards to provide less effort/spend less time on my future codes ?

Before answering these questions, we must give a definition of the development effort, and define a way to measure it. Thus, we first propose to describe existing software metrics, from the simple Single Line Of Code (SLOC) to the more complex Halstead metrics, then to implement them in an automatic tool based on Clang tools, and finally to apply them on several codes to compare their respective development efforts.

First results show that using modern C++ features like auto, decltype and lambdas help to dramatically reduce the development effort. These results may help to convince developers to use new C++ features, or to port their codes from old standards to new ones, or even switch from other languages to C++ !


Thursday September 24, 2015 3:15pm - 4:15pm
Hamilton (403) Meydenbauer Center

3:15pm

Value Semantics: It ain't about the syntax!, Part I
When people talk about a type as having *value* *semantics*, they are often thinking about its ability to be passed to (or returned from) a function by value. In order to do that, the C++ language requires that the type implement a copy constructor, and so people routinely implement copy constructors on their classes, which begs the question, "Should an object of that type be copyable at all?" If so, what should be true about the copy? Should it have the same state as the original object? Same behavior? What does copying an object mean?! By *value* *type*, most people assume that the type is specifically intended to represent a member of some set (of values). A *value-semantic* *type*, however, is one that strives to approximate an abstract *mathematical* type (e.g., integer, character set, complex-number sequence), which comprises operations as well as values. When we copy an object of a value-semantic type, the new object might not have the same state, or even the same behavior as the original object; for proper value-semantic types, however, the new object will have the same *value*. In this talk, we begin by gaining an intuitive feel for what we mean by *value* by identifying *salient* *attributes*, i.e., those that contribute to value, and by contrasting types whose objects naturally represent values with those that don't. After quickly reviewing the syntactic properties common to typical value types, we dive into the much deeper issues that *value* *semantics* entail. In particular, we explore the subtle *Essential* *Property* *of* *Value*, which applies to every *salient* mutating operation on a value-semantic object, and then profitably apply this property to realize a correct design for each of a variety of increasingly interesting (value-semantic) classes.

Speakers
avatar for John Lakos

John Lakos

Software Infrastructure Manager, Bloomberg LP
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... Read More →


Thursday September 24, 2015 3:15pm - 4:15pm
Hopper Theater Meydenbauer Center

3:15pm

Secure C++ Programming
Security vulnerabilities are fundamentally defects in our code. We know many of these defects stem from string processing, buffer overflows and integer underflow and overflows. These defects become security vulnerabilities when an attacker can crash an application, cause undefined behavior that leads to a Denial of Service, privilege escalation or hidden installation of rogue software.

So how do we build more secure C++ software? It starts by gaining an understanding of the basics of security vulnerabilities and how to identify them using the rich set of tools we now have available. With this foundation we can build a development culture where security considerations are pervasive and treated as important as program and algorithm correctness.

This session begins with a survey of common C/C++ string, integer and STL container issues and mitigations for these vulnerabilities. Follows with two detailed examples of vulnerabilities and how to fix their problems. Finishes with a survey of tools and references we have available today.

Speakers
avatar for Gwendolyn Hunt

Gwendolyn Hunt

Principal Software Engineer, Tripwire, Inc.


Thursday September 24, 2015 3:15pm - 4:15pm
Six (406) Meydenbauer Center

4:45pm

Comparison is not simple, but it can be simpler
The standard's algorithms typically require a 'strict weak ordering'. I will explain what this really means and show that even simple uses of sort can have latent failures. Programmers can avoid the problems today with a bit of work. Changes to the standard will reduce errors and programming effort.

Speakers
avatar for Lawrence Crowl

Lawrence Crowl

Dr. Lawrence Crowl has expertise in programming languages, compilers, and parallel programming. He has been mixing threads with C++ for twenty-five years and is a major contributor to C++11. His goal is to achieve both high quality and high performance programs.


Thursday September 24, 2015 4:45pm - 5:45pm
Franklin (407) Meydenbauer Center

4:45pm

Pruning Error Messages From Your C++ Template Code
Many template libraries are regarded with ambivalent feelings by developers: On the one hand, such libraries can offer wonderful functionality. On the other hand, they are dreaded for the sheer amount of error messages spilled out by the compiler when there is even a small bug in the developer's code. This talk will demonstrate several techniques to drastically reduce the amount of compiler output in case of errors (with real-life examples, of course).

Speakers
avatar for Roland Bock

Roland Bock

Principal Software Engineer, PPRO Financial Ltd
From my days at the university, I hold a PHD in physics (although that was in the previous century and seems like a different life by now). Ever since then I have been developing software and/or managing engineering teams. In 2008, I started to learn C++ because I could not believe that it was as difficult as some people claimed. Turns out they were totally wrong and totally right at the same time. | | Today, I am still learning and I hope... Read More →


Thursday September 24, 2015 4:45pm - 5:45pm
Six (406) Meydenbauer Center

4:45pm

string_view - when to use it, and when not.
The library fundamentals TS contains a new class "string_view", which appears to be unlike anything else in the standard library. In this talk, we will explore the uses of string_view, when it is appropriate to use it, and when it is not. Along the way, I will discuss other possible "_view" classes, with an eye to the upcoming "ranges" proposal before the standards committee.


Speakers
avatar for Marshall Clow

Marshall Clow

Principal Engineer, Qualcomm
Marshall is a long-time LLVM and Boost participant. He is a principal engineer at Qualcomm, Inc. in San Diego, and the code owner for libc++, the LLVM standard library implementation. He is the author of the Boost.Algorithm library and maintains several other Boost libraries.


Thursday September 24, 2015 4:45pm - 5:45pm
Hamilton (403) Meydenbauer Center

4:45pm

Testing Battle.net (before deploying to millions of players)
Battle.net is the online service that runs Blizzard's games. As such, it is a large scale distributed system with many interacting parts and dependencies on various services and data. While developing Battle.net servers, I needed a way to isolate and test functionality that I was working on.

In this talk I will cover my experience designing for testability of components in a distributed system, and practical ways to structure classes and data to facilitate testing. I will also present my solution to the problem of testing my code for correctness, performance and scalability without having to deploy a full-scale environment and spin up a million clients.

Speakers
avatar for Ben Deane

Ben Deane

Principal Software Engineer, Blizzard Entertainment
Ben has been writing games for almost 20 years, and in C++ for most of that. He is currently a Principal Engineer at Blizzard Entertainment where he works on the Battle.net team. He's always looking for useful new techniques in C++, and he likes functional programming.


Thursday September 24, 2015 4:45pm - 5:45pm
McClintock (404) Meydenbauer Center

4:45pm

Value Semantics: It ain't about the syntax!, Part II
When people talk about a type as having *value* *semantics*, they are often thinking about its ability to be passed to (or returned from) a function by value. In order to do that, the C++ language requires that the type implement a copy constructor, and so people routinely implement copy constructors on their classes, which begs the question, "Should an object of that type be copyable at all?" If so, what should be true about the copy? Should it have the same state as the original object? Same behavior? What does copying an object mean?! By *value* *type*, most people assume that the type is specifically intended to represent a member of some set (of values). A *value-semantic* *type*, however, is one that strives to approximate an abstract *mathematical* type (e.g., integer, character set, complex-number sequence), which comprises operations as well as values. When we copy an object of a value-semantic type, the new object might not have the same state, or even the same behavior as the original object; for proper value-semantic types, however, the new object will have the same *value*. In this talk, we begin by gaining an intuitive feel for what we mean by *value* by identifying *salient* *attributes*, i.e., those that contribute to value, and by contrasting types whose objects naturally represent values with those that don't. After quickly reviewing the syntactic properties common to typical value types, we dive into the much deeper issues that *value* *semantics* entail. In particular, we explore the subtle *Essential* *Property* *of* *Value*, which applies to every *salient* mutating operation on a value-semantic object, and then profitably apply this property to realize a correct design for each of a variety of increasingly interesting (value-semantic) classes.

Speakers
avatar for John Lakos

John Lakos

Software Infrastructure Manager, Bloomberg LP
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... Read More →


Thursday September 24, 2015 4:45pm - 5:45pm
Hopper Theater Meydenbauer Center

8:30pm

CppCon 2016 Kick-off Meeting
The planning committee for next year's conference starts now. Join us if you'd like provide suggestions or otherwise pitch in.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!

Thursday September 24, 2015 8:30pm - 10:00pm
Hamilton (403) Meydenbauer Center

8:30pm

Emacs Birds of a Feather
Come learn about Emacs!

We're holding an informal session to:
  • Show off + improve our C++ configurations
  • Identify which IDE feature we'll be stealing next ;)
  • Help any new users get started.
All levels of experience / interest are welcome!

Moderators
Thursday September 24, 2015 8:30pm - 10:00pm
Six (406) Meydenbauer Center
 
Friday, September 25
 

8:00am

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
KG

Kate Gregory

Partner, Gregory Consulting
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... Read More →

Friday September 25, 2015 8:00am - 8:45am
Hopper Theater Meydenbauer Center

9:00am

Case study: Evolving legacy code
We will be presenting on the evolution of a legacy monitoring subsystem modernized to C++11 with enhanced interfaces and better programming techniques. The presentation will cover some abstracted example problem areas, the solutions, and talk about the strategy employed to modernize the code.

Speakers
RC

Rachel Cheng

Software Engineer, F5 Networks
avatar for Michael VanLoon

Michael VanLoon

Principal Software Engineer, F5 Networks
I have been developing software for over 30 years. Yes, I started before I was born. I have been doing C++ for over 20 years, not very well at first, and slightly better now. | | I work at F5 Networks, and have worked at Disney, VMware, Yahoo!, and Microsoft, among many others. I have benefited from a wide range of experience and personalities. | | I have a personal grudge against code that does not strive to reach a high... Read More →


Friday September 25, 2015 9:00am - 10:00am
Six (406) Meydenbauer Center

9:00am

A C++14 approach to dates and times
A new date and date/time library designed for C++14 is presented. This library stresses ease of use, easy-to-read code, catching common errors at compile time, and uncompromising run-time performance.

The design starts with the C++11 std::chrono library, and extends it into the realm of calendars, giving a seamless experience built upon chrono::system_clock::time_point, the durations you already know such as chrono::hours and nanoseconds. Functionality that allows easy and efficient conversions between the std::chrono types and year/month/day - hh::mm::ss data structures is presented.

When dates (and times) are known at compile-time (e.g. leap second transitions), all computations are available at compile time (constexpr). When only parts of a date are known at compile time, run-time efficiencies are still gained by compile-time computing parts of the date.

The syntax of the library is built around a few easy-to-learn rules, and strictly checked at compile time. This makes it easy to learn, and very forgiving for the novice.

Speakers
avatar for Howard Hinnant

Howard Hinnant

Senior Software Engineer, Ripple
Lead author of several C++11 features including: move semantics, unique_ptr and . | | Lead author on three open source projects: A std::lib implementation: http://libcxx.llvm.org | An Itanium ABI implementation: http://libcxxabi.llvm.org | A date/time/timezone library: https://github.com/HowardHinnant/date



Friday September 25, 2015 9:00am - 10:00am
Hopper Theater Meydenbauer Center

9:00am

C++ Metaprogramming: Journey from simple to insanity and back
Part I: Introduction to template metaprogramming. Template metaprogramming is a variant of generic programming, a technique that uses C++ template mechanism to perform computations at compilation time, usually to generate, from a single description, executable code that depends on the properties of the data types. It can be viewed as “programming with types”. In this example-driven class we start with the overview of the metaprogramming tools (everything you wanted to know about template specializations but were afraid to ask). We will apply these tools to simple examples, such as: how to sort a sequence in order of increasing values, unless it’s a sequence of pointers, in which case we want the values of what they point to. Part II: Advanced techniques and practical applications. Simple examples of metaprogramming are fun and useful, but once you master them you start chafing at the limitations. This is C++, where we don’t suffer limitations gladly. We therefore move on to the more advanced techniques, including SFINAE, and the appropriately more advanced examples. The journey takes us back to the beginning: after all, when sorting a sequence of values vs a sequence of pointers, you don’t really care whether the pointer is smart or dumb. What you really want to know is whether “*p” compiles or not. What you really need is an “if_compiles” metaprogramming function.

Speakers
avatar for Fedor Pikus

Fedor Pikus

Chief Engineering Scientist, Mentor Graphics
Fedor G Pikus is a Chief Engineering Scientist in the Design to Silicon division of Mentor Graphics Corp. His earlier positions included a Senior Software Engineer at Google and a Chief Software Architect for Calibre PERC, LVS, DFM at Mentor Graphics. He joined Mentor Graphics in 1998 when he made a switch from academic research in computational physics to software industry. His responsibilities as a Chief Scientist include planning long-term... Read More →


Friday September 25, 2015 9:00am - 10:00am
Hamilton (403) Meydenbauer Center

9:00am

Stop Teaching C
To this day most people who set out to help others learn C++ start with "introduction to C" material. I think this actively contributes to bad C++ code in the world. For the past few years I've been teaching C++ (and making suggestions to folks who intend to teach themselves) in an entirely different way. No char* strings, no strlen, strcmp, strcpy, no printf, and no [] arrays. Pointers introduced very late. References before pointers, and polymorphism with references rather than with pointers. Smart pointers as the default pointer with raw pointers (whether from new or &) reserved for times they're needed. Drawing on the Standard Library sooner rather than later, and writing modern C++ from lesson 1.

In this session I want to talk about the specific advantages of teaching C++ this way – a way that’s very different from the way you almost certainly learned the language. You’ll be pleasantly surprised to see what you get to leave for later or never cover at all, what bad habits you don't later need to correct, what complicated concepts actually become accessible to beginners, and how you spend a lot less time dictating magic spells you can't explain yet, and more showing someone a comprehensive, sensible, and understandable language.

You don't have to be a trainer to come to this session. If you ever mentor other developers and show them your C++ code, if you ever help somebody choose a book or a course or other material to learn from, or even if you occasionally feel bad that you work in a language that's hard to learn, come and see how one philosophical shift can turn that very same language into one that's actually pretty easy to learn!

Speakers
KG

Kate Gregory

Partner, Gregory Consulting
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... Read More →


Friday September 25, 2015 9:00am - 10:00am
Franklin (407) Meydenbauer Center

9:00am

The Birth of SG14: better C++ support for Games Developers with Low latency needs
C++ is paramount for games development, and low-latency real-time applications everywhere. But has it recall improved since C++98/03? What features in C++ 11/14 has helped, and what else do we still need from C++ 17/22? In last year's CPPCon, there was clearly demand for even better support for this community as evidenced by the large number of games submission and an impromptu BoF.

But this industry has a demanding schedule and cannot freely attend ISO C++ standard meetings. So when the prophet cannot go to the mountain, the mountain has decided to come to the prophet!

This year, we like to announce the formation of an official SG14 that will go where the community is, at CppCon 2015 will be an official SG14 meeting followed by an SG14 meeting at GDC 2015 hosted by Sony.

This talk will describe the initial findings of the unofficial real time google group https://groups.google.com/forum/#!forum/unofficial-real-time-cxx as described in: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4526.pdf where we considered improvements such as flat map, intrusive container, and other suggestions for better support for games development and low latency in ISO C++.

Speakers
avatar for Nicolas Guillemot

Nicolas Guillemot

Graphics Software Engineer, Intel
I do C++, game programming, and graphics programming. Currently doing gaming graphics stuff at Intel. Was previously at Electronic Arts, and am studying at the University of Victoria.
avatar for Sean Middleditch

Sean Middleditch

Lead Software Engineer, Wargaming Seattle
I make games.
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


Friday September 25, 2015 9:00am - 10:00am
McClintock (404) Meydenbauer Center

10:30am

Ranges and the Future of the STL
Range-based interfaces are functional and composable, and lead to code that is correct by construction. With concepts and ranges coming to the STL, big changes are in store for the Standard Library and for the style of idiomatic C++. The effort to redefine the Standard Library is picking up pace. Come hear about one potential future of the STL from one of the key people driving the change.

Friday September 25, 2015 10:30am - 12:00pm
Montessori Hall Meydenbauer Center

12:30pm

CppCon 2016 Planning Committee Work Session
This session is a follow-on to the kick-off meeting and is a chance for the planning committee to set up goals and milestones.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!

Friday September 25, 2015 12:30pm - 1:30pm
Room 303 Meydenbauer

12:30pm

CopperSpice: A Pure C++ GUI Library
CopperSpice is a collection of cross platform GUI libraries derived from Qt 4.8. Our libraries use current C++11 technology to implement Reflection, without requiring moc (a code generator) or any preprocessing. We will discuss what Reflection is, how this technology can be used, and why it can be difficult to implement.

The focus of this presentation is to show the core implementation of CopperSpice. Source code from CopperSpice will be shown to explain how we implemented Reflection using pure C++11. We will also demonstrate small samples of code which use the CopperSpice libraries.

Technologies covered in this presentation will include templates, variadic templates, and template specialization.

No prior knowledge of CopperSpice or Qt is required. A working knowledge of templates in C++11 would be helpful.

Speakers
avatar for Barbara Geller

Barbara Geller

Co-Founder, CopperSpice
I am an independent consultant with over twenty-five years of experience as a programmer and software developer. I have worked with numerous smaller companies developing in-house applications. I have also designed and developed Windows applications for several vertical markets including medical billing, transportation, and construction. | | My degree is in Electrical Engineering from Cal Poly Pomona with additional studies in Computer... Read More →
avatar for Ansel Sermersheim

Ansel Sermersheim

Co-Founder, CopperSpice
I have been working as a programmer for over fifteen years. My degree is in Computer Science from Cal Poly San Luis Obispo. | | Currently I work as a software engineer designing scalable, high performance, multi-threaded network daemons in C++. The daemons I have developed are used at a Tier 1 carrier serving static and live content to customers around the world. I am a Co-founder of CopperSpice, a C++ library derived from the existing Qt... Read More →


Friday September 25, 2015 12:30pm - 1:30pm
Six (406) Meydenbauer Center

12:30pm

Networking & Number Crunching with C++: from Incremental Statistical Computation to Online Machine Learning
Our task is simple: Get some numbers, crunch them, get some more -- lather, rinse, repeat.

Caveats:
  • the numbers arrive over the network,
  • our number crunching may take time,
  • combining numbers coming from multiple network feeds can be useful.

In this session we will examine multiple design points through several exploratory examples.

The questions we'd like to answer:
  • networking & online numerics -- what are the choices and libraries?
  • how do we test correctness?
  • how do we measure performance -- and keep track of how much computation we can perform as the data arrives?
  • task distribution & collection design -- how can the task-based concurrency help?
  • how does the choice of a network library (and the implied level of abstraction) influence the available concurrency design options?
  • can the improvements to std::future coming in Concurrency TS (composition, continuation) help -- and if so, how?


Speakers
avatar for Matt P. Dziubinski

Matt P. Dziubinski

Research & Development, Aalborg University
Matt P. Dziubinski is affiliated with the Department of Mathematical Sciences, Aalborg University, Denmark and a Junior Fellow at Center for Research in Econometric Analysis of Time Series (CREATES). His fascination with computers started in the late 1980s with an 8-bit Atari. His current research interests include Quantitative Finance and High Performance Scientific Computing, with a focus on applied cross-platform parallel computing... Read More →



Friday September 25, 2015 12:30pm - 1:30pm
Hopper Theater Meydenbauer Center

2:00pm

Technical Specifications and C++17
The panel will discuss each of the Technical Specifications that the committee has either released or will release soon. We'll cover the File System, Library Fundamentals, Parallelism, Concepts, Transactional Memory, Concurrency, and Networking Technical Specifications. We'll discuss and take questions on the nature of each TS as well as its status in the committee, in implementations, and as a candidate for inclusion in C++17.

Moderators
avatar for Chandler Carruth

Chandler Carruth

C++ Lead, Google
Chandler Carruth leads the Clang team at Google, building better diagnostics, tools, and more. Previously, he worked on several pieces of Google’s distributed build system. He makes guest appearances helping to maintain a few core C++ libraries across Google’s codebase, and is active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all... Read More →

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com
avatar for Marshall Clow

Marshall Clow

Principal Engineer, Qualcomm
Marshall is a long-time LLVM and Boost participant. He is a principal engineer at Qualcomm, Inc. in San Diego, and the code owner for libc++, the LLVM standard library implementation. He is the author of the Boost.Algorithm library and maintains several other Boost libraries.
avatar for Beman Dawes

Beman Dawes

Beman Dawes is a software developer from Virginia in the United States and the founder of boost.org. He is the author of the StreetQuick geographic atlas library used by digital map publishers to help people get really, really, lost. He wrote his first computer program 40 years ago, and does not mourn the passing of bi-quinary arithmetic. Beman has been a voting member of the ANSI/ISO C++ Standards Committee since 1992, and chaired the Library... Read More →
avatar for Gor Nishanov

Gor Nishanov

Principal Software Engineer, Microsoft
Gor Nishanov is a Principal Software Design Engineer on the Microsoft C++ team. He works on design and standardization of C++ Coroutines, and on asynchronous programming models. Prior to joining C++ team, Gor was working on distributed systems in Windows Clustering team.
avatar for Gabriel Dos Reis

Gabriel Dos Reis

Gabriel Dos Reis is a Principal Software Development Engineer at Microsoft. He is also a researcher and a longtime member of the C++ community.  His research interests include programming tools for dependable software. Prior to joining Microsoft, he was Assistant Professor at Texas A&M University.  Dr. Dos Reis was a recipient of the 2012 National Science Foundation CAREER award for his research in compilers for dependable... Read More →
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


Friday September 25, 2015 2:00pm - 3:30pm
Montessori Hall Meydenbauer Center