Loading…
This event has ended. View the official site or create your own event → Check it out
This event has ended. Create your own
Please visit the C++Now website.
View analytic

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

Monday, May 12
 

4:00pm

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

Monday May 12, 2014 4:00pm - 6:00pm
Aspen Meadows Resort

6:30pm

Dinner Break
Suggested Venue: Mezzaluna (2 for 1), Little Ollie's

Monday May 12, 2014 6:30pm - 8:30pm
Flug

8:30pm

Social Event: Informal Gathering
Get acquainted with new friends and reacquainted with old friends. Bring your family and traveling companions.

Monday May 12, 2014 8:30pm - 10:00pm
Aspen Meadows Resort
 
Tuesday, May 13
 

8:00am

General Conference Welcome
Welcome to Aspen! Orientation to the conference facilities and surroundings.

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!


Tuesday May 13, 2014 8:00am - 8:15am
Paepcke

8:15am

Library in a Week - c++ templating engine

Library in a week 2014 will attempt to build a C++ template engine library.  Templating engines are very popular libraries that provide a way to separate an application from ouput.  Often the output is a html or text that may be developed by an non-programmer or other development team.

Consider the following program which uses the ctemplate library:

    //user.tpl

    Hello {{NAME}}!

 

    //user.cpp

    #include <cstdlib>

    #include <iostream>  

    #include <string>

    #include <ctemplate/template.h>  

 

    int main() {

      std::string user = getenv("USER");

      ctemplate::TemplateDictionary dict("example");

      dict["NAME"] = user;

      std::string output;

      ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);

      std::cout << output;

      return 0;

    }

In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.

A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed.  In our case the library language will be C++11.

The workshop will work like this.  On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design.  Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.

Collaboration Tools: 

Library in a week 2014 will use a git repository for collaboration and sharing of information.

git clone https://github.com/JeffGarland/liaw2014.git 

Also the group will use an email list for discussions beyond face to face meetings.

Level: Beginner to Expert 

Attendees should have a basic background in C++.


Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has written C++ networked code for several large systems including the development high performance network servers and data distribution frameworks.Mr. Garland’s... Read More →


Tuesday May 13, 2014 8:15am - 9:00am
Paepcke

9:00am

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

Axiomatic Programming is commonly defined as structured generic programming. Not unlike Euclidean Geometry, it relies on a simple, constructive, logical system. It lies at the foundation of the STL and many successful generic libraries. This talk focuses on tools support and illustrates how ideas and methods from automated deduction and proof theory influence current and future possible developments of C++ templates.


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 May 13, 2014 9:00am - 10:30am
Paepcke

11:00am

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 the best food (which I am on a permanent quest to eat). | | Michael Wong is the CEO of OpenMP. He is the IBM and Canadian representative to the C++ Standard... Read More →


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

11:00am

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
avatar for Nat Goodspeed

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 infuriated) by C++ ever since. | | When he first encountered Boost libraries, a light shone from the heavens and choirs of angels sang "AAAAAAH..." The idea... Read More →


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

11:00am

The Canonical Class
It was a simpler time. A period in which every college student and learn-C++-in-a-weekend duffer could write a class with the assuredness that it would behave as desired when assigned and copied. There was a check list. Complete the checklist, add some domain specific behaviour, bake in the regression oven, and you were done.

Enter C++11 with its fancy new use of the delete keyword, additional applications of explicit, rvalue references, and some perfect forwarding. How are you to write a “simple” class? Should you include a swap? What does movable mean and are there expected semantics? When is the noexcept specifier used?

During this 90-minute session we will explore the boilerplate of a C++11 class. The session will touch on rvalue references, move semantics, perfect forwarding, explicit, noexcept, initializer lists, and more as it applies to producing the desired semantics for our classes and structs.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere Consulting
Michael Caisse has been crafting code in C++ for nearly 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


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

2:30pm

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 of interests spanning the fields of (Quantum) Physics, Mathematics, and Computer Science. Her current main interests include principles and mechanisms for abstraction... Read More →


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

