Loading…
C++Now 2014 has ended
Please visit the C++Now website.

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

presentation [clear filter]
Tuesday, May 13
 

11:00am MDT

C++14: Through the Looking Glass
“The time has come,” the ISO said, “to talk of many things: of move-capture and literals; of making lambdas sing; why deduction is so hot; and what if digits should grow wings?”

Have you heard of the next C++ Standard? No, it is not C++11. Even though C++11 has just been ratified, C++14 will likely replace C++11 by next year. By now, we have enough experience with C++11 to know where we are missing various fingers and toes such as:


  • Why do we not have move capture in lambdas? 

  • How about some real user-defined literal suffixes? 

  • Why did we stop with monomorphic lambdas? 

  • If lambda returns can be deduced, why not normal functions? 

  • Could we get digit separators?


C++14 will be more than a bug fix release, and will contain some important enhancements on top of C++11. It will remove some of the major annoyances from C++11 that we already know of. But more importantly, how will this change the language, library and some important idioms?

Speakers
MW

Michael Wong

OpenMP CEO/Architect, IBM/OpenMP
You can talk to me about anything including C++ (even C and that language that shall remain nameless but starts with F), Transactional Memory, Parallel Programming, OpenMP, astrophysics (where my degree came from), tennis (still trying to see if I can play for a living), travel, and... Read More →


Tuesday May 13, 2014 11:00am - 12:30pm MDT
Bethe

11:00am MDT

Coroutines, Fibers, and Threads, Oh My
Last century, it was big news when an operating system could run multiple concurrent processes on a machine. That's necessary but not sufficient. The C++11 standard officially recognizes what the industry has known for decades: that a production process cannot usually block for I/O or other time-consuming work. The standard gives us a second level of concurrency: multiple threads within a process, with library facilities to manage, synchronize and pass data between them. 

The new Boost.Fiber library gives us yet finer-grained concurrency: multiple fibers within each thread, with facilities to manage, synchronize and pass data between them. When would you choose that functionality instead of threads? What are coroutines, and how do they fit into all this? 

We will also touch on some of the concurrency proposals being considered for the next couple of releases of the C++ standard. 

Speakers
NG

Nat Goodspeed