2:30pm

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.  With prior support from an Olivia Long Fellowship in Biology, he has used hypercomplex algebras to explore the dynamics of biological morphogenesis, and is currently... Read More →


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

2:30pm

Test-Driven Development With Boost.Test and Turtle Mock, Part I
Test-driven development embraces three simple rules:

  1. You are not allowed to write any production code unless it is to make a failing unit test pass.

  2. You are not allowed to write any more of a unit test than is sufficient to fail; and compilation failures are failures.

  3. You are not allowed to write any more production code than is sufficient to pass the one failing unit test. In short, with Test-Driven Development, you always write production code in response to a failing unit test.


In this tutorial, you will see how to apply the ideas of test-driven development in C++ using the Boost.Test unit testing framework. All the major areas of Boost.Test will be covered from assertions through test case design and organization. We will cover the difference between state-based testing and behavior based testing using mock objects provided through turtle mock, a mock object framework for Boost.Test.

First, you will walk through some exercises designed to show you the mechanics of test-driven development. Next, you will apply the concepts you have learned about test-driven development as a design activity to implement a feature. Once this tutorial is over, you will see how test-driven development is a powerful design activity that will naturally lead you to creating small, cohesive and decoupled classes.

Speakers
avatar for Richard Thomson

Richard Thomson

Senior Software Engineer, Fusion-io
Richard Thomson is a passionate software craftsman.  He has been writing C programs since 1980, C++ programs since 1993 and practicing test-driven development since 2006.  For 10 years, Richard was a Microsoft MVP for Direct3D, Microsoft's native C++ API for 3D graphics. His book on Direct3D is available as a free download. Prior to that, Richard was a technical reviewer of the OpenGL 1.0 specification. He is the director of the Computer... Read More →


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

4:30pm

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 financial data. | | He has written an algorithm that solved the traveling salesman problem in polynomial time. He can square the circle and divide by zero. He... Read More →


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

4:30pm

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

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 →


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

4:30pm

Test-Driven Development With Boost.Test and Turtle Mock, Part II
Test-driven development embraces 3 simple rules: 1. You are not allowed to write any production code unless it is to make a failing unit test pass. 2. You are not allowed to write any more of a unit test than is sufficient to fail; and compilation failures are failures. 3. You are not allowed to write any more production code than is sufficient to pass the one failing unit test. In short, with Test-Driven Development, you always write production code in response to a failing unit test.

In this tutorial, you will see how to apply the ideas of test-driven development in C++ using the Boost.Test unit testing framework. All the major areas of Boost.Test will be covered from assertions through test case design and organization. We will cover the difference between state-based testing and behavior based testing using mock objects provided through turtle mock, a mock object framework for Boost.Test.

First, you will walk through some exercises designed to show you the mechanics of test-driven development. Next, you will apply the concepts you have learned about test-driven development as a design activity to implement a feature. Once this tutorial is over, you will see how test-driven development is a powerful design activity that will naturally lead you to creating small, cohesive and decoupled classes.

Speakers
avatar for Richard Thomson

Richard Thomson

Senior Software Engineer, Fusion-io
Richard Thomson is a passionate software craftsman.  He has been writing C programs since 1980, C++ programs since 1993 and practicing test-driven development since 2006.  For 10 years, Richard was a Microsoft MVP for Direct3D, Microsoft's native C++ API for 3D graphics. His book on Direct3D is available as a free download. Prior to that, Richard was a technical reviewer of the OpenGL 1.0 specification. He is the director of the Computer... Read More →


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

5:30pm

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. His areas of interest are Concurrency, Algorithms, Machine Learning, and Real-time Simulation. His background in earthquake engineering gives him a unique... Read More →


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

6:30pm

Dinner Break
Suggested Venue: White House Tavern, Zocalito Bistro, Asie

Tuesday May 13, 2014 6:30pm - 8:30pm
Flug

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 what's on your mind.

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 May 13, 2014 8:30pm - 10:00pm
Paepcke
 
Wednesday, May 14
 

8:00am

Library in a Week - c++ templating engine

Library in a week 2014 will attempt to build a C++ template engine library.  Templating engines are very popular libraries that provide a way to separate an application from ouput.  Often the output is a html or text that may be developed by an non-programmer or other development team.

Consider the following program which uses the ctemplate library:

    //user.tpl

    Hello {{NAME}}!

 

    //user.cpp

    #include <cstdlib>

    #include <iostream>  

    #include <string>

    #include <ctemplate/template.h>  

 

    int main() {

      std::string user = getenv("USER");

      ctemplate::TemplateDictionary dict("example");

      dict["NAME"] = user;

      std::string output;

      ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);

      std::cout << output;

      return 0;

    }

In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.

A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed.  In our case the library language will be C++11.

The workshop will work like this.  On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design.  Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.

Collaboration Tools: 

Library in a week 2014 will use a git repository for collaboration and sharing of information.

git clone https://github.com/JeffGarland/liaw2014.git 

Also the group will use an email list for discussions beyond face to face meetings.

Level: Beginner to Expert 

Attendees should have a basic background in C++.


Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has written C++ networked code for several large systems including the development high performance network servers and data distribution frameworks.Mr. Garland’s... Read More →


Wednesday May 14, 2014 8:00am - 9:00am
Flug

8:00am

Release Management
This meetup is for Boost Library Release Managers and is open to the public. Any interested Boosters are encouraged to attend.

Moderators
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 →

Wednesday May 14, 2014 8:00am - 9:00am
Bethe

9:00am

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

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.


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

9:00am

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 worked on the Yandex Mail team for more than 7 years. His other interests are astronomy, dog breeding, and red wine.
avatar for Sergei Khandrikov

Sergei Khandrikov

Internet search and personal services, Yandex
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 and automation systems in 2004. His career started as software engineer and system architect in automation and robotics. He conducted development and research in several... Read More →


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

9:00am

Undefined Behavior in C++; what is it, and why should I care
More and more people are becoming aware of undefined behavior (UB) in C and C++. It has become a research interest at several universities, and code generators routinely use information about UB when deciding how to optimize code. 

In this talk, I will give examples of UB, show how optimizers reason about UB while doing code generation, and talk about strategies to avoid introducing UB into your code base (with examples from Boost). Finally, I will talk about the current (and upcoming) tools for detecting UB in existing code.

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 May 14, 2014 9:00am - 10:30am
Flug

11:00am

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 research interests include C++, generic programming, and abstract interpretation. More information about Yuriy can be found at his university page.


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

11:00am

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, Spiral Genetics
Cheinan Marks is a senior software developer at Spiral Genetics, Inc., in Seattle, WA, where he helps attack genomic alignment and assembly problems by throwing dozens of computers at them simultaneously. He got his start in the TUTOR language on the PLATO system at the University of Illinois. Having gotten his doctorate in chemical engineering, he enjoys developing new ideas in software, particularly scientific ideas, and turning them into... Read More →


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

11:00am

A Tutorial Introduction to C++11/14 Part I
This is the first of two presentations on the new features of C++11/14. It covers most of the smaller aspects of the language:


  • C++ Timeline

  • Goals for C++11/14

  • The Simpler Core Language Features

  • auto, decltype, trailing return types

  • Non-member begin/end

  • nullptr

  • Range for

  • >> in template specializations

  • static_assert

  • extern template

  • noexcept

  • Variadic templates

  • constexpr functions and data

  • Template alias

  • New character literal types

  • Raw string literals

  • Literal strings and const



There's also brief coverage of scoped enums, long long, alignas/of, attributes, inline namespaces, generalized unions/PODs, garbage collection ABI, and user-defined literals.


Speakers
avatar for Leor Zolman

Leor Zolman