Linden Lab
Nat Goodspeed first read about C++ shortly after implementing a medium-sized language interpreter in classic C. Almost every C++ feature led to forehead smacking accompanied by muttered remarks about how the language could have solved THIS problem... He has been fascinated (sometimes... Read More →


Tuesday May 13, 2014 11:00am - 12:30pm MDT
Flug

2:30pm MDT

ConceptClang: Theoretical Advances with Full C++ Concepts
Concepts are an essential feature of generic programming and have been anticipated as a language extension to C++ for over a decade. Different designs have been proposed, but a consensus has not emerged for standardization. In 2010, we introduced ConceptClang as a general framework for implementing different C++ concepts designs in Clang, with the primary purpose of aiding in understanding the design space for concepts, as well as to understand general concepts issues which are independent of particular language designs for them. One such general issue emerged in the area of name binding, i.e., the process of matching the use of a name to the declaration to which it refers. It appears that full support for any concepts design will benefit from a new scoping rule for name binding, which we call weak hiding. Weak hiding allows the transition from unconstrained templates to constrained templates to preserve seemingly valid programs — something that has not been previously well addressed. To implement weak hiding, we have introduced two-stage name binding (Bindx2), which defines how existing name binding can be extended with weak hiding. Generalizing Bindx2 from simple function calls to other kinds of name uses such as associated members (including special members), operators, and types requires a first-class implementation of archetypes — a surprising consequence of which is that open/extensible classes/structures are essentially provided for free with full C++ concepts.

This talk will focus primarily on illustrating how one can use ConceptClang in practice, highlighting and motivating key components of its implementation structure, such as Bindx2 and our “structure opening” archetypes. The audience can expect to learn how our implementation of concepts not only helps with designing concepts for C++, but also affects other programming languages, thereby increasing the need for full concepts support in C++.

Speakers
avatar for Larisse Voufo

Larisse Voufo

Larisse Voufo is a research assistant in the Center for Research in Extreme Scale Technologies (CREST) at Indiana University, led by Dr. Andrew Lumsdaine. She is completing a PhD degree in Computer Science, with concentration in programming languages theory. Larisse has a vast pool... Read More →


Tuesday May 13, 2014 2:30pm - 4:00pm MDT
Flug

2:30pm MDT

Generic Programming of Generic Spaces: Compile-Time Geometric Algebra with C++11
This hands-on graphics session will explore compile-time synthesis of n-dimensional geometries and spaces using a lightweight C++11 library called Versor, a case study in the strength of template meta-programming for generating combinatoric complexity.  Templates for constructing geometries (affine, projective, conformal, or experimental) are delineated at compile time through nimble use of variadic template programming and constant expressions.  In particular, we propose novel techniques for listing, sorting, and evaluating geometric algebras during compilation as part of a unique optimization strategy and a potentially new Boost library for n-dimensional computing.  

Discussion will be encouraged to help develop these techniques as we explore basic C++11 features to illustrate the logic of geometric algebra.   Both interactive and visual, we will examine the marriage of generic programming techniques with generic spatial computing, allowing for a dimensional fluidity of expression.  From 2D through to 4D and above, efficient implementations of concepts from group theory, vector, matrix, tensor and lie algebras can be tied to specific idioms of C++11. These function spaces have a wide range of applications in a diverse set of fields, from material science to quantum computation.  An example of videos created with this approach can be seen at vimeo.com/wolftype.  More information about Versor is available at versor.mat.ucsb.edu.

Speakers
avatar for Pablo Colapinto

Pablo Colapinto

UCSB, AlloSphere Research Group
Pablo Colapinto is a video artist and computer scientist specializing in geometric algebra.  He is pursuing a PhD from the Media Art and Technology Program at UC Santa Barbara, having received a bachelor's degree in Visual and Environmental Studies from Harvard University in 2000... Read More →


Tuesday May 13, 2014 2:30pm - 4:00pm MDT
Hudson

4:30pm MDT

Removing undefined behavior from integer operations: the bounded::integer library
Integer arithmetic in C-derived languages is notoriously dangerous. Signed overflow is undefined behavior; unsigned overflow silently wraps around; comparing a signed and unsigned integer implicitly promotes to unsigned, causing a signed -1 to be greater than an unsigned 12; even the guaranteed size of "int" is less than most people expect and require. Most attempts to remedy the situation add in run-time overhead to all integer operations, making them non-starters for many projects.

This talk presents the bounded::integer library (https://bitbucket.org/davidstone/bounded_integer). bounded::integer is a C++14 library that has the following goals:

1. Never perform a run-time check when a compile-time check would work instead.
2. Never allow a conversion that is definitely wrong.
3. Allow conversions that might be wrong (such as assigning a value between 1 and 10 to a value between 5 and 20), but
only when explicitly requested.
4. Allow implicit conversions to larger types.
5. Have no space or time overhead, assuming basic compiler optimizations like inlining, so that bounded::integer can be used on very large data sets or systems with hard real-time requirements.

bounded::integer provides these guarantees by requiring static bounds on the integer types. A typical declaration might look something like `bounded::integer<1, 10> x(5)` to create a type that is always between 1 and 10. Arithmetic expressions automatically adjust the bounds to keep the result in range. In other words, the result of `x + x` is given the type `bounded::integer<2, 20>`. Thanks to type deduction with auto and templates, the user can specify only the types that they care about and be guaranteed (at compile time) that all intermediate calculations will be correct. Even better, because the compiler knows exact bounds of all integers, the library allows space and time optimizations that actually allow code to run faster than the default "use int everywhere to avoid surprises" strategy.

 This talk will include proposed idioms for using the library; prior work, such as boost::constrained_value, integer types in Ada, and the As-if Infinitely Ranged integer model; and limitations / design trade offs of the library.

Speakers
avatar for David Stone

David Stone

Vice President, Markit
David Stone has spoken at C++Now and Meeting C++. He is the author of the bounded::integer library: http://doublewise.net/c++/bounded/ and has a special interest in compile-time code generation and error checking, as well as machine learning. He works at Markit integrating real-time... Read More →


Tuesday May 13, 2014 4:30pm - 5:30pm MDT
Hudson

4:30pm MDT

Value Semantics and Range Algorithms - Composability and Efficiency
I want to write one line of code to compute the top N elements in a sequence which satisfy a specific predicate. And I want to write the same line of code regardless of whether I can do this in-place or not:

  x = std::slice(std::sort(std::filter(y, predicate)), 0, 10);

In this talk I will present a design of range algorithms which give them value semantics and show how this provides significant expressive power over other designs through composition. Finally, I will provide a reasonably in-depth treatment of the efficiency concerns this design presents and how we can overcome them and more.

Speakers
avatar for Chandler Carruth

Chandler Carruth

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


Tuesday May 13, 2014 4:30pm - 6:00pm MDT
Flug

5:30pm MDT

Preparing the C++11 Library AFIO for Boost Peer Review
The Boost C++ libraries have a well deserved reputation for excellence, and the prospect of contributing to them can be a bit overwhelming. My talk will focus on demystifying the process of porting a preexisting library to Boost through illustrative examples of my experiences preparing AFIO, the first C++11-only Boost Library to enter peer review, during 2013's Google Summer of Code. Because AFIO’s pre-Boost codebase was entirely C++11, many of these examples should highlight issues facing developers wanting to backport modern C++, and also show one possible set of solutions to those issues. From internal compiler errors to tackling the Boost build system, the process will be revealed, and hopefully become less daunting as the problems I encountered and their solutions are presented.

Speakers
avatar for Paul Kirth

Paul Kirth

Paul Kirth is a Computer Science Masters candidate at California State University Northridge, with a B.S. in Civil Engineering from UCLA. After several years as a Civil Engineer, Paul decided to return to academia to pursue a Masters degree, and eventually a PhD, in Computer Science... Read More →


Tuesday May 13, 2014 5:30pm - 6:00pm MDT
Hudson
 
Wednesday, May 14
 

9:00am MDT

MPL11: A New Metaprogramming Library for C++11
This talk has two distinct but related goals. The first is to present a survey of C++11 template metaprogramming techniques, along with benchmarks and case studies, in an attempt to spot improvements over C++03. This will provide an objective basis upon which the future of the current Boost.MPL can be discussed. The second is to present a general purpose C++11 template metaprogramming library which I hope to propose for inclusion into Boost, perhaps as a successor to the current Boost.MPL (github.com/ldionne/mpl11). I will introduce the core concepts of the library, explain some design choices and perform an objective comparison with the current Boost.MPL.

The talk is intended for people with a good knowledge of TMP and functional programming. People making extensive use of TMP and those interested in FP should benefit most from the presentation.

Speakers
avatar for Louis Dionne

Louis Dionne

C++ Standard Library Engineer, Apple
Louis is a math and computer science enthusiast who got swallowed by the C++ monster when he was a naive, unsuspecting student. He now works for Apple, where he is responsible for libc++, the Standard Library shipped with LLVM/Clang. He is a member of the C++ Standards Committee and... Read More →


Wednesday May 14, 2014 9:00am - 10:30am MDT
Hudson

9:00am MDT

The Optimization of a Boost.Asio-Based Networking Server
Yandex is one of the biggest internet companies in Russia, providing network interactive services, such as web search, e-mail, maps, photo hosting, and so on. Our team develops the e-mail backend, which receives, processes, and sends more than 50 million messages per day for over 6 million active users.

In this talk, we examine a series of Boost-based solutions to tackle these tasks and their effect on performance. We start with a simple Asio + Spirit implementation, discuss its problems and limitations, and then propose workarounds and optimizations. In particular, we show how various reactor patterns affect performance and how the use of coroutines and our specially crafted smart streambufs can help save memory and CPU resources.

(We wish to acknowledge the efforts of Alexander Drachevskiy, who was instrumental in creating this presentation and the code on which it is based, and was to deliver the presentation, but was unable to attend the conference.)

Speakers
avatar for Nikita Chumakov

Nikita Chumakov

Yandex LLC
Nikita Chumakov was born in Moscow, Russia, where he attended the State University Department of Computational Mathematics and Cybernetics. He began programming with Pascal in the mid-80s, but quickly switched to C and Unix system programming. Nikita is a C++ programmer who has... Read More →
avatar for Sergei Khandrikov

Sergei Khandrikov

Lead Developer, Yandex.SDG
Sergei Khandrikov has over 10 years of experience in software engineering and C++ development. He has been a backend C++ developer on the Web Mail Interface team at Yandex, LLC, since 2011. Sergei graduated from Bauman Moscow State Technical University as a specialist in robotics... Read More →


Wednesday May 14, 2014 9:00am - 10:30am MDT
Bethe

11:00am MDT

Mach7: The Design and Evolution of a Pattern Matching Library for C++
Pattern matching is an abstraction mechanism that can greatly simplify source code. In particular, it provides an easier to use and faster alternative to the visitor design pattern, as well as simplifies other forms of case analysis on types. We present functional-style pattern matching for C++ implemented as a library called Mach7. The solution is non-intrusive and is open to both the introduction of new patterns and the extensibility of classes. This presentation will concentrate on some design choices, implementation details, initial user feedback, and other factors that shaped the library. The presentation is intended for a broad audience of developers interested in pattern matching and how it can be brought into an object-oriented language like C++ without restricting the existing language facilities.

Speakers
avatar for Yuriy Solodkyy

Yuriy Solodkyy

Software Engineer, Microsoft
Yuriy Solodkyy received his PhD from Texas A&M University, while working under the supervision of Dr. Bjarne Stroustrup on the ways to simplify the analysis of C++ programs. He is currently trying to materialize some of those ideas while working in the Visual C++ team at Microsoft. His... Read More →


Wednesday May 14, 2014 11:00am - 12:30pm MDT
Flug

11:00am MDT

Practical Type Erasure: A boost::any Based Configuration Framework
Configuration frameworks have been around a long time, ranging from the classic .INI file to Boost Property Tree and many many others, but one of the problems in C++ implementations has been how to store and return different types while keeping a sane interface.

The configuration framework presented in this talk features a client-facing front end that can return any copyable C++ object based on a string key. The back end stores the data in memory, a file, a database, or any other storage mechanism, of which the client and front end are blissfully unaware. A glue layer connects the front and back ends and remains ignorant of the nature of the data being passed around. The magic is a combination of boost:any and objects and it's all done in C++03. This presentation will show the framework's objectives, design, and usage, emphasizing the practicalities of using type erasure and boost::any. If time permits, a simple back-end storage object will be developed and added to the framework.

The code for this framework was originally developed for a US Government project and is in the public domain courtesy of the US taxpayers.

Speakers
avatar for Cheinan Marks

Cheinan Marks

Senior Developer
Cheinan Marks is a senior software developer, living in Berlin, where he starting a non-profit to research bioinformatics and bio-computation, specializing in genetics. He got his start in the TUTOR language on the PLATO system at the University of Illinois. Having gotten his doctorate... Read More →


Wednesday May 14, 2014 11:00am - 12:30pm MDT
Bethe

2:30pm MDT

C++11 in Space Plasma Model Development
The benefits of the latest C++ standard, for the development of massively parallel computational (space plasma) models, will be discussed. Special attention will be given to variadic templates, which allow the development of readable and very extensible computational models without sacrificing serial or parallel performance. A basic understanding of variadic templates will be assumed, but no prior knowledge of space, plasma, or physics will be required.

Speakers
avatar for Ilja Honkonen

Ilja Honkonen

Ilja Honkonen recently received a Ph.D. in physics (space plasma model development) from the University of Helsinki. He is currently visiting Goddard Space Flight Center as part of the NASA postdoc program, where he is developing a new type of a computational space plasma model.


Wednesday May 14, 2014 2:30pm - 4:00pm MDT
Bethe

2:30pm MDT

C++11 Library Design
If you're writing reusable code and you're not taking full advantage of C++11's new features, stop what you're doing! The rules have changed, from the bottom -- like parameter-passing -- to the top -- like library versioning. Code written with C++11 can be more modular and composable than ever, with easier, more powerful, and safer-to-use interfaces and with less boilerplate. It's library design without the compromises.

In this talk, we'll cover functions, classes, and "modules", discussing best-practices for designing efficient, reusable, composable, and versionable components taking full advantage of C++11. It's a holistic look at all that the author has learned over the past few years about writing reusable code for today's modern compilers.

Speakers
avatar for Eric Niebler

Eric Niebler

Eric Niebler is a freelance software developer, consultant, trainer and author. His specialty is C++ library and application development, with special emphasis on modern C++ techniques, and extra special emphasis on generic programming, metaprogramming, and domain-specific languages... Read More →


Wednesday May 14, 2014 2:30pm - 4:00pm MDT
Flug

4:30pm MDT

Goals for Better Code: Implement Complete Types
The C++ Seasoning talk presented at GoingNative 2013 centered on 3 goals for better code. This talk provides foundational material on types, references, and basis operations. We'll look at how the definition of type, and physical nature of the machine, leads to the conclusion that all types are regular and why implementing complete types is a worthy goal.

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


Wednesday May 14, 2014 4:30pm - 6:00pm MDT
Flug

4:30pm MDT

Multiplatform C++
This talk will help to answer common questions related to writing and building cross-platform software.  How can software be built natively on Windows and Linux, given their radically different tool chains?  How can the various programming and deployment differences between Linux and FreeBSD be managed?  How can the cross-tool, cross-platform editing problems be solved?  How can the dramatic maintenance cost increase be prevented?  This talk also addresses the non-obvious, indirect benefits of supporting multi-platform development.

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


Wednesday May 14, 2014 4:30pm - 6:00pm MDT
Hudson

4:30pm MDT

Octopus: A Policy-Driven Framework for CFD Simulations
Octopus is an adaptive mesh refinement (AMR) library for scientific
applications, implemented on top of the HPX C++ runtime system. Octopus allows
domain scientists to solve computational fluid dynamics (CFD) problems on a
hierarchy of Cartesian meshes with different scales of spatial resolution
utilizing a technique known as adaptive mesh refinement (AMR). Astrophysicists
at Louisiana State University are using Octopus to simulate important
phenomena such as binary star mergers. 

Octopus is a policy-driven framework. Domain scientists select policies, either
at run-time or compile-time, which fulfill a specified interface in
the library, known as a customization point. These policies are used by the
underlying framework to implement application functionality. Many aspects of
Octopus are completely controlled by policies, such as the methods for
time discretization, interpolation and spatial decomposition.

This talk will discuss how the use of policies allows us to build efficient,
scalable and accessible libraries for scientific applications. We will show how
this powerful generic programming technique abstracts scientists away from
complex networking and synchronization code. 

The intended audience for this talk is developers interested in the field of
scientific computing, library design or generic programming. No particular
knowledge of any of the background mathematics or astrophysics will be expected
of the audience.

Speakers
avatar for Bryce Adelstein Lelbach

Bryce Adelstein Lelbach

CUDA C++ Core Libraries Lead, NVIDIA


Wednesday May 14, 2014 4:30pm - 6:00pm MDT
Bethe
 
Thursday, May 15
 

11:00am MDT

Interactive Metaprogramming Shell Based on Clang
Developing metaprograms is hard and painful. Templight (http://plc.inf.elte.hu/templight/) supports the development and debugging of template metaprograms, but the code has to be recompiled after every minor change and tricks are needed to retrieve useful information about the result.

A number of languages (Python, Haskell, Erlang, etc) provide an interactive shell for trying code out and displaying the results immediately. For example adding a new element to a list and displaying the result in a Python shell is an easy thing to do:

> l = [2, 3, 4]
> l.insert(0, 1)
> l
[1, 2, 3, 4]

The shell can display the result immediately. The developer does not need to compile his code and start up a debugger to see the result of an expression.

This talk presents Metashell, which is an interactive shell for template metaprogramming. It provides a testing and development environment for template metaprogramming which is as easy to use as a Python shell. For example one can do the following:

> #include <boost/mpl/vector.hpp>
> #include <boost/mpl/push_front.hpp>
> #include <metashell/formatter.hpp>
> using namespace boost::mpl;

> push_front<vector<int, char>, double>::type
boost_::mpl::vector<double, int, char>

The shell displays the result of a template metafunction.

Metashell is available here: https://github.com/sabel83/metashell. One can try it online in a browser as well: http://abel.web.elte.hu/shell. Metashell is based on the libClang library.

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


Thursday May 15, 2014 11:00am - 12:30pm MDT
Hudson

11:00am MDT

libcppa: Type-safe Messaging Systems in C++
The actor model offers a message-oriented programming paradigm that makes concurrent & distributed applications less error-prone, easier to write, understand, and debug than standard C++ facilities. In this talk, we will survey concepts and support offered by libcppa to build complex distributed applications in C++.

In the first half of this talk, Dominik Charousset will give an introduction to actor programming in C++ with a focus on new developments since C++Now in 2013. In particular, these new features include type-safe interfaces for actors that enable strongly typed messaging in distributed applications.

The second half of the talk, Matthias Vallentin will cover a case study about the scalability of VAST, a distributed database built with libcppa. This system uses actors not only to facilitate network transparency in cluster-based deployments, but also as a unit of fine-grained parallelism to speed up tasks on the critical path, such as data ingestion and query processing. Through analysis of profiler results, we showcase how to parallelize bottleneck components in parallel processing pipelines. Furthermore, we illustrate how libcppa's actor model helps to design a distributed indexing system.

 Vallentin's portion of this talk will not be recorded.

Speakers
avatar for Dominik Charousset

Dominik Charousset

Dominik Charousset studied computer science at the Hamburg University of Applied Sciences. After receiving his Master’s degree in 2012, he became a PhD student at the Internet Technologies Group (iNET). His research focuses on concurrent & distributed systems – in particular based on the actor model... Read More →
avatar for Matthias Vallentin

Matthias Vallentin

PhD student, UC Berkeley
Matthias Vallentin pursues a PhD in computer science at UC Berkeley. Before moving to California, he received his MSc and BSc from the Technical University in Munich. His research interests include high-performance intrusion detection, network monitoring, and large-scale computer... Read More →


Thursday May 15, 2014 11:00am - 12:30pm MDT
Bethe

2:30pm MDT

CppComponents: A Modern Portable C++11 Component System
One of the major things holding C++ back is the lack of a good component system. Other languages have the ability to easily incorporate prebuilt libraries into your project. With C++, you are often stuck rebuilding (or trying to rebuild) code, since C++ code built with a different compiler, with a different version of the same compiler, or as debug and release builds with the same compiler is ABI incompatible. With a good component system, it is easier to both package and consume libraries. This presentation introduces you to CppComponents, a component system for C++ that allows you to easily use binary components created with one compiler in a project compiled with another compiler and/or standard library. You can do this while still using your favorites from the Standard Library — such as string, vector, tuple, chrono, etc. — as function parameters and return values, as well as using exceptions. In addition, CppComponent provides cross ABI compatible function objects, futures, promises, executors, and channels. All of these are available in a header-only library that only depends on the C++11 standard library.

In this talk we will look at the techniques that underlie this library, provide examples of how to easily consume and create binary components that can be used from many compilers, and look at some example components that make multithreading and network programming much simpler. We will also look at some advanced uses of the library such as easy dependency injection and dynamic, name-based method calling. We will wrap up the talk looking at future directions, including how this library can enable a "C++ PyPI", and a C++ component renaissance that will make C++ easier to use in a wide variety of domains. The target audience for this talk is intermediate and advanced C++ programmers, though beginners will also find this talk to be helpful.

Speakers
avatar for John Bandela

John Bandela

Software Engineer, Google
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... Read More →


Thursday May 15, 2014 2:30pm - 4:00pm MDT
Flug

2:30pm MDT

UI. Aesthetics. C++
smile the senses
action/reaction, cause/effect
what are these symbols?

This is possibly a talk about UI. Probably about Aesthetics. Definitely about C++. Hopefully pertinent to both newer programmers and seasoned developers. A bit philosophical, but applicable to daily code.

Definitely not about lockfree programming, for a change. :-)

Speakers
avatar for Tony Van Eerd

Tony Van Eerd

Ninja/Jedi/Tony, Christie Digital
Tony has been coding for well over 25 years, and maybe coding well for some of that. Lots of pixel++, UX, threading, etc. Previously at Inscriber, Adobe, BlackBerry, he now enables Painting with Light at Christie. He is on the C++ Committee. He is a Ninja and a Jedi.Follow @tvaneerd... Read More →


Thursday May 15, 2014 2:30pm - 4:00pm MDT
Hudson

4:30pm MDT

Designing XML API for Modern C++
While there are many XML parsing/serialization libraries available for C++, most of them feel as if they were designed for some other language first and then retrofitted to C++ with minimal consideration for its idioms. Designing an XML API that satisfies everyone appears to be surprisingly hard. The fact that Boost, let alone standard C++, still doesn't have an XML library is a testament to that, despite numerous attempts from the Boost community. In fact, the discussion seldom gets past the streaming (SAX) vs. in-memory (DOM) debate.

In this talk I would like to take a different approach and first consider common XML usage patterns in typical C++ applications. Guided by this I will then present an XML API design and implementation, for both parsing and serialization. As the usage patterns range from low-level XML processing (document-centric applications) to simply viewing XML as a data storage medium (data-centric applications), so does the presented API start with low-level access and build higher-level abstractions on top of it.

For completeness, I will also briefly cover these topics: what it means to be a conforming XML 1.0 parser (hint: the one you wrote for fun over the weekend is most likely not), existing XML libraries/tools for C++ and their advantages/disadvantages, and other XML-related technologies such as XML Schema, XPath, XQuery, and how they fit into the overall picture. I will also be seeking the audience's feedback in how the presented XML API will or won't handle use-cases that they are facing.

Speakers
avatar for Boris Kolpackov

Boris Kolpackov

Chief Hacking Officer, Code Synthesis
Boris Kolpackov is a founder and CHO (Chief Hacking Officer) at Code Synthesis, a company focusing on the development of open-source tools and libraries for C++. For the past 10 years Boris has been working on solving interesting problems in the context of C++ using domain-specific... Read More →


Thursday May 15, 2014 4:30pm - 6:00pm MDT
Bethe

4:30pm MDT

Modern C++ as Concurrent Assembly
C++ — with the help of newly adopted, fast evolving, development cycles — has become the assembly language of the current generation. C++11, by itself, can provide the necessary building blocks to develop a brand new, domain independent language that supports native parallelism.

Doppl is a programming language which features cache efficiency, high concurrency, data oriented design, and non-blocking logic as language constructs. It is built on top of C++11 and its latest stable standard library implementations.

In this talk, we will focus on using tools from <thread> as well as new constructs inherited from functional programming, and introduced first in C++11, to achieve Doppl's features. Doppl code samples will only be shown as references for the audience to visualize these high level structures.

Speakers
avatar for Diego Perini

Diego Perini

Student, Istanbul Technical University
Diego Perini is a computer engineering student from Istanbul Technical University, Turkey. His main area of research is concurrency and general purpose programming language design. He maintains a programming language named Doppl since January 2013. Quote from his personal website... Read More →


Thursday May 15, 2014 4:30pm - 6:00pm MDT
Hudson

8:30pm MDT

Boost Library Incubator
Boost has been enormously successful, but is becoming a victim of it's own success. It’s getting bogged down:a
  • Libraries are in the review queue for ages.
  • It’s hard to find review managers.
  • Libraries don't get enough reviews.
  • Some libraries are left without a maintainer.
  • Library documentation is not nearly good enoug
  • Boost is getting larger and hard to manage and deploy.
  • Some libraries become obsolete and there is no way to deprecate them.

BUT, more than ever, C++ needs more and better libraries!!!

I've distilled my ideas for addressing these problems in a website: Boost Library Incubator (www.blincubator.com). I'll walk through the website showing how it addresses the above mentioned problems. I hope this will serve as a basis for ideas for the near term enhancement and evolution of Boost. I expect a lot of spirited audience participation here!

Speakers
avatar for Robert Ramey

Robert Ramey

Software Developer, RRSD
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... Read More →


Thursday May 15, 2014 8:30pm - 10:00pm MDT
Paepcke
 
Friday, May 16
 

9:00am MDT

Iterators May Stay
The search for a convenient interface between containers and algorithms hasn't stopped with the Standard Library's iterators. Boost.Range is just one of many examples of alternate interfaces. A multitude of different approaches has sprung up in recent years, and with the Ranges study group, the C++ Standardization Committee itself is participating.

This talk will compare and contrast a number of these approaches and show their strengths and weaknesses. Participants should have working knowledge of the standard algorithms and containers library, and understand the principles behind generic programming.

Speakers
avatar for Sebastian Redl

Sebastian Redl

Senior Programmer, Teoco
Sebastian holds a BSc in Software Engineering from the Technical University of Vienna and is currently finishing an MSc. He is working at a small software company called Symena (part of Teoco), and recently spent a year's sabbatical working at Google. He has contributed heavily to... Read More →


Friday May 16, 2014 9:00am - 10:30am MDT
Flug

9:00am MDT

Value Semantics: It ain't about the syntax!
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 Engineer, Bloomberg
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’s Evolution Working Group. Previously, Dr. Lakos... Read More →


Friday May 16, 2014 9:00am - 10:30am MDT
Bethe

11:00am MDT

How to Design C++ Implementations of Complex Combinatorial Algorithms
This presentation will focus on one specific way of designing optimization frameworks. We will face the problem of designing combinatorial algorithms to be general and easy to extend as well as providing a user friendly interface. We mainly will make use of templates, including the features introduced in C++11.

As an example problem we will consider the local search meta-heuristic. Local search is one of the most popular optimization methods. On the one hand, it is a natural way of tackling problems and on the other, it achieves very good results in practice. It is worth mentioning that local search is a generalization of many other well known optimization heuristics such as simulated annealing.

The presentation is for those interested in designing complex algorithms, in template metaprogramming, or in optimization. C++11 skills are essential to understand some parts of the presentation.

Speakers
avatar for Piotr Wygocki

Piotr Wygocki

Piotr Wygocki graduated from the University of Warsaw with a double master's degree in Computer Science and Mathematics. He has experience both in the theoretical and commercial aspects of computer science. He completed an internship at Centrum Wiskunde Informatica in Amsterdam, which... Read More →


Friday May 16, 2014 11:00am - 12:30pm MDT
Bethe

2:30pm MDT

0xBADC0DE
My motivation for this talk is my own expierence as a freelancer and trainer. I have seen a lot of good and bad code in different places. This talk tries not only to show examples of bad code, but also to analyze why it exists in the first place, and how to deal with it or fix it. I'll visit anti-patterns, but this talk is not about anti-patterns, as that would only spotlight one of the many problems.

Speakers
avatar for Jens Weller

Jens Weller

Meeting C++ / Community Organizer, Meetingcpp GmbH
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... Read More →


Friday May 16, 2014 2:30pm - 4:00pm MDT
Bethe

2:30pm MDT

Expected — An Exception-friendly Error Monad
The Expected library is based on the Expected class introduced by A. Alexandrescu in 2012. It is a new way to handle errors in C++, lying somewhere between the classic error-code returns and exceptions. Expected is fully compatible with exception-throwing code and helps to design exception-free interfaces. This open the door to novel techniques enforcing error handling safety while keeping code clean through the use of monads, which are borrowed from functional languages like Haskell. No prior knowledge of monads is needed, however.

The talk will start with a presentation of the existing techniques for handling errors. We will compare the return error code and the exception systems and then we will introduce expected in this context. The std::future and the std::experimental::optional classes are similar utility classes and we will speak about the conceptual differences among these classes.

The core of the Expected library will be presented next using an example to show the different features and semantics of the expected class. We will discuss how the expected class can be used to define exception-free interfaces using any user defined error type.

The monad error methods next and recover will be presented then through several examples. They enable programming techniques that help to distinguish the error-handling layer from the normal code flow. Moreover, they help the programmer to handle errors in a non-invasive way while being visible if forgotten. We will briefly talk about monads in functional languages and why expected can be seen as a monad.

The rest of the talk will discuss the possibility of using a similar interface for other potential monad classes such as std::experimental::optional and std::future.

As for Haskell monads, some syntactic sugar could make the code more readable. We will present how the use of a new expect expression, similar to the await expression presented in N3858 Resumable functions,  could make the code as readable as if the function could throw an exception.

Note: This library has not been proposed yet to the C++ standard, but should be by the time of the conference.

Speakers
avatar for Vicente J. Botet Escriba

Vicente J. Botet Escriba

Vicente J. Botet Escriba got a Masters in Computer Science from University Complutense of Madrid, Spain in 1986. He has over 25 years of experience in software engineering for fault tolerant systems, and over 15 years of C++ experience. His main research area is on concurrent systems... Read More →


Friday May 16, 2014 2:30pm - 4:00pm MDT
Hudson

4:30pm MDT

Functional Data Structures in C++
To write correct and efficient concurrent and parallel programs you need concurrent data structures. Simply slapping a mutex on top of a vector is rarely the right solution. Functional programmers have discovered a great trick – they use immutable data structures that are by definition thread safe. But how can you write programs if you can’t modify your data? And why can’t you just use a const vector?

It turns out that there is a whole science to designing efficient functional data structures. There is sharing and mutation behind the scenes and some tricky synchronization problems. There are tricks to defer copying of data using lazy evaluation that let you, for instance, reverse a singly linked list in constant time (well, sort of).

In my talk, I’ll introduce you to the implementation of efficient thread-safe data structures in C++ based on lessons from functional programming -- in particular from Chris Okasaki’s seminal book, Purely Functional Data Structures.

Speakers
avatar for Bartosz Milewski

Bartosz Milewski

Owner, Reliable Software
Bartosz Milewski always tries to be where the action is. He started as a quantum physicist when superstrings were hot, joined the software industry to build the search engine for Microsoft Windows right before Google started indexing the Internet, became an avid proponent of object-oriented... Read More →


Friday May 16, 2014 4:30pm - 6:00pm MDT
Flug
 
Saturday, May 17
 

9:00am MDT

The Future of Accelerator Programming in C++
OpenCL, CUDA, C++ AMP, OpenACC, RenderScript, Thrust, Bolst, Vexcl, Boost.Compute, ViennaCL, MTL4, NT2, Arrayfire — the list of tools, environments, frameworks and libraries for accelerator programming is long. This talk will give an overview of a number of these tools and map them to different cases of accelerator use. How do they compare in terms of developer productivity, generality, and performance?

With all these tools at our disposal, the problem of accelerator programming is far from solved. There must be a better way to describe data parallelism and concurrency in C++. Maybe the functional programming community can come to our rescue? Or, as Bret Victor put it so appropriately, we must simply "forget everything we think we know about computers. Forget that we think we know what a computer is" to find a good solution. Comments from the audience are welcome for this second part of the talk.

Speakers
avatar for Sebastian Schaetz

Sebastian Schaetz

Sebastian Schaetz is a software developer and C++ enthusiast from Germany. His work focuses on bridging the gap between science and high performance computing. He is particularly interested in enabling scientists to utilize accelerators and co-processors. He currently works for the... Read More →


Saturday May 17, 2014 9:00am - 9:45am MDT
Hudson

9:00am MDT

Functional Reactive Programming - Cleanly Abstracted Interactivity
In 1997 Conal Elliot and Paul Hudak published their discovery of a new mathematical model of interactivity dubbed functional reactive programming (FRP). Their time-function based model radically departs from the typical event and callback paradigms. The end result is a much more natural and concise means of writing interactive programs—time steps, frames, connections, and other such considerations are completely abstracted away.

In this talk we will introduce the FRP methodology and present 'sfrp': a novel, industrial strength, functional reactive programming framework that is readily usable in domains such as robotics, computer animation, and user interfaces. 'sfrp' will be compared with other C++ and Haskell FRP implementations and experience using 'sfrp' in commercial applications will be noted. It is our hope that after attending this talk, an attendee will know when to use the FRP paradigm and how to apply it to their application using 'sfrp'.

The target audience for this talk is C++ developers of all skill levels interested in making their interactive programs more powerful and concise. No prior experience in functional reactive programming or functional programming is required.

Speakers
avatar for David Sankel

David Sankel

Software Engineering TL, Bloomberg
David Sankel is a Software Engineering Manager/TL at Bloomberg and an active member of the C++ Standardization Committee. His experience spans microservice architectures, CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography... Read More →


Saturday May 17, 2014 9:00am - 10:30am MDT
Flug

9:45am MDT

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

C++ 98/03 already has a reputation for overwhelming complexity compared to other programming languages. The raft of new features in C++ 11/14 suggests that the complexity in the next generation of C++ code bases will overwhelm still further. The planned C++ 17 will probably worsen matters in ways difficult to imagine presently.

Countervailing against this rise in software complexity is the hard de-exponentialisation of computer hardware capacity growth expected no later than 2020, and which will have even harder to imagine consequences on all computer software. WG21 C++ 17 study groups SG2 (Modules), SG7 (Reflection), SG8 (Concepts), and to a lesser extent SG10 (Feature Test) and SG12 (Undefined Behaviour), are all fundamentally about significantly improving complexity management in C++ 17, yet WG21's significant work on improving C++ complexity management is rarely mentioned explicitly.

This presentation pitches a novel implementation solution for some of these complexity scaling problems, tying together SG2 and SG7 with parts of SG3 (Filesystem): a standardised, but very lightweight, transactional graph database based on Boost.ASIO, Boost.AFIO and Boost.Graph at the very core of the C++ runtime, making future C++ codebases considerably more tractable and affordable to all users of C++.

Position Paper (Right click and save as.) 

...

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


Saturday May 17, 2014 9:45am - 10:30am MDT
Hudson