Owner, BD Software
Leor Zolman has been involved in system software/compiler development, system administration, application development, and education for 40 years, spanning the CP/M, UNIX, and Windows operating systems. | Leor is the author of The BD Software C Compiler (“BDS C”, 1979), the first native-code C compiler targeted exclusively for personal computers. | In the early 90’s, Leor was a member of the technical staff of R&D... Read More →


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

2:30pm

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
Bethe

2:30pm

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. He has written code for Microsoft Research, Microsoft Visual C++, and Boost.org, where he has authored 4 Boost libraries: Proto, Foreach, Xpressive, and... Read More →


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

2:30pm

A Tutorial Introduction to C++11/14 Part II
This is the second of two presentations on the new features of C++11/14. It covers the meatier features added to the language:



  • Class design features: default and deleted generated functions, delegating and inheriting constructors, new flexibility for in-class initializers, and explicit conversion operators

  • Initialization: initializer lists, uniform initialization, and narrowing prevention

  • Lambdas

  • Rvalue references: lvalues and rvalues (the modern view), move semantics, universal references, perfect forwarding


Speakers
avatar for Leor Zolman

Leor Zolman

Owner, BD Software
Leor Zolman has been involved in system software/compiler development, system administration, application development, and education for 40 years, spanning the CP/M, UNIX, and Windows operating systems. | Leor is the author of The BD Software C Compiler (“BDS C”, 1979), the first native-code C compiler targeted exclusively for personal computers. | In the early 90’s, Leor was a member of the technical staff of R&D... Read More →


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

4:30pm

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 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 May 14, 2014 4:30pm - 6:00pm
Flug

4:30pm

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 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 →


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

4:30pm

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

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 May 14, 2014 4:30pm - 6:00pm
Bethe

6:30pm

Social Event: Picnic
Bring your family and friends and your appetite!

Wednesday May 14, 2014 6:30pm - 9:30pm
Picnic Area
 
Thursday, May 15
 

8:00am

Library in a Week - c++ templating engine

Library in a week 2014 will attempt to build a C++ template engine library.  Templating engines are very popular libraries that provide a way to separate an application from ouput.  Often the output is a html or text that may be developed by an non-programmer or other development team.

Consider the following program which uses the ctemplate library:

    //user.tpl

    Hello {{NAME}}!

 

    //user.cpp

    #include <cstdlib>

    #include <iostream>  

    #include <string>

    #include <ctemplate/template.h>  

 

    int main() {

      std::string user = getenv("USER");

      ctemplate::TemplateDictionary dict("example");

      dict["NAME"] = user;

      std::string output;

      ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);

      std::cout << output;

      return 0;

    }

In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.

A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed.  In our case the library language will be C++11.

The workshop will work like this.  On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design.  Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.

Collaboration Tools: 

Library in a week 2014 will use a git repository for collaboration and sharing of information.

git clone https://github.com/JeffGarland/liaw2014.git 

Also the group will use an email list for discussions beyond face to face meetings.

Level: Beginner to Expert 

Attendees should have a basic background in C++.


Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has written C++ networked code for several large systems including the development high performance network servers and data distribution frameworks.Mr. Garland’s... Read More →


Thursday May 15, 2014 8:00am - 9:00am
Paepcke

8:00am

Community Maintenance Team
This meetup is for the Community Maintenance Team and is open to the public. Any interested Booster are encouraged to attend.

Moderators
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 →

Thursday May 15, 2014 8:00am - 9:00am
Bethe

9:00am

Keynote: Beware of C++
With C++11 (and C++14), C++ has become a different programming language. As an application programmer you can declare, initialize, iterate, and move far more easily than before. However, there is a price to pay for that power, which ideally only "foundation library developers" should have to pay. But is that really true? How much must the average application programmer know about the tricky details to be able to program effectively in C++11? Because things have changed, we also have to ask how much, and in which direction, do basic programming patterns change with C++11? For example, how should I declare template arguments and when should I use explicit in C++11?

Even the Library Working Group of the C++ Standardization Committee have no clear answers for these questions. I will present some of the issues I see for the average application programmer, combined with some insights based on discussions about defects in the C++11 Standard Library.

video

Speakers
avatar for Nicolai Josuttis

Nicolai Josuttis

Nicolai Josuttis (http://www.josuttis.com) is an independent system architect, technical manager, author, and consultant. He designs mid-sized and large software systems for the telecommunications, traffic, finance, and manufacturing industries. He is well known in the programming community because he not only speaks and writes with authority (being the (co-)author of the world-wide best sellers The C++ Standard Library (www.cppstdlib.com... Read More →


Thursday May 15, 2014 9:00am - 10:30am
Paepcke

11:00am

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 language embedding based on template metaprogramming and libraries supporting template metaprogrammers. He has also been working on tools... Read More →


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

11:00am

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. Dominik looks back on more than 10 years of experience in C++ development for both industry and academia, including end-user... 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 security architectures. He currently develops a distributed platform for network forensics in C++11, with libcppa providing the building block for concurrency and... Read More →


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

11:00am

Unicode in C++
In some programming languages, text processing is easy. Unfortunately, C++ is not one of those languages. C++ lacks good, built-in support for Unicode, though the situation is starting to improve.

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

Speakers
avatar for James McNellis

James McNellis

Senior Software Engineer, Microsoft Visual C++
James McNellis is a senior engineer on the Visual C++ team at Microsoft, where he works on C++ library design and is responsible for the Microsoft C Runtime (CRT) and C Standard Library implementation. He can be found on Twitter at @JamesMcNellis and can be found elsewhere online via http://www.jamesmcnellis.com.


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

2:30pm

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

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 →


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

2:30pm

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

Christie Digital
Tony Van Eerd has been coding for well over 25 years, and hopefully coding well for at least some of that. Most of that time has been in the graphics/video/film/broadcast industry (at Inscriber/Adobe), writing low level pixel++, high level UI, as well as threading and everything else in between. After a few years of being "the C++ Guy" at BlackBerry, he is back to doing math and pixel++, now at Christie Digital.


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

2:30pm

Accelerator Programming with C++ AMP
Today, heterogeneous programming is ubiquitous across many segments of the C++
industry. Data centers utilize GPGPUs to process vast quantities of data,
supercomputers increasingly draw upon accelerators to provide the bulk of their
computational power, and mobile devices frequently couple "capability" CPUs with
"capacity" GPUs to provide high-efficiency computational power.

Typically, accelerators are only suitable for executing certain portions of a
program. They frequently rely on CPUs to make big-picture execution decisions,
access main memory, and manage peripheral hardware. The interactions between
CPUs, accelerators and other system components makes heterogeneous systems
complex.

Furthermore, accelerators may live off-chip, contain their own
private memory, or have noticeable communication latencies. Heterogeneous
systems may contain multiple CPUs that communicate via vendor-specific
processor interconnects. System complexity can be further complicated by
applications that are storage- or network-intensive.

For many C++ programmers, heterogeneous programming is no longer a luxury;
instead, it has become a necessity. C++14 provides no mechanism for
heterogeneous programming; C++ programmers must rely on software libraries to
harness the power of accelerators. There are numerous high-quality frameworks for
utilizing accelerators, but many of these frameworks are usable only
with certain types of accelerators or emphasize a purely synchronous offloading
model.

The C++ Accelerated Massive Parallelism (C++ AMP) open specification, published
by Microsoft, presents a hardware-agnostic interface for exploiting accelerator
hardware in modern C++ applications. C++ AMP consists of both language
extensions and an STL-like library component. It provides support for both
synchronous and asynchronous offloading. C++ AMP allows programmers to write
accelerator-aware applications without having a detailed knowledge of the
intricacies of heterogeneous hardware.

In addition to the mature C++ AMP implementation provided by Visual Studio, there
a number of C++ AMP implementations for a variety of platforms. To name a
few, Intel is developing an implementation called Shevlin Park and the HSA
foundation is working on a Clang-based C++ AMP implementation.

This tutorial will present an overview of C++ AMP from a software-centric
viewpoint, covering the following topics:

* Programmatically preparing data for accelerators
* Transferring data to/from accelerators
* Offloading code to accelerators (e.g. restrict(amp), parallel_for_each)
* Controlling accelerator parallelism (e.g. tiling, barriers)

This talk will emphasize usage of the asynchronous interfaces provided by C++
AMP to write wait-free offloaded code.

The intended audience is C++ developers who are either using accelerators today
or will be using accelerators in the future. The talk will include limited
discussion of specific accelerator hardware or software implementations of C++
AMP. This presentation will be relevant to developers on all platforms, not just
Windows.

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 →


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

4:30pm

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 languages (DSL), C++ parsing, source-to-source | translation, and code generation. His notable projects to date | include ODB (ORM for C++), XSD... Read More →


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

4:30pm

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: "It delights me when I am allowed to contribute to technologies that currently empowers our digital experiences. Either for users or developers, I tend to put myself... Read More →


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

4:30pm

Understanding &&
C++11 introduced rvalue references or '&&'. That simple double '&' gives move semantics its mojo. But '&&' is yet more powerful. The power hidden behind both std::move and std::forward is also '&&'. Additionally, you may have heard of Universal References, which also are based on '&&'. 

With all that power, it turns out that '&&' can be a bit tricky. This presentation summarizes the different uses for '&&'. It covers how to distinguish the different roles that '&&' can take on while you are reading or writing code. It also covers current best practices for using '&&' in code. The talk is intended for beginning C++ programmers who want to find out what the '&&' fuss is about or for intermediate programmers who perhaps tried to use '&&' and then didn't get the behavior they expected. 

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 →


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

6:30pm

Dinner Break
Suggested Venue: Hickory House, Little Annie's (fried chicken special)

Thursday May 15, 2014 6:30pm - 8:30pm
Flug

8:30pm

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

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 →


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

8:00am

Library in a Week - c++ templating engine

Library in a week 2014 will attempt to build a C++ template engine library.  Templating engines are very popular libraries that provide a way to separate an application from ouput.  Often the output is a html or text that may be developed by an non-programmer or other development team.

Consider the following program which uses the ctemplate library:

    //user.tpl

    Hello {{NAME}}!

 

    //user.cpp

    #include <cstdlib>

    #include <iostream>  

    #include <string>

    #include <ctemplate/template.h>  

 

    int main() {

      std::string user = getenv("USER");

      ctemplate::TemplateDictionary dict("example");

      dict["NAME"] = user;

      std::string output;

      ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);

      std::cout << output;

      return 0;

    }

In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.

A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed.  In our case the library language will be C++11.

The workshop will work like this.  On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design.  Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.

Collaboration Tools: 

Library in a week 2014 will use a git repository for collaboration and sharing of information.

git clone https://github.com/JeffGarland/liaw2014.git 

Also the group will use an email list for discussions beyond face to face meetings.

Level: Beginner to Expert 

Attendees should have a basic background in C++.


Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has written C++ networked code for several large systems including the development high performance network servers and data distribution frameworks.Mr. Garland’s... Read More →


Friday May 16, 2014 8:00am - 9:00am
Flug

8:00am

Review Process Meetup
This meetup is for anyone interested in the review process for Boost library candates and Boost Incubator. It is open to anyone interested.

Moderators
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 →

Friday May 16, 2014 8:00am - 9:00am
Bethe

9:00am

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 the Clang C++ compiler and maintains the Boost.PropertyTree library.


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

9:00am

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 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 →


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

9:00am

Create Your Own Refactoring Tool with Clang
Refactoring tools for C++ have lagged behind those available in other languages. We've all heard the excuses about how C++ is too hard to parse and too hard to reason about. Well, get ready to have your socks blown off by the tooling infrastructure provided with clang. It makes writing refactoring tools simple and easy.

In this talk, I will incrementally develop a refactoring tool with clang that transforms a "(void)" function argument list to an empty argument list: "()".  This will give you a concrete example of how to apply the tooling library from clang: exploring the parsed abstract syntax tree (AST), writing code that matches elements of the AST, and operating on the matched nodes to create source code transformations that are applied by the tooling library.

If time is available, we'll look at some other examples of refactoring tools and discuss how they operate.

Speakers
avatar for Richard Thomson

Richard Thomson

Senior Software Engineer, Fusion-io
Richard Thomson is a passionate software craftsman.  He has been writing C programs since 1980, C++ programs since 1993 and practicing test-driven development since 2006.  For 10 years, Richard was a Microsoft MVP for Direct3D, Microsoft's native C++ API for 3D graphics. His book on Direct3D is available as a free download. Prior to that, Richard was a technical reviewer of the OpenGL 1.0 specification. He is the director of the Computer... Read More →


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

11:00am

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 is one of the leading European research centers. After his graduation he has gained experience working in industry. | | He started his career as a GPS navigation... Read More →


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

11:00am

Intro to Functional Programming in C++
What's the point of functional programming? Don't I have to do that in Haskell? Is functional programming an all-or-nothing thing? Can I benefit from making my C++ "more functional"? If so, how would I do that?

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 →


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

11:00am

Managing Object Lifetimes
One of the most powerful features of C++ is deterministic, scope based object lifetimes. Used properly, this can help ensure that your code is does not leak resources and is exception-safe. In this talk, I will show examples and discuss techniques that you can use to make your code simpler, easier to read, and more obviously correct. 

We'll start with the basics of construction/destruction, move on to RAII and smart_pointers, then discuss exception safety, and finish up with a discussion about ownership when passing parameters. 

Along the way, I will discuss the changes in C++11 and C+14 that make this style of programming easier.

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.


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

2:30pm

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


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

2:30pm

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 and parallel computing. Since January 2008, he has contributed actively to the Boost community. He is the coauthor and maintainer of Boost.Thread/Chrono/Ratio. He is... Read More →


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

2:30pm

Lifetime and Usage of Global, Thread-local, and Static Data
C has the facility to declare data, both initialized and uninitialized, that is available to whole programs. C++ extends this with the ability to create global and thread-local objects. As with all objects, global and thread-local objects are constructed at the beginning of their lifetimes and destructed at the end.

This talk will cover what the C++11 standard guarantees concerning global, static, and thread-local object lifetimes.  It will then cover what compilers actually do.  How to use global data for complex initialization will be discussed.  Patterns for dealing with global data and how to minimize global data will also be discussed.

Speakers
avatar for Daniel Dilts

Daniel Dilts

Firmware Engineer, GE
Daniel Dilts currently works as a Firmware Engineer at General Electric.  His interests range from hardware to software and everything in-between, as evidenced by his BS in Mechanical Engineering obtained at BYU, followed by his later position as a Software Engineer at GE.  Daniel is generally considered to be either insane or a glutton for punishment, as he has been known to program "just for fun."


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

4:30pm

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 programming back when the only C++ compiler was called Cfront. He got into concurrency and parallelism before the free lunch was over, and now he’s... Read More →


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

4:30pm

Asynchronous Programming Using Boost.MetaStateMachine and the Upcoming Asynchronous Library
Let's face it, for large applications where blocking while waiting for a future is not an option, std::async doesn't make the cut. N3558 and N3650 still do not solve the problem.

Would an ASIO-style callback-based solution be better?

We will first study a Qt application (a CD Player) where the functional behavior will be provided by Boost Meta State Machine and the asynchronous part by the upcoming Asynchronous library.

The second part of the talk will be more focused on the Asynchronous library: Active Objects, threadpools, algorithms, and much more.

Speakers
avatar for Christophe Henry

Christophe Henry

Manager Software Engineering, Dr. Schenk
Christophe has been programming in C++ (and loving every second of it) for over 15 years. Even in his current job as a manager of software engineering, he insists on writing code on a daily basis. He is also the author of the Boost Meta State Machine library.


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

4:30pm

Ownership of Memory in C++
In this talk, we will cover various popular methods of defining ownership of an object: automatic variables ("stack based"), raw pointers, and smart pointers. We also put forth a minor improvement to the collection of smart pointers available in the C++ standard library. 

Most treatments of the ownership topic in C++ briefly mention performance (if at all), with most of the focus being on simply convincing people to use (or not use) them. This talk, however, will have a significant component dedicated to how to effectively optimize time and memory usage while retaining correctness. 

The focus of this talk will be on ownership as it relates to memory. We will briefly touch on important principles such as RAII, but only in the context of memory management, not general resource management. 

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 financial data. | | He has written an algorithm that solved the traveling salesman problem in polynomial time. He can square the circle and divide by zero. He... Read More →


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

6:30pm

Dinner Break
Suggested Venue: Campo de Fiori, Cantina

Friday May 16, 2014 6:30pm - 8:30pm
Flug

8:30pm

C++Now 2015 Planning Session
The planning committee for next year's conference gets started early. 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!

Friday May 16, 2014 8:30pm - 10:00pm
Flug
 
Saturday, May 17
 

8:00am

Library in a Week - c++ templating engine

Library in a week 2014 will attempt to build a C++ template engine library.  Templating engines are very popular libraries that provide a way to separate an application from ouput.  Often the output is a html or text that may be developed by an non-programmer or other development team.

Consider the following program which uses the ctemplate library:

    //user.tpl

    Hello {{NAME}}!

 

    //user.cpp

    #include <cstdlib>

    #include <iostream>  

    #include <string>

    #include <ctemplate/template.h>  

 

    int main() {

      std::string user = getenv("USER");

      ctemplate::TemplateDictionary dict("example");

      dict["NAME"] = user;

      std::string output;

      ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);

      std::cout << output;

      return 0;

    }

In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.

A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed.  In our case the library language will be C++11.

The workshop will work like this.  On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design.  Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.

Collaboration Tools: 

Library in a week 2014 will use a git repository for collaboration and sharing of information.

git clone https://github.com/JeffGarland/liaw2014.git 

Also the group will use an email list for discussions beyond face to face meetings.

Level: Beginner to Expert 

Attendees should have a basic background in C++.


Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has written C++ networked code for several large systems including the development high performance network servers and data distribution frameworks.Mr. Garland’s... Read More →


Saturday May 17, 2014 8:00am - 9:00am
Flug

9:00am

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 Biomedizinische NMR Forschungs GmbH at the Max Planck Institute for Biophysical Chemistry on real-time medical imaging.


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

9:00am

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

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 →


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

9:00am

Disambiguation: The Black Technology
Overloading gives C++ function calling much greater flexibility than C's.  However, overloading can lead to ambiguities, for which there are common tools: SFINAE, MPL's integral_constant, and tag dispatching.  However, using those tools is a black art compared to just renaming functions. In this talk, we will learn how to use those tools to manage function overload sets.  We will also discover when you must, should, should not, or cannot disambiguate function calls with those tools.

Examples come from implementations of library proposals, libc++, libstdc++, and Boost. MPL experience is not required.

Speakers
avatar for Zhihao Yuan

Zhihao Yuan

Rackspace
Zhihao Yuan is one of the few C++ programmers in Rackspace.  He wrote several proposals and participates in the C++ standardization due to personal interests, but contributed only 10 lines to the C++14 working draft.


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

9:45am

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 University of Waterloo, Canada, and holds postgraduate qualifications in Business Information Systems and Educational and Social Research as well as a second... Read More →


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

11:00am

Future of Boost
The people who bring you Boost and C++ Now! talk and answer questions about what they see coming.

Speakers
avatar for Steering Committee and C++Now Committee Chairs

Steering Committee and C++Now Committee Chairs

Currently the members of the Boost Steering Committee are Michael Caisse, Marshall Clow, Beman Dawes, Hartmut Kaiser, Jon Kalb, Eric Niebler, Sebastion Redl, and Rob Stewart.


Saturday May 17, 2014 11:00am - 12:30pm
Paepcke